Lua 元表(metatable)与元方法(metamethod)

note 目录

  • 元表(metatable)和元方法(metamethod)
  • 算术类的元方法
  • 关系类的元方法
  • 库定义的元方法

- table访问的元方法

1:元表(metatable)和元方法(metamethod)

1.1 元表的作用

可以通过元表来修改一个值的行为,使其在面对一个非预定义的操作时,执行一个指定的操作。
例如:
假设ab都是table
通过元表可以定义如何计算a+b

当Lua试图将2个table相加时,先进行3个步骤
第一步:它会先检查两者(ab)之一是否有元表。
第二步:然后检查该元表中是否有一个叫__add的字段。
第三步:如果有这个字段,就调用该字段对应的值(这个值也就是所谓的“元方法”,它是一个函数)。

可以看到元表的作用类似于C++的操作符重载。如上面的我们可以重载__add 元方法,来计算2个Lua数组的并集。
或者重载__index,来定义我们自己的Hash函数。

1.2 设置,获取元表

任何table可以作为任何值的元表,而一组相关的 table也可以共享一个通用的元表,此表描述了它们的共同行为。
一个table也可以作为他自己的元表,用于描述其特有的行为。

表和完全用户数据有独立的元表 (当然,多个表和用户数据可以共享同一个元表)。 其它类型的值按类型共享元表; 也就是说所有的数字都共享同一个元表, 所有的字符串共享另一个元表等等。 默认情况下,值是没有元表的, 但字符串库在初始化的时候为字符串类型设置了元表

在Lua中使用setmetatable来设置或修改任何table的元表。

使用 getmetatable来获取元表。

t = {}
t1 = {}
setmetatable(t,t1)
assert(getmetatable(t) == t1)    ---> true

1.3 元表的定义

元表本身是一张普通的表,通过特定的方法setmetatable(),设置到某对象上。从而影响这张表的行为。
元表决定了一个对象在数学运算、位运算、比较、连接、 取长度、调用、索引时的行为。


2:算术类的元方法
2.1 所有的算术类的元方法

算术类的元方法在Lua中有如下方法可以重载:

元方法含义
__add+加法操作
__sub-减法操作
__mul*乘法操作
__div/除法操作
__unm-相反数
__mod%取模
__pow^乘幂
__concat..字符串的连接
2.2 重载__add,_mul的example
Set = {}
Set.mt = {}           --集合的元表

--根据表中的值创建一个新的集合
function Set.new(t)
   local set = {}
   setmetatable(set,Set.mt)
   for __,v in pairs(t) do
      set[v] = true
   end
   return set
end

--并集操作
function Set.union(a,b)
    local res = Set.new{}   --等效于Set.new({})

    for k in pairs(a) do
        res[k] = true
    end    

    for k pairs(b) do
        res[k] = true
    end

    return res

end

-- 交集操作
function Set.intersection(a,b)
    local res = Set.new({})
    for k in pairs(a) do
       res[k] = b[k]
    end
    return res
end

-- 打印集合的操作
function Set.tostring(t)
   local tb = {}
   for k in pairs(t) do
       tb[#tb + 1] = k
   end
   return "{" .. table.contat(tb,",") .. "}"
end

function Set.print(t)
    print(Set.tostring(t))
end

local s1 = Set.new({10,20,30,50})
local s2 = Set.new({30,1})

print(getmetatable(s1))    --->table:00672B60
print(getmetatable(s2))    --->table:00672B60 说明s1和s2有同一张元表

Set.mt.__add = Set.union   --重载元表的__add方法
Set.print(s1 + s2)         ---> output: {1,30,10,20,50}

Set.mt.__mul = Set.intersecton      --重载元表的乘法(交集)
Set.print((s1 + s2) * s1)  ---> output:{10,20,30,50}     (输出的顺序不定的因为pairs不是按索引)

上述只是写了__add,__mul方法的重载,除此之外,还有__sub,__div,__mod,__unm,__pow,__concat的可以重载。

2.3 选择metamethod(重载)的原则

当2个集合相加时,可以使用任意一个集合的元表。然而当一个表达式中混合了不同的元表的值时:

s = Set.new{1,2,3}
s = s + 8

Lua会按照如下步骤来查找元表:

第一先查找表达式的第一个值是否有元表,并且元表中有__add字段,那么Lua就可以以这个字段来作为元方法(重载方法),而与第二个值无关。

第二如果第一个值没有元表,或没有__add字段(元方法),则查找表达式的第二个值是否有元表并且是否有__add字段来作为元方法(重载函数)

如果表达式的2个值都没有元方法,则Lua会报错。

如果我们运行上面的s3=s1+8的例子在Set.union发生错误:

bad argument #1 to `pairs' (table expected, got number)
function Set.union(a, b) 
    if getmetatable(a) ~= Set.mt or getmetatable(b) ~= Set.mt then
        error("attempt to 'add' a set with a non-set value",2)
    end
    local res = Set.new{} --相当于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

3:关系类的元方法

元表还可以指定关系操作符的含义。元方法如下:

元方法含义
__eq等于
__le小于等于
__lt小于

对剩下的三个关系运算符没有专门的metamethod,因为Lua将a~= b转换为not (a == b);a > b转换为b < a;a >= b转换为 b <= a。

在我们关于集合操作的例子中,有类似的问题存在。<=代表集合的包含:a <= b表示集合a是集合b的子集。这种意义下,可能a<= b和b < a都是false;因此,我们需要将__le和__lt的实现分开:

--判断两个集合的包含关系(小于等于)--子集关系
Set.mt.__le = function (a,b)
    for k in pairs(a) do
        if not b[k] then
            return false
        end
    end
    return true
end

--判断两个集合是否为真子集关系
Set.mt.__lt = function(a,b)
    return a <= b and not (b <= a)
end

--判断两个集合是否相等
Set.mt.__eq = function(a,b)
    return a <= b and b <= a
end

local s1 = Set.new({2,4})
local s2 = Set.new({4,10,2})

print(s1 <= s2)      --output:true
print(s1 < s2)       --output:true
print(s1 >= s1)      --output:true
print(s1 > s1)       --output:false
print(s1 == s1* s2)  --output:true

与算术运算的metamethods不同,关系元算的metamethods不支持混合类型运算。对于混合类型比较运算的处理方法和Lua的公共行为类似。如果你试图比较一个字符串和一个数字,Lua将抛出错误。相似的,如果你试图比较两个带有不同metamethods的对象,Lua也将抛出错误。

但相等比较从来不会抛出错误,如果两个对象有不同的metamethod,比较的结果为false,甚至可能不会调用metamethod。这也是模仿了Lua的公共的行为,因为Lua总是认为字符串和数字是不等的,而不去判断它们的值。仅当两个有共同的metamethod的对象进行相等比较的时候,Lua才会调用对应的metamethod。


4:库定义的元方法
元方法含义
__tostring转换成字符串
__call当Lua调用一个值时调用
__mode用于弱表(weak table)
_metatable用于metatable不被访问

4.1 用于metatable不被访问

前面讲到的元方法都只针对于Lua的核心,也就是一个虚拟机,它会检测一个操作中的值是否有元表,这些元表中是否有元方法,从另一方面来说,元表也是一种常规的table,所以任何人,任何函数都可以使用他们。

假设想要保护集合的元表,是用户既不能看也不能修改集合的元表,那么就需要使用字段_metatable,当设置了该字段,getmetatable就会返回该字段,而setmetatable则会引发一个错误。

mt._metatable = "not your business"

s1 = Set.new{}
print(getmetatable(s1))      --> not your business
setmetatable(s1,{})

stdin:1:cannot change protected metatable

4.2 __call 当Lua调用一个值时调用

__call 元方法的功能类似于 C++ 中的仿函数,使得普通的表也可以当作函数来被调用。

functor = {}
function func1(self, arg)
  print ("called from", arg)
end

setmetatable(functor, {__call = func1})

functor("functor")  --> called from functor
print(functor)      --> output:0x00086ab0 

5:table访问的元方法

Lua在table的元方法:

元方法含义
__index取下表操作table[key]
__newindex赋值给指定下表table[key] = value

在Lua中提供了可以改变table行为的方法。
有2种方法可以改变table的行为:

(1)查询table

(2)修改table中不存在的字段

5.1 __index 取下表操作table[key]

当访问一个table中不存在的字段时,得到的结果是nil,这是对的,但并非完全正确。实际上,这些访问会促使解释器去查找一个叫__index的元方法。如果没有这个元方法,那么访问结果就是nil,否则,就由这个元方法提供最终结果。

Window = {}      --创建一个名字空间
Window.prototype = {x = 0,y = 0,width = 100,height = 100}
Window.mt = {}          --创建元表
function Window.new(o)  --声明构造函数
   setmetatable(o,Window.mt)
   return o
end

-- 现在来定义__index元方法:
Window.mt.__index = function(table , key)
    return Window.prototype[key]
end

--创建一个新的窗口,并查询一个它没有的字段:

w = Window.new({x = 10,y = 20})
print(w.width)             ---> output:100

Lua中检测到W中你又这个字段,但在其元表中却有一个__index 字段,那么Lua中就会以w(table)和”width”(不存在的key)来调用这个__index 方法。

在Lua中,将__index元方法用于继承是很普遍的方法。
__index元方法不一定是一个函数,他还可以是一个table。当它是一个函数时,Lua以table和不存在的key作为参数来调用这个函数,当它作为一个table的时候,Lua会以相同的方式重新访问这个table。因此上面可以简单地写为:

Window.mt__index = Window.prototype

【rawget】
如果不想在访问一个table时涉及到它的__index元方法,可以使用函数rawget
调用rawget(t,i)就是对table t进行了一个“原始的(raw)”访问,也就是一次不考虑元表的简单访问。
依次原始的访问并不会加速代码执行,但有时间会用到。

5.2 __newindex 赋值给指定下表table[key] = value

__newindex元方法与__index类似,不同之处在于__newindex用于table的更新,而__index用于table查找,相对于一个table中不存在的索引赋值时,解释器就会查找__newindex元方法。
如果有这个元方法,解释器就会调用它,而不是去执行赋值,如果这个元方法是一个table,解释器就在这个table中执行赋值,而不是原来的table

【rawset函数】
在Lua中有一个原始方法:

rawset(t,k,v)

就是不涉及任何元方法而直接设置table t中与key k相关两的value v

5.3 具有默认值的table

常规的table中任何字段默认都是nil,通过元表可以很容易的设置这个默认值:

function setDefault(t,d)
    local mt = {__index = function() return d end}
    setmetatable(t,mt)
end    

tab = {x = 10,y = 10}
print(tab.x,tab.z)       -->10 nil
setDefault(tab,0)
print(tab.x,tab,z)       -->10 0

在调用setDefault后,任何对tab中存在字段的访问都会创建一个新的元表。如果准备创建很多需要默认值的table,这种方法的开销就会很大。有2种方案可以解决这个问题:
(1)不担心命名冲突的话,可以使用”_ _ _”这样的key来作为额外的字段。

local mt = {__index = function(t) rturn t.___ end}
function setDefault(t,d)
   t.___ = d
   setmetatable(t,mt)
end   

(2)如果担心名字冲突,那么要确保这个特殊的key的唯一性也很容易,只需要创建一个新的table并用它作为key即可。

local key = {}
local mt = {__index = function(t) return t[key] end}
function setDefault(t,d)
    t[key] = d
    setmetatable(t,mt)
end
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值