lua学习之表达式篇

表达式

1. 表达式用于表达值
2. lua 中表达式能够为数字常量，自变字符串，变量，一元和二元操做符，函数调用、函数定义、table 构造式

算数操做符

一元操做符

1. -负号

二元操做符

2. -减号

4. /

5. ^

6. %

x ^ 0.5
x ^ (-1 / 3)  -- x 的三次方再求导
10 % 3 = 1 -- 余数计算
x % 1 -- 获得的是 x 的小数部分
x - x % 1 -- 获得的是 x 的整数部分
x - x % 0.01  -- 对几位小数进行取余，就获得几位小数 + 整数

关系操做符

返回获得的结果都是 true 或 false，非真即假

1. <
2. >
3. <=
4. >=
5. == 相等性测试
6. ~= 不等性测试，两个值具备
7. == 和 ~= 可用于任何的两个值
8. 若是两个值具备不一样的类型，lua 就认为它们是不相等的
9. nil 值与自身相等

print(nil == nil)

对于 table, userdata, function ,是作引用比较的，当他们引用同一个对象的时候，他们才是相等的。

a = {}
a.x = 1
a.y = 0
b = {}
b.x = 1
b.y = 0
c = a
print(type(a == b)) -- false
print(type(a == c)) -- true

比大小的关系操做符，能够对数字或字符串进行比较。

1. 在 lua 按照字母的次序对字符串进行比较
2. 字母的次序取决于 lua 的区域设置
3. 不一样类型的值比较，字符0与数字0是不一样的
4. 将数字和字符串比较时，lua 会报错

逻辑操做符

1. and
2. or
3. not

与条件控制语句同样，全部的逻辑操做符将 false, nil 视为假，其余全部类型视为真

and

1. 第一个操做数为假就返回第一个操做数
2. 不然返回第二个操做数

print(2 and 4) -- 2
print(nil and 4) -- nil
print(false and 4) -- false
print(4 and false) -- false

or

1. 第一个操做数为真就返回第一个操做数
2. 不然返回第二个操做数

print(2 or 4) -- 4
print(nil or 4) -- 4
print(false or 4) -- 4
print(4 and false) -- 4

短路操做

1. 只在须要的时候才回去评估第二个操做数
2. and 和 or 都支持短路操做

-- 习惯写法1
-- 用于当 x 没有值时，赋值一个默认值
print(x=x or v)
-- 等价于
if not x then
    x = v
end
-- 习惯写法2
print((a and b) or c)
-- 相似 C 语言中 a ? b : c 
--a 为真获得 b, 不然就为 c,但前提是 b 不为假,安全作法使用if-else语句

-- a真,b假,and 返回 b, or 就是 b 与 c 比
-- a真,b真,and 返回 b, or 就是 b 与 c 比，但因为 a 与 b 的真假性相同，因此等同 a 与 c 比
-- a假,b真,and 返回 a, or 就是 a 与 c 比

-- 习惯写法3
-- 比较两个数中的较大者
max = (x > y) and x or y

not

1. 只返回一个值 true 或者 false

print(not nil) -- true
print(not false) -- true
print(not true) -- false
print(not 0) -- false
print(not "0") -- false
print(not not nil) -- false

字符串链接

1. 用两个点操做符 ..
2. lua 中字符串是不可变的值
3. 链接操做符只会建立一个新的字符串，而不会对原操做数进行修改

a = "Hello"
print(a .. "World") -- Hello World
print(a) -- Hello

优先级

一级优先

1. ^

二级优先

1. not
3. -（一元操做符负号）

三级优先

2. /
3. %

四级优先

五级优先

1. ..(字符串链接)

六级优先

1. 大于 >
2. 小于 <
3. 大于等于 >=
4. 小于等于 <=
5. 不等于 ~=
6. 等于 ==

七级优先

1. and

八级优先

1. or

在二元操做符中除了 指数运算符 ^ 和链接操做符 .. 是右结合的，其余全部操做符都是左结合的，能够用括号() 显示指定运算顺序

table 构造式

初始化数组

days = {}
days = {"Sunday", "Monday", "Thusday", "Wednesday", "Thursday", "Friday", "Staurday"}
print(days[1]) -- "Sunday"

初始化记录风格的 table

a = {x = 10, y = 20} -- 等效于 a = {}; a.x = 10; a.y = 20

添加或删除某个字段

w = {x = 0, y = 0, label = "console"}
x = {math.sin(0), math.sin(1), math.sin(2)}
w[1] = "another field"
w.x = nil

链表

1. 有一系列节点组成，节点就是元素
2. 节点能够在运行时动态生成
3. 每一个节点包括两部分
   1. 存储数据的数据域
   2. 存储下一个地址节点的指针域

-- 建立链表
list = nil
-- 从标准输入中读取每行内容，而后将每行按相反的次序存储到一个链表中
-- 链表的每一个节点都是一个 table
-- value 每行的内容
-- next 指向下一个节点的引用
for line in io.lines() do
    list = {next = list, value = line}    
end
local l  = list
while l do
    print(l.value) 
    l = l.next
end

使用记录方式的建立 + 链表 混合使用

1. 但这两种风格的构造式须要注意
2. 不能使用 负数 做为索引
3. 不能用运算符做为字段名

polyline = {color = "blue", thickness = 2, npoints = 4, 
    {x = 0, y = 0},
    {x = -10, y = 0},
    {x= 0, y = 1}
}

print(polyline[2].x) -- -10
print(polyline["color"]) -- "blue"

[] 显式初始化索引值

opnames = {["+"] = "add", ["-"] = "sub", ["*"] = "mul", ["/"] = "div"}
i  = 20; s = "+"
a = {[i + 0] = s, [i + 1] = s..s, [i + 2] = s .. s .. ss}
print(opnames[s]) -- add
print(a[22]) -- +++ 
{x = 0, y = 0} -- 等效于 {["x"] = 0, ["y"] = 0}
{"r", "g", "b"} -- 等效于 {[1] = "r", [2] = "g", [3] = "b"}
{[0] = "r"} -- 不建议以 0 做为索引，由于 lua 中不少函数都假设数组起始索引是从1开始的
-- 最后一个元素后的逗号是可选的，合法的
{[0] = "r", [1] = "g" ,}
-- 能够在构造式中用分号代替逗号
{[0] = "r"; [1] = "g"}