第四章   基本語法
4.1賦值語句
賦值是改變一個變數的值和改變表域的最基本的方法。 
a = "hello" .. "world" 
t.n = t.n + 1 
Lua 可以對多個變數同時賦值，變數列表和值列表的各個元素用逗號分開，賦值語
句右邊的值會依次賦給左邊的變數。 
a, b = 10, 2*x  <-->  a=10; b=2*x 


遇到賦值語句 Lua 會先計算右邊所有的值然後再執行賦值操作，所以我們可以這樣
進行交換變數的值： 
x, y = y, x       -- swap 'x' for 'y' 
a[i], a[j] = a[j], a[i]    -- swap 'a[i]' for 'a[i]' 
當變數個數和值的個數不一致時，Lua 會一直以變數個數為基礎採取以下策略：
a. 變數個數>值的個數      按變數個數補足 nil 
b. 變數個數<值的個數      多餘的值會被忽略 


例如： 
a, b, c = 0, 1  
print(a,b,c)     --> 0   1   nil 
 
a, b = a+1, b+1, b+2   -- value of b+2 is ignored 
print(a,b)       --> 1   2 
 
a, b, c = 0 
print(a,b,c)     --> 0   nil   nil 
上面最後一個例子是一個常見的錯誤情況，注意：如果要對多個變數賦值必須依次
對每個變數賦值。 
a, b, c = 0, 0, 0 
print(a,b,c)     --> 0   0   0 
多值賦值經常用來交換變數，或將函式呼叫返回給變數： 
a, b = f() 
f()返回兩個值，第一個賦給 a，第二個賦給 b。 


4.2區域性變數與程式碼塊(block)
使用 local 建立一個區域性變數，與全域性變數不同，區域性變數只在被宣告的那個程式碼塊
內有效。程式碼塊：指一個控制結構內，一個函式體，或者一個 chunk（變數被宣告的那
個檔案或者文字串）。 
x = 10 
local i = 1     -- local to the chunk 
 
while i<=x do 
  local x = i*2    -- local to the while body 
 print(x)     --> 2, 4, 6, 8, ... 
 i = i + 1 
end 


if i > 20 then 
  local x     -- local to the "then" body
 x = 20 
 print(x + 2) 
else 
 print(x)     --> 10  (the global one) 
end 
 
print(x)      --> 10  (the global one) 
注意，如果在互動模式下上面的例子可能不能輸出期望的結果，因為第二句 local i=1
是一個完整的 chunk，在互動模式下執行完這一句後，Lua 將開始一個新的 chunk，這樣
第二句的 i 已經超出了他的有效範圍。可以將這段程式碼放在 do..end（相當於 c/c++的{}）
塊中。 


應該儘可能的使用區域性變數，有兩個好處： 
1.  避免命名衝突 
2.  訪問區域性變數的速度比全域性變數更快. 
我們給 block 劃定一個明確的界限：do..end 內的部分。當你想更好的控制區域性變數
的作用範圍的時候這是很有用的。 
do 
  local a2 = 2*a 
  local d = sqrt(b^2 - 4*a*c) 
 x1 = (-b + d)/a2 
 x2 = (-b - d)/a2 
end      -- scope of 'a2' and 'd' ends here 
 
print(x1, x2) 


4.3控制結構語句
控制結構的條件表示式結果可以是任何值，Lua認為 false 和nil 為假，其他值為真。
if語句，有三種形式： 
if conditions then  
 then-part 
end; 
 
if conditions then  
 then-part 
else 
 else-part 
end; 
 
if conditions then  
 then-part 
elseif conditions then 
 elseif-part 
..     --->多個 elseif 
else 
 else-part 
end; 


while 語句： 
while condition do 
 statements; 
end; 


repeat-until語句： 
repeat 
 statements; 
until conditions; 


for語句有兩大類： 
第一，數值 for迴圈： 
for var=exp1,exp2,exp3 do 
 loop-part 
end 
for 將用 exp3 作為 step 從 exp1（初始值）到 exp2（終止值），執行 loop-part。其中
exp3 可以省略，預設 step=1 


有幾點需要注意： 
1.  三個表示式只會被計算一次，並且是在迴圈開始前。 
for i=1,f(x) do 
 print(i) 
end 
 
for i=10,1,-1 do 
 print(i) 
end 
第一個例子 f(x)只會在迴圈前被呼叫一次。 
2.控制變數var是區域性變數自動被宣告，並且只在迴圈內有效
for i=1,10 do 
 print(i) 
end 
max = i   -- probably wrong! 'i' here is global 


如果需要保留控制變數的值，需要在迴圈中將其儲存 
-- find a value in a list 
local found = nil 
for i=1,a.n do 
  if a[i] == value then 
  found = i    -- save value of 'i' 
   break 
  end 
end 
print(found) 


3.  迴圈過程中不要改變控制變數的值，那樣做的結果是不可預知的。如果要退出循
環，使用 break 語句。 
第二，範型 for迴圈： 
前面已經見過一個例子： 
-- print all values of array 'a'  
for i,v in ipairs(a) do print(v) end 
範型 for遍歷迭代子函式返回的每一個值。 
再看一個遍歷表 key的例子： 
-- print all keys of table 't' 
for k in pairs(t) do print(k) 
end 
範型 for和數值 for有兩點相同： 
1.  控制變數是區域性變數 
2.  不要修改控制變數的值 
再看一個例子，假定有一個表： 
days = {"Sunday", "Monday", "Tuesday", "Wednesday", 
     "Thursday", "Friday", "Saturday"} 


revDays = {["Sunday"]=1, ["Monday"]=2, ["Tuesday"]=3, ["Wednesday"]=4, ["Thursday"]=5, ["Friday"]=6, ["Saturday"]=7}
x = "Tuesday"
print(revDays[x])


我們不需要手工，可以自動構造反向表 
revDays = {}
for i, v in ipairs(days) do
revDays[v] = i
end


如果你對範型 for還有些不清楚在後面的章節我們會繼續來學習。 


4.4 break 和return語句
break 語句用來退出當前迴圈（for,repeat,while）。在迴圈外部不可以使用。 
return 用來從函式返回結果，當一個函式自然結束結尾會有一個預設的 return。（這
種函式類似 pascal 的過程） 


Lua 語法要求 break 和 return 只能出現在 block 的結尾一句（也就是說：作為 chunk
的最後一句，或者在 end 之前，或者 else 前，或者 until 前），例如： 
local i = 1
while a[i] do
if a[i] == v then break end
i = i + 1
end


有時候為了除錯或者其他目的需要在 block 的中間使用 return 或者break，可以顯式
的使用 do..end 來實現： 
function foo () 
  return     --<< SYNTAX ERROR 
  -- 'return' is the last statement in the next block 
  do return end    -- OK 
 ...       -- statements not reached 
end 


第五章  函式
函式有兩種用途：1.完成指定的任務，這種情況下函式作為呼叫語句使用；2.計算並
返回值，這種情況下函式作為賦值語句的表示式使用。 
語法： 
function func_name (arguments-list) 
 statements-list; 
end; 
呼叫函式的時候，如果引數列表為空，必須使用()表明是函式呼叫。 
print(8*9, 9/8) 
a = math.sin(3) + math.cos(10) 
print(os.date()) 


上述規則有一個例外，當函式只有一個引數並且這個引數是字串或者表構造的時
候，()是可選的： 
print "Hello World"  <-->  print("Hello World") 
dofile 'a.lua'   <-->  dofile ('a.lua') 
print [[a multi-line  <-->  print([[a multi-line 
   message]]        message]]) 
f{x=10, y=20}    <-->  f({x=10, y=20}) 
type{}      <-->  type({}) 


Lua 也提供了面向物件方式呼叫函式的語法，比如 o:foo(x)與o.foo(o, x)是等價的，
後面的章節會詳細介紹面向物件內容。 
Lua 使用的函式可以是 Lua 編寫也可以是其他語言編寫，對於 Lua 程式設計師來說用什
麼語言實現的函式使用起來都一樣。 
Lua 函式實參和形參的匹配與賦值語句類似，多餘部分被忽略，缺少部分用 nil 補足。  
function f(a, b) return a or b end 
 
CALL    PARAMETERS 
 
f(3)    a=3, b=nil 
f(3, 4)   a=3, b=4 
f(3, 4, 5)   a=3, b=4 (5 is discarded) 


5.1返回多個結果值
Lua 函式可以返回多個結果值，比如 string.find，其返回匹配串“開始和結束的下標”
（如果不存在匹配串返回 nil）。 
s, e = string.find("hello Lua users", "Lua") 
print(s, e)   --> 7 9 
Lua函式中，在return後列出要返回的值得列表即可返回多值，如：
function maximum (a)
local mi = 1
local m = a[mi]
for i, val in ipairs(a) do 
if val > m then 
mi = i
m = val
end
end
end


print(maximum({8, 10, 23, 12, 5}))-->23  3


Lua總是調整函式返回值的個數去適用呼叫環境，當作為一個語句呼叫函式時，所有返回值被忽略。假設有如下三個函式：
function foo0 () end       -- returns no results 
function foo1 () return 'a' end     -- returns 1 result 
function foo2 () return 'a','b' end  -- returns 2 results 
第一，當作為表示式呼叫函式時，有以下幾種情況： 
1.  當呼叫作為表示式最後一個引數或者僅有一個引數時，根據變數個數函式儘可能
多地返回多個值，不足補 nil，超出捨去。 
2.  其他情況下，函式呼叫僅返回第一個值（如果沒有返回值為 nil） 
x,y = foo2()     -- x='a', y='b' 
x = foo2()       -- x='a', 'b' is discarded 
x,y,z = 10,foo2()     -- x=10, y='a', z='b' 
 
x,y = foo0()     -- x=nil, y=nil 
x,y = foo1()     -- x='a', y=nil 
x,y,z = foo2()    -- x='a', y='b', z=nil 
end


x,y = foo2(), 20    -- x='a', y=20 
x,y = foo0(), 20, 30   -- x='nil', y=20, 30 is discarded 


第二，函式呼叫作為函式引數被呼叫時，和多值賦值是相同。 
print(foo0())     --> 
print(foo1())     --> a 
print(foo2())     --> a   b 
print(foo2(), 1)    --> a   1 
print(foo2() .. "x")   --> ax 


第三，函式呼叫在表建構函式中初始化時，和多值賦值時相同。 
a = {foo0()}     -- a = {}    (an empty table) 
a = {foo1()}     -- a = {'a'} 
a = {foo2()}     -- a = {'a', 'b'} 
 
a = {foo0(), foo2(), 4}  -- a[1] = nil, a[2] = 'a', a[3] = 4 
另外，return f()這種型別的返回 f()返回的所有值 
function foo (i) 
  if i == 0 then return foo0() 
  elseif i == 1 then return foo1() 
  elseif i == 2 then return foo2() 
  end 
end 
 
print(foo(1))    --> a 
print(foo(2))    --> a  b 
print(foo(0))    -- (no results) 
print(foo(3))    -- (no results) 


可以使用圓括號強制使呼叫返回一個值。 
print((foo0()))   --> nil 
print((foo1()))   --> a 
print((foo2()))   --> a 


一個 return語句如果使用圓括號將返回值括起來也將導致返回一個值。 
函式多值返回的特殊函式 unpack，接受一個數組作為輸入引數，返回陣列的所有元
素。unpack被用來實現範型呼叫機制，在 C 語言中可以使用函式指標呼叫可變的函式，
可以宣告引數可變的函式，但不能兩者同時可變。在 Lua中如果你想呼叫可變引數的可
變函式只需要這樣： 
f(unpack(a)) 
unpack 返回a 所有的元素作為 f()的引數 


f = string.find 
a = {"hello", "ll"} 
print(f(unpack(a)))   --> 3  4 


預定義的 unpack 函式是用 C 語言實現的，我們也可以用 Lua 來完成： 
function unpack(t, i) 
 i = i or 1 
  if t[i] then 
   return t[i], unpack(t, i + 1) 
  end 
end 


5.2可變引數
Lua 函式可以接受可變數目的引數，和 C 語言類似在函式引數列表中使用三點（...）
表示函式有可變的引數。Lua 將函式的引數放在一個叫 arg 的表中，除了引數以外，arg
表中還有一個域 n 表示引數的個數。 
例如，我們可以重寫 print 函式： 


printResult = "" 
 
function print(...) 
  for i,v in ipairs(arg) do 
  printResult = printResult .. tostring(v) .. "\t" 
  end 
 printResult = printResult .. "\n" 
end 


有時候我們可能需要幾個固定引數加上可變引數 
function g(a, b, ...) end
call parameters
g(3)a = 3, b = nil, arg={n=0}
g{3, 4}a = 3, b = 4, arg = {n = 0}
g{3, 4, 8, 5} a = 3, b = 4, arg = {5, 8 ,n = 2}


如上面所示，Lua 會將前面的實參傳給函式的固定引數，後面的實參放在 arg 表中。
舉個具體的例子，如果我們只想要 string.find 返回的第二個值： 
一個典型的方法是使用虛變數（下劃線） 
local _, x = string.find(s, p) 
-- now use `x' 
... 
還可以利用可變引數宣告一個select函式：
function select (n, ...) 
  return arg[n] 
end 
 
print(string.find("hello hello", " hel"))    --> 6  9 
print(select(1, string.find("hello hello", " hel"))) --> 6 
print(select(2, string.find("hello hello", " hel"))) --> 9 


有時候需要將函式的可變引數傳遞給另外的函式呼叫，可以使用前面我們說過的
unpack(arg)返回 arg 表所有的可變引數，Lua 提供了一個文字格式化的函式 string.format
（類似 C 語言的 sprintf函式）： 
function fwrite(fmt, ...) 
  return io.write(string.format(fmt, unpack(arg))) 
end 
這個例子將文字格式化操作和寫操作組合為一個函式。 


5.3命名引數
Lua 的函式引數是和位置相關的，呼叫時實參會按順序依次傳給形參。有時候用名
字指定引數是很有用的，比如 rename 函式用來給一個檔案重新命名，有時候我們我們記不
清命名前後兩個引數的順序了： 


-- invalid code 
rename(old="temp.lua", new="temp1.lua") 
上面這段程式碼是無效的，Lua 可以通過將所有的引數放在一個表中，把表作為函式
的唯一引數來實現上面這段虛擬碼的功能。因為 Lua 語法支援函式呼叫時實參可以是表
的構造。 
rename{old="temp.lua", new="temp1.lua"} 
根據這個想法我們重定義了 rename： 
function　rename (arg)
{
return os.rename(arg.old, arg.new)
}


當函式的引數很多的時候，這種函式引數的傳遞方式很方便的。例如 GUI 庫中建立
窗體的函式有很多引數並且大部分引數是可選的，可以用下面這種方式： 
w = Window { 
 x=0, y=0, width=300, height=200, 
 title = "Lua", background="blue", 
 border = true 
} 
 
function Window (options) 
  -- check mandatory options 
  if type(options.title) ~= "string" then 
  error("no title") 
  elseif type(options.width) ~= "number" then 
  error("no width") 
  elseif type(options.height) ~= "number" then 
  error("no height") 
  end 


  -- everything else is optional 
 _Window(options.title, 
  options.x or 0,    -- default value 
  options.y or 0,    -- default value 
  options.width, options.height, 
  options.background or "white",  -- default 
  options.border    -- default is false (nil) 
 ) 
end