Lua笔记

只是为了防止忘记而写的记录。

 

1.表的构造，所有的索引值都必须用[ ]表示，如果是字符串，可以去掉引号和中括号

2.  a and b  如果a为 false，返回a，否则b

     a or b 如果a为真，返回a,否则b

3.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--倒置的链表
list  = nil
for i = 1, 10 do
    list = { next = list, value = i}
end

local l = list
while l do
    print(l.value)
    l = l.next
end

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--队列
List = {}
function List.new()
    return {fisrt = 0, last = 0}
end
function List.push(Q,value)
    local last = Q.last + 1
    Q[last] = value
    Q.last = last
end

function List.pop(Q)
    local first = Q.first + 1

    if first > Q.last then return error("error") end
    Q.first = first
    return Q[first-1]
end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
串行化：
function serialize(o)
    if type(o) == "number" then
        io.write(o)
    elseif type(o) == "string" then
        --string.format函数的"%q"参数可以转义字符串中的元字符。
        io.write(string.format("%q",o))
    elseif type(o) == "table" then
        io.write("{\n")
        --迭代table中的各个元素，同时递归的写出各个字段的value。
        --由此可以看出，这个简单例子可以支持嵌套的table。
        for k,v in pairs(o) do
            --这样做是为了防止k中包含非法的Lua标识符。
            io.write(" ["); serialize(k); io.write("] = ")
            serialize(v)
            io.write(",\n")
        end
        io.write("}\n")
    else
        error("cannot serialize a " .. type(o))
    end
end

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
元表的应用：
Set = {}
local mt = {}

function Set.new(L)
    local set = {}
    setmetatable(set,mt)
    for _,v in pairs(L) do
        set[v] = true
    end
    return set
end

function Set.union(a,b)
    local cur = {}
    for i in pairs(a) do
        cur[i] = true
    end

    for i in pairs(b) do
        cur[i] = true
    end
    return cur
end

function Set.intersection(a,b)
    local cur = {}
    for v in pairs(a) do
        cur[v] = b[v]
    end
    return cur
end

function Set.tostring(set)
    local l = {}
    for e in pairs(set) do
        l[#l+1] = e
    end
    return "{"..table.concat(l,",").."}"
end

function Set.print(s)
    print(Set.tostring(s))
end

mt.__add = Set.union

s1 = Set.new({10,20,30,50})
s2 = Set.new({15,25,35,60})

s3 = s1+s2
Set.print(s3)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
__newindex元方法与__index类似，__newindex用于更新table中的数据，
而__index用于查询table中的数据。当对一个table中不存在的索引赋值时，在Lua中是按照以下步骤进行的：
1.Lua解释器先判断这个table是否有元表；
2.如果有了元表，就查找元表中是否有__newindex元方法；如果没有元表，就直接添加这个索引，然后对应的赋值；
3.如果有这个__newindex元方法，Lua解释器就执行它，而不是执行赋值；
4.如果这个__newindex对应的不是一个函数，而是一个table时，Lua解释器就在这个table中执行赋值，而不是对原来的table。

__index 例子：
Windows = {}

Windows.default = {
    x = 0,y = 0,with = 100,heigh = 200,
    color = {
        r = 255, g = 255, b = 255
    }
}

function Windows.tostring(s)
    if type(s) == "number" then
        io.write(s)
    elseif type(s) == "string" then
        io.write(string.format("%q",s))
    elseif type(s) == "table" then
        io.write("{")
        for key,value in pairs(s) do
            io.write("["); io.write(Windows.tostring(key)); io.write("] = ")
            io.write(Windows.tostring(value))
            io.write(",\n")
        end
        io.write("}")
    else
        error("cannot tostring!!!");
    end
end

function Windows.print(s)
    return print(Windows.tostring(s))
end
Windows.mt = {} -- 创建元表

function Windows.new(o)
    setmetatable(o,Windows.mt)
    return o
end

Windows.mt.__index = function (table ,key)
    return Windows.default[key]
end

local win = Windows.new{x = 10, y = 20 }


Windows.print(win.x)
Windows.print(win.with)
Windows.print(win.color)

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
实现类和对象的例子：
p中有没有talk这个键? 有 --> 返回talk对应的值
        |
       没有
        |
p中是否设置过metatable? 否 -->  返回nil
        |
        有
        |
在p的metatable中有没有__index这个键? 没有 -->  返回nil
        |
        有
        |      
在p的metatable中的__index这个键对应的表中有没有talk这个键? 没有 --> 返回nil
        |
        有，返回getmetatable(p).__index.talk
        
        
Person = {name = "我是一个懒人"} --类

Person.__index = Person --重定义元表的索引  设置Person类的__index为自己
function Person:talk(words)--类的一个方法
    print(self.name.." 说:"..words)
end

function Person:create(name)--构造函数一样
    local p = {}
    setmetatable(p,Person) --设置了p的元方法
    p.name = name
    return  p
end

local pa = Person:create("路人甲A") --创建一个对象
local pb = Person:create("路人甲B")

pa:talk("hello")
pb:talk("sb")

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
类的继承的一个例子：必须理解setmetatable,__index的过程。

-- http://blog.csdn.net/losophy/article/details/20311387
A  = {} --基类A

function A:new(o) --构造方法
    o = o or {} --如果为nil 则赋值为{}
    setmetatable(o,self) --设置元方法，确定在谁那寻找子类，没有的方法
    self.__index = self --这个很重要。所以理解。
    return o
end

function A:funName()
    print("A")
end

B = A:new()
B:funName()

C = B:new()

function B:funName()
    print("B")
end

C:funName()
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
使用__newindex设置只读模式，牛气
local function readOnly(t)
    local newT = {}
    local mt = {
        __index = t,
        __newindex = function()
            error("别修改我！我是只读的！")
        end
    }
    setmetatable(newT, mt)
    return newT
end
local days = readOnly({"星期一", "星期二", "星期日"})

print(days[2])
days[1]="hehe" --但调用次赋值的时候，就会找到__newindex，从而被禁止 

______________________________________________________________
a.首先，readOnly会创建一个新的table，然后把我们传进去的table作为__index元方法。
b.元表里还增加了__newindex，用来阻止不存在字段的赋值操作。
c.readOnly返回的table已经不是我们原来的table了，它是一个空的table，但是它被设置了一个新的元表。
d.开始对days执行赋值操作：days[2] = “星期三哪去了啊？” 。
e.days是一个空的table，所以它不存在这个字段，也因此，会调用__newindex元方法，赋值失败。
f.如果只是调用days，不进行赋值，如：print(days[2]); 则能正常输出字段值，因为days的元表里有__index元方法。虽然days中不存在2这个字段，但是可以通过__index找到这个字段。
总而言之，最终，days成为了一个只可以读取，不能进行赋值操作的table。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
解释__newindex的作用
a.如果__newindex是一个函数，则在给table不存在的字段赋值时，会调用这个函数。
b.如果__newindex是一个table，则在给table不存在的字段赋值时，会直接给__newindex的table赋值。

local smartMan = {
    name = "hxl",
    money = 9000,
    hello = function()
        print("hxl ni hao")
    end
}

local t = {}

local mt = {
    __index = smartMan,
    __newindex = function(table,key,value)
        print("key".."不要试图修改我,已经被禁止了!")
    end
}

setmetatable(t,mt)

print(t.name)
print(t.money)
t.hello()
t.hello = "heh"
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
__index 和 __newindex的一个很牛气的例子
 local smartMan = {
        name = "none",
    }
   
    local other = {
        name = "大家好，我是很无辜的table"
    }
   
    local t1 = {};
   
    local mt = {
        __index = smartMan,
        __newindex = other
    }
   
    setmetatable(t1, mt);
     
    print("other的名字，赋值前：" .. other.name);
    t1.name = "小偷";
    print("other的名字，赋值后：" .. other.name);
    print("t1的名字：" .. t1.name);
结果：
[LUA-print] other的名字，赋值前：大家好，我是很无辜的table
[LUA-print] other的名字，赋值后：小偷
[LUA-print] t1的名字：none
说明：修该的时候只会修改__newindex里面的指定的地方值，
      查询的时候只会读出 __index里面的值.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

4.

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lua实现多重继承：


 function search(classes, key)--查询函数
    for i = 1, #classes do
        local value = classes[i][key];
        if value ~= nil then
            return value;
        end
    end
end

 function createClass(...) --可变参数
    local parents = {...}; --保存它的可变参数
    local child = {};

    -- 设置类的元表,如果元表已经设置，就去元表里看看有没有设置__index，找有没有对应的key值.
    setmetatable(child, {
        __index = function(table, key)
            return search(parents, key);
        end
    })

    -- 给类新增一个new函数，用于创建对象
    function child:new()
        o = {};
        setmetatable(o, child);--设置元表，并且在自己的地方寻找有木有相对于的key值
        child.__index = child;--设置元表，并且在自己的地方寻找有木有相对于的key值
        return o;
    end

    -- 返回这个继承了多个类的子类
    return child;
end


 --一个精灵类
    TSprite = {}
    function TSprite:hello()
        print("谁跟你hello！");
    end

    function TSprite:new()
        o = {}
        setmetatable(o, self);
        self.__index = self;
        return o;
    end

    -- 一个子弹类
    TBullet = {}
    function TBullet:fire()
        print("别动，再动我就瞄不准了！");
    end
    function TBullet:new()
        o = {}
        setmetatable(o, self);
        self.__index = self;
        return o;
    end

    -- 继承了两个类的子类
    local BulletSprite = createClass(TSprite, TBullet);--传入这两个table，返回对应的child

    -- 子类的对象
    local bSprite = BulletSprite:new();
    bSprite:hello();
    --[[子类对象调用hello方法，会去bSprite中寻找，
    发现没有,那么此时没有就去看看 bSprite有没有设置元表有的，去元表中看有没有设置__index
    发现也是有的，就调用它对应的方法，便进入了serch了。便可以找到了
    --]]
    bSprite:fire();
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
弱引用：
1）key值弱引用，也就是刚刚说到的情况，只要其他地方没有对key值引用，
那么，table自身的这个字段也会被删除。设置方法：setmetatable(t, {__mode = “k”});
2）value值弱引用，情况类似，只要其他地方没有对value值引用，
那么，table的这个value所在的字段也会被删除。设置方法：setmetatable(t, {__mode = “v”});
3）key和value弱引用，规则一样，但是key和value都同时生效，
任意一个起作用时都会导致table的字段被删除。设置方法：setmetatable(t, {__mode = “kv”});
 
当然，这里所说的被删除，是指在Lua执行垃圾回收的时候，并不一定是立刻生效的。
我们刚刚只是为了测试，而强制执行了垃圾回收。

t = {};

    -- 给t设置一个元表，增加__mode元方法，赋值为“k”
    setmetatable(t, {__mode = "k"});

    -- 使用一个table作为t的key值
    key1 = {name = "key1"};
    t[key1] = 1;

    -- 又使用一个table作为t的key值
    key2 = {name = "key2"};
    t[key2] = 1;

    t = {}
    key1,key2 = t,t

    -- 强制进行一次垃圾收集
    collectgarbage();

    for key, value in pairs(t) do
        print(key.name .. ":" .. value);
    end
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~