掌叔
2010-01-18 20:43:54
Lua中的table由于定义的行为，我们可以对key-value对执行加操作，访问key对应的value，遍历所有的key-value。但是我们不可以对两个table执行加操作，也不可以比较两个表的大小。
Metatables 允许我们改变table的行为，例如，使用Metatables我们可以定义Lua如何计算两个table的相加操作a+b。当Lua试图对两个表进行相加时，他会检查两个表是否有一个表有Metatable，并且检查Metatable是否有__add域。如果找到则调用这个__add函数（所谓的 Metamethod）去计算结果。
Lua中的每一个表都有其Metatable。（后面我们将看到userdata也有Metatable），Lua默认创建一个不带metatable的新表
t = {}
print(getmetatable(t)) --> nil
可以使用setmetatable函数设置或者改变一个表的metatable
t1 = {}
setmetatable(t, t1)
assert(getmetatable(t) == t1)
任何一个表都可以是其他一个表的metatable，一组相关的表可以共享一个metatable（描述他们共同的行为）。一个表也可以是自身的metatable（描述其私有行为）。
13.1 算术运算的Metamethods
这一部分我们通过一个简单的例子介绍如何使用metamethods。假定我们使用table来描述结合，使用函数来描述集合的并操作，交集操作，like操作。我们在一个表内定义这些函数，然后使用构造函数创建一个集合：
Set = {}
function Set.new (t)
local set = {}
for _, l in ipairs(t) do set[l] = 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 s = "{"
local sep = ""
for e in pairs(set) do
s = s .. sep .. e
sep = ", "
end
return s .. "}"
end
function Set.print (s)
print(Set.tostring(s))
end
现在我们想加号运算符(+)执行两个集合的并操作，我们将所有集合共享一个metatable，并且为这个metatable添加如何处理相加操作。
第一步，我们定义一个普通的表，用来作为metatable。为避免污染命名空间，我们将其放在set内部。
Set.mt = {} -- metatable for sets
第二步，修改set.new函数，增加一行，创建表的时候同时指定对应的metatable。
function Set.new (t) -- 2nd version
local set = {}
setmetatable(set, Set.mt)
for _, l in ipairs(t) do set[l] = true end
return set
end
这样一来，set.new创建的所有的集合都有相同的metatable了：
s1 = Set.new{10, 20, 30, 50}
s2 = Set.new{30, 1}
print(getmetatable(s1)) --> table: 00672B60
print(getmetatable(s2)) --> table: 00672B60
第三步，给metatable增加__add函数。
Set.mt.__add = Set.union
当Lua试图对两个集合相加时，将调用这个函数，以两个相加的表作为参数。
通过metamethod，我们可以对两个集合进行相加：
s3 = s1 + s2
Set.print(s3) --> {1, 10, 20, 30, 50}
同样的我们可以使用相乘运算符来定义集合的交集操作
Set.mt.__mul = Set.intersection
Set.print((s1 + s2)*s1) --> {10, 20, 30, 50}
对于每一个算术运算符，metatable都有对应的域名与其对应，除了__add、__mul外，还有__sub(减)、__div(除)、__unm(负)、__pow(幂)，我们也可以定义__concat定义连接行为。
当我们对两个表进行加没有问题，但如果两个操作数有不同的metatable例如：
s = Set.new{1,2,3}
s = s + 8
Lua选择metamethod的原则：如果第一个参数存在带有__add域的metatable，Lua使用它作为metamethod，和第二个参数无关；
否则第二个参数存在带有__add域的metatable，Lua使用它作为metamethod 否则报错。
Lua不关心这种混合类型的，如果我们运行上面的s=s+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
... -- same as before
13.2 关系运算的Metamethods
Metatables 也允许我们使用metamethods：__eq（等于），__lt（小于），和__le（小于等于）给关系运算符赋予特殊的含义。对剩下的三个关系运算符没有专门的metamethod，因为Lua将a ~= b转换为not (a == b)；a > b转换为b < a；a >= b转换为 b <= a。
（直到Lua 4.0为止，所有的比较运算符被转换成一个，a <= b转为not (b < a)。然而这种转换并不一致正确。当我们遇到偏序（partial order）情况，也就是说，并不是所有的元素都可以正确的被排序情况。例如，在大多数机器上浮点数不能被排序，因为他的值不是一个数字（Not a Number即NaN）。根据IEEE 754的标准，NaN表示一个未定义的值，比如0/0的结果。该标准指出任何涉及到NaN比较的结果都应为false。也就是说，NaN <= x总是false，x < NaN也总是false。这样一来，在这种情况下a <= b 转换为 not (b < a)就不再正确了。）
在我们关于基和操作的例子中，有类似的问题存在。<=代表集合的包含：a <= b表示集合a是集合b的子集。这种意义下，可能a <= b和b < a都是false；因此，我们需要将__le和__lt的实现分开：
Set.mt.__le = function (a,b) -- set containment
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{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
与算术运算的metamethods不同，关系元算的metamethods不支持混合类型运算。对于混合类型比较运算的处理方法和Lua的公共行为类似。如果你试图比较一个字符串和一个数字，Lua将抛出错误。相似的，如果你试图比较两个带有不同metamethods的对象，Lua也将抛出错误。
但相等比较从来不会抛出错误，如果两个对象有不同的metamethod，比较的结果为false，甚至可能不会调用metamethod。这也是模仿了 Lua的公共的行为，因为Lua总是认为字符串和数字是不等的，而不去判断它们的值。仅当两个有共同的metamethod的对象进行相等比较的时候，Lua才会调用对应的metamethod。
13.3 库定义的Metamethods
在一些库中，在自己的metatables中定义自己的域是很普遍的情况。到目前为止，我们看到的所有metamethods都是Lua核心部分的。有虚拟机负责处理运算符涉及到的 metatables和为运算符定义操作的metamethods。但是，metatable是一个普通的表，任何人都可以使用。
tostring是一个典型的例子。如前面我们所见，tostring以简单的格式表示出table：
print({}) --> table: 0x8062ac0
（注意：print函数总是调用tostring来格式化它的输出）。然而当格式化一个对象的时候，tostring会首先检查对象是否存在一个带有 __tostring域的metatable。如果存在则以对象作为参数调用对应的函数来完成格式化，返回的结果即为tostring的结果。
在我们集合的例子中我们已经定义了一个函数来将集合转换成字符串打印出来。因此，我们只需要将集合的metatable的__tostring域调用我们定义的打印函数：
Set.mt.__tostring = Set.tostring
这样，不管什么时候我们调用print打印一个集合，print都会自动调用tostring，而tostring则会调用Set.tostring：
s1 = Set.new{10, 4, 5}
print(s1) --> {4, 5, 10}
setmetatable/getmetatable 函数也会使用metafield，在这种情况下，可以保护metatables。假定你想保护你的集合使其使用者既看不到也不能修改 metatables。如果你对metatable设置了__metatable的值，getmetatable将返回这个域的值，而调用 setmetatable 将会出错：
Set.mt.__metatable = "not your business"
s1 = Set.new{}
print(getmetatable(s1)) --> not your business
setmetatable(s1, {})
stdin:1: cannot change protected metatable
13.4 表相关的Metamethods
关于算术运算和关系元运算的metamethods都定义了错误状态的行为，他们并不改变语言本身的行为。针对在两种正常状态：表的不存在的域的查询和修改，Lua也提供了改变tables的行为的方法。
13.4.1 The __index Metamethod
前面说过，当我们访问一个表的不存在的域，返回结果为nil，这是正确的，但并不一定正确。实际上，这种访问触发lua解释器去查找__index metamethod：如果不存在，返回结果为nil；如果存在则由__index metamethod返回结果。
这个例子的原型是一种继承。假设我们想创建一些表来描述窗口。每一个表必须描述窗口的一些参数，比如：位置，大小，颜色风格等等。所有的这些参数都有默认的值，当我们想要创建窗口的时候只需要给出非默认值的参数即可创建我们需要的窗口。第一种方法是，实现一个表的构造器，对这个表内的每一个缺少域都填上默认值。第二种方法是，创建一个新的窗口去继承一个原型窗口的缺少域。首先，我们实现一个原型和一个构造函数，他们共享一个metatable：
-- create a namespace
Window = {}
-- create the prototype with default values
Window.prototype = {x=0, y=0, width=100, height=100, }
-- create a metatable
Window.mt = {}
-- declare the constructor function
function Window.new (o)
setmetatable(o, Window.mt)
return o
end
现在我们定义__index metamethod：
Window.mt.__index = function (table, key)
return Window.prototype[key]
end
这样一来，我们创建一个新的窗口，然后访问他缺少的域结果如下：
w = Window.new{x=10, y=20}
print(w.width) --> 100
当 Lua发现w不存在域width时，但是有一个metatable带有__index域，Lua使用w（the table）和width（缺少的值）来调用__index metamethod，metamethod则通过访问原型表（prototype）获取缺少的域的结果。
__index metamethod在继承中的使用非常常见，所以Lua提供了一个更简洁的使用方式。__index metamethod不需要非是一个函数，他也可以是一个表。但它是一个函数的时候，Lua将table和缺少的域作为参数调用这个函数；当他是一个表的时候，Lua将在这个表中看是否有缺少的域。所以，上面的那个例子可以使用第二种方式简单的改写为：
Window.mt.__index = Window.prototype
现在，当Lua查找metatable的__index域时，他发现window.prototype的值，它是一个表，所以Lua将访问这个表来获取缺少的值，也就是说它相当于执行：
Window.prototype["width"]
将一个表作为__index metamethod使用，提供了一种廉价而简单的实现单继承的方法。一个函数的代价虽然稍微高点，但提供了更多的灵活性：我们可以实现多继承，隐藏，和其他一些变异的机制。我们将在第16章详细的讨论继承的方式。
当我们想不通过调用__index metamethod来访问一个表，我们可以使用rawget函数。Rawget(t,i)的调用以raw access方式访问表。这种访问方式不会使你的代码变快（the overhead of a function call kills any gain you could have），但有些时候我们需要他，在后面我们将会看到。
13.4.2 The __newindex Metamethod
__newindex metamethod用来对表更新，__index则用来对表访问。当你给表的一个缺少的域赋值，解释器就会查找__newindex metamethod：如果存在则调用这个函数而不进行赋值操作。像__index一样，如果metamethod是一个表，解释器对指定的那个表，而不是原始的表进行赋值操作。另外，有一个raw函数可以绕过metamethod：调用rawset(t,k,v)不掉用任何metamethod对表t的 k域赋值为v。__index和__newindex metamethods的混合使用提供了强大的结构：从只读表到面向对象编程的带有继承默认值的表。在这一张的剩余部分我们看一些这些应用的例子，面向对象的编程在另外的章节介绍。
13.4.3有默认值的表
在一个普通的表中任何域的默认值都是nil。很容易通过metatables来改变默认值：
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
现在，不管什么时候我们访问表的缺少的域，他的__index metamethod被调用并返回0。setDefault函数为每一个需要默认值的表创建了一个新的metatable。在有很多的表需要默认值的情况下，这可能使得花费的代价变大。然而metatable有一个默认值d和它本身关联，所以函数不能为所有表使用单一的一个metatable。为了避免带有不同默认值的所有的表使用单一的metatable，我们将每个表的默认值，使用一个唯一的域存储在表本身里面。如果我们不担心命名的混乱，我可使用像"___"作为我们的唯一的域：
local mt = {__index = function (t) return t.___ end}
function setDefault (t, d)
t.___ = d
setmetatable(t, mt)
end
如果我们担心命名混乱，也很容易保证这个特殊的键值唯一性。我们要做的只是创建一个新表用作键值：
local key = {} -- unique key
local mt = {__index = function (t) return t[key] end}
function setDefault (t, d)
t[key] = d
setmetatable(t, mt)
end
另外一种解决表和默认值关联的方法是使用一个分开的表来处理，在这个特殊的表中索引是表，对应的值为默认值。然而这种方法的正确实现我们需要一种特殊的表：weak table，到目前为止我们还没有介绍这部分内容，将在第17章讨论。
为了带有不同默认值的表可以重用相同的原表，还有一种解决方法是使用memoize metatables，然而这种方法也需要weak tables，所以我们再次不得不等到第17章。
13.4.4监控表
__index 和__newindex都是只有当表中访问的域不存在时候才起作用。捕获对一个表的所有访问情况的唯一方法就是保持表为空。因此，如果我们想监控一个表的所有访问情况，我们应该为真实的表创建一个代理。这个代理是一个空表，并且带有__index和__newindex metamethods，由这两个方法负责跟踪表的所有访问情况并将其指向原始的表。假定，t是我们想要跟踪的原始表，我们可以：
t = {} -- original table (created somewhere)
-- keep a private access to original table
local _t = t
-- create proxy
t = {}
-- create metatable
local mt = {
__index = function (t,k)
print("*access to element " .. tostring(k))
return _t[k] -- access the original table
end,
__newindex = function (t,k,v)
print("*update of element " .. tostring(k) ..
" to " .. tostring(v))
_t[k] = v -- update original table
end
}
setmetatable(t, mt)
这段代码将跟踪所有对t的访问情况：
> t[2] = 'hello'
*update of element 2 to hello
> print(t[2])
*access to element 2
hello
（注意：不幸的是，这个设计不允许我们遍历表。Pairs函数将对proxy进行操作，而不是原始的表。）如果我们想监控多张表，我们不需要为每一张表都建立一个不同的metatable。我们只要将每一个proxy和他原始的表关联，所有的proxy共享一个公用的metatable即可。将表和对应的 proxy关联的一个简单的方法是将原始的表作为proxy的域，只要我们保证这个域不用作其他用途。一个简单的保证它不被作他用的方法是创建一个私有的没有他人可以访问的key。将上面的思想汇总，最终的结果如下：
-- create private index
local index = {}
-- create metatable
local mt = {
__index = function (t,k)
print("*access to element " .. tostring(k))
return t[index][k] -- access the original table
end
__newindex = function (t,k,v)
print("*update of element " .. tostring(k) .. " to "
.. tostring(v))
t[index][k] = v -- update original table
end
}
function track (t)
local proxy = {}
proxy[index] = t
setmetatable(proxy, mt)
return proxy
end
现在，不管什么时候我们想监控表t，我们要做得只是t=track(t)。
13.4.5只读表
采用代理的思想很容易实现一个只读表。我们需要做得只是当我们监控到企图修改表时候抛出错误。通过__index metamethod，我们可以不使用函数而是用原始表本身来使用表，因为我们不需要监控查寻。这是比较简单并且高效的重定向所有查询到原始表的方法。但是，这种用法要求每一个只读代理有一个单独的新的metatable，使用__index指向原始表：
function readOnly (t)
local proxy = {}
local mt = { -- create metatable
__index = t,
__newindex = function (t,k,v)
error("attempt to update a read-only table", 2)
end
}
setmetatable(proxy, mt)
return proxy
end
（记住：error的第二个参数2，将错误信息返回给企图执行update的地方）作为一个简单的例子，我们对工作日建立一个只读表：
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