元表(metatable)与元方法(meatmethod)

  通常,Lua中的每个值都有一套预定义的操作集合。例如,可以将数字相加,可以连接字符串,还可以在table中插入一对key-value等。但是我们无法将两个table相加,无法对函数作比较,也无法调用一个字符串。

  可以通过元表来修改一个值的行为,使其在面对一个非预定义的操作时执行一个指定的操作。例如,假设a和b都是table,通过元表可以定义如何计算表达式a+b。当Lua试图将两个table相加时,它会先检查两者之一是否有元表,然后检查该元表中是否有一个叫__add的字段。如果Lua找到了该字段,就调用该字段对应的值。这个值也就是所谓的“元方法”,它应该是一个函数,在本例中,这个函数用于计算table的和。

  Lua中的每个值都有一个元表。table和userdata可以有各自独立的元表,而其他类型的值则共享其类型所属的单一元表。Lua在创建新的table时不会创建元表

  1. t = {}
  2. print(getmetatable(t)) --> nil

  可以使用setmetatable来设置或修改任何table的元表:

  1. t1 = {}
  2. setmetatable(t, t1)
  3. assert(getmetatable(t) == t1)

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

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

  1. print(getmetatable("hi") --> table:0x80772e0
  2. print(getmetatable(10)) --> nil

  

算术类的元方法

  在本节中,会引入一个简单的示例,以说明如何使用元表。假设用table来表示集合,并且有一些函数用来计算集合的并集和交集等。为了保持名称空间的整齐,则将这些函数存入一个名为Set的table中。

  1. Set = {}
  2. -- 根据参数列表中的值创建一个新的集合
  3. function Set.new(l)
  4. local set = {}
  5. for _, v in ipairs(l) do set[v] = true end
  6. return set
  7. end
  8. function Set.union(a, b)
  9. local res = Set.new{}
  10. for k in pairs(a) do res[k] = true end
  11. for k in pairs(b) do res[k] = true end
  12. return res
  13. end
  14. function Set.intersection(a, b)
  15. local res = Set.new{}
  16. for k in pairs(a) do
  17. res[k] = b[k]
  18. end
  19. return res
  20. end

  为了帮助检查此示例,还定义了一个用于打印集合的函数:

  1. function Set.tostring(set)
  2. local l = {} -- 用于存放集合中所有元素的列表
  3. for e in pairs(set) do
  4. l[#l + 1] = e
  5. end
  6. return "{" .. table.concat(l, ", " .. "}"
  7. end
  8. function Set.print(s)
  9. print(Set.tostring(s))
  10. end

  假设使用加号(+)来计算两个集合的并集,那么就需要让所有用于表示集合的table共享一个元表,并且在该元表中定义如何执行一个加法操作。第一步是创建一个常规的table,准备用作集合的元表:

  1. local mt = {} -- 集合的元表

  下一步是修改Set.new函数。这个函数是用于创建集合的,在新版本中只加了一行,即将mt设置为当前所创建table的元表:

  1. function Set.new(l) -- 2
  2. local set = {}
  3. setmetatable(set, mt)
  4. for _, v in ipairs(l) do set[v] = true end
  5. return set
  6. end

  在此之后,所有由Set.new创建的集合都具有一个相同的元表:

  1. s1 = Set.new{10, 20, 30, 50}
  2. s2 = Set.new{30, 1}
  3. print(getmetatable(s1)) --> table: 00672B60
  4. print(getmetatable(s2)) --> table: 00672B60

  最后,将元方法加入元表中。在本例中,这个元方法就是用于描述如何完成加法的__add字段。

  1. mt.__add = Set.union

  此后只要Lua试图将两个集合相加,它就会调用Set.union函数,并将两个操作数作为参数传入。可以使用加号来求集合的并集:

  1. s3 = s1 + s2
  2. Set.print(s3) --> {1, 10, 20, 30, 50}

  类似地,还可以使用乘号来求集合的交集:

  1. mt.__mul = Set.intersection
  2. Set.print((s1 + s2)*s1) --> {10, 20, 30, 50}

  在元表中,每种算术操作符都有对应的字段名。除了上述的addmul外,还有sub(减法)、div(除法)、unm(相反数)、mod(取模)和pow(乘幂)。此外,还可以定义concat字段,用于描述连接操作符的行为。

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

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

  Lua会按照如下步骤来查找元表:如果第一个值有元表,并且元表中有add字段,那么Lua就以这个字段为元方法,而与第二个值无关;反之,如果第二个值有元表并含有add字段,Lua就以此字段为元方法;如果两个值都没有元方法,Lua就引发一个错误。因此,上例会调用Set.union,而表达式10+s和“hello”+s也是一样的。

  Lua可以包含这些混合类型,但实现需要注意如果执行了s=s+8,那么在Set.union内部就会发生错误:

  1. bad argument $1 to 'pairs' (table expected, got number)

  如果想要得到更清楚的错误消息,则必须在实际操作前显式地检查操作数的类型:

  1. function Set.union(a, b)
  2. if getmetatable(a) ~= mt or getmetatable(b) ~= mt then
  3. error("attempt to 'add' a set with a non-set value", 2)
  4. end
  5. <与前例相同的内容>

  注意,error的第二个参数(上例中的2)用于指示哪个函数调用造成了该错误消息。

  

关系类的元方法

  元表还可以指定关系操作符的含义,元方法为eq(等于)、lt(小于)和__le(小于等于)。而其他3个关系操作符则没有单独的元方法,Lua会将a~=b转化为not(a==b),将a>b转化为b<a,将a>=b转化为b<=a

  在Lua4.0之前,所有的顺序操作符都被转化为一种操作符(小于),例如,a<=b转化为not(b<a)。不过,这种转化遇到“部分有序(partial order)”就会发生错误。所谓“部分有序”是指,对于一种类型而言,并不是所有的值都能排序的。例如,大多数计算机中的浮点数就不是完全可以排序的。因为存在着一种叫“Not a Number(NaN)”的值。IEEE754是一份当前所有浮点数硬件都采用的事实标准,其中将NaN视为一种未定义的值,例如0/0的结果就是NaN。标准规定了任何涉及NaN的比较都应返回false(假)。这意味着NaN<=x永远为假,但是x<NaN也为假。因此,前面提到的将a<=b转化为not(b<a)就不合法了。

  在上面的集合示例中,也存在着类似的问题。在集合操作中<=通常表示集合间的包含关系:a<=b通常意味着a是b的一个子集。根据这样的表示,仍有可能得到a<=bb<a同时为假的情况。因此需要分别为le(小于等于)和lt(小于)提供实现:

  1. mt.__le = function(a, b) -- 集合包含
  2. for k in pairs(a) do
  3. if not b[k] then return false end
  4. end
  5. return true
  6. end
  7. mt.__lt = function(a, b)
  8. return a<=b and not (b<=a)
  9. end

  最后,还可以定义集合的相等性判断:

  1. mt.__eq = function(a, b)
  2. return a <= b and b <= a
  3. end

  有了这些定义后,就可以比较集合了:

  1. s1 = Set.new{2, 4}
  2. s2 = Set.new{4, 10, 2}
  3. print(s1 <= s2) -- true
  4. print(s1 < s2) -- true
  5. print(s1 >= s1) -- true
  6. print(s1 > s1) -- false
  7. print(s1 == s2 * s1) -- true

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

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

  

库定义的元方法

  各种程序库在元表中定义它们自己的字段是很普通的方法。到目前为止介绍的所有元方法都只针对于Lua的核心,也就是一个虚拟机(virtual machine)。它会检测一个操作中的值是否有元表,这些元表中是否定义了关于此操作的元方法。从另一方面说,由于元表也是一种常规的table,所以任何人、任何函数都可以使用它们。

  函数tostring就是一个典型的实例。在前面已介绍过tostring了,它能将各种类型的值表示为一种简单的文本格式:

  1. print({}) --> table: 0x8062ac0

  函数print总是调用tostring来格式化其输出。当格式化任意值时,tostring会检查该值是否有一个__tostring的元方法。如果有这个元方法,tostring就用该值作为参数来调用这个元方法。接下来由这个元方法完成实现的工作,它返回的结果也就是tostring的结果。

  在集合的示例中,已定义了一个将集合表示为字符串的函数。接下来要做的就是设置元表的__tostring字段:

  1. mt.__tostring = Set.tostring

  此后只要调用print来打印集合,print就会调用tostring函数,进而调用到Set.tostring

  1. s1 = Set.new{10, 4, 5}
  2. print(s1) --> {4, 5, 10}

  函数setmetatablegetmetatable也会用到元表中的一个字段,用于保护元表。假设想要保护集合的元表,使用户既不能看也不能修改集合的元表。那么就需要用到字段__metatable。当设置了该字段时,getmetatable就会返回这个字段的值,而setmetatable则会引发一个错误:

  1. mt.__metatable = "not your business"
  2. s1 = Set.new{}
  3. print(getmetatable(s1)) --> not your business
  4. setmetatable(s1, {})
  5. stdin:1: cannot change protected metatable

  

table访问的元方法

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

● __index元方法

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

  下面将介绍一个有关继承的典型示例。假设要创建一些描述窗口的table,每个table中必须描述一些窗口参数,例如位置、大小及主题颜色等。所有这些参数都有默认值,因此希望在创建窗口对象时可以仅指定那些不同于默认值的参数。第一种方法是使用一个构造式,在其中填写那些不存在的字段。第二种方法是让新窗口从一个原型窗口处继承所有不存在的字段。首先,声明一个原型和一个构造函数,构造函数创建新的窗口,并使它们共享同一个元表:

  1. Window = {} -- 创建一个名字空间
  2. -- 使用默认值来创建一个原型
  3. Window.prototype = {x=0, y=0, width=100, height=100}
  4. Window.mt = {} -- 创建元表
  5. -- 声明构造函数
  6. function Window.new(o)
  7. setmetatable(o, Window.mt)
  8. return o
  9. end

  现在,来定义__index元方法:

  1. Window.mt.__index = function(table, key)
  2. return Window.prototype[key]
  3. end

  在这段代码之后,创建一个新窗口,并查询一个它没有的字段:

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

  若Lua检测到w中没有某字段,但在其元表中却有一个index字段,那么Lua就会以w(table)和“width”(不存在的key)来调用这个index元方法。随后元方法用这个key来索引原型table,并返回结果。

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

  1. Window.mt.__index = Window.prototype

  现在,当Lua查找到元表的index字段时,发现index字段的值是一个table,那么Lua就会在Window.prototype中继续查找。也就是说,Lua会在这个table中重复这个访问过程,类似于执行这样的代码:

  1. Window.prototype["width"]

  然后由这次访问给出想要的结果。

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

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

● __newindex元方法

  newindex元方法与index类似,不同之处在于前者用于table的更新,而后者用于table的查询。当对一个table中不存在的索引赋值时,解释器就会查找__newindex元方法。如果有这个元方法,解释器就调用它,而不是执行赋值。如果这个元方法是一个table,解释器就在此table中执行赋值,而不是对原来的table。此外,还有一个原始函数允许绕过元方法:调用rawset(t,k,v)就可以不涉及任何元方法而直接设置table t中与key k相关联的value v。

  组合使用indexnewindex元方法就可以实现出Lua中的一些强大功能,例如,只读的table、具有默认值的table和面向对象编程中的继承。

  

● 具有默认值的table

  常规table中的任何字段默认都是nil。通过元表就可以很容易地修改这个默认值:

  1. function setDefault(t, d)
  2. local mt = {__index = function() return d end}
  3. setmetatable(t, mt)
  4. end
  5. tab = {x=10, y=20}
  6. print(tab.x, tab.z) --> 10 nil
  7. setDefault(tab, 0)
  8. print(tab.x, tab.z) --> 10 0

  在调用setDefault后,任何对tab中存在字段的访问都将调用它的__index元方法,而这个元方法会返回0(这个元方法中d的值)。

  setDefault函数为所有需要默认值的table创建了一个新的元表。如果准备创建很多需要默认值的table,这种方法的开销或许就比较大了。由于在元表中默认值d是与元方法关联在一起的,所以setDefault无法为所有table都使用同一个元表。若要让具有不同默认值的table都使用同一个元表,那么就需要将每个元表的默认值都存放到table本身中。可以使用额外的字段来保持默认值。如果不担心名字冲突的话,可以使用“_”这样的key作为这个额外的字段:

  1. local mt = {__index = function(t) return t.___ end}
  2. function setDefault(t, d)
  3. t.___ = d
  4. setmetatable(t, mt)
  5. end

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

  1. local key = {} -- 唯一的key
  2. local mt = {__index = function(t) return t[key] end}
  3. function setDefault(t, d)
  4. t[key] = d
  5. setmetatable(t, mt)
  6. end

  还有一种方法可以将table与其默认值关联起来:使用一个独立的table,它的key为各种table,value就是各种table的默认值。不过,为了正确地实现这种做法,我们还需要一种特殊性质的table,就是“弱引用table(Weak Table)”。在这里我们就不使用它了。将在后续章节中详细讨论。

  

● 跟踪table的访问

  indexnewindex都是在table中没有所需访问的index时才发挥作用的。因此,只有将一个table保持为空,才有可能捕捉到所有对它的访问。为了监视一个table的所有访问,就应该为真正的table创建一个代理。这个代理就是一个空的table,其中indexnewindex元方法可用于跟踪所有的访问,并将访问重定向到原来的table上。假设,我们想跟踪table t的访问。那么可以这么做:

  1. t = {} -- 原来的table(在其他地方创建的)
  2. -- 保持对原table的一个私有访问
  3. local _t = t
  4. -- 创建代理
  5. t = {}
  6. -- 创建元表
  7. local mt = {
  8. __index = function(t, k)
  9. print("*access to element " .. tostring(k))
  10. return _t[k] -- 访问原来的table
  11. end,
  12. __newindex = function(t, k, v)
  13. print("*update of element " .. tostring(k) .. " to " .. tostring(v))
  14. _t[k] = v -- 更新原来的table
  15. }
  16. setmetatable(t, mt)

  这段代码跟踪了所有对t的访问:

  1. >t[2] = "hello"
  2. *update of element 2 to hello
  3. >print(t[2])
  4. *access to element 2
  5. hello

  但上例中的方法存在一个问题,就是无法遍历原来的table。函数pairs只能操作代理table,而无法访问原来的table。

  如果想要同时监视几个table,无须为每个table创建不同的元表。相反,只要以某种形式将每个代理与原来table关联起来,并且所有代理都共享一个公共的元表。这个问题与上节所讨论的将table与其默认值相关联的问题类似。例如将原来的table保存在代理table的一个特殊的字段中。代码如下:

  1. local index = {} -- 创建私有索引
  2. local mt = {
  3. __index = function(t, k)
  4. print("*access to element " .. tostring(k))
  5. return t[index][k] -- 访问原来的table
  6. end,
  7. __newindex = function(t, k, v)
  8. print("*update of element " .. tostring(k) .. " to " .. tostring(v))
  9. t[index][k] = v -- 更新原来的table
  10. end
  11. }
  12. function track(t)
  13. local proxy = {}
  14. proxy[index] = t
  15. setmetatable(proxy, mt)
  16. return proxy
  17. end

  现在,若要监视table t,唯一要做的就是执行:t = track(t)

  

● 只读的table

  通过代理的概念,可以很容易地实现出只读的table。只需跟踪所有对table的更新操作,并引发一个错误就可以了。由于无须跟踪查询访问,所以对于index元方法可以直接使用原table来代替函数。这也更简单,并且在重定向所有查询到原table时效率也更高。不过,这种做法要求为每个只读代理创建一个新的元表,其中index指向原来的table。

  1. function readOnly(t)
  2. local proxy = {}
  3. local mt = { -- 创建元表
  4. __index = t,
  5. __nexindex = function(t, k, v)
  6. error("attempt to update a read-only table", 2)
  7. end
  8. }
  9. setmetatable(proxy, mt)
  10. return proxy
  11. end

  下面是一个使用的示例,创建了一个表示星期的只读table:

  1. days = readOnly{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
  2. print(days[1]) -- Sunday
  3. days[2] = "Noday"
  4. stdin:1: attempt to update a read-only table

?