lua

lua表

复制：

mytable = {}
mytable[1] = "lua"
newtable = mytable
newtable[1] = "c#"
print(mytable[1]) -- c#
print(newtable[1]) -- c#
newtable[2] = "java"
print(mytable[2]) -- java
mytable = nil -- newtable还可用

操作：
mttable = {“lua”,“c#”,“java”,“c++”}
连接： table.concat(mytable, “,”, 2, 4) – c#,java,c++
插入：table.insert(mytable,2,“c”) – lua c c# java c++
删除：table.remove(mytable, 2) – 会使索引前移 “lua”,“java”,“c++”
排序：table.sort(mytable) – 按ASCII排序

#：

tab[1] = 2
tab[2] = 9
tab[4] = 10
print(#tab) -- 4

返回最大key索引的数值（key为字符不行）

元表

mytable = setmetatable(mytable, mymetatable) – mymetatable:元表
1. __index : 访问的索引不存在
例： mytable = {key1 = “one”}
mymetatable.__index = {key2 = “two”}
setmetatable(mytable, mymetatable)
2. __newindex: 添加新索引
3. __add: mytable+newtable
4. __call: 把表当做函数用
例：mymetatable = {
__call = function(tab, arg1, arg2)
end
}
mytable(12, 23)

实现继承

Parent = {}  
Parent.__index = Parent
function Parent.new()
    local self = {}
    setmetatable(self, Parent)
    return self
end`

lua闭包特性

1. 函数内部可定义函数，内层函数可访问到外层函数定义的局部变量
2. 外部函数的局部变量的状态会被闭包函数保持住
3. 函数可被赋值给另一变量，作为函数参数传递或作为函数返回值返回

lua弱引用

llua的垃圾回收器没有循环引用的问题

testa = {}
key = {}
mt = {__mode = 'k'}
setmetatable(testa, mt)

key1 = {name = "key1"};
t[key1] = 1;
key1 = nil;


-- 又使用一个table作为t的key值
key2 = {name = "key2"};
t[key2] = 1;
key2 = nil;
   
-- 强制进行一次垃圾收集,这个table里的字段被删除
collectgarbage();

local mt = {__mode = 'v'}
testa[key] = nil -- 这块内存就会被回收

local mt = {__mode = 'kv'}
-- 上述两种方式都会被回收