lua总结

第一章基础用法

1.1全局函数

在某一个模块中的函数，如果该模块要被其他模块使用，则该模块中的函数不能定义为local的。

1.2可变参数

Lua 函数可以接受可变数目的参数，和 C 语言类似在函数参数列表中使用三点（…），表示函数有可变的参数。Lua 将函数的参数放在一个叫 arg 的表中，除了参数以外，arg表中还有一个域 n 表示参数的个数。

function fun(...)
    print(#arg, arg[1])--此处打印出1   10
end

fun(10)

第二章元表与元方法

2.1__index

Window.mt.__index = function (table, key)
    return Window.prototype[key]
end

--调用
print(w.width)--w中没有width域

当__index等于函数时，Lua 使用w（the table）和 width（缺少的值）来调用__index metamethod。Lua 将 table 和缺少的域作为参数调用这个函数。

2.2__call

__call(a, …) 对应表达式 a(…)

2.3__gc

Lua中的垃圾回收主要是针对Lua对象，但是也可以做一些额外的资源管理工作。
可以为表设定垃圾收集的元方法（对于完全用户数据，则需要使用C API），该元方法称为 终结器。Lua用”__gc” 元方法实现终结器：

o = {x  = "hi" }
setmetatable(o , {__gc = function (o ) print (o.x) end } )
o = nil
collectgarbage()  --> hi       -- 触发元方法__gc

如果我们没有对对象进行__gc标记，它就不会终结。
在它之后才给元表加上这个__gc域，那么这个对象是没有被标记需要触发终结器的：

o = { x = "hi"}
mt = {}
setmetatable(o,mt )
mt.__gc = function(o) print(o.x) end
o = nil
collectgarbage()   -->  不会打印任何东西

在标记__gc域后，还是可以自由地改变其元表中的 “__gc” 域：

o = {x = "hi" }
mt = {__gc = true }　　　　　　　　　　　　 --先用任何值给它赋值，作为占位符
setmetatable(o, mt )
mt.__gc = function(o) print (o.x) end   --再次修改，也是可以的
o = nil
collectgarbage()   --> hi

当用同一个循环对几个对象进行垃圾回收，调用终结器的顺序和标记对象__gc域的顺序刚好相反。

mt = { __gc = function (o) print (o[1]) end }
list = nil
for i = 1, 3 do
    list = setmetatable({i , link = list}, mt )
end
list = nil
collectgarbage()
--> 3
--> 2 
--> 1

第三章面相对象编成

3.1多重继承

local function search (k, plist)
    for i=1, table.getn(plist) do
        local v = plist[i][k]
        if v then return v end
    end
end

function createClass (...)
    local c = {}

    --c的metatable是一个表，该表的__index是一个函数，该函数去查找父类
    setmetatable(c, {__index = function (table, k)
        return search(k, arg)
    end})

    c.__index = c

    function c:new (o)--c是new出的子类的metatable
        o = o or {}
        setmetatable(o, c)
        return o
    end

    return c
end

Named = {}

function Named:getname ()
    return self.name
end

function Named:setname (n)
    self.name = n
end

Acount = {
    value = 10,
    withdraw = function(self, v)
        self.value = v
    end
}

NamedAccount = createClass(Account, Named)--子类

account = NamedAccount:new{name = "Paul"}--account是一个实例
print(account:getname()) --> Paul

现在我们看看上面最后一句发生了什么，Lua 在 account 中找不到 getname，因此他查找 account 的 metatable 的__index，即NamedAccount。但是，NamedAccount 也没有getname，因此 Lua 查找 NamedAccount 的 metatable 的__index，因为这个域包含一个函数，Lua 调用这个函数并首先到 Account 中查找 getname，没有找到，然后到 Named 中查找，找到并返回最终的结果。当然，由于搜索的复杂性，多重继承的效率比起单继承要低。

第四章库的使用

4.1encode and decode

json.encode

将表格数据编码为 JSON 字符串。

格式：

jsonString = json.encode(表格对象)
用法示例：

local str = json.encode({a=1,b="ss",c={c1=1,c2=2},d={10,11},100})
echo(str) -- {"a":1,"b":"ss","c":{"c1":1,"c2":2},"d":[10,11],"1":100}
local str = json.encode({1,2,"3",{10,11}})
echo(str) -- [1,2,"3",[10,11]]
Note: table作为字典使用时，整型键值将被转换为字符串键值

local str = json.encode({a=1,[5]=3})
echo(str) -- {"a":1,"5":3}
Note: table所有键值为整型时，会当作数组看待，空位将转化为null

local str = json.encode({[3]=2,[5]=3})
echo(str) -- [null,null,2,null,3]
~~

json.decode

将 JSON 字符串解码为表格对象。

格式：

table = json.decode(string)
用法示例：

local json = require("framework.shared.json")
local tb = json.decode('{"a":1,"b":"ss","c":{"c1":1,"c2":2},"d":[10,11],"1":100}')
dump(tb) --[[
- "<var>" = {
-     "1" = 100
-     "a" = 1
-     "b" = "ss"
-     "c" = {
-         "c1" = 1
-         "c2" = 2
-     }
-     "d" = {
-         1 = 10
-         2 = 11
-     }
- }
]]
local tb = json.decode('[1,2,"3",[10,11]]')
dump(tb) --[[
- "<var>" = {
-     1 = 1
-     2 = 2
-     3 = "3"
-     4 = {
-         1 = 10
-         2 = 11
-     }
- }
]]

……待更新