玩转lua：搞懂lua潜规则

Lua可以被C/C++ 代码调用，反过来也可以调用C/C++的函数，这使得Lua被广泛应用。Lua由标准C编写而成，代码简洁优美，几乎在所有操作系统和平台上都可以编译，运行。Lua在目前解释型脚本引擎中，速度是最快的，这决定了Lua嵌入式脚本的最佳选择。文章列举lua使用中遇到的小问题，做个汇总。

if判断

lua把 nil 和false 视为“假”，其他都为“真”

local变量声明

local var1=1,var2

以上 ，var1和var2的作用域不同，var1是所在作用域的变量，var2可能是全局变量。实际上述命令解释后为 var1 取 "1,var2" 组成的值第一个值，类似 local var1 = ...

正确的写法是：

local  var1, var2=1

table是否为空

if a == {} then

结果是false，这是一个逻辑错误，实际比较table a的内存地址和一个匿名table的是否相同

正确的写法是：

if next(a) == nil then

多个变量赋值

name,name = 1,2

那name等于多少呢？

实际上name值为1，可以写个小例子 a,b = 2,3,4打印汇编码就可以看到了。 方法：luac -l test.lua

table的key规则

t[name]与t["name"]， t.name

第一种和后两种是不同的，第一种会根据取name的值做key，后两种以 "name"做key。这种情况还有：
t = {[name] = 1}

t = {name = 1}
t = {["name"] = 1}

table的长度

取得 table 长度最常用的做法是 #table，如下：

[plain]  view plain  copy

1. > t = {1,2,3}  
2. > #t  
3. 3  

但 # 操作符也是有局限的

[plain]  view plain  copy

1. > t = { 10, n = 20, 30, 40 }  
2. > #t  
3. 3  

实际上，#操作符取到的是 table内部数组空间的大小

[plain]  view plain  copy

1. > t = {}  
2. > t[1] =1  
3. > t[2] =1  
4. > #t  
5. 2  
6. > t[4] =1  
7. > #t  
8. 4  

另外，通过把元素设 nil 无法改变 #table 的结果（除非是数组最后一个元素）；而 table.remove 则可以立即更新 #table 的结果

[plain]  view plain  copy

1. > t ={1,2,3}  
2. > t[1]=nil  
3. > #t  
4. 3  
5. > table.remove(t,1)  
6. nil  
7. > #t  
8. 2  

所以，获取table长度，在不确定元素类型（或连续性）时使用 for in pairs，也就是遍历table

table引用问题

将一个table复制给另外一个table，修改这个新的table值会影响原来的table，但通过clone可以改变这一行为。

[plain]  view plain  copy

1. -- 下面的代码，t2 是 t1 的引用，修改 t2 的属性时，t1 的内容也会发生变化  
2. local t1 = {a = 1, b = 2}  
3. local t2 = t1  
4. t2.b = 3    -- t1 = {a = 1, b = 3} <-- t1.b 发生变化  
5.    
6. -- clone() 返回 t1 的副本，修改 t2 不会影响 t1  
7. local t1 = {a = 1, b = 2}  
8. local t2 = clone(t1)  
9. t2.b = 3    -- t1 = {a = 1, b = 2} <-- t1.b 不受影响  

clone不是原生的lua内置函数，这里也补充这个函数：

[plain]  view plain  copy

1. function clone(object)  
2.     local lookup_table = {}  
3.     local function _copy(object)  
4.         if type(object) ~= "table" then  
5.             return object  
6.         elseif lookup_table[object] then  
7.             return lookup_table[object]  
8.         end  
9.         local new_table = {}  
10.         lookup_table[object] = new_table  
11.         for index, value in pairs(object) do  
12.             new_table[_copy(index)] = _copy(value)  
13.         end  
14.         return setmetatable(new_table, getmetatable(object))  
15.     end  
16.     return _copy(object)  
17. end  

函数返回值

> function f123() return 1, 2, 3 end

> function f456() return 4, 5, 6 end

> print(f123(), f456())

1       4       5       6

> print(f456(), f123())

4       1       2       3

> print(f456())

4       5       6

> print(f456(),1)

4       1

如果函数不是处于列的最后一个，只返回一个值

浮点数问题

> math.floor(0.57*100)
56

这是浮点数都会有的精度丢失问题，lua也有这个问题。再看下整数与浮点数的比较：

> =10==10.00000000000000000
true
> =10==10.00000000000000001
true
> =10==10.00000000000000000
true
> =10==9.999999999999999999
true

如何比较两个浮点数是否相等？这里介绍一个方法：

[plain]  view plain  copy

1. function float_equal(x,v)  
2.     local EPSILON = 0.000001  
3.     return ((v - EPSILON) < x) and (x <( v + EPSILON))  
4. end  
5.   
6. print(float_equal(0.9999999, 1.0000001))  

其中，EPSILON就是你允许的精度差

lua整数

在lua5.3之前，lua没有整数，都是用浮点数表示的，最早的版本用float，然后在3.1之后改用double。直到lua5.3，lua才引入了整数，默认是64bit。既然之前的lua版本用到的是浮点数，那必然有精度问题，浮点数需要一部分位来表示指数，double的有效数字是53bit，能表达的最大的有效整数是6755399441055744，而lua5.3能表达的最大整数是 9223372036854775807

至于为什么是6755399441055744，有兴趣的可以看下寂寞同学写的 浮点数到整数的快速转换，还有一篇国外的文档  Let's Get to the (Floating)Point

冒号语法

冒号语法可以用来定义函数， 这样的话，函数会有一个隐式的形参 self。 

写法如下：
    function t:f (params) body end
冒号语法实际上是一种语法糖，等效于：
    t.f = function (self, params) body end

这里补充例子说明下：

[plain]  view plain  copy

1. local t={a=123}  
2.   
3. function t.f1(self, p)  
4.     print(self.a, p)  
5. end  
6.   
7. function t:f2(p)  
8.     print(self.a, p)  
9. end  
10.   
11. t:f1(1)  
12. t.f1(t,1)  
13. t:f2(1)  
14. t.f2(t,1)  

以上几个结果都是 123     1
这里，通过冒号方式调用函数不需要加入self参数，而点号则需要。

文章转载自：没有开花的树--http://blog.csdn.net/mycwq/article/details/48765303