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"}