举例说明Lua中元表和元方法的使用

table的元表提供了一种机制，可以重定义table的一些操作。

之后我们会看到元表是如何支持类似js的prototype行为。

f1 = {a = 1, b = 2} -- 表示一个分数 a/b.

f2 = {a = 2, b = 3}

-- 这个是错误的：

-- s = f1 + f2

metafraction = {}

function metafraction.__add(f1, f2)

sum = {}

sum.b = f1.b * f2.b

sum.a = f1.a * f2.b + f2.a * f1.b

return sum

end

setmetatable(f1, metafraction)

setmetatable(f2, metafraction)

s = f1 + f2 -- 调用在f1的元表上的__add(f1, f2) 方法

-- f1, f2 没有能访问它们元表的key，这与prototype不一样，

-- 所以你必须用getmetatable(f1)去获得元表。元表是一个普通的table，

-- Lua可以通过通常的方式去访问它的key，例如__add。

-- 不过下面的代码是错误的，因为s没有元表：

-- t = s + s

-- 下面的类形式的模式可以解决这个问题：

-- 元表的__index 可以重载点运算符的查找：

defaultFavs = {animal = 'gru', food = 'donuts'}

myFavs = {food = 'pizza'}

setmetatable(myFavs, {__index = defaultFavs})

eatenBy = myFavs.animal -- 可以工作！这要感谢元表的支持

如果在table中直接查找key失败，会使用元表的__index 继续查找，并且是递归的查找

__index的值也可以是函数function(tbl, key) ，这样可以支持更多的自定义的查找。

__index、__add等等，被称为元方法。

这里是table的元方法的全部清单：

-- __add(a, b) for a + b

-- __sub(a, b) for a - b

-- __mul(a, b) for a * b

-- __div(a, b) for a / b

-- __mod(a, b) for a % b

-- __pow(a, b) for a ^ b

-- __unm(a) for -a

-- __concat(a, b) for a .. b

-- __len(a) for #a

-- __eq(a, b) for a == b

-- __lt(a, b) for a < b

-- __le(a, b) for a <= b

-- __index(a, b) <fn or a table> for a.b

-- __newindex(a, b, c) for a.b = c

-- __call(a, ...) for a(...)

类风格的table和继承

类并不是内置的；有不同的方法通过表和元表来实现。

下面是一个例子，后面是对例子的解释

Dog = {} -- 1.

function Dog:new() -- 2.

newObj = {sound = 'woof'} -- 3.

self.__index = self -- 4.

return setmetatable(newObj, self) -- 5.

end

function Dog:makeSound() -- 6.

print('I say ' .. self.sound)

end

mrDog = Dog:new() -- 7.

mrDog:makeSound() -- 'I say woof' -- 8.

-- 1. Dog看上去像一个类；其实它完全是一个table。

-- 2. 函数tablename:fn(...) 与函数tablename.fn(self, ...) 是一样的

-- 冒号（:）只是添加了self作为第一个参数。

-- 下面的第7和第8条说明了self变量是如何得到其值的。

-- 3. newObj是类Dog的一个实例。

-- 4. self为初始化的类实例。通常self = Dog，不过继承关系可以改变这个。

-- 如果把newObj的元表和__index都设置为self，

-- newObj就可以得到self的函数。

-- 5. 记住：setmetatable返回其第一个参数。

-- 6. 冒号（：）在第2条是工作的，不过这里我们期望

-- self是一个实例，而不是类

-- 7. 与Dog.new(Dog)类似，所以 self = Dog in new()。

-- 8. 与mrDog.makeSound(mrDog)一样; self = mrDog。

继承的例子：

LoudDog = Dog:new() -- 1.

function LoudDog:makeSound()

s = self.sound .. ' ' -- 2.

print(s .. s .. s)

end

seymour = LoudDog:new() -- 3.

seymour:makeSound() -- 'woof woof woof' -- 4.

-- 1. LoudDog获得Dog的方法和变量列表。

-- 2. 通过new()，self有一个'sound'的key from new()，参见第3条。

-- 3. 与LoudDog.new(LoudDog)一样，并且被转换成

-- Dog.new(LoudDog)，因为LoudDog没有'new' 的key，

-- 不过在它的元表可以看到 __index = Dog。

-- 结果: seymour的元表是LoudDog，并且

-- LoudDog.__index = LoudDog。所以有seymour.key

-- = seymour.key, LoudDog.key, Dog.key, 要看

-- 针对给定的key哪一个table排在前面。

-- 4. 在LoudDog可以找到'makeSound'的key；这与

-- LoudDog.makeSound(seymour)一样。

-- 如果需要，子类也可以有new()，与基类的类似：

function LoudDog:new()

newObj = {}

-- 初始化newObj

self.__index = self

return setmetatable(newObj, self)

end