这一部分应该挺重要的，Lua中唯一的数据结构便是table，几乎所有的的数据操作都是在table的基础上进行。而本文提到的元表和元方法，便是帮助table实现更强大的功能而设计的。
日期：2014.7.11
Part Ⅱ
Metatables and Metamethods
Lua中不能直接对table进行相加、比较等操作。除非使用元表(Metatables)。元表可以使得我们改变元素在处理未定义操作的应对行为，如定义两个table直接的相加操作。Lua在处理两个table的相加操作时会首先检查两个table是否有元表，且元表中是否有 __add 元方法字段，如果有这个字段则lua会遵循这个字段内定义的操作执行两个table的相加操作。
Lua中各个类似的变量有一个相关联的元表？(到底有没有？)，而table与userdata有各自独立的元表。默认的，新创建的table是没有元表的：
e.g.
t = {}
print(getmetatable(t)) --nil
此时我们可以通过setmetatable方法来设置元表，元表其实也相当于一个table
e.g.
t1 = {}
setmetatable(t,t1)
print(getmetatable(t) == t1) --ture
当然，在lua中我们只可以对table执行setmetatable操作，对其余类型的变量执行这个操作需要使用C 代码。书上string库涉及到了给string类型变量执行设置元表的操作。其余类型的变量默认是没有元表的？
print(getmetatable("ss")) -- table
print(getmetatable(10)) --nil
Arithmetic Metamethods
算术运算元方法
这里介绍元表的使用,在这里用一个table表示set，我们需要运算set的并集等操作
e.g.
Set = {}
local mt = {} --metatable for sets
function Set.new(l) --新建一个set，初始化并且设置其元表
local set = {}
setmetatable(set,mt)
for _ v in ipairs(l) do set[v] = true end
return set
end
这样每次我们新建一个set其都会有同样的元表：
s1 = Set.new{10,20,11,13}
s2 = Set.new{30,1}
print(getmetatable(s1)) --table: 0x7fa1eb4093a0
print(getmetatable(s2)) --table: 0x7fa1eb4093a0
给元表添加元方法：__add 字段表示table如果执行相加操作
mt.__add = Set.union --注意此时的 __add 字段还是不能使用的，因为Set.union 还未定义,而且这段代码也需要放在定义Set.union之后，否则会报错。正确的用法是先定义再赋值
--假若mt.__add = Set.union
--定义Set.union
function Set.union( a,b )
local res = Set.new{}
for k in pairs(a) do
res[k] = true
end
for k in pairs(b) do
res[k] = true
end
return res
end
--此时
s3 = s1 + s2 会报错 --attempt to perform arithmetic on global 's1' (a table value)
--需要将mt.__add = Set.union 放置在定义Set.union之后。
同样的，设置 __mul 元方法也是类似的要求
--定义 Set.intersection
function Set.intersection( a,b )
local res = Set.new{}
for k in pairs(a) do
res[k] = b[k]
end
return res
end
mt.__mul = Set.intersection
所有的算术运算元方法：
__add(加)、__mul(乘)、__sub(减)、__div(除)、__unm(负)、__mod(取模)、__pow(取幂)、__concat(连接)
Lua在处理两个变量的算术运算时，针对不同类型的变量，如
e.g.
s = Set.new {1,2,3}
s = s + 8
此时运行的话会报错：
--bad argument #1 to 'pairs' (table expected, got number)
其处理两个变量的算术运算遵循的步骤是：如果第一个变量定义了元方法则使用第一个变量的元方法，而不会再考虑第二个元素的元方法；第一个没有而第二个有，则使用第二个的；否则就会报错。
因此为了更好的控制程序运行，我们需要限制两个变量为同类型拥有同一个元表，以__add为例，可以如下操作：
function Set.union( a,b )
if getmetatable(a) ~= mt or getmetatable(b) ~= mt then
error("xxx",2) --注意这里的参数是2，表示是提醒用户是传递的参数有问题
local res = Set.new{}
for k in pairs(a) do
res[k] = true
end
for k in pairs(b) do
res[k] = true
end
return res
end
Relational Metamethods
关系运算元方法
Lua中的关系运算元方法主要有：
__eq(相等)、__lt(小于)、__le(小于或等于)。而对于其他的关系操作符，Lua直接做了转换：a ~= b 相当于 not (a == b) 、a > b 相当于 b < a、a >= b 相当于 b <= a;
关系运算元方法的具体使用类似于上文提到的算术运算元方法;
要注意的是，当两个变量的元方法不同的时候执行相等关系运算会返回false;
Library-Defined Metamethods
库定义的元方法
__tostring 元方法
当调用tostring函数的时候，函数首先会寻找变量是否有__tostring 元方法：
同上文：
s = Set.new{1,2,2}
print(s) --table: 0x7f8349403d30
print(getmetatable(s)) --table: 0x7f8349409fd0
此时打印出来的并不是其值，但也不是其元表
--to string
function Set.tostring( set )
local l = {}
for e in pairs(set) do
l[#l + 1] = e
end
return "{" .. table.concat(l," , ") .. "}"
end
mt.__tostring = Set.tostring
print(s) --{1,2,2}
在设置了其元方法之后，才会正确的打印出其值
当然我们可以通过一定的方法来保护我们的元表，setmetatabe和getmetatable也是使用到了元方法，我们可以根据这一特性达到我们的目的：
e.g.
mt.__metatable = "cannot change"
s1 = Set.new{}
print(getmetatable(s1)) --cannot change
而当我们想改变其元表的时候
e.g. setmetatable(s1,mt) --error:cannot change a protected metatable
会报错，不能修改其元表，这样就达到了我们要保护元表的目的
Table-Access Metamethods
Lua允许通过元表来控制修改和访问table中不存在的元素的行为
The __index metamehod
当我们试图访问一个table中不存在的元素时，我们得到的值将会是nil。这是一般意义上将的，事实上，我们访问table中不存在的元素的时候，会触发编译器寻找__index 元方法，当没有该方法的时候会返回nil；而当该元方法存在被定义了，将会返回该方法定义的操作。
这一个特性对我们使用继承机制，继承默认变量的时候有很大的帮助，书上也是以这个为例子做了讲解：
--有默认变量的table
prototype = {x = 0,y = 0,width = 100,height = 100}
--元表
mt = {}
--构造函数
function new(o)
setmetatable(o,mt)
return o
end
--定义元方法
mt.__index = function(_,key)
return prototype[key]
end
--创建一个新的table，使用继承机制,需要技能默认变量的table
w = new{x = 10,y = 20}
print(w.width) --100
此时w使用到了prototype里面的值
__index 元方法不一定需要是一个函数，也可以是一个table。当该方法是一个函数的是，Lua会执行函数里定义的操作，当是一个table的时候，Lua直接在table中执行访问操作。
函数 rawget(t,i) 可以使得我们访问table各个元素的时候不去调用 __index 操作.将会对t执行raw访问？啥意思
The __newindex metamethod
该元方法的作用表现在更新table中元素值的时候。当我们试图给table中不存在的键赋值的时候，编译器会寻找 __newindex 的元方法，如果有编译器将会执行该方法定义的操作，否则就会直接赋值。这里也有一个函数 rawset(t,k,v)，该函数会绕开元方法，直接在t中对键k设置值v。
书中提到，有效的结合__index 和 __newindex 两个元方法的使用将会带来很强大的设计技巧,如创建只读table，带默认值的table等。
Tables with default values
table带有默认的值，其原理主要是在我们访问一个table中不存在或者没有赋值的键的时候，返回值是一个固定值，这里就涉及到了 __index 元方法
e.g.
function setDefault( t,d )
local mt = {__index = function ( ... )
return d
end}
setmetatable(t,mt)
end
tab = {x = 10,y = 20}
print(tab.x,tab.z) --10,nil
setDefault(tab,0)
print(tab.x,tab.z) --10,0
以上操作就为tab设置了默认值0，如果试图访问tab中没有定义或者不存在的元素，返回值将会是0
为多个不同的table执行设置多个不同默认值的操作
e.g.
local mt = {__index = function (t) return t.___ end}
function setDefault (t,d)
t.___ = d
setmetatable(t,mt)
end
这里的技巧在于，元表的定义在函数的外部，且将默认值存储在了要设置默认值的table本身的内部。
避免命名冲突的操作:
e.g.
local key = {} --以一个table作为key
local mt = {__index = function (t) return t[key] end}
function setDefault (t,d)
t[key] = d
setmetatable(t,mt)
end
Tracking table accesses
有效的使用__index 和 __newindex 可以帮助我们监控对table的访问和赋值操作。结合使用 proxy (代理) 便可以追踪所有对table的访问操作并且追踪到其访问的值。书上提到的只有当table为空的时候才能捕获到所有对其的访问操作，为啥？
t = {} --original table
--keep a private access to the original table
local _t = t
--create proxy 代理
t = {}
--create metatable
local mt = {
__index = function ( t,k )
print("*access to element " .. tostring(k))
return _t[k]
end,
__newindex = function ( t,k,v )
print("*update of element " .. tostring(k) .. " to " .. tostring(v))
_t[k] = v --update original table
end
}
setmetatable(t,mt)
t[2] = "hello"
print(t[2])
打印出来的，追踪了table从赋值到访问的过程
*update of element 2 to hello *access to element 2 hello
Read-only tables
只读table
只读table的原理主要就是在试图给table赋值的时候做限制，这里就涉及到了__newindex 元方法的使用。
e.g.
--read only table
function readOnly (t)
local proxy = {}
local mt = {
__index = t,
__newindex = function (t,k,v)
error("attempt to update a read-only table",2) --在试图改变元素的时候抛出错误，且参数为2，表示在报错的地方将会是调用该方法的地方。
end
}
setmetatable(proxy,mt)
return proxy
end
通过在__newindex元方法里面做恰当的修改，便能将我们的table改写为只读table。