lua总结

亦凉 2022-07-15 08:41 236阅读 0赞

### 第一章基础用法 ###

#### 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 - } - } ]]

……待更新