在这里插入图片描述
接上文

文章目录

元表
- `__tostring`
- `__call`
- `__index`
- `__newindex`
- 运算符元方法
- 其它元表操作

元表

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