LUA语言注意点归集

统计元素个数接口--只计算以整数为下标的 第一段连续元素的数目

#tab 和 table.getn()

 

http://ju.outofmemory.cn/entry/29450

 

我们修改table：

tab = {1, 4, 5, 8}
print(#tab)                    --=====> 4
print(table.getn(tab))         --=====> 4
 
tab[9] = 10
print(#tab)                    --=====> 4
print(table.getn(tab))         --=====> 4
print(tab[9])                  --=====> 10

使用上述的两种方法，发现返回的table元素依旧是4。为什么呢，我们再把上面的代码修改为：

tab = {1, 4, 5, 8}
print(#tab)                    --=====> 4
print(table.getn(tab))         --=====> 4
 
tab[5] = 10
print(#tab)                    --=====> 5
print(table.getn(tab))         --=====> 5
print(tab[5])                  --=====> 10

我们可以看到，这段代码可以得到我们想要的结果。

 

如果要打印总体数目， 包括以hash值为key的元素， 需要使用for循环

print("----------")

for _, v in pairs(tab) do

    print(v)

end

 

 

Lua 里没有 continue

http://www.cnblogs.com/jeJee/archive/2012/09/22/2697952.html

对于Lua里没有continue的问题相信很多用lua的人都遇到过，官方也有作出了解释。

 

那么如何用别的机制来代码continue呢？有一个比较简单的方法：在循环内套一个repeat ... until true，再将想用continue的地方写成break。如：

for i = 1, 10 do
    repeat
        if i == 5 then
            break
        end
        print(i)
    until true
end

 

元表实现对象间属性继承

如果把对象特殊对待为类原型， 则为类继承。

 

setmetatable 指定元表 
元表的__index指向为被继承的对象。

local base = {a=1}

print(base.a)

local inst = {}
print(inst.a)

setmetatable(inst, base)

print(inst.a)

base.__index = base 

print(inst.a)

 

函数可变参数获取

http://www.cnblogs.com/cbscan/articles/2022164.html

arg 对象 和 select 方法均是获取 可变参数 ...

且两者使用上互斥， 使用了select， lua解析器就不会再构造arg对象。

function printArgLength(a, ...)

 --print(select("#", ...))
 print(#arg)

 --print(select(2, ...))
end

printArgLength(1, 2, 5)

 

函数可变参数原样获取

func(...) 定义的函数， 使用时候 func(a, b, c)

在此函数定义中， 只能获取arg对象， 如果需要 类似 func(a, b, c)形式 将arg对象， 传递给调用函数， 则需要使用unpack方法

function unpack(t, i)

    i = i or 1

    if t[i] then

       return t[i], unpack(t, i + 1)

    end

end

 

例如将 format中 元素个数不固定， 但是format在第一个的函数定义情况：

function fwrite(fmt, ...)

    return io.write(string.format(fmt, unpack(arg)))

end

 

如果一个函数定义为 func(tab, ....)

此函数， 需要返回 tab（一个表）的upack形式（，分割参数）， 并添加...参数（若干, 分割参数）， 则使用此函数

local function myunpack(packs, ...)

    local ret = {}

    if "table" == type(packs) then

        for i, v in ipairs(packs) do

            ret[i] = v

        end

    end

   

    local n = table.maxn(ret)

    for i, v in ipairs(arg) do

        ret[n + i] = v

    end

   

    return unpack(ret)

end

 

module 定义 ... 和  package.seeall

module(..., package.seeall)
1、 第一个参数为...， 表示 此模块以文件名为准， 如果不是则使用此字符串作为模块名。
2、 第二个参数为 seeall 表示，  此模块内可以引用 所有全局环境。
3、 require 返回的module对象为一个表， 此表没有元表， 但是如果 定义的seeall， 则可以引用全局环境。 即此模块可以访问全局环境， 不是使用元表来实现。


moduleAa.lua

local print = print
local getfenv = getfenv
local pairs = pairs
local tostring = tostring
--module (..., package.seeall)
module (...)
a = 1
function printTest()
    print("module in printAa print")
 for k,v in pairs(getfenv(1)) do
  print("k="..k..", v="..tostring(v))
 end
end

moduleb.lua

local model = require("moduleAa")
--model.printTest()
print(type(model))
for k,v in pairs(model) do
 print("k="..k..", v="..tostring(v))
end
model.print("helll")