Metatable和Metamethod（转）

　　Metatable和Metamethod是用来干啥的？它们可以使得表a和b的表达式“a + b”变得有意义，其中metatable使两个不相关的表a和b之间可以进行操作，而操作的具体行为比如说"+"由metamethod来具体定义。

　　Metatable和Metamethod大多数地方都翻译成“元表”和“元函数”，这是一种直译，相当不直观。根据Metatable的用法，我倾向于将Metatable翻译成关联表，Metamethod翻译成关联函数。通过给两个table设置Metatable可以使两个table产生联系，然后对两个table进行一些操作，具体的操作行为由Metamethod来定义。下面的例子中，在对表t1和t2设置关联表mt，并在mt中定义关联函数__add后，就可以对这两个表进行"+"相加操作了。

t1 = {1, 2, 3}
t2 = {4,5,6,7,8}

mt = {}
mt.__add = function(a, b)
    local ret = 0
    for _, v in pairs(a) do
        ret = ret + v
    end
    for _, v in pairs(b) do
        ret = ret + v
    end
    return ret
end

setmetatable(t1, mt)
setmetatable(t2, mt)
print(t1 + t2)

从上面的代码中可以看到关联表就是一个表，而关联函数就是一个函数。当碰到表达式"t1+t2"时，Lua首先查找他们的关联表，找到关联表mt后，会在mt中找与相加操作对应的关联函数__add，找到__add后就将t1和t2作为参数来执行该函数，最后返回结果。

下面是一个使用关联表来对集合（用table实现的集合）进行操作的示例，实例中定义了集合的并集、交集、比较等运行：

Set = {}

--专门用来作为metatable，定义在Set里面以免影响外部的命名空间
Set.mt = {}    

--转化为string
Set.tostring = function (set)
    local s = "{"
    local sep = " "
    for e in pairs(set) do
        s = s .. sep .. e
        sep = ", "
    end
    return s.."}"
end

--打印
Set.print = function(s)
    print(Set.tostring(s))
end

Set.mt.__tostring = Set.tostring

--新建一个集合
Set.new = function (t)
    local set = {}
    setmetatable(set, Set.mt)        --指定所创建集合的metatable
    for _, l in ipairs(t) do set[l] = true end
    return set
end

--并集
Set.union = function (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 res
end

--给metatable增加__add函数(metamethod)，当Lua试图对两个集合相加时，将调用这个函数，以两个相加的表作为参数
Set.mt.__add = Set.union

--交集
Set.intersection = function (a,b)
    local res = Set.new{}
    for k in pairs(a) do
        res[k] = b[k]
    end
    return res
end
--定义集合相乘操作为求交集
Set.mt.__mul = Set.intersection

--先定义"<="操作，然后基于此定义"<"和"="
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

--测试
s1 = Set.new{1, 2, 3}
s2 = Set.new{10, 20, 30, 40, 50}
print(getmetatable(s1))
print(getmetatable(s2))
s3 = s1 + s2    --等同于Set.union(s1, s2)
print(s3)
print(s3 * s2)

print(s1 <= s3)
print(s1 == s3)
print(s1 < s3)
print(s1 >= s3)
print(s1 > s3)

--起保护作用，getmetatable将返回这个域的值，而setmettable将会出错
Set.mt.__metatable = "not your business"

print(getmetatable(s1))
setmetatable(s1, {})

　　当Lua试图对两个表进行相加时，他会检查两个表是否有一个表有Metatable，并且检查Metatable是否有__add域。如果找到则调用这个__add函数（所谓的Metamethod）去计算结果。当两个表有不同的Metatable时，以谁的为准呢？Lua选择metamethod的原则：

　　（1）如果第一个参数存在带有__add域的metatable，Lua使用它作为metamethod，和第二个参数无关；

　　（2）否则，第二个参数存在带有__add域的metatable，Lua使用它作为metamethod；

　　（3）否则，报错。

　　Lua中定义的常用的Metamethod如下所示：

　　算术运算符的Metamethod：__add（加运算）、__mul（乘）、__sub(减)、__div(除)、__unm(负)、__pow(幂)，__concat（定义连接行为）。

　　关系运算符的Metamethod：__eq（等于）、__lt（小于）、__le（小于等于），其他的关系运算自动转换为这三个基本的运算。

　　库定义的Metamethod：__tostring（tostring函数的行为）、__metatable（对表getmetatable和setmetatable的行为）。

　　注意：__metatable不是函数，而是一个变量。假定你想保护你的集合使其使用者既看不到也不能修改metatables。如果你对metatable设置了__metatable的值，getmetatable将返回这个域的值，而调用用setmetatable将会出错：

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

　　print总是调用tostring来格式化它的输出，tostring会首先检查对象是否存在一个带有__tostring域的metatable。

 　　表相关的Metamethod:

　　(1)__index metamethod：在继承中使用较多。当访问表不存在的一个域时，会触发Lua解释器去查找__index metamethod，如果不存在，则返回nil，否则由__index metamethod返回结果。

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__index = function(table, key)
    return Window[key]
end

w = {x = 10, y = 20}
setmetatable(w, mt)
print(w.width)

　　可以看到w没有width域，但有关联表mt，且关联表有__index，因此w.width会触发mt.__index的调用（Lua会将w作为第一个参数、width作为第二个参数来调用该函数）。

　　__index除了作为一个函数，还可以直接作为一个表来使用当__index是一个表时，Lua会直接在这个表中查找width域。因此代码也可以像这样来写：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__index = Window

w = {x = 10, y = 20}
setmetatable(w, mt)
print(w.width)

 　　rawget(table, index)函数获取表中指定域的值，该函数可以绕过metamethod，直接返回表的域信息，看下面这个例子：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__index = function(table, key) return Window[key] end

w = {x = 10, y = 20}
setmetatable(w, mt)

print(w.width)                    --100
print(rawget(w, "width"))        --nil
print(rawget(w, "x"))            --10

　　看上面倒数第二行，rawget(w, "width")访问不存在的域不会触发查找__index。

　　(2)__newindex metamethod：__newindex metamethod用来对表更新，__index则用来对表访问。

　　当给表的一个不存在的域赋值时(比如w.add = 1)，会触发Lua查找__newindex，如果不存在__newindex，则像一般的赋值行为一样导致表添加了一个域。

　　(1)不存在__newindex，则像一般的赋值行为一样导致表添加了一个域(w多了一个域add，值为1)

　　(2)存在__newindex，则不进行赋值操作，而是由__newindex拦截了赋值操作，并且将(table、域名、值)作为参数调用__newindex。

　　也就是说，__newindex可以使得任何对表的添加元素的行为都要经过__newindex，这确实是一个很好的把关。

　　rawset(t, k, v)函数也是一个等同于赋值的操作（w.add = 1相当于rawset(w, "add", 1)），但调用该函数可以绕过metamethod，即不会导致__newindex的调用：

mt = {}
mt.__newindex = function(table, key, value)
    rawset(table, key, value)　　　　　　　　--这里不能写成table.key = value；因为这个给不存在域的赋值操作又会导致__newindex的调用，因而陷入死循环
end

w = {x = 10, y = 20}
setmetatable(w, mt)

w.add = 1
print(w.add)            -- 1

 　　和__index一样，__newindex也可以是一个表，如果__newindex是一个表，会导致对指定的那个表而不是原始的表进行赋值操作。

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__newindex = Window

w = {x = 10, y = 20}
setmetatable(w, mt)

w.add = 1
print(w.add)                --nil
print(Window.add)            --1

　　赋值操作导致Windows添加了一个元素add，而w不影响。

　　当__index和__newindex混合使用时，一定要注意区分每个行为都干了什么事情：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__index = Window
mt.__newindex = Window

w = {x = 10, y = 20}
setmetatable(w, mt)

w.add = 1
print(w.add)                --1
print(Window.add)            --1

　　__newindex为表时，w.add=1表示给Window添加了add，但通过__index，w也能访问到Window的add。

　　再看下面这个例子：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__index = function(table, key)
    return Window[key]
end
mt.__newindex = function(table, key, value)
    rawset(table, key, value)
end

w = {x = 10, y = 20}
setmetatable(w, mt)

w.add = 1
print(w.add)            -- 1
print(Window.add)        -- nil

　　__newindex为函数时，w.add直接给w添加了add域，但Window并不存在add。所以结论是：当__newindex是函数时，给目标表w添加域；当__newindex是表时，给指向表添加域。

 　　关于__index和__newindex一定要注意区分，什么时候进入__index，什么时候进入__newindex：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__index = function(table, key)
    print("going here __index")
    return Window[key]
end

w = {x = 10, y = 20}
setmetatable(w, mt)

s = w.width                         　　 -- going here __index 访问语句会进入__index
w.width = 1                              -- 赋值语句不会进入__index，这里会导致w表添加width域
print(w.width)                        　　-- 1
print(rawget(w, "width"))            　　 -- 1
print(Window.width)                　　　 -- 100

　　访问语句进入__index，赋值语句不进入__index。

mt = {}
mt.__newindex = function(table, key, value)
    print("going here __newindex")
    rawset(table, key, value)
end

w = {x = 10, y = 20}
setmetatable(w, mt)

s = w.add                             -- 访问语句不会进入__newindex
w.add = 1                            -- going here __newindex 赋值语句进入__newindex
print(w.add)                        -- 1
print(rawget(w, "add"))            -- 1

　　赋值语句进入_newindex，访问语句不进入__newindex。

 　　结合上面这两句话就很容易理解下面这个例子了：

Window = {x = 0, y = 0, width = 100, height = 100}

mt = {}
mt.__index = function(table, key)
    print("going here __index")
    return Window[key]
end
mt.__newindex = function(table, key, value)
    print("going here __newindex")
    rawset(table, key, value)
end

w = {x = 10, y = 20}
setmetatable(w, mt)

s = w.width                            -- going here __index
w.width = 1                            -- going here __newindex
print(w.width)                        -- 1
print(rawget(w, "width"))            -- 1

　　倒数第三条语句w.width = 1不会进入__index，所以会导致给w表添加新的域width。也就是说__index逻辑不会影响__newindex的判断，虽然__index可以访问到域width，但__newindex依然仍未w没有width域。

　　这些概念非常的绕，而且Lua是一种弱类型化语言，所以对于很多概念的具体行为你一定要自己多加测试，不能够想当然。

http://www.cnblogs.com/sifenkesi/p/3834128.html

时间： 2024-08-01 17:54:38

Metatable和Metamethod（转）的相关文章

把C++类成员函数集成到lua

       有时我们会把C++类导入到lua,这样方便在lua里面对C++类进行操作,这在游戏编程里面经常使用,本文只是简单介绍一种实现.        1.       lua里面面向对象的实现               在lua里面,我们可以这样操作表,如下:          Account = {balance = 0}        function Account:withdraw (v)               self.balance = self.balan

Lua中的元表(metatable)、元方法(metamethod)详解_Lua

终于到了在实际中经常要用到的内容了--元表与元方法. 在第一次看见这两样东西的时候,可能会觉得它很深奥,但其实很好理解,虽然实际上它可能真的很深奥.(小若:停!滚粗.) 1.知道为什么1 + 1 = 2吗? 为什么在Lua中,1+1会等于2呢?(小若:难道除了Lua,其他地方就不等于2了?) 为什么数字和数字相加是合法的,为什么table和table相加就会报错?大家有想过这些问题吗?   没错,规则,这一切都只是规则而已,Lua规定了数字之间可以进行加减乘除,而table之间则不可以. 这是因

Lua中的metatable介绍_Lua

setmetatable (table, metatable) Lua 中的每个值都可以用一个 metatable. 这个 metatable 就是一个原始的 Lua table , 它用来定义原始值在特定操作下的行为. 你可以通过在 metatable 中的特定域设一些值来改变拥有这个 metatable 的值 的指定操作之行为. 举例来说,当一个非数字的值作加法操作的时候, Lua 会检查它的 metatable 中 "__add" 域中的是否有一个函数. 如果有这么一个函数的话,

Lua中的metatable详解_Lua

Lua 中 metatable 是一个普通的 table,但其主要有以下几个功能: 1.定义算术操作符和关系操作符的行为 2.为 Lua 函数库提供支持 3.控制对 table 的访问 Metatables 定义操作符行为 Metatable 能够被用于定义算术操作符和关系操作符的行为.例如:Lua 尝试对两个 table 进行加操作时,它会按顺序检查这两个 table 中是否有一个存在 metatable 并且这个 metatable 是否存在 __add 域,如果 Lua 检查到了这个 __

Lua编程示例（二）：面向对象、metatable对表进行扩展_Lua

counter = { count = 0 } function counter.get(self) return self.count end function counter:inc() self.count=self.count+1 end print(counter.get(counter)) counter.inc(counter) print(counter.get(counter)) counter2={ count=4, get = counter.get, inc = coun

Lua中使用元表（metatable）执行算术类元方法实例_Lua

上一节对元表和元方法有了一个初步的认识,这篇就来举个最简单的例子吧,加深一下印象,也为后续内容做准备. 1.元方法名 Lua其实已经规定好了各种算术操作符的元方法名字,如: __add:加法 __sub:减法 __mul:乘法 __div:除法 __unm:相反数 __mod:取模 __pow:乘幂   只要在自定义元表的时候,给这些元方法名赋予新的函数就可以实现自定义操作了. 2.例子 开始举例吧,我们新建一个自定义的元表(也就是一个table变量),用来定义一些操作: 复制代码 代码如下:

Lua中的元表和元方法学习笔记_Lua

元表(metatable)是 Lua 里每种类型的值的默认操作方式的集合,例如,数字可以加减乘除.字符串可以连接合并.table 可以插入一对 key-value 值.函数可以被调用等等,这些操作都遵循其预定义的行为来执行. 而值的默认操作方式不是一成不变的,可以通过元表来修改其行为表现,或者是新定义一些默认没有的操作.例如,当两个 table 相加时, Lua 会检查它们之间的元表里是否有 "__add" 这个函数,如果定义有这个函数, 则调用这个函数来执行一次加法操作. 这里,相加

Lua中类的实现原理探讨（Lua中实现类的方法）_Lua

Lua中没有类的概念,但我们可以利用Lua本身的语言特性来实现类. 下文将详细的解释在Lua中实现类的原理,涉及到的细节点将拆分出来讲,相信对Lua中实现类的理解有困难的同学将会释疑. 类是什么? 想要实现类,就要知道类到底是什么. 在我看来,类,就是一个自己定义的变量类型.它约定了一些它的属性和方法,是属性和方法的一个集合. 所有的方法都需要一个名字,即使是匿名函数实际上也有个名字.这就形成了方法名和方法函数的键值映射关系,即方法名为键,映射的值为方法函数. 比如说有一个类是人,人有一个说话的

Lua中的元表与元方法学习总结_Lua

前言 元表对应的英文是metatable,元方法是metamethod.我们都知道,在C++中,两个类是无法直接相加的,但是,如果你重载了"+"符号,就可以进行类的加法运算.在Lua中也有这个道理,两个table类型的变量,你是无法直接进行"+"操作的,如果你定义了一个指定的函数,就可以进行了.那这篇博文就是主要讲的如何定义这个指定的函数,这个指定的函数是什么?希望对学习Lua的朋友有帮助. Lua是怎么做的? 通常,Lua中的每个值都有一套预定义的操作集合,比如数