Lua極簡入門指南（一）：基礎知識篇

2024-07-21 23:04:16

字體：大中小

來源：轉載

供稿：網友

本文是《Programming in Lua 3rd》讀書筆記。

Chunks

一個 Chunk 就是一組被執行的語句，例如一個文件或者交互模式下的一行。

標識符（identifiers）

我們應該避免使用以 _ 開頭并跟上一個或者多個大寫字母的字符串來作標識符，它們被保留作特殊的用途（例如：_VERSION）。

注釋

單行注釋使用

復制代碼代碼如下:

多行注釋使用

復制代碼代碼如下:

--[[ 和 --]]

類型簡介

Lua 存在的數據類型包括：

1.nil。此類型只有一個值 nil。用于表示“空”值。全局變量默認為 nil，刪除一個已經賦值的全局變量只需要將其賦值為 nil（對比 JavaScript，賦值 null 并不能完全刪除對象的屬性，屬性還存在，值為 null）

2.boolean。此類型有兩個值 true 和 false。在 Lua 中，false 和 nil 都表示條件假，其他值都表示條件真（區別于 C/C++ 等語言的是，0 是真）

3.number。雙精浮點數（IEEE 754 標準），Lua 沒有整數類型

4.string。你可以保存任意的二進制數據到字符串中（包括 0）。字符串中的字符是不可以改變的（需要改變時，你只能創建一個新的字符串）。獲取字符串的長度，可以使用 # 操作符（長度操作符）。例如：print(#”hello”)。字符串可以使用單引號，也可以使用雙引號包裹，對于多行的字符串還可以使用 [[ 和 ]] 包裹。字符串中可以使用轉義字符，例如 /n /r 等。使用 [[ 和 ]] 包裹的字符串中的轉義字符不會被轉義

5.userdata。用于保存任意的 C 數據。userdata 只能支持賦值操作和比較測試

6.function。函數是第一類值（first-class value），我們能夠像使用其他變量一樣的使用函數（函數能夠保存在變量中，可以作為參數傳遞給函數）

7.thread。區別于我們常常說的系統級線程

8.table。被實現為關聯數組（associative arrays），可以通過任何值來進行索引（nil 除外）。和全局變量一樣，table 中未賦值的域為 nil，刪除一個域只需要將其賦值為 nil（實際上，全局變量就是被放置在一個 table 中）

type 函數用于返回值的類型：

復制代碼代碼如下:

	
	print(type("Hello World")) --> string
	print(type(10.4*3))        --> number
	print(type(print))         --> function
	print(type(type(X)))       --> string

在 Lua 中，任何的變量都可以保存任何的值。

table 使用簡介

使用構造表達式可以創建一個 table：

復制代碼代碼如下:

	
	-- 創建一個空的 table
	a = {}
	 
	-- 創建并初始化一個 table，這里
	-- days[1] == "Sunday"
	-- days[2] == "Monday"
	-- ...
	days = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }
	 
	-- 創建并初始化一個 table，這里
	-- a["x"] == 10
	-- a["y"] == 20
	a = { x = 10, y = 20 }

使用 [] 操作符訪問 table 的域：

復制代碼代碼如下:

	
	a = {}
	k = "x"
	a[k] = 10
	a["x"] = 20
	print(a["y"]) --> nil
	a.x = 30

注意，a.name 的語法等價于 a["name"]。

table 可以用于表示數組，這時候索引為整數，并且從 1（而非 0）開始，例如：

復制代碼代碼如下:

	
	a = { 'a', 'b' }
	a[1] == 'a'
	a[2] == 'b'

長度操作符可以獲取 table 數組部分的長度：

復制代碼代碼如下:

	
	a = {}
	a[1] = 1
	a[2] = 2
	print(#a) --> 2
	 
	a.a = 1
	a.b = 2
	print(#a) --> 2
	 
	a = {}
	a.a = 1
	a.b = 2
	print(#a) --> 0

表達式

算術操作符

1.+（加）
2.-（減）
3.*（乘）
4./（除）
5.^（冪）
6.%（取模）

任何算術操作符都試圖將操作數轉換為數值類型，例如：

復制代碼代碼如下:

print(10 + '1') --> 11

關系操作符

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

兩個不同類型的值是不相等的，例如：

復制代碼代碼如下:

nil ~= false

table、userdata 類型是通過引用進行比較的，例如：

復制代碼代碼如下:

	
	a = {}; a.x = 1; a.y = 0
	b = {}; b.x = 1; b.y = 0
	c = a

這里 a 和 c 引用一個相同的對象，因此 a == c，但是 a ~= b（即便 a、b 內容相同）。

邏輯操作符

1.and
2.or
3.not

邏輯操作符有返回值。對于 and 操作來說，如果第一個操作數為 false 時返回此操作數，否則返回第二個操作數。對于 or 操作來說，如果第一個操作數不為 false 時返回此操作數，否則返回第二個操作數。

連接操作符

字符串連接可以使用連接操作符 “..”，例如：

復制代碼代碼如下:

print("Hello " .. "World")

連接操作符試圖將操作數轉化為字符串，例如：

復制代碼代碼如下:

print("number: " .. 1)

語句

多賦值（multiple assignment）支持，例如：

復制代碼代碼如下:

	
	a, b = 1, 2
	print(a) --> 1
	print(b) --> 2

多賦值的一個慣用法就是交換兩個變量的值：

復制代碼代碼如下:

	
	x, y = 1, 2
	x, y = y, x
	print(x) --> 2
	print(y) --> 1

創建局部變量使用 local：

復制代碼代碼如下:

	
	j = 10       -- 全局變量 j
	local i = 10 -- 局部變量 i

局部變量的作用域限制于他們聲明的塊（block）。塊（block）包括：

1.控制結構的主體部分
2.函數體
3.chunk
4.do-end

范例：

復制代碼代碼如下:

	
	if true then
	    local x = 20
	    print(x) --> 20
	end
	 
	print(x) --> nil

我們可以使用 do-end 關鍵字來構造一個塊：

復制代碼代碼如下:

	
	do
	    local x = 20
	    print(x) --> 20
	end
	 
	print(x) --> nil

訪問局部變量要快于訪問全局變量。在 Lua 中有一個習慣用法：

復制代碼代碼如下:

local foo = foo

用于創建一個局部變量并初始化為同名的全局變量。這樣做常常出于兩個原因：

1.避免某些類型的全局變量被修改
2.提高訪問速度

控制結構

if then elseif else

復制代碼代碼如下:

	
	if a < 0 then
	    a = 0
	end
	 
	if a < b then
	    return a
	else
	    return b
	end
	 
	if op == '+' then
	    r = a + b
	elseif op == '-' then
	    r = a - b
	elseif op == '*' then
	    r = a * b
	elseif op == '/' then
	    r = a / b
	else
	    error('invalid operation')
	end

Lua 中沒有 switch 語句。

while

復制代碼代碼如下:

	
	local i = 1
	while a[i] do
	    print(a[i])
	    i = i + 1
	end

repeat

復制代碼代碼如下:

	
	repeat
	    line = io.read()
	until line ~= ''
	print(line)

區別于 while，repeat 會先執行循環體，然后判斷測試條件。

數值型 for（numeric for）

for 有兩種：

數值型 for（numeric for）

1.泛型 for（generic for）
2.數值型 for 的語法如下：

復制代碼代碼如下:

	
	for var = exp1, exp2, exp3 do
	    <something>
	end

這里 exp1 作為 var 的初始值，exp2 為 var 的最大值，exp3 為 var 每次遞增的值，exp3 是可選的，默認為 1。范例：

復制代碼代碼如下:

	
	-- 輸出 1 2 3
	for i = 1, 3 do
	    print(i)
	end

有一些需要注意的地方：

1.for 中的 exp1、exp2、exp3 只會被計算一次值，例如：

復制代碼代碼如下:

for i = 1, f(x) do print(i) end

這里的 f(x) 只會被調用一次

2.控制變量 var 只是一個局部變量
3.不要嘗試去修改控制變量 var 的值（結果是未知的）

泛型 for

泛型 for 通過一個迭代器函數來實現遍歷，例如：

復制代碼代碼如下:

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

這里的 pairs 就是一個迭代器函數，此 for 循環遍歷 table t，每次獲取到的 key 保存在變量 k 中，獲取到的 value 保存在變量 v 中。除了 pairs 還有其他的迭代器可以用：

1.io.lines 可用于迭代文件中的行
2.ipairs 可用于迭代 table 的數組部分

我們還可以自己編寫迭代器。

break、return、goto

break 語句用于跳出一個循環（for、repeat、while）。

return 語句用于為函數返回結果。在 Lua 中，return 語句必須是一個塊的最后一條語句，看一個例子：

復制代碼代碼如下:

	
	function foo()
	    -- 語法錯誤
	    return
	    local i = 1
	end

有時候，我們出于某些原因（例如為了 debug），我們需要在一個函數中插入一個 return 語句，這時候可以這么做：

復制代碼代碼如下:

	
	function foo()
	    -- ...
	    do return end
	    -- ...
	end

goto 語句用于在函數中跳轉。goto 語句可以讓執行跳轉到特定的標簽（label）處，例如：

復制代碼代碼如下:

	
	goto quit
	print('come on')
	::quit::
	print('quit')

這里輸出 quit。正如我們看到的，標簽的寫法為 ::name::。goto 跳轉也是存在限制的：

1.不允許跳轉到一個塊中去
2.不允許跳轉到函數之外去
3.不允許跳入局部變量的作用域中

對于第三點，看一個例子：

復制代碼代碼如下:

	
	goto quit
	local a
	::quit::
	print('quit')

這里，會出現語法錯誤（jumps into the scope of local 'a'）。但是，有一個細節需要注意，我們先修改上面的例子：

復制代碼代碼如下:

	
	goto quit
	local a
	::quit::

執行成功，沒有語法錯誤。這是因為局部變量的作用域結束于變量定義的塊的最后一個非 void 語句，而標簽被認為是一個 void 語句，對于上面的例子來說，a 的作用域在 ::quit:: 之前就結束了，因此 goto quit 并沒有跳入局部變量 a 的作用域中。

利用 goto 可以比較方便的編寫狀態機，例如（s1、s2 為狀態）：

復制代碼代碼如下:

	
	::s1:: do
	    local c = io.read(1)
	    if c == '0' then goto s2
	    elseif c == nil then print'ok'; return
	    else goto s1
	    end
	end
	 
	::s2:: do
	    local c = io.read(1)
	    if c == '0' then goto s1
	    elseif c == nil then print'not ok'; return
	    else goto s2
	    end
	end
	 
	goto s1