【Lua学习笔记】Lua进阶——Table(3) 元表

【Lua学习笔记】Lua进阶——Table(3) 元表_第1张图片
接上文

文章目录

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


元表

Q:为什么要使用元表?

A:在Lua中,常常会需要表与表之间的操作。元表中提供了一些元方法,通过自定义元方法可以实现想要的功能,相当于面向对象中给你一系列方法让你重载。

使用下列代码设置元表:

meta={}
table={}
setmetatable(table,meta) -- 第一个元素为子表,第二个元素为元表

通常在元表中操作分为三步:

  1. 操作子表
  2. 检测是否有元表
  3. 若有元表,检测有无对应元方法,没有元方法则返回对应操作本来的处理。若有对应元方法执行元方法。

元方法索引一般以"__"(两个下划线,我想这是因为命名私有静态变量常常以一个下划线作为开头)作为开头,例如下面的例子:

__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

整个查找的流程其实是:

  1. 查询子表
  2. 子表查询失败,查询元表有无 __index元方法
  3. 若有,则查询 __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

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,即使table1table2内容不同。因为这是我们自定义的元方法,我们默认返回的就是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

你可能感兴趣的:(Lua学习笔记,lua,学习,笔记)