如何快速學會一門編程語言之Lua：高級特性

內置數據結構 table

靈活的下標

a = {2, 4, 6, 8}
print(a[1], a[2]) --> 顯示：2 4

p = {a=1, b=3, c=9}



     




print(a["b"]) --> 顯示：3

p.d = 10
print(p.a) --> 顯示：9
print(p["d"]) --> 顯示：10

k = {}
k[2]="hello"
k["haha"]="world"
print(k[2],k["haha"]) --> 顯示：hello world

遍歷 table

a={}
a[1]="one"
a["second"]="two"
a[78]="three"
a["last"]="four"
for k,v in pairs(a) do
  print(k,v)
end

1       one



     




last    four
78      three
second  two

列表形 table

• 用 # 來獲得長度。需要特別注意不要用賦值 nil 來刪除列表裡的元素，否則#的結果是不準確的。
• 用 for i,v in ipairs(...) do 來進行順序遍歷
• 用 table.insert(tb, pos, var) 來追加和插入元素
• 用 table.remove(tb, pos) 來刪除元素
• 用 table.sort(tb) 來排序，這個尤其有用，甚至可以用來排序漢字（因為漢字的內碼是按拼音順序設計的）

一點小結

• 符號 # 在其他語言裡常常是單行註釋符號，Lua 用來作為長度運算符了。
• 符號 // 在其他語言裡面也常常是單行註釋符號，Lua 用來作為整除運算符了（Lua5.3之後支持）。所以 Lua 用了 -- 作為註釋符號。
• Lua 也沒有遞增 ++ 和遞減 -- 運算符。其實這兩個運算符在 a = b++ 這種寫法下，運行的結果比較反直覺，所以Python 也不支持。
• Lua 的 table 用起來和 PHP 的數組還挺像的，都是挺“萬能”的。

面向對象

1. 封裝：就是支持一種叫對象的變量，這個變量是可以同時攜帶屬性值（成員變量）和方法（成員函數）的。開發者不但可以通過對象讀寫其攜帶的屬性，還可以調用對象所攜帶的方法。很多語言還設置了類似 this 或者 self 這種關鍵字，以便在方法中調用攜帶此方法的對象變量。
2. 繼承：支持對象的屬性和方法定義可以被重用，可以讓一類對象的定義，通過繼承語法自動帶上另外一類對象的定義，從而避免大量的重複而類似的定義。
3. 多態：支持多個不同類型（定義）的對象，只要它們都滿足其中一種類型定義，就可以“作為”這類對象來使用。這種特性最常用於取代複雜的 switch...case 語法，做法就是為不同類型的對象，都定義同一個名字的方法，這些不同類型的對象，都可以被調用這個相同名字的方法，但執行的代碼則會被自動調用那些應該屬於那種類型的方法。等於自動以對象的類型為 switch 的選擇，每個對象的方法為 case 的代碼段。

通過原型獲得屬性

father = { last_name="Han", first_name="Da" } --> 被繼承的父對象
son = {first_name="Xiao"} --> 子對象

meta_table = {__index=father} --> 建立去 father 查找成員的元表
setmetatable(son, meta_table) --> 設置 son 對象的元表，以便通過 father 查找未知屬性

print(son.first_name, son.last_name) --> Xiao Han

方法：table 身上的函數

obj = {}
obj.method = function(a, b) 
              return a+b
           end
result = obj.method(1, 2)
print(result) --> 顯示 3

obj = {a=1}
obj.method = function(my_obj, b)
                 return my_obj.a + b
             end
print(obj.method(obj, 2)) --> 顯示 3          

obj = {a=1}
function obj:method(b) --> 定義方法用冒號 : 會自動加上 self 參數作為第一個參數
  return self.a + b
end
print(obj:method(2)) --> 調用方法用冒號 : 會自動傳入本對象 obj 作為第一個參數

構造器

-- 定義 Person 原型對象（類）
Person = {
  Name = "default", 
  Age = 18
}


     






-- 構造器函數
function Person:New(name) 
  local new_obj = {}
  setmetatable(new_obj, {__index = self})
  new_obj.Name = name  --> 此處對 new_obj 插入了屬性 Name，不再需要從元表查找此屬性了
  return new_obj
end

function Person:Show()
  print(self.Name, self.Age)
end

me = Person:New("HanDa") --> 通過原型Person對象，構造一個使用對象
me:Show() --> 通過原型Person對象的Show()方法打印屬性：HanDa 18

繼承

-- Person 原型對象的定義 --
Person = {
  Name = "default", 
  Age = 18
}
function Person:New(name) 
  local new_obj = {}
  setmetatable(new_obj, {__index = self})
  new_obj.Name = name  --> 此處對 new_obj 插入了屬性 Name，不再需要從元表查找此屬性了
  return new_obj
end
function Person:Show()
  print(self.Name, self.Age)
end

-- Student 原型對象繼承於 Person --
Student = Person:New("default student")
Student.School = "211or985" -->添加自己的屬性
function Student:New(name, school)
  local new_obj = {}
  setmetatable(new_obj, {__index = self})
  new_obj.School = school
  new_obj.Name = name --> 覆蓋掉Student原型的默認值,此處無法通過調用 Persion:New() 來進行覆蓋
  return new_obj
end
function Student:Show()
  print(self.Name, self.Age, self.School)
end

me = Student:New("HanDa","三本") --> 通過原型Student對象，構造一個使用對象
me:Show() --> 通過原型Person對象的Show()方法打印屬性：HanDa 18 三本

function Person:Init(name)
  self.Name = name
end

me = Student:New("Anything", "大專")
me:Init("HanDa") <--此處調用父類原型對象的 Init() 方法來設置自己
me:Show() --> HanDa 18 大專

反思

模板和泛型

內存管理/垃圾收集

a = 10
function f()
  a = 11
  b = 20
end

f()
print(a,b)

a = 10
function f()
  local a = 11
  local b = 20
end

f()
print(a,b) -- 打印結果：10 nil

1. 所有的全局變量都不會被回收
2. 所有的非 Table 類型的 local 變量，都會被回收。
3. 正在被使用的 Table 變量，包括全局變量和局部變量——其內容的 key 和 value 都不會被回收，除非這個 Table 被聲明為 weak 弱引用的。
4. 如果有一個變量，所有包含它的 Table 的引用（包括 key 和 value）都是弱引用，那麼它就會被回收。

1. 儘量使用 local 局部變量
2. 不要往一個全局的 Table 變量裡面無限制的加入內容
3. 如果一個變量，明確已經在某個 Table 裡面包含了，那麼其他使用這個變量的其他 Table，可以考慮作為 weak 弱引用 Table 來包含它。這樣有助於減少洩漏的可能性，如果使用大量 Table 包含一個變量，這裡面任何一個 Table 不小心放到某個全局變量或者全局 Table 裡面去了，就會洩漏了。

錯誤處理

1. 發現“錯誤”後，生成一個錯誤信息，讓調用代碼知道這個情況。對於 C 語言我們常見的有返回錯誤碼，設置一個全局的 errno 變量等法子；Java 語言則設計了異常，可以通過throw關鍵字作為一種特殊的返回值拋給上層。
2. 調用代碼在發生“錯誤”後，編寫一段特別的代碼來處理它。C 語言的代碼通常通過 if 判斷返回值是否為 0，來發現函數中是否發生了錯誤；Java 代碼則被要求必須編寫 try...catch 代碼來捕獲和處理拋出的異常（或者繼續拋出這些異常）。

• 你可以通過 assert(expr, "err msg") 函數來進行判斷，如果表達式為 false，則會“拋出”一個 Lua 定義的錯誤；你也可以直接調用 error("err msg") 來拋出一個 Lua 錯誤。只要拋出了錯誤，Lua 程序在默認情況下，就會中斷執行，並且打印你定義的錯誤消息內容，以及錯誤發生的源碼位置，函數調用（棧）信息等等。
• 你可以通過使用 pcall(func_name, ...) 的方式來發起對一個函數的調用，如果這個函數會拋出錯誤，Lua 程序將不會中斷運行；而是讓 pcall() 返回兩個返回值：false 和 errinfo，其中 errinfo 返回值是你通過 error() 函數傳入的參數，不必是一個字符串，可以是一個 table，這樣你可以設計任意的內容以便上層調用者進行處理。如果 pcall() 調用的函數沒有拋出錯誤，那麼它返回的一個返回值會是 true，而後面的返回值則是具體調用函數的返回值。

-- 此函數會拋出錯誤
function add(a,b)
        assert(type(a) == "number", "a is not a number")
        if type(b) ~= "number" then
                error("b is not a number")
        end
        return a+b
end

-- 通過 pcall() 捕獲錯誤
rs, err = pcall(add, 1, "kk")
print(rs, err)

rs, err = pcall(add, "ww", 2)
print(rs, err)

rs, err = pcall(add, 1, 2)
print(rs, err)

false   test.lua:4: b is not a number
false   test.lua:2: a is not a number
true    3

多任務支持

1. 同時運行的多個函數，對於可以讀寫的同一塊堆內存（或者叫變量），可能造成不可預期的結果。因此誕生了很多種類的“鎖”，來試圖解決多個程序同時修改、讀取同一組變量造成的故障。

1. 同時運行的多個函數，也許不是性能最好的做法，因為計算機需要在這多個函數的運行環境之間反覆切換，這種切換本身也需要成本。

1. 對於同時讀寫變量的問題。由於協程是可以自己寫代碼進行切換的，所以把可能出現同時操作的代碼，有意識的不要用 yield 斷開。由於始終只有一個線程在運行，只要別切換出去，變量就不會被其他程序修改。——這樣也不需要什麼鎖了。
2. 由於只有一個線程在運行，協程之間切換的代價會大大降低，而且切換的代碼是手工編寫的，也提供了更細緻的調優的手段。

function foo()
    print("協同程序 foo 開始執行")
    local value = coroutine.yield("暫停 foo 的執行")
    print("協同程序 foo 恢復執行，傳入的值為: " .. tostring(value))
    return "協同程序 foo 結束執行"
end

-- 創建協同程序
local co = coroutine.create(foo)

-- 啟動協同程序
local status, result = coroutine.resume(co)
print(result) 

-- 恢復協同程序的執行，並傳入一個值
status, result = coroutine.resume(co, 42)
print(result) 

• coroutine.resume() 用來進入一個協程函數，輸入參數會成為協程函數的入參，或者 coroutine.yield() 的返回值。Lua 支持多返回值的好處這裡就看見了，多個 resume() 參數可以自然的成為 yield() 的多個返回值。
• coroutine.yield() 用來以一種特殊的 return 切出函數，其參數是 coroutine.resume() 的返回值。如果協程函數結束，return 的返回值也會以 resume() 的返回值形式提供給調用者。

框架支持

回調函數

-- 回調函數
add = function(a, b) return a+b end
sub = function(a, b) return a-b end

-- 框架代碼，主要功能是打印計算結果
function cal(cal_fun, a, b)
  print(cal_fun(a,b))
end

--使用框架
cal(add, 3, 2) --> 5
cal(sub, 3, 2) --> 1

反射

-- 框架代碼：從命令行參數執行命令
function run_cmd()
  -- arg 是一個全局 table 變量，記錄了全部的命令行參數
  if not arg[1] or not arg[2] or not arg[3] then
    print("Usage: cmd arg1 arg2")
    return
  end
  local f=load("return "..arg[1].."("..arg[2]..","..arg[3]..")")
  print(f())
end

-- 回調函數
function add(a, b) return a+b end
function sub(a, b) return a-b end

-- 運行框架
run_cmd()

$ lua test.lua add 1 3
4
$ lua test.lua sub 1 3
-2

-- local f=load("return ".."add".."(".."1"..",".."3"..")")
local f = function(...)
            return add(1,3)
          end

tb = {a=1, b=2}
pirnt(tb["a"]) --> 1

a = 100
print(_G["a"]) --> 100

所謂反射，就是可以在運行時，通過在字符串變量名中的函數名字來調用這個函數；通過字符串變量中的變量名字來讀寫變量。

註解

模塊管理

1. 定義模塊：怎樣寫代碼，怎樣命名文件才能成為一個合法的“模塊”
2. 引用模塊：怎樣寫代碼才能調用另外一個模塊裡面的功能，譬如調用函數或者構造類對象
3. 編譯或運行的方法：怎樣操作才能讓各個模塊的代碼一起運行

• 建立一個以模塊名為文件名的源碼，譬如 aaa.lua，就代表了你想要設計一個叫 aaa 的模塊
• 在模塊源文件內，定義一個 table，如 tb = {}，然後把你希望提供給使用者的變量、函數，都存放到這個 table 變量（tb）裡面，最後在源文件末尾寫上 return tb 來返回這個 table

module = {}
 
-- 定義一個常量
module.constant = "這是一個常量"
 
-- 定義一個函數
function module.func1()
    io.write("這是一個公有函數！\n")
end
 
local function func2()
    print("這是一個私有函數！")
end
 
function module.func3()
    func2()
end
 
return module

-- module 模塊為上文提到到 module.lua
require("module")
print(module.constant)
module.func3()

這是一個常量
這是一個私有函數！

export LUA_PATH="./?.lua;/usr/local/share/lua/5.1/?.lua;/usr/local/share/lua/5.1/?/init.lua;/usr/local/lib/lua/5.1/?.lua;/usr/local/lib/lua/5.1/?/init.lua"

./module.lua
/usr/local/share/lua/5.1/module.lua
/usr/local/share/lua/5.1/module/init.lua
/usr/local/lib/lua/5.1/module.lua
/usr/local/lib/lua/5.1/module/init.lua

小結

下一篇介紹 Lua 為數不多但靈活好用的庫函數