Lua之Table个人总结

在lua中Table是数组和集合的混合物。作为数组时,可以使用除了nil以外的值作为索引。


Table的构造

利用下标来标明元素
1  
2  
3  
4  
5  
6  
local table  = {}  
table[1]='hello'  
table[5]='world'  
for i,v in pairs(table)do  
    print(table[i])  
end  

—|—

输出

1  
2  
1	hello  
5	world  

—|—

在Table内部通过索引来声明
1  
2  
3  
4  
local table = { [1] = 'hello', [5] = 'world' }  
for i, v in pairs(table) do  
    print(table[i])  
end  

—|—

输出

1  
2  
1	hello  
5	world  

—|—

在Table内部不通过索引来声明
1  
2  
3  
4  
local table = {'hello','world'}  
for k, v in pairs(table) do  
    print(k,v)  
end  

—|—

输出

1  
2  
1	hello  
2	world  

—|—


Note:

1,可以看到通过下标标明元素(方法1)和在内部通过索引方式(方法2)构造的table是一样的。如果不声明索引(方法3),则默认为数字,且从1开始。

2,索引可以为字符串。

1  
2  
3  
4  
5  
6  
local table  = {}  
table[1]='hello'  
table["skr"]='world'  
for k, v in pairs(table) do  
    print(k,v)  
end  

—|—

或者是

1  
2  
3  
4  
local table = { [1] = 'hello', skr = "world" }  
for k, v in pairs(table) do  
    print(k, v)  
end  

—|—

输出

1  
2  
1	hello  
skr	world  

—|—

这时table有点像Java的HashMap,下标作为key。

3,如果索引为数字访问方式为 table[1]
如果索引为其他类型,访问方式为 table.skr 或者是 table[‘skr’](注意 [ ] 内为字符串,两侧有引号)

1  
2  
3  
4  
print(table[1])         --输出hello  
print(table.skr)       --输出world  
print(table[skr])      --输出nil(没有引号,错误)  
print(table['skr'])     --输出world(有引号,正确)  

—|—

4,#运算符

利用#运算符可以获得table中使用数字做key的元素总数。

1  
2  
local table = { [1] = 'hello', skr = "world", _2 = "123" }  
print(#table)  --输出1,只有索引为1的元素才会被计算,skr和_2都是字符串  

—|—


Table的其他用法

上面的例子可以看到,Lua的Table,索引Key为数字时像Java的ArrayList,索引为字符串的时候像Java的HashMap。Java的HashMap可以存储对象,Lua的Table也可以。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
local CPU = { name = 'CPU', cost = 400 }  
local Monitor = { name = 'bird', cost = 200 }  
local Memory = { name = 'memory', cost = 100 }  
local Computer = {  
    CPU,  
    cpu = Monitor  
}  
Computer.memory = Memory  
Computer[6] = Memory  
  
for k, v in pairs(Computer) do  
    print(k, v.name, v.cost)  
end  

—|—

输出

1  
2  
3  
4  
1	CPU	400   --数字索引  
cpu	bird	200	2   --字符串索引  
6	memory	100	2   --数字索引,构造后添加  
memory	memory	100	4      --字符串索引,构造后添加  

—|—

Table中利用索引存储Table,这种思想类似面向对象的封装。而对象是由属性和方法组成,在Lua中,对象由Table作属性,function作方法,共同组成对象。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
local CPU = { name = 'CPU', cost = 400 }  
local Monitor = { name = 'bird', cost = 200 }  
local Memory = { name = 'memory', cost = 100 }  
local Computer = {  
    description = "this is a computer",  
    cpu = CPU,  
    monitor = Monitor,  
    memory = Memory  
}  
  
function Computer.getDescription()  
    return Computer.description  
end  
  
print(Computer.getDescription())  

—|—

输出

1  
this is a computer  

—|—

Table的常用方法

这些方法的使用类似Java的静态方法

table.insert(table,pos,value):往table中第pos中插入value的值。如果pos已存在,则往后移动。
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
print('before insert')  
local tb = { '1', '2', '3', '5' }  
for k, v in pairs(tb) do  
    print(k, v)  
end  
table.insert(tb, 2, '6')  
print('after insert')  
for k, v in pairs(tb) do  
    print(k, v)  
end  

—|—

输出

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
before insert  
1	1  
2	2  
3	3  
4	5  
after insert  
1	1  
2	6  
3	2  
4	3  
5	5  

—|—

往tb中index=2的地方插入了6,原来index=2的位置变成了3。类似Java的list.add(index,object).

如果没有索引,则往最后的地方插入。类似Java的list.add(object)

pos,否则会报错。

table.remove(table,pos):和insert类似
table.sort(table, 排序规则)

排序规则为自定义排序规则,缺省为升序

下面的例子是定义了一个排序规则为年龄降序的排序。

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
local people = {  
    { name = 'a', age = 11 },  
    { name = 'b', age = 14 },  
    { name = 'c', age = 12 },  
    { name = 'd', age = 10 },  
}  
  
function sortByAge(a, b)  
    return a.age > b.age  
end  
  
function printArray(showText, array)  
    print(showText)  
    for i, v in ipairs(array) do  
        print(v.name, v.age)  
    end  
end  
  
printArray('before', people)  
table.sort(people, sortByAge)  
printArray('after', people)  

—|—

其中sortByAge(object1,object2)需要传入两个对象。如果返回true的话就交换位置,由于这里用的是大于,则表示从大到小排序,则为降序。输出结果为:

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
before  
a	11  
b	14  
c	12  
d	10  
after  
b	14  
c	12  
a	11  
d	10  

—|—

如果改变排序规则,比较名字。使用升序,输出应该为abcd

1  
2  
3  
function sortByName(a, b)  
    return a.name < b.name  
end  

—|—

输出的确为a-b-c-d

1  
2  
3  
4  
5  
after  
a	11  
b	14  
c	12  
d	10  

—|—

另外,字符串的排序应该是按照首个字符的AscII码排序。

1  
2  
3  
4  
5  
6  
local people = {  
    { name = '+a', age = 11 },  
    { name = 'ab', age = 14 },  
    { name = 'Dc', age = 12 },  
    { name = '9d', age = 10 },  
}  

—|—

其中+的Ascii码为43,a为97,D为68,9为57,输出结果为

1  
2  
3  
4  
5  
after  
+a	11  
9d	10  
Dc	12  
ab	14  

—|—

table.concat(table[,间隔符[,start[,end]]])

把table内部的元素从start开始到end,以 间隔符 拼接,拼接后的对象属性为String

1  
2  
3  
4  
5  
6  
7  
local tb = {'1','2','3','4'}  
local s1 = table.concat(tb,'*',2,3)  
local s2 = table.concat(tb)  
print(s1)  
print(type(s1))  
print(s2)  
print(type(s2))  

—|—

上面展示了把table的每个元素拼接,元素之间以 * 和 ‘’(空字符串) 间隔,输出

1  
2  
3  
4  
2*3  --从第二到第三个元素,期间以*连接  
string  
1234    --不带参数表示从头到尾,以空字符串连接  
string  

—|—

糖果

糖果
LUA教程

Lapis框架的常用处理方法

Lapis框架的常用处理方法 Continue reading

MoonScript实现选择排序

Published on February 26, 2017

MoonScript与Redis客户端

Published on January 19, 2017