Lua memorandum 备忘录

Lua memorandum

Lua Boolean 布尔值

Lua Boolean有两个值： true 和 false。
条件测试将除Boolean值false和nil外的所有值视为真。因此，零（number 0）和空字符串（string “”）也都被视为真。注意：Boolean false 和string “false”的不同。

Lua 逻辑运算符

and 和 or 都遵循短路求值（Short-circuit evaluation）。只在必要时才对第二个操作数进行求值。
And: 代码：a and b，如果a为true，return b；如果a为false，return a。
Or: 代码：a or b，如果a为true，return a；如果a为false，return b。
举例：
print(1>2 and 2>1) => false print(1>2 or 2>1) => true
a>b and a or b 等价于 C语言中的 a>b?a:b
分析：
And 的运算优先级比or高，即：(a>b and a) or b
1.假设a>b为true，(a>b and a) or b => (a) or b。只有当a为nil或者false的时候才会被判定为false，所以(a) or b => a.
2.假设a>b为false，(a>b and a) or b => (a>b) or b。已知a>b为false，所以(a>b) or b 返回第二个参数即 b。

Lua math相关

pi圆周率： math.pi = 3.1415926535898
abs取绝对值：math.abs(-2012) = 2012
ceil向上取整：math.ceil(9.1) = 10
floor向下取整： math.floor(9.9) = 9
max取参数最大值：math.max(2,4,6,8) = 8
min取参数最小值：math.min(2,4,6,8) = 2
pow计算x的y次幂：math.pow(2,16) = 65536
sqrt开平方：math.sqrt(65536) = 256
mod取模：math.mod(65535,2) = 1
modf取整数和小数部分：math.modf(20.12) = 20 0.12
randomseed设随机数种子：math.randomseed(os.time())
random取随机数： math.random(5,90) = 5~90
rad角度转弧度：math.rad(180) = 3.1415926535898
deg弧度转角度：math.deg(math.pi) =180
expe的x次方：math.exp(4) = 54.598150033144
log计算x的自然对数：math.log(54.598150033144) = 4
log10计算10为底，x的对数：math.log10(1000) = 3
frexp将参数拆成x * (2 ^ y)的形式：math.frexp(160) = 0.6258
ldexp计算x * (2 ^ y)：math.ldexp(0.625,8) =160
sin正弦：math.sin(math.rad(30)) = 0.5
cos余弦： math.cos(math.rad(60)) = 0.5
tan正切：math.tan(math.rad(45)) = 1
asin反正弦：math.deg(math.asin(0.5)) = 30
acos反余弦：math.deg(math.acos(0.5)) = 60
atan反正切：math.deg(math.atan(1)) = 45
四舍五入: math.floor(9.67 + 0.50) = 10

附录：

运算符的优先级如下（从高到低）
从高到低的顺序：
^
not - (unary) --单元运算符
*   /
+   -
…
< > <= >= ~= ==
and
or
除了 ^和 … 外所有的二元运算符都是左连接

Lua 点和分号

分号是把自己（self）也作为一个参数传递。
The colon is for implementing methods that pass self as the first parameter.
So x:bar(3,4) should be the same as x.bar(x,3,4). (syntactic suger)

变长参数： ...

通常和table，多重赋值一起出现。
Lua函数可以接受不同数量的实参：参数中的三个点（…）表示该函数可接受不同数量的实参。当这个函数被调用时，它的所有参数都会被收集到一起，这部分收集起来的实参称为这个函数的“变长参数”。 一个函数要访问他的变长参数时，仍需要用到3个点（…）,只是此时的3个点作为一个表达式来使用的。
比如：

function add(...)
local s = 0
  for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组
    s = s + v
  end
  return s
end

print(add(3,4,5,6,7))  --->25

多重赋值：

function sum3(...)
a,b,c = ...
a = a or 0
b = b or 0
c = c or 0
return a + b +c
end
=sum3(1,2,3,4)
6
return sum3(1,2)
3

Lua table

一般使用pairs只遍历非nil的元素；但是table中的key是无序的，所以使用pairs迭代并不能保证按次序访问元素。（为了解决该问题，可以用另外的方法，比如链表。）

for k,v in pairs(table2) do
    print(k,v)
end

table.insert(table, vale) //insert without index (key)
table.insert(table, key, vale)
table.remove(table, key) //remove elements using index (key)

Get key by using value:

1. Invert table then get element via key:

function table_invert(t)
   local s={}
   for k,v in pairs(t) do
     s[v]=k
   end
   return s
end

tableB = table_invert(tableA)
print(tableB["value"])

2. Looping

function get_key_for_value( t, value )
  for k,v in pairs(t) do
    if v==value then return k end
  end
  return nil
end

print(get_key_for_value( chars, "1" ))

Table merge

将第二个表合并到第一个表中，比如：

local tableA = { [1] = "A", [2] = "B", [3] = "C" }

local tableB = { [1] = "One", [2] = "Two" }

table.merge(tableA,tableB)
PrintTable(tableA)

1 One
2 Two
3 C

Table Sort

Lua table.sort() 使用时的注意事项

1. table.sort是排序函数，它要求要排序的目标table的必须是从1到n连续的，即中间不能有nil。
2. 当比较函数没有写的时候，table.sort默认按照lua里面的排序规则升序排序
3. 当额外写了比较函数时，相当于用你额外写的比较函数重载了lua中自带的“<”操作符。
   1. 因此，在重写比较函数的时候要特别注意 <, >, = 的使用
   2. 重写的比较函数，两个值相等时不能return true (一定要返回false); 如果两个值相等都，排序函数返回true时则会报错 invalid order function for sorting。

举例

table.sort(tbl, function(a, b)
       if (a.type == b.type) then
           return (a.id < b.id)         //此处千万不能用小于等于
end)

复杂情况组合排序

local _sortFunc1(a, b, type, attr)
   local isUp = attr == "Up"
   if isUp then
   	if a[type] == b[type] then
   		return a.ID < b.ID
   	else
   		return a[type] < b.[type]
   	end 
   else
   	if a[type] == b[type] then
   		return a.ID < b.ID
   	else
   		return a[type] > b.[type]
   	end 
   end
end

table.sort(tbl, function(a, b)
   if a.Atk== b.Atk then
       	if a.Hp== b.Hp then
       		return _sortFunc1(a, b, "Def", "Down")
       	else
       		return a.Hp < b.Hp
       	end
   else
   		return a.Atk < b.Atk
   end
end)

浅拷贝与深拷贝

在Lua中，使用赋值运算符"="进行浅拷贝的时候，分两种情况：

1. 拷贝对象的类型是string、number、boolean这些基本类型的时候，会进行复制，创建一个新的对象，拷贝出来的对象和原来的对象互不影响，所以修改拷贝出来的对象的值不会影响到原来的对象的值！
2. 拷贝对象的类型是table的时候，则是直接进行引用，拷贝出来的对象和原来的对象实际上是同一个对象，所以修改拷贝出来的对象中的元素的值也会使原来的对象中元素的值发生改变！

Lua中是没有提供深拷贝的api的，就要自己封装一个函数，递归拷贝table中所有元素以及设置元表。

function clone(object)
    local lookup_table = {}
    local function _copy(object)
        if type(object) ~= "table" then
            return object
        elseif lookup_table[object] then
            return lookup_table[object]
        end
        local new_table = {}
        lookup_table[object] = new_table
        for key, value in pairs(object) do
            new_table[_copy(key)] = _copy(value)
        end
        return setmetatable(new_table, getmetatable(object))
    end
    return _copy(object)
end

---