首页 > 代码库 > lua metatable和metamethod元表和元方法

lua metatable和metamethod元表和元方法

  Lua中提供的元表是用于帮助Lua数据变量完成某些非预定义功能的个性化行为,如两个table的相加。假设a和b都是table,通过元表可以定义如何计算表达式a+b。当Lua试图将两个table相加时,它会先检查两者之一是否有元表,然后检查该元表中是否存在__add字段,如果有,就调用该字段对应的值。这个值就是所谓的“元方法”,这个函数用于计算table的和
    Lua中每个值都有一个元表。table和userdata可以有各自独立的元表,而其它数据类型的值则共享其类型所属的单一元表。缺省情况下,table在创建时没有元表,如:
    t = {}
    print(getmetatable(t))  --输出为nil
    这里我们可以使用setmetatable函数来设置或修改任何table的元表。
    t1 = {}
    setmetatable(t,t1)
    assert(getmetatable(t) == t1)
    任何table都可以作为任何值的元表,而一组相关的table也可以共享一个通用的元表,此元表将描述了它们共同的行为。一个table甚至可以作为它自己的元表,用于描述其特有的行为。在Lua代码中,只能设置table的元表,若要设置其它类型值的元表,则必须通过C代码来完成。

 

任何table都可以作为任何值的元表,而一组相关的table也可以共享一个通用的元表,此元表描述了他们共同的行为,一个table甚至可以作为他自己的元表,用于描述其特有的行为。总之,任何搭配形式都是合法的。

 

   在Lua代码中,只能设置table的元表,若要设置在其他类型的值的元表,则必须通过C代码来完成。在第20章中,将会看到标准的字符串程序库为所有的字符串都设置了一个元表,而其他类型在默认情况下都没有元表。

 


print(getmetatable("hi")) --table:0x80772e0
print(getmetatable(10)) --nil

 

1. 算术类的元方法:
    在下面的示例代码中,将用table来表示集合,并且有一些函数用来计算集合的并集和交集等。为了保持名称空间的整齐,则将这些函数存入一个名为Set的table中。

Set = {}local metatable = {} --元表--根据参数列表中的值创建一个新的集合function Set.new(l)    local set = {}    --将所有由该方法创建的集合的元表都指定到metatable    setmetatable(set,metatable)    for _, v in ipairs(l) do        set[v] = true    end    return setend--取两个集合并集的函数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 resend--取两个集合交集的函数,function Set.intersection(a,b)    local res = Set.new{}    for k in pairs(a) do        res[k] = b[k]    end    return resendfunction Set.tostring(set)    local l = {}    for e in pairs(set) do        l[#l + 1] = e    end    return "{" .. table.concat(l,", ") .. "}";endfunction Set.print(s)    print(Set.tostring(s))end--最后将元方法加入到元表中,这样当两个由Set.new方法创建出来的集合进行--加运算时,将被重定向到Set.union方法,乘法运算将被重定向到Set.intersectionmetatable.__add = Set.unionmetatable.__mul = Set.intersection--下面为测试代码s1 = Set.new{10,20,30,50}s2 = Set.new{30,1}s3 = s1 + s2Set.print(s3)Set.print(s3 * s1)--输出结果为:--{1, 30, 10, 50, 20}--{30, 10, 50, 20}

 在元表中,每种算术操作符都有对应的字段名,除了上述的__add(加法)和__mul(乘法)外,还有__sub(减法)、__div(除法)、__unm(相反数)、__mod(取模)和__pow(乘幂)。此外,还可以定义__concat字段,用于描述连接操作符的行为。

当2个集合相加时,可以使用任意一个集合的元表,然而,当一个表达式中混合了具有不同元表的值时,例如:
s=Set.new{1,2,3}
s=s+8
Lua会按照如下步骤来查找元表:如果第一个值有元表,并且元表中有__add字段,那么Lua就以这个字段为元方法,而与第二个值无关,反之,如果第二个值有元表并含有__add方法,Lua就以此字段为元方法,如果都没有,引发错误。因此,上例中会调用
Set.union,而表达式10+s和"hello"+s也是一样的。

然而对于上例中的Set.union函数,如果执行s1 = s1 + 8将会引发一个错误,因为8不是table对象,不能基于它执行pairs方法调用。为了得到更准确的错误信息,我们需要给Set.union函数做如下的修改,如:

function Set.union(a,b)    if getmetatable(a) ~= metatable or getmetatable(b) ~= metatable then        error("attempt to ‘add‘ a set with a non-set value")    end    --后面的代码与上例相同。    ... ...end

2. 关系类的元方法:
    元表还可以指定关系操作符的含义,元方法分别为__eq(等于)、__lt(小于)和__le(小于等于),至于另外3个关系操作符,Lua没有提供相关的元方法,可以通过前面3个关系运算符的取反获得。

a={1,2,5} b={1,2,4}

 

 

Set = {}local metatable = {}function Set.new(l)    local set = {}    setmetatable(set,metatable)    for _, v in ipairs(l) do        set[v] = true    end    return setendmetatable.__le = function(a,b)     for k in pairs(a) do        if not b[k] then return false end    end    return trueendmetatable.__lt = function(a,b) return a <= b and not (b <= a) endmetatable.__eq = function(a,b) return a <= b and b <= a end--下面是测试代码:s1 = Set.new{2,4}s2 = Set.new{4,10,2}print(s1 <= s2) --trueprint(s1 < s2)  --trueprint(s1 >= s1) --trueprint(s1 > s1)  --false

与算术类的原方法不同的是,关系类的元方法不能应用于混合的类型,对于混合类型而言,关系类元方法的行为就模拟这些操作符在Lua中普通的行为,如果试图将一个字符串与一个数字做顺序性比较,Lua会引发一个错误

等于比较永远不会引发错误,如果两个对象拥有不同的元方法,那么等于操作不会调用任何一个元方法,而是直接返回false,这种行为模拟了Lua的普通行为。在Lua的普通行为中,字符串总是不等于数字的,与他们的值无关。另外,只有当两个比较对象共享一个元方法时,Lua才会调用等于比较的元方法。

 

 3. 库定义的元方法:
    除了上述基于操作符的元方法外,Lua还提供了一些针对框架的元方法,如print函数总是调用tostring来格式化其输出。如果当前对象存在__tostring元方法时,tostring将用该元方法的返回值作为自己的返回值,如:

Set = {}local metatable = {}function Set.new(l)    local set = {}    setmetatable(set,metatable)    for _, v in ipairs(l) do        set[v] = true    end    return setendfunction Set.tostring(set)    local l = {}    for e in pairs(set) do        l[#l + 1] = e    end    return "{" .. table.concat(l,", ") .. "}";end metatable.__tostring = Set.tostring--下面是测试代码:s1 = Set.new{4,5,10}print(s1) --{5,10,4}

 

1 mt.__metatable = "not your business"
2 s1 = Set.new{}
3 print(getmetatable(s1)) --此时将打印"not your business"
4 setmetatable(s1,{}) --此时将输出错误信息:"cannot change protected metatable"

    从上述代码的输出结果即可看出,一旦设置了__metatable字段,getmetatable就会返回这个字段的值,而setmetatable将引发一个错误。

  4. table访问的元方法:
    算术类和关系类运算符的元方法都为各种错误情况定义了行为,它们不会改变语言的常规行为。但是Lua还提供了一种可以改变table行为的方法。有两种可以改变的table行为:查询table及修改table中不存在的字段

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

 

Window = {} Window.prototype = {x = 0, y = 0, width = 100, height = 100}Window.mt = {}  --Window的元表function Window.new(o)    setmetatable(o,Window.mt)    return oend--将Window的元方法__index指向一个匿名函数--匿名函数的参数table和key取自于table.key。Window.mt.__index = function(table,key) return Window.prototype[key] end--下面是测试代码:w = Window.new{x = 10, y = 20}print(w.width)   --输出100print(w.width1)  --由于Window.prototype变量中也不存在该字段,因此返回nil。

在Lua中,将__index元方法用于继承是很普遍的方法,因此Lua还提供了一种更健康的方式来是实现此功能.__index元方法不必一定是一个函数,他还可以是一个talbe。当他是一个函数时,lua以table和不存在的key作为参数来调用该函数,这就如同上述内容。而当它是一个table时,Lua就以相同的方式来重新访问这个table。因此前例中
__index的声明可以简单地写成:

如:Window.mt.__index = Window.prototype

现在,当Lua查找到元表的__index字段时,发现__index字段是一个table,那么Lua就会在Window.prototype中继续查找。

  将一个table作为__index元方法是一种快捷的、实现单一继承的方式。虽然将函数作为__index来实现相同功能的开销较大,但函数更加灵活。可以通过函数来实现多重继承、缓存及其他一些功能。

   如果想在访问table时禁用__index元方法,可以通过函数rawget(table,key)完成。通过该方法并不会加速table的访问效率。rawget(t,i)

就是访问原始的table中i.

   2). __newindex元方法:
    和__index不同的是,该元方法用于不存在键的赋值,而前者则用于访问。当对一个table中不存在的索引赋值时,解释器就会查找__newindex元方法。如果有就调用它,而不是直接赋值。如果这个元方法指向一个table,Lua将对此table赋值,而不是对原有的table赋值。此外,和__index一样,Lua也同样提供了避开元方法而直接操作当前table的函数rawset(table,key,value),其功能类似于rawget(table,key)。

    3). 具有默认值的table:
    缺省情况下,table的字段默认值为nil。但是我们可以通过元表修改这个默认值,如:

function setDefault(table,default)    local mt = {__index = function() return default end }    setmetatable(table,mt)endtab = {x = 10, y = 20}print(tab.x,tab.z)  --10    nilsetDefault(tab,0)print(tab.x,tab.z)  --10    0

更详细看programmign in lua;

 

4). 跟踪table的访问:
    __index和__newindex都是在table中没有所需访问的index时才发挥作用的。因此,为了监控某个table的访问状况,我们可以为其提供一个空table作为代理,之后再将__index和__newindex元方法重定向到原来的table上,见如下代码:

t = {}        --原来的tablelocal _t = t  --保持对原有table的私有访问。t = {}        --创建代理
--
创建元表local mt = { __index = function(table,key) print("access to element " .. tostring(key)) return _t[key] --通过访问原来的表返回字段值 end, __newindex = function(table,key,value) print("update of element " .. tostring(key) .. " to " .. tostring(value)) _t[key] = value --更新原来的table end}setmetatable(t,mt)t[2] = "hello"print(t[2])--输出结果为--update of element 2 to hello--access to element 2--hello

5). 只读的table:
    通过代理的概念,可以很容易的实现只读table。只需跟踪所有对table的更新操作,并引发一个错误即可,

由于无需跟踪查询访问,所以对于__index元方法可以使用使用元table来代替函数,这也更简单,并且在重定向所有查询到元table时效率也更高。不过,这种做法要求为每个只读代理创建一个新的元表,其中__index指向原来的table。

function readOnly(t)    local proxy = {} --我们在创建创建了一个保护代理,当调用readOnly函数时,返回的是保护代理。    local mt = {        __index = t,        __newindex = function(t,k,v)            error("attempt to update a read-only table")        end    }    setmetatable(proxy,mt)    return proxyenddays = readOnly{"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}print(days[1])days[2] = "Noday"--输出结果为:--[[Sundaylua: d:/test.lua:6: attempt to update a read-only tablestack traceback:        [C]: in function ‘error‘        d:/test.lua:6: in function <d:/test.lua:5>        d:/test.lua:15: in main chunk        [C]: ?]]--

下面转自:programming in lua