javascript语言本身不支持面向对象,ES2015中增加了class关键字,却不过是prototype语法糖而已,本质上prototype形式的面向对象只能算是一种“模拟”,这其中很重要的原因之一是js从来没有一套完美的深拷贝方案,子类只能借助原型链获取父类方法的引用,这不能算是严格意义的继承,当然也就算不上面向对象。

和js一样,lua的面向对象需要通过table来模拟,有些行为很像js中的原型,比如下面的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Animal = {name = "Animal"}
Animal.__index= Animal
function ()
local re = {}
setmetatable(re, self)
return re
end
function Animal:GetName()
return self.name
end
x = Animal:new()

在lua中,元表是个很有意思的存在。上面Animal是实例出的对象x的元表,元表在某种意义上相当于js中的构造函数,而__index则类似prototype(这里__index我设置为指向自身)。

1
2
3
4
5
print(x.name)
print(x:GetName())
Animal.name = "Animal2"
print(x.name) -- Animal2
print(x:GetName()) -- Animal2

如果在x中不存在name键,对x.name的访问实际上会从x的元表中的__index键寻找,如果仍然找不到,则会在Animal的元表中继续找,若既没有元表也找不到该键,返回nil,这和js原型链如出一辙。

借助元表,我们很容易模拟面向对象中的继承和多态,比如我们来实现一个继承自Animal的Dog类。

1
2
3
4
5
6
7
8
9
Dog = {}
setmetatable(Dog, Animal)
function Dog:new()
local re = {}
setmetatable(re, self)
self.__index = self
return re
end

效果如下。

1
2
3
4
5
6
7
y = Dog:new()
print(y:GetName())
Animal.name = "Hello"
print(y.GetName()) -- Hello
Dog.name = "Dog"
print(y.GetName()) -- Dog

实际上,lua中的元表比js中的原型机制强大的多。

上述的例子是Lua中最常见的实现OO的方法,除了关键的setmetatable函数,__index键也很重要,它不仅可以是另一个table的引用,也可以是一个函数,当实例对象试着从__index寻找时便会调用这个函数,可以想象,这为多重继承的实现提供了可能,而js做不到这一点(参考)。

举个简单的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
-- 定义两个相似的类A和B
A = {foo1 = 123, name = "A"}
A.__index = A
B = {foo2 = 456, name = "B"}
B.__index = B
function A:new()
local re = {}
setmetatable(re, self)
return re
end
function A:GetName()
print(self.name)
end
function B:new()
local re = {}
setmetatable(re, self)
return re
end
function B:GetName()
print(self.name)
end
function B:MethodOnB()
print("method on B")
end
-- 定义类C,继承自A和B
C = {}
function C:new()
local childA = A:new()
local childB = B:new()
local re = {}
setmetatable(re, {
__index = function (table, key)
if childA[key] then
return childA[key]
elseif childB[key] then
return childB[key]
else
return "not found"
end
end
})
return re
end
x = C:new()
print(x.foo1) -- 123
print(x.foo2) -- 456
x:GetName() -- A
x:MethodOnB() -- method on B

C类继承了来自A和B的方法。

注意到上面的例子中A和B都拥有GetName方法,我们可以进一步假设A和B都继承自另外一个对象,而他们各自的GetName方法其实都继承自这个对象,这就产生了经典的钻石问题(也叫菱形继承问题),即:C继承到的GetName方法到底来自A还是B?一些原生支持面向对象和多重继承的语言为了解决钻石问题,往往会采用特定的遍历算法,如Python采用的是从左到右广度优先原则,使用的是名叫“C3”的算法。而在上面这里例子里我只是简单的指定了先从A中寻找,再从B中寻找,所以C继承了A的GetName方法。

在lua中,元表除了用来模拟面向对象,还有一些不可思议的作用:自定义table间运算的行为。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
-- 定义加法行为
meta = {__add = function(A, B)
local re = {}
for _, val in ipairs(A) do
table.insert(re, val)
end
for _, val in ipairs(B) do
table.insert(re, val)
end
return re
end
}
a = setmetatable({1, 2, 3}, meta)
b = setmetatable({4, 5, 6}, meta)
c = a + b -- {1, 2, 3, 4, 5, 6}

除了__add,元表上可自定义的运算行为包括如下。

1
2
3
4
5
6
7
8
9
10
__add 对应的运算符 '+'.
__sub 对应的运算符 '-'.
__mul 对应的运算符 '*'.
__div 对应的运算符 '/'.
__mod 对应的运算符 '%'.
__unm 对应的运算符 '-'.
__concat 对应的运算符 '..'.
__eq 对应的运算符 '=='.
__lt 对应的运算符 '<'.
__le 对应的运算符 '<='.

而除了运算,元表甚至可以让table像函数一样调用,使用__call

1
2
3
4
5
a = setmetatable({}, {__call = function(mytable, params)
print("123"..params)
end})
a(456) -- 123456

所有上述提到的在元表上以__开头的方法统称为元方法

元表有这么多有意思的设计,也难怪lua程序员说js中的原型只能算实现了元表功能的十分之一。

话说回来,在lua中使用面向对象和在js中的感觉差不多,过去基于prototype模拟OO,很多人有不同的实现,如今js在语法层面统一了写法,而在lua中仍然有很多人尝试对上面这些例子的写法进行封装,试图让代码更容易维护和扩展,这样的折腾其实没什么意义,因为面向对象本身就不易维护。以小而精致著称的lua也不太可能提供语言层面支持,毕竟连社区都没几个,也没看到有人表达这样的诉求,函数式语言就写函数式,多好。