深度理解Lua中的table
Lua的table是个很有意思的东西。有些内容平时写代码的时候很少接触到，但是了解一下还是很有意思的。
这篇blog参考MetatableEvents，一个一个边写测试边细说。
__newindex
原文翻译：
__newindex用于分配属性，当调用 myTable[key]=value时，如果元表中有__newindex并且指向一个function，就会调用这个function，传入的参数为table, key 和 value
- 用
rawset(myTable, key, value)可以跳过这个元方法直接给myTable的key属性赋值为value。 - 如果
__newindex指向的方法中，没有调用rawset方法，传入的键值对（key/value）就不会添加到myTable中。
测试代码：
local meta = {
__newindex = function(t, key, value)
print("call __newindex",t, key, value)
end
}
local test = {}
setmetatable(test, meta)
print("test", test)
print("meta", meta)
test.name = "t1"
test.name = "t2"
print("test.name", test.name)
---- result output ----
test table: 0x7f9c13406f00
meta table: 0x7f9c13407240
call __newindex table: 0x7f9c13406f00 name t1
call __newindex table: 0x7f9c13406f00 name t2
test.name nil
测试代码中，当给t的name的赋值时，就会触发元表中的__newindex指向的function，打印的信息可以看到key和value的值。
__newindex方法中传进来的参数t的指针和test的指针指向同一个地址，说明__newindex中的参数t，并不是元表。
测试代码中对t.name连续赋值时，__newindex会连续调用，需要留意一下这里，后面的测试会跟这里做一个对比。
赋值之后打印 t.name 的值是空的。原因是__newindex并没有给t.name赋值，我们用一个错误的方式给t.name赋值，来加深__newindex的理解。修改一下测试代码：
报错信息，栈溢出。因为t[key] = value这段代码会调用t元表中的__newindex的方法，__newindex的方法又会调用t[key] = value，这样就进入了死循环，导致栈溢出。这时就需要用到方法rawset。
修改测试代码：
local meta = {
__newindex = function(t, key, value)
print("call __newindex",t, key, value)
rawset(t, key, value)
end
}
local test = {}
setmetatable(test, meta)
test.name = "t1"
test.name = "t2"
print("test.name", test.name)
---- result output ----
call __newindex table: 0x7fdade404e20 name t1
test.name t2
这段代码中信息比较多
在__newindex中使用了rawset方法，可以看到，没有栈溢出的错误了，说明用rawset给table赋值，不会进入__newindex
的方法。
给t.name连续赋值，会发现只进入__newindex一次，跟之前不同的是，我们在__newindex给t.name赋了值。如果t中没有这个key时，才会进入__newindex方法。否则不会进入。
__newindex的默认值就是上面meta.__newindex的代码。如果不需要额外处理，完全可以不写。如下：
__index
翻译原文
__index用于控制属性（prototype）的继承，当访问 myTable[key] 时，如果myTable中不存在这个key，但是如果元表（metatable）中有 __index时：
- 如果
__index是一个function，传递的参数是table和key,function的返回值作为结果返回。 - 如果
__index是一个table，就返回这个表中key对应的值。- 如果这个
table不存在该key，但是这个table有元表，会继续寻找元表中的__index属性，以此类推。都没有就返回nil
- 如果这个
- 使用 “rawget(myTable,key)” 可以跳过这个元方法（__index）.
写点测试：
local test = {}
local meta = {
__index = function(t, k)
print("__index", k)
if rawget(t, k) == nil then
print("Can't find "… k)
end
return rawget(t, k)
end,
}
setmetatable(test, meta)
print("test.name1", test.name)
test.name = "hello"
print("test.name2", test.name)
---- result output ----
__index name
Can't find name
test.name1 nil
test.name2 hello
__newindex和__index其实可以类比成setter和getter，这么类比会比较容易理解，但是实际上还是有比较大的区别。
上面的测试中__index是个function。当执行test.name时，如果test.name是nil，会调用__index的function，并返回function的返回值。否则，直接返回test[key]，不会进入__index。
再做一个测试，这次__index是个table
这个测试可以看到，访问顺序是先访问test的name，如果没有值，再访问test元表中__index的table。如果test的元表还有元表，会继续向上访问，Lua继承的实现就是利用这个特性。
掌握__newindex和__index这两个元方法，可以把这两个元方法看做两个事件，那要就要清楚两个方法的触发条件和特性。才能融会贯通。
举个例子：
禁用全局变量
local meta = {
__newindex = function(t, k, v)
print("Error! Can't set globle variable", k)
end,
-- 默认实现
-- __index = function(t, k)
-- return rawget(t, k)
-- end
}
setmetatable(_G, meta)
test = "test"
print(test)
---- result output ----
Error! Can't set globle variable test
nil
__mode
原文翻译:
控制弱引用，用字符k和v来代表table的键和值是否是弱引用。这个感觉没什么好说的，只写个测试就好了。
local meta = {__mode = "k"}
local test = {}
setmetatable(test, meta)
key = {}
test[key] = 1
key = {}
test[key] = 2
for k,v in pairs(test) do
print(v)
end
collectgarbage()
print("collectgarbage")
for k,v in pairs(test) do
print(v)
end
---- result output ----
1
2
collectgarbage
2
例子中当调用collectgarbage()进行回收后，test表中只剩下一个值。弱引用的key被清理了。我们也可以在__mode中设置v,kv来表示值 键和值都是弱引用。
__call
原文翻译:
把table当做一个function使用，当table后跟一个圆括号时，而且table的元表中的__call指向一个function，就会调用这个function，table自己做为第一个参数，后面可接任意数量的参数，返回值就是function的返回值。
测试代码来模拟实现一个构造方法。
local meta = {
__call = function(t, ...)
local instance = {}
for k, v in pairs(t) do
instance[k] = v
end
return instance
end
}
local A = setmetatable({}, meta)
function A:info()
print("info",self)
end
local a = A()
local b = A()
a:info()
b:info()
---- result output ----
info table: 0x7f8771e05030
info table: 0x7f8771e050a0
__metatable
原文翻译：
隐藏真正的元表，当调用getmetatable时，而且table的元表有__metatable字段，则返回__metatable字段中的值。
测试代码：
local meta = {
name = "meta"
}
local test = setmetatable({}, meta)
print(getmetatable(test).name)
local meta = {
__metatable = {name = "__metatable"},
name = "meta"
}
local test = setmetatable({}, meta)
print(getmetatable(test).name)
---- result output ----
meta
__metatable
结果很直观不解释了，我另外还做了个的测试，让__metatable指向了一个function，调用getmetatable时也会返回这个function。很有意思，但是暂时没想到有什么应用场景。
__tostring
原文翻译：
控制字符串的表现，当调用tostring(myTable)时，且myTable的元表中有__tostring字段时，就会调用这个方法。返回值是方法的返回值。
测试代码：
local meta = {
__tostring = function(t)
return string.format("My name is %s", t.name)
end
}
local test = setmetatable({}, meta)
test.name = "test"
print(test)
print(tostring(test))
---- result output ----
My name is test
My name is test
这个也不做过多说明了，很容易理解。有一点提一下就是print方法会自动调用tostring(test)
__len
原文翻译：
控制table的长度。当用#操作符请求长度时，且table的元表有__len字段指向一个function，就会调用这个function，参数是table自己，返回值是function的返回值。
写个测试代码：
local meta = {
__len = function(t)
local result = 0
for k, v in pairs(t) do
result = result + 1
end
return result
end
}
local test = {
[1] = "A",
[2] = "B",
[3] = "C",
[5] = "D",
[6] = "E",
[8] = "F",
}
print(#test)
setmetatable(test, meta)
print(#test)
---- result output ----
3
6
Lua中使用#获取长度有个特性，就是如果某个key对应的值是nil就结束，上面例子中，test第4个值是nil，那返回的长度为3。我们重新定义了__len后返回了，用遍历的方式计算长度，返回table内元素的数量为6。
__gc
原文翻译：
简单说就是数据被垃圾回收的时候会首先触发__gc。
测试代码：
local meta = {
__gc = function(t)
print("gc")
end
}
local function test()
local test = {}
setmetatable(test, meta)
end
test()
---- result output ----
gc
Lua table中所有的元方法就分析完了，还有一些操作符重载的，之后再写。
