接上文
元表
Q：为什么要使用元表？
A：在Lua中，常常会需要表与表之间的操作。元表中提供了一些元方法，通过自定义元方法可以实现想要的功能，相当于面向对象中给你一系列方法让你重载。
使用下列代码设置元表：
meta={
}
table={
}
setmetatable(table,meta) -- 第一个元素为子表，第二个元素为元表
通常在元表中操作分为三步：
- 操作子表
- 检测是否有元表
- 若有元表，检测有无对应元方法，没有元方法则返回对应操作本来的处理。若有对应元方法执行元方法。
元方法索引一般以"__"（两个下划线，我想这是因为命名私有静态变量常常以一个下划线作为开头）作为开头，例如下面的例子:
__tostring
meta = {
}
table={
}
setmetatable(table, meta)
print(table)
输出：
table: 00ABA2A8
meta = {
__tostring = function () <--注意两个下划线
return "123"
end
}
table={
}
setmetatable(table, meta)
print(table)
输出：
123
上例相当于使用元方法重载print函数
meta = {
__tostring = function (t)
return t.name
end
}
table={
name = "233"}
setmetatable(table, meta)
print(table)
输出：
233
在上例中，即使我们未指定元方法的入参，但是因为子表和元表的关联，元方法会自动地将子表作为参数传入元方法。
__call
让我们再定义一个__call元方法
meta = {
__tostring = function ()
return "456"
end,
__call = function(a)
print(a.name)
print(a)
print("call")
end
}
table={
name = "123"}
setmetatable(table, meta)
table(2) --无论table(x)中给出的x为几，结果都是一样的
输出：
123
456
call
定义了__call元方法后，我们使用table(index)，发现__call元方法打印了123，456和call,123是子表的元素，而456是__tostring的返回结果。这意味着__call方法调用了子表作为入参a。并且像我们上面的打印样例一样，print(a)方法又同时会调用__tostring的元方法。而table(2)中的参数2很明显被无视了。
现在我们可以确定一个基本规则：当使用__tostring和__call元方法时，我们定义的第一个参数一定是子表table本身，只有定义更多参数才能接收其它入参：
meta = {
__tostring = function ()
return "456"
end,
__call = function(a,b)
print(a)
print(b)
print("call")
end
}
table={
name = "123"}
setmetatable(table, meta)
table(2)
输出：
456
2
call
__index
meta = {
}
table1 = {
age = 1 }
setmetatable(table1, meta)
print(table1.name)
输出:
nil
我们想要找到表中的name索引，当然是没有的，输出结果是nil
那能不能让元表拥有这个索引呢？答案是不行，因为找的还是table1：
meta = {
name =1}
table1 = {
age = 1 }
setmetatable(table1, meta)
print(table1.name)
输出:
nil
现在我们定义一个元方法 __index，它会指向一个其他的查询表
meta = {
name = 2 }
meta.__index = meta
table1 = {
age = 1 }
setmetatable(table1, meta)
print(table1.name)
输出：
2
整个查找的流程其实是：
- 查询子表
- 子表查询失败，查询元表有无
__index元方法 - 若有，则查询
__index元方法指向的表
但是还有种情况，建议不要把__index元方法在元表内部定义：
meta = {
name = 2,
__index = meta,
}
table1 = {
age = 1 }
setmetatable(table1, meta)
print(table1.name)
输出：
nil --不明觉厉
还可以套娃
meta = {
}
metaFather = {
name =4,
}
table1 ={
age =1}
meta.__index = meta --让元表的index指向meta，子表找不到就去meta里找
metaFather.__index =metaFather --让元表的index指向metaFather，子表找不到就去metaFather里找
setmetatable(meta,metaFather)
setmetatable(table1, meta)
print(table1.name)
输出：i
4 --允许套娃
__newindex
看4个例子：
meta = {
}
table1 ={
}
table1.age = 1
setmetatable(table1, meta)
print(table1.age)
输出：
1
meta = {
}
table1 ={
age = 1}
meta.__newindex = {
}
setmetatable(table1, meta)
print(table1.age)
输出：
1
meta = {
}
table1 ={
}
meta.__newindex = {
}
setmetatable(table1, meta)
table1.age = 1
print(table1.age)
输出：
nil
meta = {
}
table1 ={
}
meta.__newindex = {
}
table1.age = 1
setmetatable(table1, meta)
print(table1.age)
输出：
1
有没有很诡异？其实很好理解，这是由于__newindex元方法，它的作用其实是将子表新加入的元素加入到__newindex所指向的表而不修改子表（当然__newindex也可以套娃）：
meta = {
}
table1 ={
}
meta.__newindex = {
}
setmetatable(table1, meta)
table1.age =1
print(table1.age)
print(meta.__newindex.age)
输出：
nil
1
运算符元方法
meta = {
__sub = function (t1,t2)
return t1.age - t2.age
end
}
table1={
age=1}
table2={
age=2}
setmetatable(table1, meta) --无论把元表设置给table1还是table2，结果都一样
print(table1 - table2)
输出：
-1
我们发现使用运算符元方法的时候，第一个参数也不默认是绑定的子表了。而是根据运算符的左右变量依次给元方法赋值。而且无论元表设置给减数还是被减数，最终结果都是不变的。运算符元方法较多，这里就不详细列举了，从菜鸟教程上直接抄了个表格：
| 元方法 | 描述 |
|---|---|
| __add | 对应的运算符 ‘+’ |
| __sub | 对应的运算符 ‘-’ |
| __mul | 对应的运算符 ‘*’ |
| __div | 对应的运算符 ‘/’ |
| __mod | 对应的运算符 ‘%’ |
| __unm | 对应的运算符 ‘-’ |
| __concat | 对应的运算符 ‘..’ |
| __pow | 对应的运算符 ‘^’ |
| __eq | 对应的运算符 ‘==’ |
| __lt | 对应的运算符 ‘<’ |
| __le | 对应的运算符 ‘<=’ |
在这之中除了正常的数学运算，我们还需要讲一下比较特殊的逻辑判断的元方法（就是上表中加粗的几列），这几个元方法需要运算符的双方都绑定同一个元表。原因是元方法没有提供大于符号，运算a>b的元方法其实相当于运算b<a的原方法，这就需要b也绑定元表，因此逻辑运算硬性要求运算双方都绑定同一个元表，让我们看看下列的例子：
meta = {
__eq= function (t1,t2)
return true
end,
}
table1 = {
age = 1 }
table2 = {
name = nil }
setmetatable(table1, meta)
print(table1 == table2)
setmetatable(table2, meta)
print(table1 == table2)
输出：
false
true
我们可以发现上述的相等的逻辑判断是有问题的，第一个print出false，第二个print出true。
在第一个print的时候，只有table1绑定了元表，而table2没有，之所以return false是因为在逻辑运算的时候需要左右双方都绑定同一个元表。
而在第二个print的时候打印了true，即使table1和table2内容不同。因为这是我们自定义的元方法，我们默认返回的就是true。
几道例题，请思考下列几个例子的输出结果：
meta = {
__eq= function (t1,t2)
if t1.age == t2.age then
return true
end
end,
}
table1 = {
age = 1 }
table2 = {
age = 2 }
setmetatable(table1, meta)
setmetatable(table2, meta)
print(table1 == table2)
输出：
false
上述例子中，我们用__eq元方法来判断age索引值是否相同，显然是不同的，因此是false
meta = {
__eq= function (t1,t2)
if t1.name == t2.name then
return true
end
end,
}
table1 = {
age = 1 }
table2 = {
name = nil }
setmetatable(table1, meta)
setmetatable(table2, meta)
print(table1 == table2)
输出：
true
上述例子中，我们用元方法判断name索引值是否相同，而table1没有name索引，默认为nil，table2有name = nil，因此是true
meta = {
__eq= function (t1,t2)
if t1 == t2 then
return true
end
end,
}
table1 = {
age = 1 }
table2 = {
name = nil }
setmetatable(table1, meta)
setmetatable(table2, meta)
print(table1 == table2)
输出：
栈溢出
上述例子中，我们在元方法内部判断t1==t2，而进行判断时相当于再次调用了__eq元方法，因此会无限循环最终导致栈溢出。
其它元表操作
print(getmetatable(table1)) --使用getmetatable方法获得table1的元表地址
输出：
table: 00BBA320
meta = {
name = 2 }
meta.__index = meta
table1 = {
age = 1 }
setmetatable(table1, meta)
print(rawget(table1,"nane")) --rawget方法只查询子表，无视元表index
输出：
nil
meta = {
}
table1 ={
}
meta.__newindex = {
}
setmetatable(table1, meta)
table1.age =1
print(table1.age)
rawset(table1, "age", 1) --rawset方法可以无视元表的newindex，直接修改子表
print(table1.age)
输出：
nil
1