通常，Lua中的每个值都有一套预定义的操作集合。例如，可以将数字相加，可以连接字符串，还可以在table中插入一对key-value等。但是我们无法将两个table相加，无法对函数作比较，也无法调用一个字符串。
可以通过元表来修改一个值的行为，使其可以在面对一个非预定义的操作时执行一个指定的操作。例如，假设a和b是两个table，通过元表可以定义如何计算表达式a+b。当Lua试图将两个table相加时，它会先检查两者之一是否有元表，然后检查该元表中是否有一个叫__add的字段。如果Lua找到了该字段，就调用该字段对应的值。这个值就是所谓的“元方法”，它应该是一个函数，在本例中，这个函数用于计算table的和。
Lua中每个值都有一个元表。table和userdata可以有各自独立的元表，而其他类型的值则共享其类型所属的单一元表。Lua在创建新的table时不会创建元表：
t = {}
print(getmetatable(t)) -->nil
可以使用setmetatable来设置或者是修改任何table的元表：
t1 = {}
setmetatable(t, t1)
assert(getmetatable(t) == t1)
任何table都可以作为任何值的元表，而一组相关的table也可以共享一个通用的元表，此元表描述了它们共同的行为。一个table也可以作为它自己的元表，用于描述其特有的行为。总之，任何搭配形式都是合法的。
在Lua代码中，只能设置table 的元表。若要设置其他类型的值的元表，则必须通过C代码来完成，这个限制的目的是为了防止过度地使用某些特定类型的元表，这些设置通常会导致不可复用的代码。标准的字符串程序库为所有的字符串都设置了一个元表，而其他类型在默认情况中是没有元表的。
print(getmetatable("hi")) -->table:0x80772e0
print(getmetatable(10)) -->nil
算术类的元方法
假设用table来表示集合，并且有一些函数用来计算集合的并集和交集等。为了保持命名空间的整齐，则将这些函数存入一个名为Set的table中。
Set = {}
--根据参数列表中的值创建一个新集合
function Set.new (l)
local set = {}
for _, v in ipairs(l) do set[v] = true end
return set
end
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 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 (set)
local l = {} --用于存放集合中所有元素的列表
for e in pairs(set) do
l[#l + 1] = e
end
return "{" .. table.concat(l, ", ") .. "}"
end
function Set.print (s)
print(Set.tostring(s))
end
假设使用加号（+）来计算两个集合的并集，那么就需要让所有用于表示集合的table共享一个元表，并且在该元表中定义如何执行一个加法操作。
第一步：创建一个常规的table，准备用作集合的元表
local mt = {} --集合的元表
第二步：修改Set.new函数。这个函数用于创建集合的，在新版本中只加了一行，即将mt设置为当前所创建table的元表
function Set.new (l)
local set = {}
setmetatable(set, mt)
for _, v in ipairs(l) do set[v] = true end
return set
end
第三步：将元方法加入到元表中。在本例中，这个元方法就是用于描述如何完成加法的__add字段
mt.__add = Set.union
类似地，还可以使用乘号来求集合的交集
mt.__mul = Set.intersection
s1 = Set.new{10, 20, 30, 50}
s2 = Set.new{30, 1}
print(getmetatable(s1)) -->table: 005D9A10
print(getmetatable(s2)) -->table: 005D9A10
s3 = s1 + s2
Set.print(s3) -->{1, 10, 20, 30, 50}
Set.print((s1 + s2) * s1) -->{10, 20, 30, 50}
在元表中，每种算术操作符 都有对应的字段名。
__add +
__sub -
__mul *
__div /
__unm 相反数-
__mod 取模%
__pow 乘幂^
__concat 连接操作符
当两个集合相加时，可以使用任意一个集合的元表。然而，当一个表达式中混合了具有不同元表的值时，例如：
s = Set.new{1, 2, 3}
s = s + 8
Lua会按照如下步骤来查找元表：
如果第一个值有元表，并且元表中有__add字段，那么Lua就以这个字段为元方法，而与第二个值无关；反之，如果第二个值有元表并含有__add字段，Lua就以此字段为元方法；如果两个值都没有元方法，Lua就引发一个错误。因此，上例会调用Set.union，而表达式10 + s和"hello"+ s也是一样。
这样的调用会在Set.union内部发生错误，如果想要得到更清楚的错误信息，则必须在实际操作前显示地检查操作数的类型：
function Set.union (a, b)
if getmetatable(a) ~= mt or getmetatable(b) ~= mt then
error("attemp to 'add' a set with non-set value", 2)
end
<剩余代码相同>
end
注意，error的第二个参数用于指示哪个函数调用造成了该错误消息。
关系类的元方法
关系操作符：
__eq ==
__lt <
__le <=
a~=b <==>not(a==b)
a>b <==>b<a
a>=b <==>b<=a
集合的__le和__lt的实现：
mt.__le = function (a, b)
for k in pairs(a) do
if not b[k] then return false end
end
return true
end
mt.__lt = function (a, b)
return a <= b and not (b <= a)
end
mt.__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) -->true
print(s1 < s2) -->true
print(s1 >= s1) -->true
print(s1 > s1) -->false
print(s1 == s2 * s1) -->true
与算数类元方法不同的是，关系类元方法不能应用于混合类型。对于混合类型而言，关系类元方法的行为就模拟这些操作符在Lua中 普通的行为。如果试图将一个字符串与一个数字作顺序性比较，Lua会引发一个错误。同样，如果试图比较两个具有不同元方法的对象，Lua也会引发一个错误。
等于操作永远不会引发错误。但是如果两个对象拥有不同的元方法，那么等于操作不会调用任何一个元方法，而是直接返回false。这种行为模拟了Lua的普遍行为。在Lua的普遍行为中，字符串总是不等于数字的，与它们值无关。另外，只有当两个比较对象共享一个元方法时，Lua才会调用这个等于比较的元方法。
库定义的元方法
函数tostring，它能将各种类型的值表示为一种简单的文本格式：
print({}) -->table: 0x8062ac0
函数print总是调用tostring来格式化其输出。当格式化任意值时，tostring会检查该值是否有一个__tostring的元方法。如果有这个元方法，tostring就用该值作为参数来调用这个 元方法。
mt.__tostring = Set.tostring
此后，只要调用print 来打印集合，print就会调用tostring函数，进而调用到Set.tostring：
s1 = Set.new{10, 4, 5}
print(s1) -->{4, 5, 10}
函数setmetatable和getmetatable也会用到元表中的一个字段，用于保护元表。假设想要保护集合的元表，使用户既不能看也不能修改集合的元表，那么就需要用到字段__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
table访问的元方法
算术类和关系类运算符的元方法都为各种错误情况定义了行为，它们不会改变语言的常规行为。但是Lua还 提供了一种可以改变table行为的方法。有两种可以改变的table行为：查询table及修改table中不存在的字段。
__index元方法
当访问一个table中不存在的字段时，得到的结果是nil。这是对的，但并非完全正确。实际上，这些访问会促使解释器去查找一个叫__index的元方法。如果没有这个元方法，那么访问结果如前所述的为nil。否则，就由这个元方法来提供最终的结果。
介绍一个有关继承的典型示例。假设要创建一些描述窗口的table，每个table中必须描述一些窗口参数，例如位置、大小以及主题颜色等。所有这些参数都有默认值，因此希望在创建窗口对象时可以仅指定那些不同于默认值的参数。第一种方法是使用构造式，在其中填写那些不存在的字段。第二种方法是让新窗口从一个原型窗口处继承所有不存在的字段。首先，声明一个原型和一个构造函数，狗杂函数创建新的窗口，并使它们共享同一个元表：
Window = {}
Window.prototype = {x = 0, y = 0, width = 100, height = 100}
Window.mt = {}
function Window.new (o)
setmetatable(o, Window.mt)
return o
end
Window.mt.__index = function (table, key)
return Window.prototype[key]
end
w = Window.new{x = 10, y = 10}
print(w.width) -->100
在Lua中，将__index 元方法用于继承是很普遍的方法，因此，Lua还提供了一种更便捷的方式来实现此功能。__index方法不必一定是一个函数，它还可以是一个table。当它是一个函数时，Lua以table和不存在的key作为参数来调用该函数，这就如同上述内容。而当它是一个table时，Lua就以相同的方法来重新访问这个table。因此，前例中__index的声明可以简单地写为：
Window.mt.__index = Window.prototype
将一个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。
组合使用__index和__newindex元方法就可以实现出Lua中的一些强大功能，例如，只读的table、具有默认值的table和面向对象编程中的继承。
具有默认值的table
常规table中的任何字段默认都是nil。通过元表就可以很容易地修改这个默认值：
function setDefault (t, d)
local mt = {__index = function return d end}
setmetatable(t, mt)
end
tab = {x = 10, y = 20}
print(tab.x, tab.z) -->10 nil
setDefault(tab, 0)
print(tab.x, tab.z) -->10 0
setDefault函数为所有具有默认值的table创建了一个新元表。如果准备创建很多需要默认值的table，这种方法的开销或许就比较大了。由于在元表中默认值d是与元方法关联在一起的，所以setDefault无法为所有table都使用同一个元表。若要让具有不同默认值的table都使用同一个元表，那么就需要将每个元表的默认值存放到table本身。可以使用一个额外的字段来保持默认值。如果不担心名字冲突的话，可以使用“___”这样的key作为这个额外的字段：
local mt = {__index = function (t) return t.___ end}
function setDefault (t, d)
t.___ = d
setmetatable(t, mt)
end
如果担心 名称冲突，那么要确保这个key的唯一性也很容易。只需要创建一个新的table，并用它作为key即可：
local key = {} --唯一的key
local mt = {__index = function (t) return t[key] end}
function setDefault (t, d)
t[key] = d
setmetatable(t, mt)
end
还有两种方法涉及到“弱引用”table，后面详细介绍：
1、可以将table与其默认值关联起来：使用一个独立的table，它的key为各种table，value就是各种table的默认值；
2、备忘录元表的方法，它能使具有相同默认值的table复用同一个元表。
跟踪table的访问
__index和__newindex都是在table中没有所需访问的index时才发挥作用的。因此，只有将一个table保持为空，才有可能捕捉到所有对它的访问。为了监视一个table的所有访问，就应该为真正的table创建一个代理。这个代理就是一个空的table，其中__index和__newindex元方法可用于跟踪所有的访问，并将访问重定向到原来table中。
t = {} --原来 的table（在其他地方创建的）
--保持对原table的一个私有访问
local _t = t
--创建代理
t = {}
--创建元表
local mt = {
__index = function (t, k)
print("*access to element " .. tostring(k))
return _t[k]
end,
__newindex = function (t, k, v)
print("*update of element " .. tostring(k) .. "to " .. tostring(v))
_t[k] = v
end
}
setmetatable(t, mt)
这段代码跟踪了所有对t的访问：
t[2] = "hello"
*update of element 2 to hello
print(t[2])
*access to element 2
hello
但上例中的方法存在一个问题，就是无法遍历原来的table。函数pairs只能操作代理table，而无法访问原来的table。
如果想要同时监控几个table， 无须为每个table创建不同的元表。相反，只要以某种形式将每个代理与其原table关联起来。并且所有代理都共享一个公共的元表。这个问题与上节所讨论的将table与其默认值相关联的问题类似。例如，将原来的table 保存在代理table的一个特殊字段中。
local index = {}
local mt = {
__index = function (t, k)
print("*access to element " .. tostring(k))
return t[index][k] --访问原来的table
end,
__newindex = function (t, k, v)
print("*update of element " .. tostring(k) .. " to " .. tostring(v))
t[index][k] = v --更新原来的table
end
}
function track (t)
local proxy = {}
proxy[index] = t
setmetatable(proxy, mt)
return proxy
end
若要监视table t，唯一要做的就是执行：t = track(t)。
只读的table
通过代理的概念，可以很容易实现出只读的table。只需要跟踪所有对table的更新操作，并引发一个错误就可以了。由于无需跟踪查询操作，所以对__index元方法可以直接使用原table来代替函数。这也更简单，并且在重定向所有查询操作到原table时效率也更高。不过，这种做法要求为每个只读代理创建一个新的元表，其中__index指向原来的table。
function readOnly (t)
local proxy = {}
local mt = {
__index = t,
__newindex = function (t, k, v)
error("attempt to update a read-only table", 2)
end
}
setmetatable(proxy, mt)
return proxy
end
days = readOnly{"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}
print(days[1]) -->Sunday
days[2] = "Noday"
stdin:1 attempt to update a read-only table
扫一扫
189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
