元表

lua中的变量是没有数据类型的，值有类型。类型有八种nil,number,boolean, string, function, thread, userdata以及table。

table 作为 Lua 中唯一的数据结构，我们可以利用 table 实现面向对象编程中的类、继承、多重继承等等。

元表的概念

Lua 中的每个值都有一个元表。这个元表就是一个普通的 Lua 表，它用于定义原始值在特定操作下的行为。如果你想改变一个值在特定操作下的行为，你可以在它的元表中设置对应域。

table 和 userdata 可以有各自独立的元表，而其他类型的值则共享其类型所属的单一元表。任何 table 都可以作为任何值的元表，而一组相关的 table 也可以共享一个通用的元表。一个 table 甚至可以作为它自己的元表。

通过 getmetatable 方法可以获取一个值的元表，而 setmetatable 方法则可以设置一个值的元表。

t = {}
print(getmetatable(t)) --> nil
t1 = {}
setmetatable(t, t1)
assert(getmetatable(t) == t1)t2 = {}
setmetatable(t2, t2)
assert(getmetatable(t2) == t2)

在 Lua 代码中，只能设置 table 的元表。若要设置其他类型的值的元表，则必须通过 C 代码来完成。从下面的代码也可以看出 Lua 中的所有字符串值是共用一个元表的。

print(getmetatable("hi")) --> table: 0x7fd0b14074b0
print(getmetatable("hello")) --> table: 0x7fd0b14074b0
print(getmetatable(10)) --> nil
print(getmetatable(false)) --> nil
print(getmetatable(function () end)) --> nilsetmetatable("hi", {}) --> error:bad argument #1 to 'setmetatable' (table expected, got string)

元方法

元方法的概念

元表中的键对应着不同的事件名；键关联的那些值被称为元方法。

例如，当你对非数字值做加操作时，Lua 会检查该值的元表中的 “__add” 域下的函数。如果能找到，Lua 则调用这个函数来完成加这个操作。
在这个例子中引用的事件为 “add” ，完成加操作的那个函数就是元方法。

你可以用 getmetatable 函数来获取任何值的元表。

使用 setmetatable 来替换一张表的元表。在 Lua 中，你不可以改变表以外其它类型的值的元表（除非你使用调试库）；若想改变这些非表类型的值的元表，请使用CAPI。

表和完全用户数据有独立的元表（当然，多个表和用户数据可以共享同一个元表）。其它类型的值按类型共享元表；也就是说所有的数字都共享同一个元表，所有的字符串共享另一个元表等等。默认情况下，值是没有元表的，但字符串库在初始化的时候为字符串类型设置了元表。

元表决定了一个对象在数学运算、位运算、比较、连接、取长度、调用、索引时的行为。元表还可以定义一个函数，当表对象或用户数据对象在垃圾回收时调用它。

注意：Lua 从元表中直接获取元方法；访问元表中的元方法永远不会触发另一次元方法。

下面的代码模拟了 Lua 从一个对象 obj 中获取一个元方法的过程：

rawget(getmetatable(obj) or {}, "__" .. event_name)。

对于一元操作符（取负、求长度、位反），元方法调用的时候，第二个参数是个哑元，其值等于第一个参数。这样处理仅仅是为了简化 Lua 的内部实现（这样处理可以让所有的操作都和二元操作一致），这个行为有可能在将来的版本中移除。（使用这个额外参数的行为都是不确定的。）

下面给出一张元表可以控制的事件的完整列表。每个操作都用对应的事件名来区分。每个事件的键名用加有 ‘__’ 前缀的字符串来表示；例如 “add” 操作的键名为字符串 “__add”。

"add": + 操作。如果任何不是数字的值（包括不能转换为数字的字符串）做加法，Lua 就会尝试调用元方法。首先、Lua 检查第一个操作数（即使它是合法的），如果这个操作数没有为 “__add” 事件定义元方法，Lua 就会接着检查第二个操作数。一旦 Lua 找到了元方法，它将把两个操作数作为参数传入元方法，元方法的结果（调整为单个值）作为这个操作的结果。如果找不到元方法，将抛出一个错误。
"sub": - 操作。行为和 “add” 操作类似。
"mul": * 操作。行为和 “add” 操作类似。
"div": / 操作。行为和 “add” 操作类似。
"mod":% 操作。行为和 “add” 操作类似。
"pow":^ （次方）操作。行为和 “add” 操作类似。
"unm":- （取负）操作。行为和 “add” 操作类似。
"idiv": // （向下取整除法）操作。行为和 “add” 操作类似。
"band"& （按位与）操作。行为和 “add” 操作类似，不同的是 Lua 会在任何一个操作数无法转换为整数时尝试取元方法。
"bor": | （按位或）操作。行为和 “band” 操作类似。
"bxor":~ （按位异或）操作。行为和 “band” 操作类似。
"bnot":~ （按位非）操作。行为和 “band” 操作类似。
"shl":<< （左移）操作。行为和 “band” 操作类似。
"shr":>> （右移）操作。行为和 “band” 操作类似。
"concat":… （连接）操作。行为和 “add” 操作类似，不同的是 Lua 在任何操作数即不是一个字符串也不是数字（数字总能转换为对应的字符串）的情况下尝试元方法。
"len":# （取长度）操作。如果对象不是字符串，Lua 会尝试它的元方法。如果有元方法，则调用它并将对象以参数形式传入，而返回值（被调整为单个）则作为结果。如果对象是一张表且没有元方法，Lua 使用表的取长度操作。其它情况，均抛出错误。
"eq":== （等于）操作。和 “add” 操作行为类似，不同的是 Lua 仅在两个值都是表或都是完全用户数据且它们不是同一个对象时才尝试元方法。调用的结果总会被转换为布尔量。
"lt":< （小于）操作。和 “add” 操作行为类似，不同的是 Lua 仅在两个值不全为整数也不全为字符串时才尝试元方法。调用的结果总会被转换为布尔量。
"le":<= （小于等于）操作。和其它操作不同，小于等于操作可能用到两个不同的事件。首先，像 “lt” 操作的行为那样，Lua 在两个操作数中查找 “__le” 元方法。如果一个元方法都找不到，就会再次查找 “__lt” 事件，它会假设 a <= b 等价于 not (b < a)。而其它比较操作符类似，其结果会被转换为布尔量。
"index":索引 table[key]。当 table 不是表或是表 table 中不存在key 这个键时，这个事件被触发。此时，会读出 table 相应的元方法。尽管名字取成这样，这个事件的元方法其实可以是一个函数也可以是一张表。如果它是一个函数，则以 table 和 key 作为参数调用它。如果它是一张表，最终的结果就是以 key 取索引这张表的结果。（这个索引过程是走常规的流程，而不是直接索引，所以这次索引有可能引发另一次元方法。）
"newindex":索引赋值 table[key] = value 。和索引事件类似，它发生在table 不是表或是表 table 中不存在key 这个键的时候。此时，会读出 table 相应的元方法。同索引过程那样，这个事件的元方法即可以是函数，也可以是一张表。如果是一个函数，则以 table、 key、以及 value 为参数传入。如果是一张表，Lua 对这张表做索引赋值操作。（这个索引过程是走常规的流程，而不是直接索引赋值，所以这次索引赋值有可能引发另一次元方法。）一旦有了 “newindex” 元方法，Lua 就不再做最初的赋值操作。（如果有必要，在元方法内部可以调用 rawset来做赋值。）
"call":函数调用操作 func(args)。当 Lua 尝试调用一个非函数的值的时候会触发这个事件（即 func 不是一个函数）。查找 func 的元方法，如果找得到，就调用这个元方法，func 作为第一个参数传入，原来调用的参数（args）后依次排在后面。

算术类的元方法：__add（加法）、__mul（乘法）、__sub（减法）、__div（除法）、__unm（相反数）、__mod（取模）、__pow（乘幂）。

关系类的元方法：__eq（等于）、__lt（小于）、__le（小于等于）。其他的关系操作符则没有单独的元方法，Lua 会将 a ~= b 转换为 not a == b ，将 a > b 转换为 a < b ，将 a >= b 转换为 a <= b 。

库定义的元方法：__tostring、__metatable。

函数 print 总是调用 tostring 来格式化其输出。当格式化任意值时，tostring 会检查该值是否有一个 __tostring 的元方法。如果有这个元方法，tostring 就用该值作为参数来调用这个元方法，该元方法的返回值就是 tostring 的结果。

函数 setmetatable 和 getmetatable 会触发 __metatable 元方法。当 Lua 中的值拥有该元方法时，getmetatable 就会返回这个字段的值，而 setmetatable 则会引发一个错误。因此我们可以使用 __metatable 元方法来保护任意值的元表，这样值的元表就不会被随意修改了。

t = {}
mt = {}
mt.__metatable = "not your business"
setmetatable(t, mt)print(getmetatable(t)) --> not your business
setmetatable(t, {}) --> error:cannot change a protected metatable

table 访问的元方法：__index、__newindex。

算术类和关系类的元方法

算术类和关系类的元方法类似于其他编程语言中的操作符重载，我们可以利用元方法来实现任何不是数字的值（包括不能转换为数字的字符串）的算术和关系运算。

local mt = {}
mt.__add = function (a, b)print("call mt.__add")return {x = a.x + b.x, y = a.y + b.y}
endmt.__eq = function (a, b)print("call mt.__eq")return a.x == b.x and a.y == b.y
endmt.__tostring = function (point)print("call mt.__tostring")return string.format("[x = %f, y = %f]", point.x, point.y)
endPoint = {}
function Point.new(x, y)local point = {x = x, y = y}setmetatable(point, mt)return point
endlocal p1 = Point.new(10, 10)
local p2 = Point.new(20, 20)
print(p1)
print(tostring(p2))print("----------")
local p3 = p1 + p2
print(p3)print("----------")
print(p1 == p2)print("----------")
print(p1 ~= p2)

执行以上代码输出如下：

call mt.__tostring
[x = 10.000000, y = 10.000000]
call mt.__tostring
[x = 20.000000, y = 20.000000]
----------
call mt.__add
table: 0x7fd462504e10
----------
call mt.__eq
false
----------
call mt.__eq
true

rawget 和 rewset 方法

rawget (table, index) 在不触发任何元方法的情况下获取 table[index] 的值。table 必须是一张表；index 可以是任何值。

rawset (table, index, value) 在不触发任何元方法的情况下将 table[index] 设为 value。table 必须是一张表，index 可以是 nil 与 NaN 之外的任何值。value 可以是任何 Lua 值。这个函数返回 table。

index 元方法

当访问一个 table 中不存在的字段时，会去查找一个叫 index 的元方法。如果没有这个元方法，那么访问结果就为nil，否则，就有这个元方法来提供最终结果。

Window = {}
Window.prototype = {x = 0, y = 0, width = 100, height = 100}
Window.mt = {}function Window.new(o)setmetatable(o, Window.mt)return o
endWindow.mt.__index = function (table, key)print("call __index function", table, key)return Window.prototype[key]
endw = Window.new({x = 10, y = 20})print("w", w)
print("w.x =", w.x)
print("w.y =", w.y)print("----------\n")
print("rawget w.x =", rawget(w, "width"))
print("w.width =", w.width)
print("w.height =", w.height)print("----------\n")
print("set w.width = 555")
w.width = 555
print("w.width =", w.width)

执行上面代码会输出：

w   table: 0x7fc932c08b70
w.x =   10
w.y =   20
----------rawget w.x =    nil
call __index function   table: 0x7fc932c08b70   width
w.width =   100
call __index function   table: 0x7fc932c08b70   height
w.height =  100
----------set w.width = 555
w.width =   555

index 元方法不必一定是一个函数，它还可以是一个 table。当他是一个 table 时，Lua 就以相同的方式来重新访问这个table。

Window = {}
Window.prototype = {x = 0, y = 0, width = 100, height = 100}
Window.mt = {}function Window.new(o)setmetatable(o, Window.mt)return o
endWindow.mt.__index = Window.prototypew = Window.new({x = 10, y = 20})print("w.x =", w.x)
print("w.y =", w.y)
print("w.width =", w.width)
print("w.height =", w.height)print("----------\n")
print("set w.height = 888")
w.height = 888
print("w.height =", w.height)
print("getmetatable(w).__index.height =", getmetatable(w).__index.height)

执行上面代码会输出：

w.x =   10
w.y =   20
w.width =   100
w.height =  100
----------set w.height = 888
w.height =  888
getmetatable(w).__index.height =    100

总结：一般我们会把一个 table 作为 index 元方法，只有在特殊需求时才会把一个函数作为 index 元方法。将一个 table 作为 index 元方法是一种快捷的、实现单一继承的方式。虽然用函数作为 index 来实现相同功能的开销很大，但函数更加灵活。可以通过函数来实现多重继承、缓存及其他功能。如果我们想在不触发 index 元方法的情况下访问一个 table，可以使用 rawget 方法。

ipairs 和 pairs

t = {1, 2, a = "a"}
mt = {}
-- mt.__index = function (t, key)
--  print("call __index function", t, key)
-- endmt.__index = {111, 222, 333, 444, a = "aaa", b = "bbb"}setmetatable(t, mt)-- 从下列代码的打印可以看出，ipairs 会触发 __index 元方法
print("--- ipairs --")
for i,v in ipairs(t) doprint(i,v)
endprint("")-- 从下列代码的打印可以看出，pairs 不会触发 __index 元方法
print("--- pairs --")
for k,v in pairs(t) doprint(k,v)
end

执行上面代码会输出：

--- ipairs --
1   1
2   2
3   333
4   444--- pairs --
1   1
2   2
a   a

从以上输出可以看出：ipairs 会触发 index 元方法；而 pairs 不会触发 index 元方法。

newindex 元方法

当对一个 table 中不存在的索引赋值时，解释器就会查找 newindex 元方法。如果有这个元方法，解释器就调用它，而不是执行赋值。如果这个元方法是一个 table，解释器就在此 table 中执行赋值，而不是对原来的 table。调用 rawset(t, k, v) 就可以不涉及任何元方法而直接设置 table t 中与 key k 相关联的 value v。

t = {a = 100}
mt = {}mt.__newindex = function (t, key, value)print("call __newindex function", t, key, value)
end
setmetatable(t, mt)print("set t.a = 666")
t.a = 666
print("set t.b = 888")
t.b = 888print("----------\n")
print([=[rawset(t, "c", 999)]=])
rawset(t, "c", 999)

执行上面代码会输出：

set t.a = 666
set t.b = 888
call __newindex function    table: 0x7f8842500000   b   888
----------rawset(t, "c", 999)

简单应用实例

具有默认值的 table

local key = {} -- 唯一的 key
local mt = {__index = function (t) return t[key] end}
function setDefault(t, d)t[key] = dsetmetatable(t, mt)
endt = {x = 10, y = 10}
print(t.x, t.z) --> 10 nilsetDefault(t, 100)
print(t.x, t.z) --> 10 100

跟踪 table 的访问

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

如果想要同时监视几个 table，无须为每个 table 创建不同的元表。相反，只要以某种形式将每个代理与其原 table 关联起来，并且所有代理都共享一个公共的元表。

local index = {}
local mt = {__index = function (t, k)print("*access to element " .. tostring(k))return t[index][k]end,__newindex = function (t, k, v)print("*update of element " .. tostring(k) .. " to " .. tostring(v))t[index][k] = vend
}function track(t)local proxy = {}proxy[index] = tsetmetatable(proxy, mt)return proxy
endt = {}
t = track(t)t[1] = "hello"
print(t[1])t["k"] = "v"
print(t["k"])

执行以上代码会输出：

*update of element 1 to hello
*access to element 1
hello
*update of element k to v
*access to element k
v

只读 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
enddays = readOnly{"Sunday", "Monday", "Tuesday"}
print(days[1]) --> Sunday
days[2] = "Noday" --> error: attempt to update a read-only table