表(table)
aardio中除了基础数据类型外，其他的复合对象都是table(例如类和名字空间等)。table可以用来存放aardio的任何对象，包括另一个table。
在其他语言中的字典、列表、数组、集合映射等，在aardio中都使用table来实现。
创建字典
import console;
var tab = {
a = 123;
str = "字符串";
[123] = "不符合变量命名规则的键应放在下标内。";
["键 名"] = "不符合变量命名规则的键应放在下标内。";
键名 = {
test = "表也可以包含表";
}
}
// 新版也可以使用类json语法定义
var tab = {
"a": 123,
"str": "字符串",
//123: "不符合变量命名规则的键应放在下标内。" // 这样定义键不能是数值类型
"键名": {"test":"表也可以包含表"}
}
tab.a = 456;
tab["str"] = "aaaa" ;
// 赋值为null等同于删除该键
tab.键名 = null;
// 遍历
for k,v in tab{
console.dump(k,v);
}
console.pause();
创建数组
var array = {1;2;3;"a"};
// 遍历
for(i=1;#array;1){
console.dump(i, array[ i ]);
}
数组和字典可以混用
var t = {
1;
2;
a=2;
}
// #只能获取到数组长度，也就是2
console.log(#t)
// 获取表长度, 3
console.log(table.count(t))
类
使用class关键字定义类。类可以动态创建数据结构相同的table对象
定义类
//定义类
class 类名字{
//构造函数可以省略
ctor( 构造参数列表 ){
//构造函数代码
}
类属性 = "属性值";
类方法 = function(参数){
}
}
和定义一个table的语法基本一样，只是类可以创建出对象
var 对象 = 类名字();
io.print(对象.类属性)
对象.类方法();
类的名字空间
定义类时，默认会创建一个同名的名字空间。赋值给名字空间的变量就是类的公用静态成员
io.open(); //打开控制台窗口
//定义一个类
class cls{
a = 123;
}
//每一个类拥有独立的名字空间，名字空间中的变量也就是类的公用静态成员。
cls.A = "类的静态成员A";
c = cls(); //创建新对象
io.print( "c.a" , c.a ) //显示123
io.print( "cls.A" , cls.A ) //显示"类的静态成员A";
在库代码里可以经常看到，定义类的时候一般会定义一个同名的名字空间，用于存放一些静态函数或变量
class base{
a = 123;
b = 456;
c = 789
}
namespace base{
static = 123; //类的静态成员
}
this对象
也就是Python的self，表示当前对象
owner对象
这个解释起来比较麻烦，但理解了就很简单，举个例子：
class cls{
func = function(){
//类有自已的名字空间，访问全局对象要加上..前缀
..io.print("owner", owner )
..io.print("this", this )
..io.print("owner == this", owner == this )
}
}
//创建对象
obj = cls();
//打开控制台
io.open()
//调用对象方法
obj.func(); //默认table与owner是同一个对象
func = obj.func;
func();//这里owner为null空值，而this对象没有改变
当一个table对象调用成员函数时,默认会传递一个owner对象给函数。而在类创建的对象成员函数里，owner对象与this对象是指向同一个对象。
this对象与owner对象的区别在于: this是类内部指向当前创建对象的指针，this指针不会因为函数的table前缀改变而改变。而owner对象是会根据函数调用时函数名前缀的table对象而相应改变
构造函数
ctor函数就是类的构造函数，等同于__init__，只是参数没有self
//定义类
class cls{
//使用ctor关键字定义构造函数
ctor( a,b ){
this.a = a;
this.b = b;
}
c = "this.c";
d = "this.d";
}
//调用类的构造函数创建对象
var obj = cls(123,456);
import console;
console.log( obj.a, obj.b )
console.pause();
类的直接继承
//创建一个基类
class base{
a = 123;
b = 456;
c = 789
}
namespace base{
static = 123; //类的静态成员
}
class inheritance{
// 构造函数，三个点表示可变参数，类似Python的*args
ctor(...){
// 在类函数里访问其他名字空间前面都需要加上.., 内核库也要，比如..string.format
this = ..base(...); //调用基类构造对象原型。
};
c = "覆盖基类成员";
d = "子类的新成员";
}
import console;
var obj = inheritance();//从子类创建对象
//输出对象的所有成员(包括直接继承的基类成员)
for(k,v in obj){
console.log(k,v);
}
console.pause();
类的间接继承
class base{
a = 123;
b = 456;
c = 789
}
class inheritance{
c = "覆盖基类成员";
d = "子类的新成员";
// @表示类的元表，名称是随意的
@_prototype;
}
// 在类的名字空间内指定静态共享成员 _prototype
// 可以在元表中定义相应的元方法，来改变类的一些行为，比如_get是访问类属性时触发
inheritance._prototype = { _get = ..base() };
import console;
var obj = inheritance();//从子类创建对象
//与类的直接继承不同
//遍历只能输出子类的所有对象,（不会遍历元表中原型对象的成员）
for(k,v in obj){
console.log(k,v);
}
//通过元方法继承仅在使用成员操作符时生效
console.log("访问base类的成员", obj.a );
console.pause();
类的私有成员
用var定义的成员变量，作用域只在类里面，所以外部无法访问
类的只读成员
用下划线开头的变量为类的只读成员，无法修改它。也可以通过元表来定义只读成员，元表和元方法的时候再具体说
网友评论