AAuto编程【函数】table列表库函数

【函数】table列表库函数
1.table.range()

【函数说明】取得数组大小，返回数组的最小长度及最大长度两个数值(#则取数组长度）

min , max = table.range( tarr )

【示例】

io.open()

tarr = { 123;456;77;99 };//创建数组，数字索引默认从1开始

io.print( table.range( tarr ) )

运行显示 1  4


2.table.insert()

【函数说明】在数组中插入元素

table.insert(tab,value ,pos = 1)

在table类型参数tab中插入元素(value),
pos指定插入位置,如果指定这个参数,table.insert首先在tab[pos]插入value并将后面的所有元素顺序向后移动。
pos为可选参数，默认值为1(即在数组开始插入)

【示例】

t={}

table.insert(t,1)//插入1

table.insert(t,2)//插入2

table.insert(t,3)//插入3

table.insert(t,1236,2)//在第二个位置插入1236

io.open()
for(name,value in t){
    io.print(name,value)

}

运行显示
1     3
2     1236
3     2
4     1

3.table.remove()
【函数说明】在数组中删除元素

value = table.remove (tab ,pos = 1)

在数组指定位置移除元素，然后从此位置开始将所有元素前移一位。
pos为可选参数，默认值为1(即在数组开始移除）返回值为移除的元素

【示例】

t={}

table.insert(t,1)//插入1

table.insert(t,2)//插入2

table.insert(t,3)//插入3

table.insert(t,1236,2)//在第二个位置插入1236

table.remove(t,3)//移除第三个位置的数值

io.open()
for(name,value in t){
    io.print(name,value)

}

运行显示
1   3
2   1236
3   1

如果您不希望在删除无素后改变其他的元素的位置，可以使用赋值为null的方法删除一个元素

tab = {"a";"b";"c";"d";"e"}
table.remove (tab ,2); //移除第二个元素,后面的元素全部向前移动一个单位.
tab[2] = null; //删除第二个元素,不会改变其他元素的位置。

io.open()
for name,value in tab{
     io.print( name,value);
}

4.table.push()
【函数说明】用数组实现堆栈操作，堆栈操作避免了数组的重新排序，效率高于table.insert,table.remove

table.push(tab ,value[, value , ... ] )

在数组尾部添加一个或多个值。table.push返回新数组的长度（最后一个元素所在的索引)

【示例】

t={}

io.open()

table.push(t,1,2,3)
io.print(table.tostring(t))

table.insert(t,1236,2)

io.print(table.tostring(t))

table.remove(t,2)

io.print(table.tostring(t))

运行显示(由于用了tostring转换为字符串输出)
{1;2;3}
{1;1236;2;3}
{1;2;3}


5.table.pop()
【函数说明】在数组尾部弹出一个或n个值。 n为可选参数，默认为1，返回值为一个或n个移除的数组元素。                  

table.pop(tab [, n] )

（数组中不能有null值,有null值则null后面不显示弹出来）

【示例】

//实现一个堆栈类（堆栈必须用push压入pop弹出）
class Stack {
    @{ _get = self }
}
Stack.push = function( ... ){
    table.push( owner , ... );
}
Stack.pop = function( n ){
    return table.pop( owner , n );
}
sk = Stack();//创建新的堆栈对象

sk.push("a","b","c") //压入一个或多个参数

io.open();
io.print( sk.pop(2) ) //弹出一个或多个参数

运行显示： b  c  (由尾部弹出2个数值)

6.table.sort()
【函数说明】数组排序（不指定参数默认升序排序）

table.sort (tab [, comProc])

对数组tab重新排序,comProc是一个可选参数,comProc是一个排序回调函数，用于比较两个元素的大小。
table.sort在排序过程中，每遇到两个元素就调用comProc函数比较大小,并将两个元素作为参数传递给comProc函数。
如果comProc函数认为第一个参数比较小返回true,如果认为第二个参数比较小应当返回false。（即降序排列）
如果没有提供排序回调函数,table.sort默认调用小于操作符比较两个元素的大小.（升序排列）

【示例】

io.open()

tab ={3;4;7;8;6;5;2;1}
table.sort(tab);

//看看排序后的结果
for i=1; #tab; 1 {
    io.print( tab[ i ] );//显示 1 2 3 4 5 6 7 8
}

//table.sort会调用这个函数比较元素大小
comProc = function(b) begin
    return owner > b ;//反过来排序
end;

table.sort(tab,comProc);

//看看排序后的结果
for i=1; #tab; 1 {
    io.print( tab[ i ] );//显示 8 7 6 5 4 3 2 1
}

table.sort是对数组的值域进行排序,不能对字典排序，也不能对键域(下标域)进行排序。

如果我们需要对字典进行排序，可以自已写一个迭代器。将字典中的数据复制到一个数组中然后进行排序。

下面我们介绍如何对table中的键域进行排序.

//支持table中的键域排序,参数tab为table对象,f为排序回调函数(可省略）
function kpairs(tab,f) begin

    //kpairs被调用时创建闭包
    var tarr = {}

    //字典中的数据复制到一个数组中然后进行排序
    for k in tab
        table.push(tarr, k);

    table.sort(tarr, f);//调用默认的排序函数f对字典中的键进行排序

    var i = 0 //迭代器计数器.(在闭包中保存值)


    return function () { //迭代函数
        i = i + 1
        if(not tarr[ i ])
            return null
        else
            return tarr[ i ], tab[tarr[ i ]]
    }

end

//table必须是同类型，若含有数组与字典一起的table表不适用
tab ={c=2;d=7;e=4;g=2;h=8;a=1;b=6;f=5;i=1;j=1;k=9};


io.open();

for k,v in kpairs(tab)
io.print(k,v); //table中的键按字母顺序排序了，并不是按值排列

7.table.reverse()

【函数说明】反序，将一个table数组按原来的顺序反向排列。注意这个函数没有返回值，直接修改原来的table
   

table.reverse(tab)

【示例】

io.open();

tab = { 1;2;3;4;5;6;7}
table.reverse(tab); //反序排列

for i = 1; #tab;1{
    io.print( tab[ i ] )
}//竖排显示 7 6 5 4 3 2 1

---

作者: qqmmcc    时间: 2010-12-28 18:03
本帖最后由 qqmmcc 于 2011-8-8 18:01 编辑

8.table.unpack()
【函数说明】拆分数组

table.unpack(tab,i=1,e=#tab)

参数tab：表对象
参数i：起始索引，默认为1
参数e：结束索引，默认数组长度。
返回值：从索引位置i，到索引位置e，拆分并返回table对象的数组成员。
   

table.left(tab,len)

参数len：从数组左侧返回的数组元素个数。
返回值：从数组左侧侧拆分并返回table对象的len个数组成员。

table.right(tab,len)

参数len：从数组右侧返回的数组元素个数。
返回值：从数组右侧拆分并返回table对象的len个数组成员。

【示例】

import process;
io.open();
tab = { 1;2;3;4;5;6;7}
a,b,c,d,e = table.unpack(tab); //将数组全部拆分并返回。
io.print( table.unpack(tab,2,4) ); //返回第2个、第3个、第4个数组成员
io.print( a,b,c,d,e )
io.print( table.left(tab,4) ) //自左侧开始拆分指定长度数组元素
io.print( table.right(tab,4) ) //自右侧开始拆分指定长度数组元素

运行显示：2   3   4
1   2   3   4   5
1   2   3   4
4   5   6   7



9.table.tostring(tab)

【函数说明】将table对象序列化为字符串形式，序列化的table必须使用合法的标志符、或数值作为键.
【示例】

io.open();
tab = {1;2;3;a=123;b='456'}

str = table.tostring( tab ); //序列化为字符串（AAuto代码）

io.print( str ) //显示序列化后的字符串


for(k,v in tab){
   
    io.print(v)//由于有键值对,用遍历显示数组
}
  

【运行显示】
{1;2;3;a=123;b=“456”}
1
2
3
123
456

10.table.concat(tab,tab2[,tab3 [,... ] ])

【函数说明】将多个表连接为一个新的表，表中如包含数组，索引值修改为原索引值加上在新表中的位置

【示例】

io.open();

tab = {1;2;3}
tab2 = {4;5;6}

tab3 = table.concat(tab,tab2 ); //将多个表拼接为一个表

io.print( table.unpack( tab3 ) ) //再拆分横显示显示

//如不拆分数组则序列化显示
for(i=1;#tab3;1){
   
    io.print(tab3[ i ])
}

【运行显示】
1   2   3   4   5   6
1
2
3
4
5
6
  
11.table.count(tab)

【函数说明】获取成员总数，包含键值


12.table.copy()

【函数说明】复制table对象


13.table.load()

【函数说明】将table代码转换为table对象



{下面几个函数说明待续}

---

14.table.new()
function(l,v=0){

var t = {}

for(i=1;l)(t[ i ]=v);

return t;


}


15.table.toclass()
table.toclass = function(t){

return {@(table.ctor(t))};
}


16.table.ctor()




17.table.next()