aardio教程二) 进阶语法

表(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();