lua

Lua语言学习笔记

Posted by spirytusz on 2019-04-26

0. 前言

最近学习了Lua语言，记录一下自己觉得对几个重要概念的学习过程。

1. Table

table是Lua语言的一个重要的数据结构。它很像一个Map，我们可以通过给出一个key来获得对应的value。并且，table的key可以是除nil以外的任意类型。看代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
local tab = {}

tab.a = 1

tab['b'] = '233'

tab[f] = function()
    print('call a function')
end

for k, v in pairs(tab) do
    print(string.format('tab.%s = %s', tostring(k), tostring(v)))
end

-- Output:
-- tab.a = 1
-- tab.b = 233
-- tab.f = function

Lua的table不止于此，还有很多骚操作。

1.1. MetaTable

MetaTable是Lua中元表。个人认为，元表是对table操作时触发的行为的集合。「触发的行为」是什么？它可以是一个function，定义这个行为做什么；也可以是一个table，定义这个行为的备选table。元表可以有很多属性，具体参照官网，我以__index为例。

1.1.1. __index

__index定义了在table中通过给定的key找到的value为nil时怎么办的行为。话不多说看代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
local aTable = {}
local aMetatable = {}

print(aTable.y)

setmetatable(aTable, aMetatable)
print(aTable.y)

aMetatable.__index = function(t,k)
    -- t就是aTable
    local tempTable = { y = 666 }
    return tempTable[k]
end
print(aTable.y)

-- Output:
-- nil
-- nil
-- 666

首先先声明和定义两个table，aMetatable后面用作aTable的元表。元表同样也是一个表，所以这么声明没毛病。然后获取aTable的y属性的值，不用想，肯定是获得的是一个空值。接着，把aTable的元表设为aMetatable，然后再获取一次aTable的y属性的值。同样的，获得的是一个空值。为什么？因为aTable的元表没有任何可以触发的行为。那就为aTable的元表增加一个行为__index，在打印一个aTable的y属性的值，这会就打印出666了。总结一下这个过程：当我们访问aTable的y属性时，Lua虚拟机发现它是空值，所以他就会在aTable的元表中找到__index这个属性，如果这个属性是一个function，那就执行它，并把它的执行结果，返回作aTable的y属性的值。

当然上面的代码在设置元表时可以更加简化：

1
aMetatable.__index = { y = 666 }

执行完这段语句，元表中__index这个行为就是一个table了。这个当我们访问aTable的y属性时，Lua虚拟机发现aTable.y是空的，就会去aMetatable.__index这个「表」里面把y作为key去取一个值并返回。这与上面的代码是等价的。

然而我总感觉还少了点什么，上面的代码，我只是根据输出来猜测它的行为，而不能确定它是怎么做到的。于是我在Lua的源代码里，全局搜索关键词「__index」，成功定位到__index的实现：

lvm.c
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
/*
** Finish the table access 'val = t[key]'.
** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
** t[k] entry (which must be nil).
*/
void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
                      const TValue *slot) {
  int loop;  /* counter to avoid infinite loops */
  const TValue *tm;  /* metamethod */
  for (loop = 0; loop < MAXTAGLOOP; loop++) {
    if (slot == NULL) {  /* 't' is not a table? */
      lua_assert(!ttistable(t));
      tm = luaT_gettmbyobj(L, t, TM_INDEX);
      if (ttisnil(tm))
        luaG_typeerror(L, t, "index");  /* no metamethod */
      /* else will try the metamethod */
    }
    else {  /* 't' is a table */
      lua_assert(ttisnil(slot));
      tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);  /* table's metamethod */
      if (tm == NULL) {  /* no metamethod? */
        setnilvalue(val);  /* result is nil */
        return;
      }
      /* else will try the metamethod */
    }
    if (ttisfunction(tm)) {  /* is metamethod a function? */
      luaT_callTM(L, tm, t, key, val, 1);  /* call it */
      return;
    }
    t = tm;  /* else try to access 'tm[key]' */
    if (luaV_fastget(L,t,key,slot,luaH_get)) {  /* fast track? */
      setobj2s(L, val, slot);  /* done */
      return;
    }
    /* else repeat (tail call 'luaV_finishget') */
  }
  luaG_runerror(L, "'__index' chain too long; possible loop");
}

解释一下，首先定义声明一个loop防止死循环，tm存储在元表中查找__index的结果。至于为什么要防止死循环可以不管，因为不是我们读源码的目的。接着定位到for循环内的第一个if-else分支，if分支内，注释说这是t不是一个table的情况。我们可以跳过，看看else分支，else分支是t是table的情况。else分支会去找table: t的元表，如果找到的元表为空，或者是元表中找不到__index属性，那就把结果设置为空，提前返回。如果找到了__index那就继续。接着看第二个if分支，如果__index是一个函数，那就用luaT_callTM调用它，luaT_callTM的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
                  const TValue *p2, TValue *p3, int hasres) {
  ptrdiff_t result = savestack(L, p3);
  StkId func = L->top;
  setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
  setobj2s(L, func + 1, p1);  /* 1st argument */
  setobj2s(L, func + 2, p2);  /* 2nd argument */
  L->top += 3;
  if (!hasres)  /* no result? 'p3' is third argument */
    setobj2s(L, L->top++, p3);  /* 3rd argument */
  /* metamethod may yield only when called from Lua code */
  if (isLua(L->ci))
    luaD_call(L, func, hasres);
  else
    luaD_callnoyield(L, func, hasres);
  if (hasres) {  /* if has result, move it to its place */
    p3 = restorestack(L, result);
    setobjs2s(L, p3, --L->top);
  }
}

可以看到，luaT_callTM先把栈的状态保存起来，再把__index这个函数，及其第一个参数，第二个参数推入，因为hasres为1，所以第一个if分支不执行。接着，第二个if-else就调用__index方法。到了第三个if分支，因为hasres为1，所以会执行这个分支。这个if分支会还原栈的状态，并把结果赋值给p3，也就是上游传过来的val，然后把结果推入栈中。结束。
再回到luaV_finishget，到了最后一个if分支，看代码的意思，就是直接把__index当做一个table，在这个table中以给定的key查找value，并把查找结果返回。至此__index的实现原理就结束了。
结论是，如果__index是一个function，那就会把原table以及key传入给这个function，这个function处理后把结果返回，Lua虚拟机会把这个结果当做是查询结果；如果__index是一个table，那就用给定的key在__index中查询，并把结果返回。这和上面的猜测是相符的。

1.2. Function的默认参数

我们初始化一个对象，这个对象里面可能有些属性不是必填的。比如一个person，它的属性name、age、sex都是必填的，而height、weight是选填的。我们很自然的就会这么定义一个函数来初始化person：

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
function initPerson(name, age, sex, height, weight)
    -- 初始化..
    local person = getDefault()
    person.name = name
    person.age = age
    person.sex = sex
    person.height = height or 0
    person.weight = weight or 0
    return person
end

function printPerson( person )
    print(string.format(
            'name = %s, age = %d, sex = %s, height = %d, weight = %d', 
            person.name, 
            person.age, 
            person.sex, 
            person.height, 
            person.weight
    ))
end

-- 仅传入必填属性
local p1 = initPerson('Q1', 23, 'female')
printPerson(p1)

-- 传入必填属性+身高？
local p2 = initPerson('Q2', 23, 'female', 169)
printPerson(p1)

-- 传入必填属性+体重？
local p3 = initPerson('Q3', 23, 'female', 55)
printPerson(p1)

-- Output:
-- name = Q1, age = 23, sex = female, height = 0, weight = 0
-- name = Q2, age = 23, sex = female, height = 169, weight = 0
-- name = Q3, age = 23, sex = female, height = 55, weight = 0

输出不符合我们的预期，因为Lua在传递参数是会把实参顺序推入到栈中，再按顺序对号入座到形参。如何解决默认参数的问题，我们可以传入一个table，这个table中以key为参数，value为参数的值。在初始化person的函数中，我们用key来在传来的table中取出对应参数的值，如果取出来的value为空，那就或一下，给它设置一个默认值就好了。代码如下：

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
function initPerson( tPerson )
    -- 初始化..
    local person = getDefault()
    person.name = tPerson.name
    person.age = tPerson.age
    person.sex = tPerson.sex
    person.height = tPerson.height or 0
    person.weight = tPerson.weight or 0
    return person
end

-- 仅传入必填属性
local p1 = initPerson({name = 'Q1', age = 23, sex = 'female'})
printPerson(p1)

-- 传入必填属性+身高？
local p2 = initPerson({name = 'Q1', age = 23, sex = 'female', height = 169})
printPerson(p1)

-- 传入必填属性+体重？
local p3 = initPerson({name = 'Q1', age = 23, sex = 'female', weight = 55})
printPerson(p1)

-- Output:
-- name = Q1, age = 23, sex = female, height = 0, weight = 0
-- name = Q2, age = 23, sex = female, height = 169, weight = 0
-- name = Q3, age = 23, sex = female, height = 0, weight = 55

结果符合预期。不过，上面的代码，严格意义上来说，person的五个属性都成了可选参数，因为开发者是可能会忘了填name、age或sex属性。解决方法是：要么在开发的时候，开发者要知道name，age和sex一定要填值；要么就直接把name，age和sex单独抽出来，在加上一个table作为initPerson的参数列表，像这样

1
2
3
4
5
6
7
8
9
10
11
function initPerson(name, age, sex, tOptArgs )
    -- 初始化..
    local person = getDefault()
    person.name = name
    person.age = age
    person.sex = sex
    tOptArgs = tOptArgs or {}
    person.height = tOptArgs.height or 0
    person.weight = tOptArgs.weight or 0
    return person
end

才能做到完美的必选参数+可选参数的初始化。

2. Lua中的面向对象

Lua支持一定的OOP。Lua本身没有提供面向对象编程的支持，当时我们可以用Lua的一个重要数据结构「table」来模拟OOP的过程。不多说，上代码。

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
MyObject = {
    name = "MyObject",
    doWhat = "something"
}

function MyObject:newInstance( obj )
    obj = obj or {}
    setmetatable(obj, self)
    self.__index = function(t,k)
        return self[k]
    end
    obj.name = "Q"
    obj.fieldB = "eat"
    return obj
end

function  MyObject:doSomething()
    print(string.format('%s do %s.', self.name, self.doWhat))
end

local oneObj = MyObject:newInstance()
oneObj:doSomething()

-- Output:
-- Q do eat.

MyObject这个表，有两个属性，name和doWhat，我们可以把它看做一个“类”；并且还定义了两个方法newInstance和doSomething。形如「XXX.xxx()」和「XXX:xxx()」的形式是Lua语言的语法糖，同样都是在“类”中声明一个函数：

1
2
3
4
5
6
7
8
9
10
11
// 1
Person.say = function(self)
end

// 2
function Person.say(self)
end

// 3
function Person:say()
end

上面的代码中，三者是等价的，同样为Person中的say属性赋值一个函数。对于1和2，2是Lua的语法糖，2等价于1。对于2和3，3是Lua的语法糖，「.」号和「:」号的区别在于，「:」号会在调用函数时，首先推入一个self，再推入函数的参数。

然后看看newInstance函数。它首先对obj进行或操作，确保传进来的obj不为空，保证其至少是一个空表。然后，就是为obj设置元表，设置为self，而self就是MyObject。接着就是为self设置一个属性__index，这个属性的值是一个function。和上面的setmetatable联合来看，这两句语句的意思是：
如果在obj中，根据一个key找到的结果是nil，那就去执行__index这个function。在这个function中，会去查找self这个表并返回，self就是MyObject。所以，如果我们访问obj的doSomething属性，因为obj没有，那就执行__index，在MyObject中查找，找到了，那就返回作查询结果。所以newInstance还有另一个版本：

1
2
3
4
5
6
7
8
function MyObject:newInstance( obj )
    obj = obj or {}
    setmetatable(obj, self)
    self.__index = self
    obj.name = "Q"
    obj.fieldB = "eat"
    return obj
end

更加的简化，意思是如果在obj中，根据的key到的结果是空，那就用这个key去self中查找，并作为查询结果。（这个版本我一开始无法理解，看了Lua的源码才知道是什么意思，还是function版的好理解..）

回到newInstance中，接下来就是为obj设置一些属性，然后返回。在doSomething中，因为我们执行的是

1
oneObj:doSomething()

所以在doSomething中，self就是oneObj。oneObj的name属性和doWhat属性是’Q’和’eat’，所以输出符合预期。

3. 函数式编程

Lua支持函数式编程。因为我之前更熟悉Java，转到Lua一时半会理解不了函数式编程。所以新的概念，我喜欢和Java比较。Lua中的函数式编程，就是把function看成是一个「值」，你可以在任意一个地方声明它，也可以把它赋值到某一个变量中。所以，只要把Lua中的函数当成一个值就好了，只不过这个值不能加减乘除和逻辑变换罢了。所以，下面的代码在Lua中是合法的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
local f = function()
    return '2333'
end

function test()
    print(f())
    f = function()
        return '666'
    end
    print(f())
end

-- Output:
-- 2333
-- 666

可以看到上面的代码，test中有嵌套了一个function。我在想，如果这个function访问了test的局部变量，那会是什么情形？做个实验：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function getIncreaser()
    local level = 0
    return function()
        level = level + 1
        return level
    end
end

local increaser = getIncreaser()
for i = 1, 5 do
    print(increaser())
end

-- Output:
-- 1
-- 2
-- 3
-- 4
-- 5

讲道理，getIncreaser的level仅在getIncreaser的生命周期内有效。然后，getIncreaser返回的function中持有了level，所以在getIncreaser退出后，level并没有释放，因为increaser持有了它。所以每调用一次increaser，level就会自增一次，就是一个简单的自增器。这种现象，有一个很厉害的名字，叫做「闭包(Closure)」

简单的了解了函数式编程后，我继续和Java比较。Java中，回调函数怎么做？传一个函数？不行，因为Java不能把function作为参数。那就把这个function包装成一个类，再把这个类的实例作为参数就好了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public interface Callback {
    void callback();
}

public class MyProcessor {

    private Callback mCallback;
    
    public void setCallback(Callback callback) {
        mCallback = callback
    }

    public void notifyCallback() {
        if (mCallback != null) {
            mCallback.callback();
        }
    }
}

好啰嗦啊，我只是要回调而已，如果是观察者模式，那我还要维护一个List。Lua支持函数式编程，那就只需这样：

1
2
3
4
5
6
7
8
9
function setCallback(callback)
    myProcessor.callback = callback
end

function notifyCallback()
    if myProcessor.callback then
        myProcessor.callback()
    end
end

很简洁。如果是观察者模式，那就把callback插入到一个table就可以了，需要notify的时候遍历一下，挨个调用就好了。

4. 总结

  1. table是Lua的一个数据结果，其行为类似于一个map。
  2. metatable是对table操作时触发的行为的一个集合。
  3. 可以用table来实现function的默认参数。
  4. 运用table + metatable可以实现简单的OOP。
  5. Lua支持函数式编程与闭包。

5. 感想

刚开始学Lua的时候，感觉它就是一个动态类型的语言。学完之后，觉得table很重要，只要精通table，我觉得就能精通Lua的七八成。另外，学了Lua之后，有了比较，才觉得Java有点啰嗦（非贬义，Java有他的道理），才能理解Kotlin中一些api为什么要这么设计，以及设计的理由是什么。虽然说技多不压身，但是学完之后一定要比较，我觉得才能理解作者设计某一门语言的理由，它适用于什么情况，不适用于什么情况。有了比较，才能更好地使用一门语言，写出更好的代码，因为编程是一门艺术。没有比较，我觉得学再多也没用。