運算式

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 = https://www.cnblogs.com/door-leaf/p/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"}

標籤：其他

上一篇：lua學習之基礎概念篇

下一篇：lua學習之函式篇