1 - 介紹

Lua 是一個(gè)擴(kuò)展式程序設(shè)計(jì)語(yǔ)言，它被設(shè)計(jì)成支持通用的過(guò)程式編程，并有相關(guān)數(shù)據(jù)描述的設(shè)施。 Lua 也能對(duì)面向?qū)ο缶幊蹋瘮?shù)式編程，數(shù)據(jù)驅(qū)動(dòng)式編程提供很好的支持。它可以作為一個(gè)強(qiáng)大、輕量的腳本語(yǔ)言，供任何需要的程序使用。 Lua 以一個(gè)用 clean C 寫(xiě)成的庫(kù)形式提供。（所謂 Clean C ，指的 ANSI C 和 C++ 中共通的一個(gè)子集）

作為一個(gè)擴(kuò)展式語(yǔ)言，Lua 沒(méi)有 "main" 程序的概念：它只能 嵌入 一個(gè)宿主程序中工作，這個(gè)宿主程序被稱作 embedding program

或簡(jiǎn)稱為 host

。宿主程序可以通過(guò)調(diào)用函數(shù)執(zhí)行一小段 Lua 代碼，可以讀寫(xiě) Lua 變量，可以注入 C 函數(shù)讓 Lua 代碼調(diào)用。這些擴(kuò)展的 C 函數(shù)，可以大大的擴(kuò)展了 Lua 可以處理事務(wù)的領(lǐng)域，這樣就可以訂制出各種語(yǔ)言，而它們共享一個(gè)統(tǒng)一的句法格式的框架。 Lua 的官方發(fā)布版就包含了一個(gè)叫做 lua 的簡(jiǎn)單的宿主程序，它用 Lua 庫(kù)提供了一個(gè)保證獨(dú)立的 Lua 解釋器。

Lua 是一個(gè)自由軟件，它的使用許可決定了對(duì)它的使用過(guò)程一般沒(méi)有任何保證。這份手冊(cè)中描述的東西的實(shí)現(xiàn)，可以在 Lua 的官方網(wǎng)站 http://www.lua.org/ 找到，

跟其它的許多參考手冊(cè)一樣，這份文檔有些地方比較枯燥。關(guān)于 Lua 的設(shè)計(jì)想法的探討，可以看看 Lua 網(wǎng)站上提供的技術(shù)論文。有關(guān)用 Lua 編程的細(xì)節(jié)介紹，可以讀一下 Roberto 的書(shū)，Programming in Lua (Second Edition)

2 - 語(yǔ)言
這一節(jié)從詞法、語(yǔ)法、句法上描述 Lua 。換句話說(shuō)，這一節(jié)描述了哪些 token （符記）是有效的，它們?nèi)绾伪唤M合起來(lái)，這些組合方式有什么含義。
關(guān)于語(yǔ)言的構(gòu)成概念將用常見(jiàn)的擴(kuò)展 BNF 表達(dá)式寫(xiě)出。也就是這個(gè)樣子： {a} 意思是 0 或多個(gè) a ， [a] 意思是一個(gè)可選的 a 。非最終的符號(hào)會(huì)保留原來(lái)的樣子，關(guān)鍵字則看起來(lái)像這樣 kword ，其它最終的符號(hào)則寫(xiě)成 `=′ 。完整的 Lua 語(yǔ)法可以在本手冊(cè)最后找到。
2.1 - 詞法約定
Lua 中用到的 名字（也稱作 標(biāo)識(shí)符）可以是任何非數(shù)字開(kāi)頭的字母、數(shù)字、下劃線組成的字符串。這符合幾乎所有編程語(yǔ)言中關(guān)于名字的定義。（字母的定義依賴于當(dāng)前環(huán)境：系統(tǒng)環(huán)境中定義的字母表中的字母都可以被用于標(biāo)識(shí)符。）標(biāo)識(shí)符用來(lái)命名變量，或作為表的域名。
下面的關(guān)鍵字是保留的，不能用作名字：
and break do else elseif
end false for function if
in local nil not or
repeat return then true until while
Lua 是一個(gè)大小寫(xiě)敏感的語(yǔ)言： and 是一個(gè)保留字，但是 And 和 AND 則是兩個(gè)不同的合法的名字。一般約定，以下劃線開(kāi)頭連接一串大寫(xiě)字母的名字（比如 _VERSION）被保留用于 Lua 內(nèi)部全局變量。
下面這些是其它的 token ：
+ - * / % ^ #
== ~= <= >= < > =
( ) { } [ ]
; : , . .. ...
字符串既可以用一對(duì)單引號(hào)引起，也可以是雙引號(hào)，里面還可以包含類似 C 的轉(zhuǎn)義符： '\a' （響鈴）， '\b' （退格）， '\f' （表單）， '\n' （換行）， '\r' （回車）， '\t' （橫向制表）， '\v' （縱向制表）， '\\' （反斜杠）， '\"' （雙引號(hào)），以及 '\'' （單引號(hào))。而且，如果在一個(gè)反斜杠后跟了一個(gè)真正的換行符，其結(jié)果就是在字符串中產(chǎn)生一個(gè)換行符。我們還可以用反斜杠加數(shù)字的形式 \ddd 來(lái)描述一個(gè)字符。這里， ddd 是一串最多三位的十進(jìn)制數(shù)字。（注意，如果需要在這種描述方法后接一個(gè)是數(shù)字的字符，那么反斜杠后必須寫(xiě)滿三個(gè)數(shù)字。）Lua 中的字符串可以包含任何 8 位的值。包括用 '\0' 表示的零。
只有在你需要把不同的引號(hào)、換行、反斜杠、或是零結(jié)束符這些字符置入字符串時(shí)，你才必須使用轉(zhuǎn)義符。別的任何字符都可以直接寫(xiě)在文本里。（一些控制符可以會(huì)影響文件系統(tǒng)造成某些問(wèn)題，但是不會(huì)引起 Lua 的任何問(wèn)題。）
字符串還可以用一種長(zhǎng)括號(hào)括起來(lái)的方式定義。我們把兩個(gè)正的方括號(hào)間插入 n 個(gè)等號(hào)定義為第 n 級(jí)正長(zhǎng)括號(hào)。就是說(shuō)，0 級(jí)正的長(zhǎng)括號(hào)寫(xiě)作 [[ ，一級(jí)正的長(zhǎng)括號(hào)寫(xiě)作 [=[ ，如此等等。反的長(zhǎng)擴(kuò)展也作類似定義；舉個(gè)例子，4 級(jí)反的長(zhǎng)括號(hào)寫(xiě)作 ]====] 。一個(gè)長(zhǎng)字符串可以由任何一級(jí)的正的長(zhǎng)括號(hào)開(kāi)始，而由第一個(gè)碰到的同級(jí)反的長(zhǎng)括號(hào)結(jié)束。整個(gè)詞法分析過(guò)程將不受分行限制，不處理任何轉(zhuǎn)意符，并且忽略掉任何不同級(jí)別的長(zhǎng)括號(hào)。這種方式描述的字符串可以包含任何東西，當(dāng)然特定級(jí)別的反長(zhǎng)括號(hào)除外。
另一個(gè)約定是，當(dāng)正的長(zhǎng)括號(hào)后面立即跟了一個(gè)換行符，這個(gè)換行符就不包含在這個(gè)字符串內(nèi)。舉個(gè)例子，假設(shè)一個(gè)系統(tǒng)使用 ASCII 碼（這時(shí)，'a' 編碼為 97 ，換行符編碼為 10 ，'1' 編碼為 49 ），下面五種方式描述了完全相同的字符串：
a = 'alo\n123"'
a = "alo\n123\""
a = '\97lo\10\04923"'
a = [[alo
123"]]
a = [==[
alo
123"]==]
數(shù)字常量可以分兩部分寫(xiě)，十進(jìn)制底數(shù)部分和十進(jìn)制的指數(shù)部分。指數(shù)部分是可選的。 Lua 也支持十六進(jìn)制整數(shù)常量，只需要在前面加上前綴 0x 。下面是一些合法的數(shù)字常量的例子：
3 3.0 3.1416 314.16e-2 0.31416E1 0xff 0x56
注釋可以在除字符串內(nèi)的任何地方是以兩橫 (--) 開(kāi)始。如果跟在兩橫后面的不是一個(gè)長(zhǎng)括號(hào)，這就是一個(gè)短注釋，它的作用范圍直到行末；否則就是一個(gè)長(zhǎng)注釋，其作用范圍直到遇到反的長(zhǎng)括號(hào)。長(zhǎng)注釋通常被用來(lái)臨時(shí)屏蔽代碼塊。
2.2 - 值與類型
Lua 是一種 動(dòng)態(tài)類型語(yǔ)言。這意味著變量沒(méi)有類型，只有值才有類型。語(yǔ)言中不存在類型定義。而所有的值本身攜帶它們自己的類型信息。
Lua 中的所有值都是一致 (first-class) 的。這意味著所有的值都可以被放在變量里，當(dāng)作參數(shù)傳遞到另一個(gè)函數(shù)中，并被函數(shù)作為結(jié)果返回。
Lua 中有八種基本類型： nil, boolean, number, string, function, userdata, thread, and table. Nil 類型只有一種值 nil ，它的主要用途用于標(biāo)表識(shí)和別的任何值的差異；通常，當(dāng)需要描述一個(gè)無(wú)意義的值時(shí)會(huì)用到它。 Boolean 類型只有兩種值：false 和 true。 nil 和 false 都能導(dǎo)致條件為假；而另外所有的值都被當(dāng)作真。 Number 表示實(shí)數(shù)（雙精度浮點(diǎn)數(shù)）。（編譯一個(gè)其它內(nèi)部數(shù)字類型的 Lua 解釋器是件很容易的事；比如把內(nèi)部數(shù)字類型改作單精度浮點(diǎn)數(shù)或長(zhǎng)整型。參見(jiàn)文件 luaconf.h 。） String 表示一串字符的數(shù)組。 Lua 是 8-bit clean 的：字符串可以包含任何 8 位字符，包括零結(jié)束符 ('\0') （參見(jiàn) §2.1）。
Lua 可以調(diào)用（和處理）用 Lua 寫(xiě)的函數(shù)以及用 C 寫(xiě)的函數(shù)（參見(jiàn) §2.5.8）.
userdata 類型用來(lái)將任意 C 數(shù)據(jù)保存在 Lua 變量中。這個(gè)類型相當(dāng)于一塊原生的內(nèi)存，除了賦值和相同性判斷，Lua 沒(méi)有為之預(yù)定義任何操作。然而，通過(guò)使用 metatable （元表） ，程序員可以為 userdata 自定義一組操作（參見(jiàn) §2.8）。 userdata 不能在 Lua 中創(chuàng)建出來(lái)，也不能在 Lua 中修改。這樣的操作只能通過(guò) C API。這一點(diǎn)保證了宿主程序完全掌管其中的數(shù)據(jù)。
thread 類型用來(lái)區(qū)別獨(dú)立的執(zhí)行線程，它被用來(lái)實(shí)現(xiàn) coroutine （協(xié)同例程）（參見(jiàn) §2.11）。不要把 Lua 線程跟操作系統(tǒng)的線程搞混。 Lua 可以在所有的系統(tǒng)上提供對(duì) coroutine 的支持，即使系統(tǒng)并不支持線程。
table 類型實(shí)現(xiàn)了一個(gè)關(guān)聯(lián)數(shù)組。也就是說(shuō)，數(shù)組可以用任何東西（除了nil）做索引，而不限于數(shù)字。 table 可以以不同類型的值構(gòu)成；它可以包含所有的類型的值（除 nil 外）。 table 是 lua 中唯一的一種數(shù)據(jù)結(jié)構(gòu)；它可以用來(lái)描述原始的數(shù)組、符號(hào)表、集合、記錄、圖、樹(shù)、等等。用于表述記錄時(shí)，lua 使用域名作為索引。語(yǔ)言本身采用一種語(yǔ)法糖，支持以 a.name 的形式表示 a["name"]。有很多形式用于在 lua 中創(chuàng)建一個(gè) table （參見(jiàn) §2.5.7）。
跟索引一樣， table 每個(gè)域中的值也可以是任何類型（除 nil外）。特別的，因?yàn)楹瘮?shù)本身也是值，所以 table 的域中也可以放函數(shù)。這樣 table 中就可以有一些 methods 了 （參見(jiàn)see §2.5.9）。
table， function ，thread ，和 (full) userdata 這些類型的值是所謂的對(duì)象：變量本身并不會(huì)真正的存放它們的值，而只是放了一個(gè)對(duì)對(duì)象的引用。賦值，參數(shù)傳遞，函數(shù)返回，都是對(duì)這些對(duì)象的引用進(jìn)行操作；這些操作不會(huì)做暗地里做任何性質(zhì)的拷貝。
庫(kù)函數(shù) type 可以返回一個(gè)描述給定值的類型的字符串。
2.2.1 - 強(qiáng)制轉(zhuǎn)換
Lua 提供運(yùn)行時(shí)字符串到數(shù)字的自動(dòng)轉(zhuǎn)換。任何對(duì)字符串的數(shù)學(xué)運(yùn)算操作都會(huì)嘗試用一般的轉(zhuǎn)換規(guī)則把這個(gè)字符串轉(zhuǎn)換成一個(gè)數(shù)字。相反，無(wú)論何時(shí)，一個(gè)數(shù)字需要作為字符串來(lái)使用時(shí)，數(shù)字都會(huì)以合理的格式轉(zhuǎn)換為字符串。需要完全控制數(shù)字怎樣轉(zhuǎn)換為字符串，可以使用字符串庫(kù)中的 format 函數(shù)（參見(jiàn) string.format）。
2.3 - 變量
寫(xiě)上變量的地方意味著當(dāng)以其保存的值來(lái)替代之。 Lua 中有三類變量：全局變量，局部變量，還有 table 的域。
一個(gè)單一的名字可以表示一個(gè)全局變量，也可以表示一個(gè)局部變量 （或者是一個(gè)函數(shù)的參數(shù)，這是一種特殊形式的局部變量）：
var ::= Name
Name 就是 §2.1 中所定義的標(biāo)識(shí)符。
任何變量都被假定為全局變量，除非顯式的以 local 修飾定義 （參見(jiàn) §2.4.7）。局部變量有其作用范圍：局部變量可以被定義在它作用范圍中的函數(shù)自由使用（參見(jiàn) §2.6）。
在變量的首次賦值之前，變量的值均為 nil。
方括號(hào)被用來(lái)對(duì) table 作索引：
var ::= prefixexp `[′ exp `]′
對(duì)全局變量以及 table 域之訪問(wèn)的含義可以通過(guò) metatable 來(lái)改變。以取一個(gè)變量下標(biāo)指向的量 t 等價(jià)于調(diào)用 gettable_event(t,i)。（參見(jiàn) §2.8 ，有一份完整的關(guān)于 gettable_event 函數(shù)的說(shuō)明。這個(gè)函數(shù)并沒(méi)有在 lua 中定義出來(lái)，也不能在 lua 中調(diào)用。這里我們把它列出來(lái)只是方便說(shuō)明。）
var.Name 這種語(yǔ)法只是一個(gè)語(yǔ)法糖，用來(lái)表示 var["Name"]：
var ::= prefixexp `.′ Name
所有的全局變量都是放在一個(gè)特定 lua table 的諸個(gè)域中，這個(gè)特定的 table 叫作 environment （環(huán)境）table 或者簡(jiǎn)稱為 環(huán)境 （參見(jiàn) §2.9）。每個(gè)函數(shù)都有對(duì)一個(gè)環(huán)境的引用，所以一個(gè)函數(shù)中可見(jiàn)的所有全局變量都放在這個(gè)函數(shù)所引用的環(huán)境表（environment table）中。當(dāng)一個(gè)函數(shù)被創(chuàng)建出來(lái)，它會(huì)從創(chuàng)建它的函數(shù)中繼承其環(huán)境，你可以調(diào)用 getfenv 取得其環(huán)境。如果想改變環(huán)境，可以調(diào)用 setfenv。（對(duì)于 C 函數(shù)，你只能通過(guò) debug 庫(kù)來(lái)改變其環(huán)境；參見(jiàn) §5.9）。
對(duì)一個(gè)全局變量 x 的訪問(wèn)等價(jià)于 _env.x，而這又可以等價(jià)于
gettable_event(_env, "x")
這里，_env 是當(dāng)前運(yùn)行的函數(shù)的環(huán)境。（函數(shù) gettable_event 的完整說(shuō)明參見(jiàn) §2.8。這個(gè)函數(shù)并沒(méi)有在 lua 中定義出來(lái)，也不能調(diào)用。當(dāng)然，_env 這個(gè)變量也同樣沒(méi)有在 Lua 中定義出來(lái)。我們?cè)谶@里使用它們，僅僅只是方便解釋而已。）
2.4 - 語(yǔ)句段（Statement）
Lua 支持慣例形式的語(yǔ)句段，它和 Pascal 或是 C 很相象。這個(gè)集合包括賦值，控制結(jié)構(gòu)，函數(shù)調(diào)用，還有變量聲明。
2.4.1 - Chunk（語(yǔ)句組）
Lua 的一個(gè)執(zhí)行單元被稱作 chunk。一個(gè) chunk 就是一串語(yǔ)句段，它們會(huì)被循序的執(zhí)行。每個(gè)語(yǔ)句段可以以一個(gè)分號(hào)結(jié)束：
chunk ::= {stat [`;′]}
這兒不允許有空的語(yǔ)句段，所以 ';;' 是非法的。
lua 把一個(gè) chunk 當(dāng)作一個(gè)擁有不定參數(shù)的匿名函數(shù)（參見(jiàn) §2.5.9）處理。正是這樣，chunk 內(nèi)可以定義局部變量，接收參數(shù)，并且返回值。
chunk 可以被保存在一個(gè)文件中，也可以保存在宿主程序的一個(gè)字符串中。當(dāng)一個(gè) chunk 被執(zhí)行，首先它會(huì)被預(yù)編譯成虛擬機(jī)中的指令序列，然后被虛擬機(jī)解釋運(yùn)行這些指令。
chunk 也可以被預(yù)編譯成二進(jìn)制形式；細(xì)節(jié)參考程序 luac。用源碼形式提供的程序和被編譯過(guò)的二進(jìn)制形式的程序是可以相互替換的； Lua 會(huì)自動(dòng)識(shí)別文件類型并做正確的處理。
2.4.2 - 語(yǔ)句塊
語(yǔ)句塊是一列語(yǔ)句段；從語(yǔ)法上來(lái)說(shuō)，一個(gè)語(yǔ)句塊跟一個(gè) chunk 相同：
block ::= chunk
一個(gè)語(yǔ)句塊可以被顯式的寫(xiě)成一個(gè)單獨(dú)的語(yǔ)句段：
stat ::= do block end
顯式的語(yǔ)句塊對(duì)于控制變量的作用范圍很有用。有時(shí)候，顯式的語(yǔ)句塊被用來(lái)在另一個(gè)語(yǔ)句塊中插入 return 或是 break （參見(jiàn) §2.4.4）。
2.4.3 - 賦值
Lua 允許多重賦值。因此，賦值的語(yǔ)法定義是等號(hào)左邊放一系列變量，而等號(hào)右邊放一系列的表達(dá)式。兩邊的元素都用逗號(hào)間開(kāi)：
stat ::= varlist1 `=′ explist1
varlist1 ::= var {`,′ var}
explist1 ::= exp {`,′ exp}
表達(dá)式放在 §2.5 里討論。
在作賦值操作之前，那一系列的右值會(huì)被對(duì)齊到左邊變量需要的個(gè)數(shù)。如果右值比需要的更多的話，多余的值就被扔掉。如果右值的數(shù)量不夠需求，將會(huì)按所需擴(kuò)展若干個(gè) nil。如果表達(dá)式列表以一個(gè)函數(shù)調(diào)用結(jié)束，這個(gè)函數(shù)所返回的所有值都會(huì)在對(duì)齊操作之前被置入右值序列中。（除非這個(gè)函數(shù)調(diào)用被用括號(hào)括了起來(lái)；參見(jiàn) §2.5）。
賦值段首先會(huì)做運(yùn)算完所有的表達(dá)式，然后僅僅做賦值操作。因此，下面這段代碼
i = 3
i, a = i+1, 20
會(huì)把 a[3] 設(shè)置為 20，而不會(huì)影響到 a[4] 。這是因?yàn)?a 中的 i 在被賦值為 4 之前就被拿出來(lái)了（那時(shí)是 3 ）。簡(jiǎn)單說(shuō) ，這樣一行
x, y = y, x
可以用來(lái)交換 x 和 y 中的值。
對(duì)全局變量以及 table 中的域的賦值操作的含義可以通過(guò) metatable 來(lái)改變。對(duì)變量下標(biāo)指向的賦值，即 t = val 等價(jià)于 settable_event(t,i,val)。（關(guān)于函數(shù) settable_event 的詳細(xì)說(shuō)明，參見(jiàn) §2.8。這個(gè)函數(shù)并沒(méi)有在 Lua 中定義出來(lái)，也不可以被調(diào)用。這里我們列出來(lái)，僅僅出于方便解釋的目的）
對(duì)于全局變量的賦值 x = val 等價(jià)于 _env.x = val，這個(gè)又可以等價(jià)于
settable_event(_env, "x", val)
這里，_env 指的是正在運(yùn)行中的函數(shù)的環(huán)境。（變量 _env 并沒(méi)有在 Lua 中定義出來(lái)。我們僅僅出于解釋的目的在這里寫(xiě)出來(lái)。）
2.4.4 - 控制結(jié)構(gòu)
if、 while、以及 repeat 這些控制結(jié)構(gòu)符合通常的意義，而且也有類似的語(yǔ)法：
stat ::= while exp do block end
stat ::= repeat block until exp
stat ::= if exp then block {elseif exp then block} [else block] end
Lua 也有一個(gè) for 語(yǔ)句，它有兩種形式（參見(jiàn) §2.4.5）。
控制結(jié)構(gòu)中的條件表達(dá)式可以返回任何值。 false 和 nil 兩者都被認(rèn)為是假條件。所有不同于 nil 和 false 的其它值都被認(rèn)為是真（特別需要注意的是，數(shù)字 0 和空字符串也被認(rèn)為是真）。
在 repeat–until 循環(huán)中，內(nèi)部語(yǔ)句塊的結(jié)束點(diǎn)不是在 until 這個(gè)關(guān)鍵字處，它還包括了其后的條件表達(dá)式。因此，條件表達(dá)式中可以使用循環(huán)內(nèi)部語(yǔ)句塊中的定義的局部變量。
return 被用于從函數(shù)或是 chunk（其實(shí)它就是一個(gè)函數(shù)）中返回值。 函數(shù)和 chunk 可以返回不只一個(gè)值，所以 return 的語(yǔ)法為
stat ::= return [explist1]
break 被用來(lái)結(jié)束 while、 repeat、或 for 循環(huán)，它將忽略掉循環(huán)中下面的語(yǔ)句段的運(yùn)行：
stat ::= break
break 跳出最內(nèi)層的循環(huán)。
return 和 break 只能被寫(xiě)在一個(gè)語(yǔ)句塊的最后一句。如果你真的需要從語(yǔ)句塊的中間 return 或是 break ，你可以使用顯式的聲名一個(gè)內(nèi)部語(yǔ)句塊。一般寫(xiě)作 do return end 或是 do break end，可以這樣寫(xiě)是因?yàn)楝F(xiàn)在 return 或 break 都成了一個(gè)語(yǔ)句塊的最后一句了。
2.4.5 - For 語(yǔ)句
for 有兩種形式：一種是數(shù)字形式，另一種是一般形式。
數(shù)字形式的 for 循環(huán)，通過(guò)一個(gè)數(shù)學(xué)運(yùn)算不斷的運(yùn)行內(nèi)部的代碼塊。下面是它的語(yǔ)法：
stat ::= for Name `=′ exp `,′ exp [`,′ exp] do block end
block 將把 name 作循環(huán)變量。從第一個(gè) exp 開(kāi)始起，直到第二個(gè) exp 的值為止，其步長(zhǎng)為第三個(gè) exp 。更確切的說(shuō)，一個(gè) for 循環(huán)看起來(lái)是這個(gè)樣子
for v = e1, e2, e3 do block end
這等價(jià)于代碼：
do
local var, limit, step = tonumber(e1), tonumber(e2), tonumber(e3)
if not (var and limit and step) then error() end
while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do
local v = var
block
var = var + step
end
end
注意下面這幾點(diǎn)：
? 所有三個(gè)控制表達(dá)式都只被運(yùn)算一次，表達(dá)式的計(jì)算在循環(huán)開(kāi)始之前。這些表達(dá)式的結(jié)果必須是數(shù)字。
? var 、limit 、以及 step 都是一些不可見(jiàn)的變量。這里給它們起的名字都僅僅用于解釋方便。
? 如果第三個(gè)表達(dá)式（步長(zhǎng)）沒(méi)有給出，會(huì)把步長(zhǎng)設(shè)為 1 。
? 你可以用 break 來(lái)退出 for 循環(huán)。
? 循環(huán)變量 v 是一個(gè)循環(huán)內(nèi)部的局部變量；當(dāng) for 循環(huán)結(jié)束后，你就不能在使用它。如果你需要這個(gè)值，在退出循環(huán)前把它賦給另一個(gè)變量。
一般形式的 for 通過(guò)一個(gè)叫作疊代器（iterators）的函數(shù)工作。每次疊代，疊代器函數(shù)都會(huì)被調(diào)用以產(chǎn)生一個(gè)新的值，當(dāng)這個(gè)值為 nil 時(shí)，循環(huán)停止。一般形式的 for 循環(huán)的語(yǔ)法如下：
stat ::= for namelist in explist1 do block end
namelist ::= Name {`,′ Name}
for 語(yǔ)句好似這樣
for var_1, ???, var_n in explist do block end
它等價(jià)于這樣一段代碼：
do
local f, s, var = explist
while true do
local var_1, ???, var_n = f(s, var)
var = var_1
if var == nil then break end
block
end
end
注意以下幾點(diǎn)：
? explist 只會(huì)被計(jì)算一次。它返回三個(gè)值， 一個(gè)疊代器函數(shù)，一個(gè)狀態(tài)，一個(gè)疊代器的初始值。
? f、 s、 以及 var 都是不可見(jiàn)的變量。這里給它們起的名字都只是為了解說(shuō)方便。
? 你可以使用 break 來(lái)跳出 for 循環(huán)。
? 循環(huán)變量 var_i 對(duì)于循環(huán)來(lái)說(shuō)是一個(gè)局部變量；你不可以在 for 循環(huán)結(jié)束后繼續(xù)使用。如果你需要保留這些值，那么就在循環(huán)結(jié)束前賦值到別的變量里去。
2.4.6 - 把函數(shù)調(diào)用作為語(yǔ)句段
為了允許使用可能的副作用，函數(shù)調(diào)用可以被作為一個(gè)語(yǔ)句段執(zhí)行：
stat ::= functioncall
在這種情況下，所有的返回值都被舍棄。函數(shù)調(diào)用在 §2.5.8 中解釋。
2.4.7 - 局部變量聲名
局部變量可以在語(yǔ)句塊中任何地方聲名。聲名可以包含一個(gè)初始化賦值操作：
stat ::= local namelist [`=′ explist1]
如果有的話，初始化賦值操作的行為等同于賦值操作（參見(jiàn) §2.4.3）。否則，所有的變量將被初始化為 nil。
一個(gè) chunk 同時(shí)也是一個(gè)語(yǔ)句塊（參見(jiàn) §2.4.1），所以局部變量可以放在 chunk 中那些顯式注明的語(yǔ)句塊之外。這些局部變量的作用范圍從聲明起一直延伸到 chunk 末尾。
局部變量的可見(jiàn)規(guī)則在 §2.6 中解釋。
2.5 - 表達(dá)式
Lua 中有這些基本表達(dá)式：
exp ::= prefixexp
exp ::= nil | false | true
exp ::= Number
exp ::= String
exp ::= function
exp ::= tableconstructor
exp ::= `...′
exp ::= exp binop exp
exp ::= unop exp
prefixexp ::= var | functioncall | `(′ exp `)′
數(shù)字和字符串在 §2.1 中解釋；變量在 §2.3 中解釋；函數(shù)定義在 §2.5.9 中解釋；函數(shù)調(diào)用在 §2.5.8 中解釋； table 的構(gòu)造在 §2.5.7 中解釋；可變參數(shù)的表達(dá)式寫(xiě)作三個(gè)點(diǎn) ('...') ，它只能被用在有可變參數(shù)的函數(shù)中；這些在 §2.5.9 中解釋。
二元操作符包含有數(shù)學(xué)運(yùn)算操作符（參見(jiàn) §2.5.1），比較操作符（參見(jiàn) §2.5.2），邏輯操作符（參見(jiàn) §2.5.3），以及連接操作符（參見(jiàn) §2.5.4）。一元操作符包括負(fù)號(hào)（參見(jiàn)see §2.5.1），取反 not（參見(jiàn) §2.5.3），和取長(zhǎng)度操作符（參見(jiàn) §2.5.5）。
函數(shù)調(diào)用和可變參數(shù)表達(dá)式都可以放在多重返回值中。如果表達(dá)式作為一個(gè)獨(dú)立語(yǔ)句段出現(xiàn)（參見(jiàn) §2.4.6）（這只能是一個(gè)函數(shù)調(diào)用），它們的返回列表將被對(duì)齊到零個(gè)元素，也就是忽略所有返回值。如果表達(dá)式用于表達(dá)式列表的最后（或者是唯一）的元素，就不會(huì)有任何的對(duì)齊操作（除非函數(shù)調(diào)用用括號(hào)括起來(lái)）。在任何其它的情況下，Lua 將把表達(dá)式結(jié)果看成單一元素，忽略除第一個(gè)之外的任何值。
這里有一些例子：
f() -- 調(diào)整到 0 個(gè)結(jié)果
g(f(), x) -- f() 被調(diào)整到一個(gè)結(jié)果
g(x, f()) -- g 被傳入 x 加上所有 f() 的返回值
a,b,c = f(), x -- f() 被調(diào)整到一個(gè)結(jié)果 （ c 在這里被賦為 nil ）
a,b = ... -- a 被賦值為可變參數(shù)中的第一個(gè)，
-- b 被賦值為第二個(gè) （如果可變參數(shù)中并沒(méi)有對(duì)應(yīng)的值，
-- 這里 a 和 b 都有可能被賦為 nil）

a,b,c = x, f() -- f() 被調(diào)整為兩個(gè)結(jié)果
a,b,c = f() -- f() 被調(diào)整為三個(gè)結(jié)果
return f() -- 返回 f() 返回的所有結(jié)果
return ... -- 返回所有從可變參數(shù)中接收來(lái)的值
return x,y,f() -- 返回 x, y, 以及所有 f() 的返回值
{f()} -- 用 f() 的所有返回值創(chuàng)建一個(gè)列表
{...} -- 用可變參數(shù)中的所有值創(chuàng)建一個(gè)列表
{f(), nil} -- f() 被調(diào)整為一個(gè)結(jié)果
被括號(hào)括起來(lái)的表達(dá)式永遠(yuǎn)被當(dāng)作一個(gè)值。所以， (f(x,y,z)) 即使 f 返回多個(gè)值，這個(gè)表達(dá)式永遠(yuǎn)是一個(gè)單一值。（(f(x,y,z)) 的值是 f 返回的第一個(gè)值。如果 f 不返回值的話，那么它的值就是 nil 。）
2.5.1 - 數(shù)學(xué)運(yùn)算操作符
Lua 支持常見(jiàn)的數(shù)學(xué)運(yùn)算操作符：二元操作 + （加法）， - （減法），* （乘法）， / （除法）， % （取模），以及 ^ （冪）；和一元操作 - （取負(fù)）。如果對(duì)數(shù)字操作，或是可以轉(zhuǎn)換為數(shù)字的字符串（參見(jiàn) §2.2.1），所有這些操作都依賴它通常的含義。冪操作可以對(duì)任何冪值都正常工作。比如， x^(-0.5) 將計(jì)算出 x 的平方根。取模操作被定義為
a % b == a - math.floor(a/b)*b
這就是說(shuō)，其結(jié)果是商相對(duì)負(fù)無(wú)窮圓整后的余數(shù)。（譯注：負(fù)數(shù)對(duì)正數(shù)取模的結(jié)果為正數(shù)）
2.5.2 - 比較操作符
Lua 中的比較操作符有
== ~= < > <= >=
這些操作的結(jié)果不是 false 就是 true。
等于操作 (==) 首先比較操作數(shù)的類型。如果類型不同，結(jié)果就是 false。否則，繼續(xù)比較值。數(shù)字和字符串都用常規(guī)的方式比較。對(duì)象 （table ，userdata ，thread ，以及函數(shù)）以引用的形式比較：兩個(gè)對(duì)象只有在它們指向同一個(gè)東西時(shí)才認(rèn)為相等。每次你創(chuàng)建一個(gè)新對(duì)象（一個(gè) table 或是 userdata ，thread 函數(shù)），它們都各不相同，即不同于上次創(chuàng)建的東西。
你可以改變 Lua 比較 table 和 userdata 的方式，這需要使用 "eq" 這個(gè)原方法（參見(jiàn) §2.8）。
§2.2.1 中提及的轉(zhuǎn)換規(guī)則并不作用于比較操作。所以， "0"==0 等于 false，而且 t[0] 和 t["0"] 描述的是 table 中不同的域。
操作符 ~= 完全等價(jià)于 (==) 操作的反值。
大小比較操作以以下方式進(jìn)行。如果參數(shù)都是數(shù)字，那么就直接做數(shù)字比較。否則，如果參數(shù)都是字符串，就用字符串比較的方式進(jìn)行。再則，Lua 就試著調(diào)用 "lt" 或是 "le" 元方法（參見(jiàn) §2.8）。
2.5.3 - 邏輯操作符
Lua 中的邏輯操作符有 and, or, 以及 not。和控制結(jié)構(gòu)（參見(jiàn) §2.4.4）一樣，所有的邏輯操作符把 false 和 nil 都作為假，而其它的一切都當(dāng)作真。
取反操作 not 總是返回 false 或 true 中的一個(gè)。與操作符 and 在第一個(gè)參數(shù)為 false 或 nil 時(shí)返回這第一個(gè)參數(shù)；否則，and 返回第二個(gè)參數(shù)?；虿僮鞣?or 在第一個(gè)參數(shù)不為 nil 也不為 false 時(shí)，返回這第一個(gè)參數(shù)，否則返回第二個(gè)參數(shù)。 and 和 or 都遵循短路規(guī)則；也就是說(shuō)，第二個(gè)操作數(shù)只在需要的時(shí)候去求值。這里有一些例子：
10 or 20 --> 10
10 or error() --> 10
nil or "a" --> "a"
nil and 10 --> nil
false and error() --> false
false and nil --> false
false or nil --> nil
10 and 20 --> 20
（在這本手冊(cè)中， --> 指前面表達(dá)式的結(jié)果。）
2.5.4 - 連接符
Lua 中字符串的連接操作符寫(xiě)作兩個(gè)點(diǎn) ('..')。如果兩個(gè)操作數(shù)都是字符串或都是數(shù)字，連接操作將以 §2.2.1 中提到的規(guī)則把其轉(zhuǎn)換為字符串。否則，會(huì)取調(diào)用元方法 "concat" （參見(jiàn) §2.8）。

2.5.5 - 取長(zhǎng)度操作符
取長(zhǎng)度操作符寫(xiě)作一元操作 #。字符串的長(zhǎng)度是它的字節(jié)數(shù)（就是以一個(gè)字符一個(gè)字節(jié)計(jì)算的字符串長(zhǎng)度）。
table t 的長(zhǎng)度被定義成一個(gè)整數(shù)下標(biāo) n 。它滿足 t[n] 不是 nil 而 t[n+1] 為 nil；此外，如果 t[1] 為 nil ，n 就可能是零。對(duì)于常規(guī)的數(shù)組，里面從 1 到 n 放著一些非空的值的時(shí)候，它的長(zhǎng)度就精確的為 n，即最后一個(gè)值的下標(biāo)。如果數(shù)組有一個(gè)“空洞” （就是說(shuō)，nil 值被夾在非空值之間），那么 #t 可能是任何一個(gè)是 nil 值的位置的下標(biāo)（就是說(shuō)，任何一個(gè) nil 值都有可能被當(dāng)成數(shù)組的結(jié)束）。
2.5.6 - 優(yōu)先級(jí)
Lua 中操作符的優(yōu)先級(jí)寫(xiě)在下表中，從低到高優(yōu)先級(jí)排序：
or
and
< > <= >= ~= ==
..
+ -
* / %
not # - (unary)
^
通常，你可以用括號(hào)來(lái)改變運(yùn)算次序。連接操作符 ('..') 和冪操作 ('^') 是從右至左的。其它所有的操作都是從左至右。
2.5.7 - Table 構(gòu)造
table 構(gòu)造子是一個(gè)構(gòu)造 table 的表達(dá)式。每次構(gòu)造子被執(zhí)行，都會(huì)構(gòu)造出一個(gè)新的 table 。構(gòu)造子可以被用來(lái)構(gòu)造一個(gè)空的 table，也可以用來(lái)構(gòu)造一個(gè) table 并初始化其中的一些域。一般的構(gòu)造子的語(yǔ)法如下
tableconstructor ::= `{′ [fieldlist] `}′
fieldlist ::= field {fieldsep field} [fieldsep]
field ::= `[′ exp `]′ `=′ exp | Name `=′ exp | exp
fieldsep ::= `,′ | `;′
每個(gè)形如 [exp1] = exp2 的域向 table 中增加新的一項(xiàng)，其鍵值為 exp1 而值為 exp2。形如 name = exp 的域等價(jià)于 ["name"] = exp。最后，形如 exp 的域等價(jià)于 = exp ， 這里的 i 是一個(gè)從 1 開(kāi)始不斷增長(zhǎng)的數(shù)字。這這個(gè)格式中的其它域不會(huì)破壞其記數(shù)。舉個(gè)例子：
a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
等價(jià)于
do
local t = {}
t[f(1)] = g
t[1] = "x" -- 1st exp
t[2] = "y" -- 2nd exp
t.x = 1 -- t["x"] = 1
t[3] = f(x) -- 3rd exp
t[30] = 23
t[4] = 45 -- 4th exp
a = t
end
如果表單中最后一個(gè)域的形式是 exp ，而且其表達(dá)式是一個(gè)函數(shù)調(diào)用或者是一個(gè)可變參數(shù)，那么這個(gè)表達(dá)式所有的返回值將連續(xù)的進(jìn)入列表（參見(jiàn) §2.5.8）。為了避免這一點(diǎn)，你可以用括號(hào)把函數(shù)調(diào)用（或是可變參數(shù)）括起來(lái)（參見(jiàn) §2.5）。
初始化域表可以在最后多一個(gè)分割符，這樣設(shè)計(jì)可以方便由機(jī)器生成代碼。
2.5.8 - 函數(shù)調(diào)用
Lua 中的函數(shù)調(diào)用的語(yǔ)法如下：
functioncall ::= prefixexp args
函數(shù)調(diào)用時(shí)，第一步，prefixexp 和 args 先被求值。如果 prefixexp 的值的類型是 function，那么這個(gè)函數(shù)就被用給出的參數(shù)調(diào)用。否則 prefixexp 的元方法 "call" 就被調(diào)用，第一個(gè)參數(shù)就是 prefixexp 的值，跟下來(lái)的是原來(lái)的調(diào)用參數(shù)（參見(jiàn) §2.8）。
這樣的形式
functioncall ::= prefixexp `:′ Name args
可以用來(lái)調(diào)用 "方法"。這是 Lua 支持的一種語(yǔ)法糖。像 v:name(args) 這個(gè)樣子，被解釋成 v.name(v,args)，這里 v 只會(huì)被求值一次。
參數(shù)的語(yǔ)法如下：
args ::= `(′ [explist1] `)′
args ::= tableconstructor
args ::= String
所有參數(shù)的表達(dá)式求值都在函數(shù)調(diào)用之前。這樣的調(diào)用形式 f{fields} 是一種語(yǔ)法糖用于表示 f({fields})；這里指參數(shù)列表是一個(gè)單一的新創(chuàng)建出來(lái)的列表。而這樣的形式 f'string' （或是 f"string" 亦或是 f[[string]]）也是一種語(yǔ)法糖，用于表示 f('string')；這里指參數(shù)列表是一個(gè)單獨(dú)的字符串。
因?yàn)楸磉_(dá)式語(yǔ)法在 Lua 中比較自由，所以你不能在函數(shù)調(diào)用的 '(' 前換行。這個(gè)限制可以避免語(yǔ)言中的一些歧義。比如你這樣寫(xiě)
a = f
(g).x(a)
Lua 將把它當(dāng)作一個(gè)單一語(yǔ)句段， a = f(g).x(a) 。因此，如果你真的想作為成兩個(gè)語(yǔ)句段，你必須在它們之間寫(xiě)上一個(gè)分號(hào)。如果你真的想調(diào)用 f，你必須從 (g) 前移去換行。
這樣一種調(diào)用形式：return functioncall 將觸發(fā)一個(gè)尾調(diào)用。 Lua 實(shí)現(xiàn)了適當(dāng)?shù)奈膊空{(diào)用（或是適當(dāng)?shù)奈策f歸）：在尾調(diào)用中，被調(diào)用的函數(shù)重用調(diào)用它的函數(shù)的堆棧項(xiàng)。因此，對(duì)于程序執(zhí)行的嵌套尾調(diào)用的層數(shù)是沒(méi)有限制的。然而，尾調(diào)用將刪除調(diào)用它的函數(shù)的任何調(diào)試信息。注意，尾調(diào)用只發(fā)生在特定的語(yǔ)法下，這時(shí)， return 只有單一函數(shù)調(diào)用作為參數(shù)；這種語(yǔ)法使得調(diào)用函數(shù)的結(jié)果可以精確返回。因此，下面這些例子都不是尾調(diào)用：
return (f(x)) -- 返回值被調(diào)整為一個(gè)
return 2 * f(x)
return x, f(x) -- 最加若干返回值
f(x); return -- 無(wú)返回值
return x or f(x) -- 返回值被調(diào)整為一個(gè)
2.5.9 - 函數(shù)定義
函數(shù)定義的語(yǔ)法如下：
function ::= function funcbody
funcbody ::= `(′ [parlist1] `)′ block end
另外定義了一些語(yǔ)法糖簡(jiǎn)化函數(shù)定義的寫(xiě)法：
stat ::= function funcname funcbody
stat ::= local function Name funcbody
funcname ::= Name {`.′ Name} [`:′ Name]
這樣的寫(xiě)法：
function f () body end
被轉(zhuǎn)換成
f = function () body end
這樣的寫(xiě)法：
function t.a.b.c.f () body end
被轉(zhuǎn)換成
t.a.b.c.f = function () body end
這樣的寫(xiě)法：
local function f () body end
被轉(zhuǎn)換成
local f; f = function () body end
注意，并不是轉(zhuǎn)換成
local f = function () body end
（這個(gè)差別只在函數(shù)體內(nèi)需要引用 f 時(shí)才有。）
一個(gè)函數(shù)定義是一個(gè)可執(zhí)行的表達(dá)式，執(zhí)行結(jié)果是一個(gè)類型為 function 的值。當(dāng) Lua 預(yù)編譯一個(gè) chunk 的時(shí)候， chunk 作為一個(gè)函數(shù)，整個(gè)函數(shù)體也就被預(yù)編譯了。那么，無(wú)論何時(shí) Lua 執(zhí)行了函數(shù)定義，這個(gè)函數(shù)本身就被實(shí)例化了（或者說(shuō)是關(guān)閉了）。這個(gè)函數(shù)的實(shí)例（或者說(shuō)是 closure（閉包））是表達(dá)式的最終值。相同函數(shù)的不同實(shí)例有可能引用不同的外部局部變量，也可能擁有不同的環(huán)境表。
形參（函數(shù)定義需要的參數(shù)）是一些由實(shí)參（實(shí)際傳入?yún)?shù)）的值初始化的局部變量：
parlist1 ::= namelist [`,′ `...′] | `...′
當(dāng)一個(gè)函數(shù)被調(diào)用，如果函數(shù)沒(méi)有被定義為接收不定長(zhǎng)參數(shù)，即在形參列表的末尾注明三個(gè)點(diǎn) ('...')，那么實(shí)參列表就會(huì)被調(diào)整到形參列表的長(zhǎng)度，變長(zhǎng)參數(shù)函數(shù)不會(huì)調(diào)整實(shí)參列表；取而代之的是，它將把所有額外的參數(shù)放在一起通過(guò)變長(zhǎng)參數(shù)表達(dá)式傳遞給函數(shù)，其寫(xiě)法依舊是三個(gè)點(diǎn)。這個(gè)表達(dá)式的值是一串實(shí)參值的列表，看起來(lái)就跟一個(gè)可以返回多個(gè)結(jié)果的函數(shù)一樣。如果一個(gè)變長(zhǎng)參數(shù)表達(dá)式放在另一個(gè)表達(dá)式中使用，或是放在另一串表達(dá)式的中間，那么它的返回值就會(huì)被調(diào)整為單個(gè)值。若這個(gè)表達(dá)式放在了一系列表達(dá)式的最后一個(gè)，就不會(huì)做調(diào)整了（除非用括號(hào)給括了起來(lái)）。
我們先做如下定義，然后再來(lái)看一個(gè)例子：
function f(a, b) end
function g(a, b, ...) end
function r() return 1,2,3 end
下面看看實(shí)參到形參數(shù)以及可變長(zhǎng)參數(shù)的映射關(guān)系：
CALL PARAMETERS

f(3) a=3, b=nil
f(3, 4) a=3, b=4
f(3, 4, 5) a=3, b=4
f(r(), 10) a=1, b=10
f(r()) a=1, b=2

g(3) a=3, b=nil, ... --> (nothing)
g(3, 4) a=3, b=4, ... --> (nothing)
g(3, 4, 5, 8) a=3, b=4, ... --> 5 8
g(5, r()) a=5, b=1, ... --> 2 3
結(jié)果由 return 來(lái)返回（參見(jiàn) §2.4.4）。如果執(zhí)行到函數(shù)末尾依舊沒(méi)有遇到任何 return 語(yǔ)句，函數(shù)就不會(huì)返回任何結(jié)果。
冒號(hào)語(yǔ)法可以用來(lái)定義方法，就是說(shuō)，函數(shù)可以有一個(gè)隱式的形參 self。因此，如下寫(xiě)法：
function t.a.b.c:f (params) body end
是這樣一種寫(xiě)法的語(yǔ)法糖：
t.a.b.c.f = function (self, params) body end
2.6 - 可視規(guī)則
Lua 是一個(gè)有詞法作用范圍的語(yǔ)言。變量的作用范圍開(kāi)始于聲明它們之后的第一個(gè)語(yǔ)句段，結(jié)束于包含這個(gè)聲明的最內(nèi)層語(yǔ)句塊的結(jié)束點(diǎn)。看下面這些例子：
x = 10 -- 全局變量
do -- 新的語(yǔ)句塊
local x = x -- 新的一個(gè) 'x', 它的值現(xiàn)在是 10
print(x) --> 10
x = x+1
do -- 另一個(gè)語(yǔ)句塊
local x = x+1 -- 又一個(gè) 'x'
print(x) --> 12
end
print(x) --> 11
end
print(x) --> 10 （取到的是全局的那一個(gè)）
注意這里，類似 local x = x 這樣的聲明，新的 x 正在被聲明，但是還沒(méi)有進(jìn)入它的作用范圍，所以第二個(gè) x 指向的是外面一層的變量。
因?yàn)橛羞@樣一個(gè)詞法作用范圍的規(guī)則，所以可以在函數(shù)內(nèi)部自由的定義局部變量并使用它們。當(dāng)一個(gè)局部變量被更內(nèi)層的函數(shù)中使用的時(shí)候，它被內(nèi)層函數(shù)稱作 upvalue（上值），或是 外部局部變量。
注意，每次執(zhí)行到一個(gè) local 語(yǔ)句都會(huì)定義出一個(gè)新的局部變量?？纯催@樣一個(gè)例子：
a = {}
local x = 20
for i=1,10 do
local y = 0
a = function () y=y+1; return x+y end
end
這個(gè)循環(huán)創(chuàng)建了十個(gè) closure（這指十個(gè)匿名函數(shù)的實(shí)例）。這些 closure 中的每一個(gè)都使用了不同的 y 變量，而它們又共享了同一份 x。
2.7 - 錯(cuò)誤處理
因?yàn)?Lua 是一個(gè)嵌入式的擴(kuò)展語(yǔ)言，所有的 Lua 動(dòng)作都是從宿主程序的 C 代碼調(diào)用 Lua 庫(kù)（參見(jiàn) lua_pcall）中的一個(gè)函數(shù)開(kāi)始的。在 Lua 編譯或運(yùn)行的任何時(shí)候發(fā)生了錯(cuò)誤，控制權(quán)都會(huì)交還給 C ，而 C 可以來(lái)做一些恰當(dāng)?shù)拇胧ū热绱蛴〕鲆粭l錯(cuò)誤信息）。
Lua 代碼可以顯式的調(diào)用 error 函數(shù)來(lái)產(chǎn)生一條錯(cuò)誤。如果你需要在 Lua 中捕獲發(fā)生的錯(cuò)誤，你可以使用 pcall 函數(shù)。
2.8 - Metatable（元表）
Lua 中的每個(gè)值都可以用一個(gè) metatable。這個(gè) metatable 就是一個(gè)原始的 Lua table ，它用來(lái)定義原始值在特定操作下的行為。你可以通過(guò)在 metatable 中的特定域設(shè)一些值來(lái)改變擁有這個(gè) metatable 的值的指定操作之行為。舉例來(lái)說(shuō)，當(dāng)一個(gè)非數(shù)字的值作加法操作的時(shí)候， Lua 會(huì)檢查它的 metatable 中 "__add" 域中的是否有一個(gè)函數(shù)。如果有這么一個(gè)函數(shù)的話，Lua 調(diào)用這個(gè)函數(shù)來(lái)執(zhí)行一次加法。
我們叫 metatable 中的鍵名為 事件 (event) ，把其中的值叫作 元方法 (metamethod)。在上個(gè)例子中，事件是 "add" 而元方法就是那個(gè)執(zhí)行加法操作的函數(shù)。
你可以通過(guò) getmetatable 函數(shù)來(lái)查詢到任何一個(gè)值的 metatable。
你可以通過(guò) setmetatable 函數(shù)來(lái)替換掉 table 的 metatable 。你不能從 Lua 中改變其它任何類型的值的 metatable （使用 debug 庫(kù)例外）；要這樣做的話必須使用 C API 。
每個(gè) table 和 userdata 擁有獨(dú)立的 metatable （當(dāng)然多個(gè) table 和 userdata 可以共享一個(gè)相同的表作它們的 metatable）；其它所有類型的值，每種類型都分別共享唯一的一個(gè) metatable。因此，所有的數(shù)字一起只有一個(gè) metatable ，所有的字符串也是，等等。
一個(gè) metatable 可以控制一個(gè)對(duì)象做數(shù)學(xué)運(yùn)算操作、比較操作、連接操作、取長(zhǎng)度操作、取下標(biāo)操作時(shí)的行為， metatable 中還可以定義一個(gè)函數(shù)，讓 userdata 作垃圾收集時(shí)調(diào)用它。對(duì)于這些操作，Lua 都將其關(guān)聯(lián)上一個(gè)被稱作事件的指定健。當(dāng) Lua 需要對(duì)一個(gè)值發(fā)起這些操作中的一個(gè)時(shí)，它會(huì)去檢查值中 metatable 中是否有對(duì)應(yīng)事件。如果有的話，鍵名對(duì)應(yīng)的值（元方法）將控制 Lua 怎樣做這個(gè)操作。
metatable 可以控制的操作已在下面列出來(lái)。每個(gè)操作都用相應(yīng)的名字區(qū)分。每個(gè)操作的鍵名都是用操作名字加上兩個(gè)下劃線 '__' 前綴的字符串；舉例來(lái)說(shuō)，"add" 操作的鍵名就是字符串 "__add"。這些操作的語(yǔ)義用一個(gè) Lua 函數(shù)來(lái)描述解釋器如何執(zhí)行更為恰當(dāng)。
這里展示的用 Lua 寫(xiě)的代碼僅作解說(shuō)用；實(shí)際的行為已經(jīng)硬編碼在解釋器中，其執(zhí)行效率要遠(yuǎn)高于這些模擬代碼。這些用于描述的的代碼中用到的函數(shù)（ rawget ， tonumber ，等等。）都可以在 §5.1 中找到。特別注意，我們使用這樣一個(gè)表達(dá)式來(lái)從給定對(duì)象中提取元方法
metatable(obj)[event]
這個(gè)應(yīng)該被解讀作
rawget(getmetatable(obj) or {}, event)
這就是說(shuō)，訪問(wèn)一個(gè)元方法不再會(huì)觸發(fā)任何的元方法，而且訪問(wèn)一個(gè)沒(méi)有 metatable 的對(duì)象也不會(huì)失?。ǘ皇呛?jiǎn)單返回 nil）。
? "add": + 操作。
下面這個(gè) getbinhandler 函數(shù)定義了 Lua 怎樣選擇一個(gè)處理器來(lái)作二元操作。首先，Lua 嘗試第一個(gè)操作數(shù)。如果這個(gè)東西的類型沒(méi)有定義這個(gè)操作的處理器，然后 Lua 會(huì)嘗試第二個(gè)操作數(shù)。
function getbinhandler (op1, op2, event)
return metatable(op1)[event] or metatable(op2)[event]
end
通過(guò)這個(gè)函數(shù)， op1 + op2 的行為就是
function add_event (op1, op2)
local o1, o2 = tonumber(op1), tonumber(op2)
if o1 and o2 then -- 兩個(gè)操作數(shù)都是數(shù)字？
return o1 + o2 -- 這里的 '+' 是原生的 'add'
else -- 至少一個(gè)操作數(shù)不是數(shù)字時(shí)
local h = getbinhandler(op1, op2, "__add")
if h then
-- 以兩個(gè)操作數(shù)來(lái)調(diào)用處理器
return h(op1, op2)
else -- 沒(méi)有處理器：缺省行為
error(???)
end
end
end
? "sub": - 操作。 其行為類似于 "add" 操作。
? "mul": * 操作。 其行為類似于 "add" 操作。
? "div": / 操作。 其行為類似于 "add" 操作。
? "mod": % 操作。 其行為類似于 "add" 操作，它的原生操作是這樣的 o1 - floor(o1/o2)*o2
? "pow": ^ （冪）操作。 其行為類似于 "add" 操作，它的原生操作是調(diào)用 pow 函數(shù)（通過(guò) C math 庫(kù)）。
? "unm": 一元 - 操作。
? function unm_event (op)
? local o = tonumber(op)
? if o then -- 操作數(shù)是數(shù)字？
? return -o -- 這里的 '-' 是一個(gè)原生的 'unm'
? else -- 操作數(shù)不是數(shù)字。
? -- 嘗試從操作數(shù)中得到處理器
? local h = metatable(op).__unm
? if h then
? -- 以操作數(shù)為參數(shù)調(diào)用處理器
? return h(op)
? else -- 沒(méi)有處理器：缺省行為
? error(???)
? end
? end
? end
? "concat": .. （連接）操作，
? function concat_event (op1, op2)
? if (type(op1) == "string" or type(op1) == "number") and
? (type(op2) == "string" or type(op2) == "number") then
? return op1 .. op2 -- 原生字符串連接
? else
? local h = getbinhandler(op1, op2, "__concat")
? if h then
? return h(op1, op2)
? else
? error(???)
? end
? end
? end
? "len": # 操作。
? function len_event (op)
? if type(op) == "string" then
? return strlen(op) -- 原生的取字符串長(zhǎng)度
? elseif type(op) == "table" then
? return #op -- 原生的取 table 長(zhǎng)度
? else
? local h = metatable(op).__len
? if h then
? -- 調(diào)用操作數(shù)的處理器
? return h(op)
? else -- 沒(méi)有處理器：缺省行為
? error(???)
? end
? end
? end
關(guān)于 table 的長(zhǎng)度參見(jiàn) §2.5.5 。
? "eq": == 操作。 函數(shù) getcomphandler 定義了 Lua 怎樣選擇一個(gè)處理器來(lái)作比較操作。元方法僅僅在參于比較的兩個(gè)對(duì)象類型相同且有對(duì)應(yīng)操作相同的元方法時(shí)才起效。
? function getcomphandler (op1, op2, event)
? if type(op1) ~= type(op2) then return nil end
? local mm1 = metatable(op1)[event]
? local mm2 = metatable(op2)[event]
? if mm1 == mm2 then return mm1 else return nil end
? end
"eq" 事件按如下方式定義：
function eq_event (op1, op2)
if type(op1) ~= type(op2) then -- 不同的類型？
return false -- 不同的對(duì)象
end
if op1 == op2 then -- 原生的相等比較結(jié)果？
return true -- 對(duì)象相等
end
-- 嘗試使用元方法
local h = getcomphandler(op1, op2, "__eq")
if h then
return h(op1, op2)
else
return false
end
end
a ~= b 等價(jià)于 not (a == b) 。
? "lt": < 操作。
? function lt_event (op1, op2)
? if type(op1) == "number" and type(op2) == "number" then
? return op1 < op2 -- 數(shù)字比較
? elseif type(op1) == "string" and type(op2) == "string" then
? return op1 < op2 -- 字符串按逐字符比較
? else
? local h = getcomphandler(op1, op2, "__lt")
? if h then
? return h(op1, op2)
? else
? error(???);
? end
? end
? end
a > b 等價(jià)于 b < a.
? "le": <= 操作。
? function le_event (op1, op2)
? if type(op1) == "number" and type(op2) == "number" then
? return op1 <= op2 -- 數(shù)字比較
? elseif type(op1) == "string" and type(op2) == "string" then
? return op1 <= op2 -- 字符串按逐字符比較
? else
? local h = getcomphandler(op1, op2, "__le")
? if h then
? return h(op1, op2)
? else
? h = getcomphandler(op1, op2, "__lt")
? if h then
? return not h(op2, op1)
? else
? error(???);
? end
? end
? end
? end
a >= b 等價(jià)于 b <= a 。注意，如果元方法 "le" 沒(méi)有提供，Lua 就嘗試 "lt" ，它假定 a <= b 等價(jià)于 not (b < a) 。
? "index": 取下標(biāo)操作用于訪問(wèn) table[key] 。
? function gettable_event (table, key)
? local h
? if type(table) == "table" then
? local v = rawget(table, key)
? if v ~= nil then return v end
? h = metatable(table).__index
? if h == nil then return nil end
? else
? h = metatable(table).__index
? if h == nil then
? error(???);
? end
? end
? if type(h) == "function" then
? return h(table, key) -- 調(diào)用處理器
? else return h[key] -- 或是重復(fù)上述操作
? end
? end
? "newindex": 賦值給指定下標(biāo) table[key] = value 。
? function settable_event (table, key, value)
? local h
? if type(table) == "table" then
? local v = rawget(table, key)
? if v ~= nil then rawset(table, key, value); return end
? h = metatable(table).__newindex
? if h == nil then rawset(table, key, value); return end
? else
? h = metatable(table).__newindex
? if h == nil then
? error(???);
? end
? end
? if type(h) == "function" then
? return h(table, key,value) -- 調(diào)用處理器
? else h[key] = value -- 或是重復(fù)上述操作
? end
? end
? "call": 當(dāng) Lua 調(diào)用一個(gè)值時(shí)調(diào)用。
? function function_event (func, ...)
? if type(func) == "function" then
? return func(...) -- 原生的調(diào)用
? else
? local h = metatable(func).__call
? if h then
? return h(func, ...)
? else
? error(???)
? end
? end
? end
2.9 - 環(huán)境
類型為 thread ，function ，以及 userdata 的對(duì)象，除了 metatable 外還可以用另外一個(gè)與之關(guān)聯(lián)的被稱作它們的環(huán)境的一個(gè)表，像 metatable 一樣，環(huán)境也是一個(gè)常規(guī)的 table ，多個(gè)對(duì)象可以共享同一個(gè)環(huán)境。
userdata 的環(huán)境在 Lua 中沒(méi)有意義。這個(gè)東西只是為了在程序員想把一個(gè)表關(guān)聯(lián)到一個(gè) userdata 上時(shí)提供便利。
關(guān)聯(lián)在線程上的環(huán)境被稱作全局環(huán)境。全局環(huán)境被用作它其中的線程以及線程創(chuàng)建的非嵌套函數(shù)（通過(guò) loadfile ， loadstring 或是 load ）的缺省環(huán)境。而且它可以被 C 代碼直接訪問(wèn)（參見(jiàn) §3.3）。
關(guān)聯(lián)在 C 函數(shù)上的環(huán)境可以直接被 C 代碼訪問(wèn)（參見(jiàn) §3.3）。它們會(huì)作為這個(gè) C 函數(shù)中創(chuàng)建的其它函數(shù)的缺省環(huán)境。
關(guān)聯(lián)在 Lua 函數(shù)上的環(huán)境用來(lái)接管在函數(shù)內(nèi)對(duì)全局變量（參見(jiàn) §2.3）的所有訪問(wèn)。它們也會(huì)作為這個(gè)函數(shù)內(nèi)創(chuàng)建的其它函數(shù)的缺省環(huán)境。
你可以通過(guò)調(diào)用 setfenv 來(lái)改變一個(gè) Lua 函數(shù)或是正在運(yùn)行中的線程的環(huán)境。而想操控其它對(duì)象（userdata、C 函數(shù)、其它線程）的環(huán)境的話，就必須使用 C API 。
2.10 - 垃圾收集
Lua 提供了一個(gè)自動(dòng)的內(nèi)存管理。這就是說(shuō)你不需要關(guān)心創(chuàng)建新對(duì)象的分配內(nèi)存操作，也不需要在這些對(duì)象不再需要時(shí)的主動(dòng)釋放內(nèi)存。 Lua 通過(guò)運(yùn)行一個(gè)垃圾收集器來(lái)自動(dòng)管理內(nèi)存，以此一遍又一遍的回收死掉的對(duì)象（這是指 Lua 中不再訪問(wèn)的到的對(duì)象）占用的內(nèi)存。 Lua 中所有對(duì)象都被自動(dòng)管理，包括： table, userdata、 函數(shù)、線程、和字符串。
Lua 實(shí)現(xiàn)了一個(gè)增量標(biāo)記清除的收集器。它用兩個(gè)數(shù)字來(lái)控制垃圾收集周期： garbage-collector pause 和 garbage-collector step multiplier 。
garbage-collector pause 控制了收集器在開(kāi)始一個(gè)新的收集周期之前要等待多久。隨著數(shù)字的增大就導(dǎo)致收集器工作工作的不那么主動(dòng)。小于 1 的值意味著收集器在新的周期開(kāi)始時(shí)不再等待。當(dāng)值為 2 的時(shí)候意味著在總使用內(nèi)存數(shù)量達(dá)到原來(lái)的兩倍時(shí)再開(kāi)啟新的周期。
step multiplier 控制了收集器相對(duì)內(nèi)存分配的速度。更大的數(shù)字將導(dǎo)致收集器工作的更主動(dòng)的同時(shí)，也使每步收集的尺寸增加。小于 1 的值會(huì)使收集器工作的非常慢，可能導(dǎo)致收集器永遠(yuǎn)都結(jié)束不了當(dāng)前周期。缺省值為 2 ，這意味著收集器將以內(nèi)存分配器的兩倍速運(yùn)行。
你可以通過(guò)在 C 中調(diào)用 lua_gc 或是在 Lua 中調(diào)用 collectgarbage 來(lái)改變這些數(shù)字。兩者都接受百分比數(shù)值（因此傳入?yún)?shù) 100 意味著實(shí)際值 1 ）。通過(guò)這些函數(shù)，你也可以直接控制收集器（例如，停止或是重啟）。
2.10.1 - 垃圾收集的元方法
使用 C API　，你可以給 userdata （參見(jiàn) §2.8）設(shè)置一個(gè)垃圾收集的元方法。這個(gè)元方法也被稱為結(jié)束子。結(jié)束子允許你用額外的資源管理器和 Lua 的內(nèi)存管理器協(xié)同工作（比如關(guān)閉文件、網(wǎng)絡(luò)連接、或是數(shù)據(jù)庫(kù)連接，也可以說(shuō)釋放你自己的內(nèi)存）。
一個(gè) userdata 可被回收，若它的 metatable 中有 __gc 這個(gè)域　，垃圾收集器就不立即收回它。取而代之的是，Lua 把它們放到一個(gè)列表中。最收集結(jié)束后，Lua 針對(duì)列表中的每個(gè) userdata 執(zhí)行了下面這個(gè)函數(shù)的等價(jià)操作：
function gc_event (udata)
local h = metatable(udata).__gc
if h then
h(udata)
end
end
在每個(gè)垃圾收集周期的結(jié)尾，每個(gè)在當(dāng)前周期被收集起來(lái)的 userdata 的結(jié)束子會(huì)以它們構(gòu)造時(shí)的逆序依次調(diào)用。也就是說(shuō)，收集列表中，最后一個(gè)在程序中被創(chuàng)建的 userdata 的結(jié)束子會(huì)被第一個(gè)調(diào)用。
2.10.2 - Weak Table（弱表）
weak table 是一個(gè)這樣的 table，它其中的元素都被弱引用。弱引用將被垃圾收集器忽略掉，換句話說(shuō)，如果對(duì)一個(gè)對(duì)象的引用只有弱引用，垃圾收集器將回收這個(gè)對(duì)象。
weak table 的鍵和值都可以是 weak 的。如果一個(gè) table 只有鍵是 weak 的，那么將運(yùn)行收集器回收它們的鍵，但是會(huì)阻止回收器回收對(duì)應(yīng)的值。而一個(gè) table 的鍵和值都是 weak 時(shí)，就即允許收集器回收鍵又允許收回值。任何情況下，如果鍵和值中任一個(gè)被回收了，整個(gè)鍵值對(duì)就會(huì)從 table 中拿掉。 table 的 weak 特性可以通過(guò)在它的 metatable 中設(shè)置 __mode 域來(lái)改變。如果 __mode 域中是一個(gè)包含有字符 'k' 的字符串時(shí)， table 的鍵就是 weak 的。如果 __mode 域中是一個(gè)包含有字符 'v' 的字符串時(shí)， table 的值就是 weak 的。
在你把一個(gè) table 當(dāng)作一個(gè) metatable 使用之后，就不能再修改 __mode 域的值。否則，受這個(gè) metatable 控制的 table 的 weak 行為就成了未定義的。
2.11 - Coroutine （協(xié)同例程）
Lua 支持 coroutine ，這個(gè)東西也被稱為協(xié)同式多線程 (collaborative multithreading)　。 Lua 為每個(gè) coroutine 提供一個(gè)獨(dú)立的運(yùn)行線路。然而和多線程系統(tǒng)中的線程不同，coroutine 只在顯式的調(diào)用了 yield 函數(shù)時(shí)才會(huì)掛起。
創(chuàng)建一個(gè) coroutine 需要調(diào)用一次 coroutine.create 。它只接收單個(gè)參數(shù)，這個(gè)參數(shù)是 coroutine 的主函數(shù)。 create 函數(shù)僅僅創(chuàng)建一個(gè)新的 coroutine 然后返回它的控制器（一個(gè)類型為 thread 的對(duì)象）；它并不會(huì)啟動(dòng) coroutine 的運(yùn)行。
當(dāng)你第一次調(diào)用 coroutine.resume 時(shí)，所需傳入的第一個(gè)參數(shù)就是 coroutine.create 的返回值。這時(shí)，coroutine 從主函數(shù)的第一行開(kāi)始運(yùn)行。接下來(lái)傳入 coroutine.resume 的參數(shù)將被傳進(jìn) coroutine 的主函數(shù)。在 coroutine 開(kāi)始運(yùn)行后，它講運(yùn)行到自身終止或是遇到一個(gè) yields 。
coroutine 可以通過(guò)兩種方式來(lái)終止運(yùn)行：一種是正常退出，指它的主函數(shù)返回（最后一條指令被運(yùn)行后，無(wú)論有沒(méi)有顯式的返回指令）; 另一種是非正常退出，它發(fā)生在未保護(hù)的錯(cuò)誤發(fā)生的時(shí)候。第一種情況中， coroutine.resume 返回 true ，接下來(lái)會(huì)跟著 coroutine 主函數(shù)的一系列返回值。第二種發(fā)生錯(cuò)誤的情況下， coroutine.resume 返回 false ，緊接著是一條錯(cuò)誤信息。
coroutine 中切換出去，可以調(diào)用 coroutine.yield。當(dāng) coroutine 切出，與之配合的 coroutine.resume 就立即返回，甚至在 yield 發(fā)生在內(nèi)層的函數(shù)調(diào)用中也可以（就是說(shuō)，這不限于發(fā)生在主函數(shù)中，也可以是主函數(shù)直接或間接調(diào)用的某個(gè)函數(shù)里）。在 yield 的情況下，coroutine.resume 也是返回 true，緊跟著那些被傳入 coroutine.yield 的參數(shù)。等到下次你在繼續(xù)同樣的 coroutine ，將從調(diào)用 yield 的斷點(diǎn)處運(yùn)行下去。斷點(diǎn)處 yield 的返回值將是 coroutine.resume 傳入的參數(shù)。
類似 coroutine.create ， coroutine.wrap 這個(gè)函數(shù)也將創(chuàng)建一個(gè) coroutine ，但是它并不返回 coroutine 本身，而是返回一個(gè)函數(shù)取而代之。一旦你調(diào)用這個(gè)返回函數(shù)，就會(huì)切入 coroutine 運(yùn)行。所有傳入這個(gè)函數(shù)的參數(shù)等同于傳入 coroutine.resume 的參數(shù)。 coroutine.wrap 會(huì)返回所有應(yīng)該由除第一個(gè)（錯(cuò)誤代碼的那個(gè)布爾量）之外的由 coroutine.resume 返回的值。和 coroutine.resume 不同， coroutine.wrap 不捕獲任何錯(cuò)誤；所有的錯(cuò)誤都應(yīng)該由調(diào)用者自己傳遞。
看下面這段代碼展示的一個(gè)例子：
function foo (a)
print("foo", a)
return coroutine.yield(2*a)
end

co = coroutine.create(function (a,b)
print("co-body", a, b)
local r = foo(a+1)
print("co-body", r)
local r, s = coroutine.yield(a+b, a-b)
print("co-body", r, s)
return b, "end"
end)

print("main", coroutine.resume(co, 1, 10))
print("main", coroutine.resume(co, "r"))
print("main", coroutine.resume(co, "x", "y"))
print("main", coroutine.resume(co, "x", "y"))
當(dāng)你運(yùn)行它，將得到如下輸出結(jié)果：
co-body 1 10
foo 2

main true 4
co-body r
main true 11 -9
co-body x y
main true 10 end
main false cannot resume dead coroutine
3 - 程序接口（API）
這個(gè)部分描述了 Lua 的 C API ，也就是宿主程序跟 Lua 通訊用的一組 C 函數(shù)。所有的 API 函數(shù)按相關(guān)的類型以及常量都聲明在頭文件 lua.h 中。
雖然我們說(shuō)的是“函數(shù)”，但一部分簡(jiǎn)單的 API 是以宏的形式提供的。所有的這些宏都只使用它們的參數(shù)一次（除了第一個(gè)參數(shù)，也就是 lua 狀態(tài)機(jī)），因此你不需擔(dān)心這些宏的展開(kāi)會(huì)引起一些副作用。
在所有的 C 庫(kù)中，Lua API 函數(shù)都不去檢查參數(shù)的有效性和堅(jiān)固性。然而，你可以在編譯 Lua 時(shí)加上打開(kāi)一個(gè)宏開(kāi)關(guān)來(lái)開(kāi)啟 luaconf.h 文件中的宏 luai_apicheck 以改變這個(gè)行為。
3.1 - 堆棧
Lua 使用一個(gè)虛擬棧來(lái)和 C 傳遞值。棧上的的每個(gè)元素都是一個(gè) Lua 值（nil，數(shù)字，字符串，等等）。
無(wú)論何時(shí) Lua 調(diào)用 C，被調(diào)用的函數(shù)都得到一個(gè)新的棧，這個(gè)棧獨(dú)立于 C 函數(shù)本身的堆棧，也獨(dú)立于以前的棧。（譯注：在 C 函數(shù)里，用 Lua API 不能訪問(wèn)到 Lua 狀態(tài)機(jī)中本次調(diào)用之外的堆棧中的數(shù)據(jù)）它里面包含了 Lua 傳遞給 C 函數(shù)的所有參數(shù)，而 C 函數(shù)則把要返回的結(jié)果也放入堆棧以返回給調(diào)用者（參見(jiàn) lua_CFunction）。
方便起見(jiàn)，所有針對(duì)棧的 API 查詢操作都不嚴(yán)格遵循棧的操作規(guī)則。而是可以用一個(gè)索引來(lái)指向棧上的任何元素：正的索引指的是棧上的絕對(duì)位置（從一開(kāi)始）；負(fù)的索引則指從棧頂開(kāi)始的偏移量。更詳細(xì)的說(shuō)明一下，如果堆棧有 n 個(gè)元素，那么索引 1 表示第一個(gè)元素（也就是最先被壓入堆棧的元素）而索引 n 則指最后一個(gè)元素；索引 -1 也是指最后一個(gè)元素（即棧頂?shù)脑兀?，索?-n 是指第一個(gè)元素。如果索引在 1 到棧頂之間（也就是，1 ≤ abs(index) ≤ top）我們就說(shuō)這是個(gè)有效的索引。
3.2 - 堆棧尺寸
當(dāng)你使用 Lua API 時(shí)，就有責(zé)任保證其堅(jiān)固性。特別需要注意的是，你有責(zé)任控制不要堆棧溢出。你可以使用 lua_checkstack 這個(gè)函數(shù)來(lái)擴(kuò)大可用堆棧的尺寸。
無(wú)論何時(shí) Lua 調(diào)用 C ，它都只保證 LUA_MINSTACK 這么多的堆棧空間可以使用。 LUA_MINSTACK 一般被定義為 20　，因此，只要你不是不斷的把數(shù)據(jù)壓棧，通常你不用關(guān)心堆棧大小。
所有的查詢函數(shù)都可以接收一個(gè)索引，只要這個(gè)索引是任何棧提供的空間中的值。棧能提供的最大空間是通過(guò) lua_checkstack 來(lái)設(shè)置的。這些索引被稱作可接受的索引，通常我們把它定義為：
(index < 0 && abs(index) <= top) ||
(index > 0 && index <= stackspace)
注意，0 永遠(yuǎn)都不是一個(gè)可接受的索引。（譯注：下文中凡提到的索引，沒(méi)有特別注明的話，都指可接受的索引。）
3.3 - 偽索引
除了特別聲明外，任何一個(gè)函數(shù)都可以接受另一種有效的索引，它們被稱作“偽索引”。這個(gè)可以幫助 C 代碼訪問(wèn)一些并不在棧上的 Lua 值。偽索引被用來(lái)訪問(wèn)線程的環(huán)境，函數(shù)的環(huán)境，注冊(cè)表，還有 C 函數(shù)的 upvalue （參見(jiàn) §3.4）。
線程的環(huán)境（也就是全局變量放的地方）通常在偽索引 LUA_GLOBALSINDEX 處。正在運(yùn)行的 C 函數(shù)的環(huán)境則放在偽索引 LUA_ENVIRONINDEX 之處。
你可以用常規(guī)的 table 操作來(lái)訪問(wèn)和改變?nèi)肿兞康闹?，只需要指定環(huán)境表的位置。舉例而言，要訪問(wèn)全局變量的值，這樣做：
lua_getfield(L, LUA_GLOBALSINDEX, varname);
3.4 - C Closure
當(dāng) C 函數(shù)被創(chuàng)建出來(lái)，我們有可能會(huì)把一些值關(guān)聯(lián)在一起，也就是創(chuàng)建一個(gè) C closure ；這些被關(guān)聯(lián)起來(lái)的值被叫做 upvalue ，它們可以在函數(shù)被調(diào)用的時(shí)候訪問(wèn)的到。（參見(jiàn) lua_pushcclosure）。
無(wú)論何時(shí)去調(diào)用 C 函數(shù)，函數(shù)的 upvalue 都被放在指定的偽索引處。我們可以用 lua_upvalueindex 這個(gè)宏來(lái)生成這些偽索引。第一個(gè)關(guān)聯(lián)到函數(shù)的值放在 lua_upvalueindex(1) 位置處，依次類推。任何情況下都可以用 lua_upvalueindex(n) 產(chǎn)生一個(gè) upvalue 的索引，即使　n 大于實(shí)際的 upvalue 數(shù)量也可以。它都可以產(chǎn)生一個(gè)可接受但不一定有效的索引。
3.5 - 注冊(cè)表
Lua 提供了一個(gè)注冊(cè)表，這是一個(gè)預(yù)定義出來(lái)的表，可以用來(lái)保存任何 C 代碼想保存的 Lua 值。這個(gè)表可以用偽索引 LUA_REGISTRYINDEX 來(lái)定位。任何 C 庫(kù)都可以在這張表里保存數(shù)據(jù)，為了防止沖突，你需要特別小心的選擇鍵名。一般的用法是，你可以用一個(gè)包含你的庫(kù)名的字符串做為鍵名，或者可以取你自己 C 代碼中的一個(gè)地址，以 light userdata 的形式做鍵。
注冊(cè)表里的整數(shù)健被用于補(bǔ)充庫(kù)中實(shí)現(xiàn)的引用系統(tǒng)的工作，一般說(shuō)來(lái)不要把它們用于別的用途。
3.6 - C 中的錯(cuò)誤處理
在內(nèi)部實(shí)現(xiàn)中，Lua 使用了 C 的 longjmp 機(jī)制來(lái)處理錯(cuò)誤。（如果你使用 C++ 的話，也可以選擇換用異常；參見(jiàn) luaconf.h 文件。）當(dāng) Lua 碰到任何錯(cuò)誤（比如內(nèi)存分配錯(cuò)誤、類型錯(cuò)誤、語(yǔ)法錯(cuò)誤、還有一些運(yùn)行時(shí)錯(cuò)誤）它都會(huì)產(chǎn)生一個(gè)錯(cuò)誤出去；也就是調(diào)用一個(gè) long jump 。在保護(hù)環(huán)境下，Lua 使用 setjmp 來(lái)設(shè)置一個(gè)恢復(fù)點(diǎn)；任何發(fā)生的錯(cuò)誤都會(huì)激活最近的一個(gè)恢復(fù)點(diǎn)。
幾乎所有的 API 函數(shù)都可能產(chǎn)生錯(cuò)誤，例如內(nèi)存分配錯(cuò)誤。但下面的一些函數(shù)運(yùn)行在保護(hù)環(huán)境中（也就是說(shuō)它們創(chuàng)建了一個(gè)保護(hù)環(huán)境再在其中運(yùn)行），因此它們不會(huì)產(chǎn)生錯(cuò)誤出來(lái)： lua_newstate, lua_close, lua_load, lua_pcall, and lua_cpcall。
在 C 函數(shù)里，你也可以通過(guò)調(diào)用 lua_error 產(chǎn)生一個(gè)錯(cuò)誤。
3.7 - 函數(shù)和類型
在這里我們按字母次序列出了所有 C API 中的函數(shù)和類型。
________________________________________
lua_Alloc
typedef void * (*lua_Alloc) (void *ud,
void *ptr,
size_t osize,
size_t nsize);
Lua 狀態(tài)機(jī)中使用的內(nèi)存分配器函數(shù)的類型。內(nèi)存分配函數(shù)必須提供一個(gè)功能類似于 realloc 但又不完全相同的函數(shù)。它的參數(shù)有 ud ，一個(gè)由 lua_newstate 傳給它的指針； ptr ，一個(gè)指向已分配出來(lái)或是將被重新分配或是要釋放的內(nèi)存塊指針； osize ，內(nèi)存塊原來(lái)的尺寸； nsize ，新內(nèi)存塊的尺寸。如果且只有 osize 是零時(shí)，ptr 為 NULL 。當(dāng) nsize 是零，分配器必須返回 NULL；如果 osize 不是零，分配器應(yīng)當(dāng)釋放掉 ptr 指向的內(nèi)存塊。當(dāng) nsize 不是零，若分配器不能滿足請(qǐng)求時(shí)，分配器返回 NULL 。當(dāng) nsize 不是零而 osize 是零時(shí)，分配器應(yīng)該和 malloc 有相同的行為。當(dāng) nsize 和 osize 都不是零時(shí)，分配器則應(yīng)和 realloc 保持一樣的行為。 Lua 假設(shè)分配器在 osize >= nsize 時(shí)永遠(yuǎn)不會(huì)失敗。
這里有一個(gè)簡(jiǎn)單的分配器函數(shù)的實(shí)現(xiàn)。這個(gè)實(shí)現(xiàn)被放在補(bǔ)充庫(kù)中，由 luaL_newstate 提供。
static void *l_alloc (void *ud, void *ptr, size_t osize,
size_t nsize) {
(void)ud; (void)osize; /* not used */
if (nsize == 0) {
free(ptr);
return NULL;
}
else
return realloc(ptr, nsize);
}
這段代碼假設(shè) free(NULL) 啥也不影響，而且 realloc(NULL, size) 等價(jià)于 malloc(size)。這兩點(diǎn)是 ANSI C 保證的行為。
________________________________________
lua_atpanic
lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);
設(shè)置一個(gè)新的 panic （恐慌） 函數(shù)，并返回前一個(gè)。
如果在保護(hù)環(huán)境之外發(fā)生了任何錯(cuò)誤， Lua 就會(huì)調(diào)用一個(gè) panic 函數(shù)，接著調(diào)用 exit(EXIT_FAILURE)，這樣就開(kāi)始退出宿主程序。你的 panic 函數(shù)可以永遠(yuǎn)不返回（例如作一次長(zhǎng)跳轉(zhuǎn)）來(lái)避免程序退出。
panic 函數(shù)可以從棧頂取到出錯(cuò)信息。

lua_call
void lua_call (lua_State *L, int nargs, int nresults);
調(diào)用一個(gè)函數(shù)。
要調(diào)用一個(gè)函數(shù)請(qǐng)遵循以下協(xié)議：首先，要調(diào)用的函數(shù)應(yīng)該被壓入堆棧；接著，把需要傳遞給這個(gè)函數(shù)的參數(shù)按正序壓棧；這是指第一個(gè)參數(shù)首先壓棧。最后調(diào)用一下 lua_call； nargs 是你壓入堆棧的參數(shù)個(gè)數(shù)。當(dāng)函數(shù)調(diào)用完畢后，所有的參數(shù)以及函數(shù)本身都會(huì)出棧。而函數(shù)的返回值這時(shí)則被壓入堆棧。返回值的個(gè)數(shù)將被調(diào)整為 nresults 個(gè)，除非 nresults 被設(shè)置成 LUA_MULTRET。在這種情況下，所有的返回值都被壓入堆棧中。 Lua 會(huì)保證返回值都放入?？臻g中。函數(shù)返回值將按正序壓棧（第一個(gè)返回值首先壓棧），因此在調(diào)用結(jié)束后，最后一個(gè)返回值將被放在棧頂。
被調(diào)用函數(shù)內(nèi)發(fā)生的錯(cuò)誤將（通過(guò) longjmp）一直上拋。
下面的例子中，這行 Lua 代碼等價(jià)于在宿主程序用 C 代碼做一些工作：
a = f("how", t.x, 14)
這里是 C 里的代碼：
lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* 將調(diào)用的函數(shù) */
lua_pushstring(L, "how"); /* 第一個(gè)參數(shù) */
lua_getfield(L, LUA_GLOBALSINDEX, "t"); /* table 的索引 */
lua_getfield(L, -1, "x"); /* 壓入 t.x 的值（第 2 個(gè)參數(shù)）*/
lua_remove(L, -2); /* 從堆棧中移去 't' */
lua_pushinteger(L, 14); /* 第 3 個(gè)參數(shù) */
lua_call(L, 3, 1); /* 調(diào)用 'f'，傳入 3 個(gè)參數(shù)，并索取 1 個(gè)返回值 */
lua_setfield(L, LUA_GLOBALSINDEX, "a"); /* 設(shè)置全局變量 'a' */
注意上面這段代碼是“平衡”的：到了最后，堆?；謴?fù)成原由的配置。這是一種良好的編程習(xí)慣。
________________________________________
lua_CFunction
typedef int (*lua_CFunction) (lua_State *L);
C 函數(shù)的類型。
為了正確的和 Lua 通訊，C 函數(shù)必須使用下列定義了參數(shù)以及返回值傳遞方法的協(xié)議： C 函數(shù)通過(guò) Lua 中的堆棧來(lái)接受參數(shù)，參數(shù)以正序入棧（第一個(gè)參數(shù)首先入棧）。因此，當(dāng)函數(shù)開(kāi)始的時(shí)候， lua_gettop(L) 可以返回函數(shù)收到的參數(shù)個(gè)數(shù)。第一個(gè)參數(shù)（如果有的話）在索引 1 的地方，而最后一個(gè)參數(shù)在索引 lua_gettop(L) 處。當(dāng)需要向 Lua 返回值的時(shí)候，C 函數(shù)只需要把它們以正序壓到堆棧上（第一個(gè)返回值最先壓入），然后返回這些返回值的個(gè)數(shù)。在這些返回值之下的，堆棧上的東西都會(huì)被 Lua 丟掉。和 Lua 函數(shù)一樣，從 Lua 中調(diào)用 C 函數(shù)也可以有很多返回值。
下面這個(gè)例子中的函數(shù)將接收若干數(shù)字參數(shù)，并返回它們的平均數(shù)與和：
static int foo (lua_State *L) {
int n = lua_gettop(L); /* 參數(shù)的個(gè)數(shù) */
lua_Number sum = 0;
int i;
for (i = 1; i <= n; i++) {
if (!lua_isnumber(L, i)) {
lua_pushstring(L, "incorrect argument");
lua_error(L);
}
sum += lua_tonumber(L, i);
}
lua_pushnumber(L, sum/n); /* 第一個(gè)返回值 */
lua_pushnumber(L, sum); /* 第二個(gè)返回值 */
return 2; /* 返回值的個(gè)數(shù) */
}
________________________________________
lua_checkstack
int lua_checkstack (lua_State *L, int extra);
確保堆棧上至少有 extra 個(gè)空位。如果不能把堆棧擴(kuò)展到相應(yīng)的尺寸，函數(shù)返回 false 。這個(gè)函數(shù)永遠(yuǎn)不會(huì)縮小堆棧；如果堆棧已經(jīng)比需要的大了，那么就放在那里不會(huì)產(chǎn)生變化。
________________________________________
lua_close
void lua_close (lua_State *L);
銷毀指定 Lua 狀態(tài)機(jī)中的所有對(duì)象（如果有垃圾收集相關(guān)的元方法的話，會(huì)調(diào)用它們），并且釋放狀態(tài)機(jī)中使用的所有動(dòng)態(tài)內(nèi)存。在一些平臺(tái)上，你可以不必調(diào)用這個(gè)函數(shù)，因?yàn)楫?dāng)宿主程序結(jié)束的時(shí)候，所有的資源就自然被釋放掉了。另一方面，長(zhǎng)期運(yùn)行的程序，比如一個(gè)后臺(tái)程序或是一個(gè) web 服務(wù)器，當(dāng)不再需要它們的時(shí)候就應(yīng)該釋放掉相關(guān)狀態(tài)機(jī)。這樣可以避免狀態(tài)機(jī)擴(kuò)張的過(guò)大。
________________________________________
lua_concat
void lua_concat (lua_State *L, int n);
連接棧頂?shù)?n 個(gè)值，然后將這些值出棧，并把結(jié)果放在棧頂。如果 n 為 1 ，結(jié)果就是一個(gè)字符串放在棧上（即，函數(shù)什么都不做）；如果 n 為 0 ，結(jié)果是一個(gè)空串。 連接依照 Lua 中創(chuàng)建語(yǔ)義完成（參見(jiàn) §2.5.4 ）。
________________________________________
lua_cpcall
int lua_cpcall (lua_State *L, lua_CFunction func, void *ud);
以保護(hù)模式調(diào)用 C 函數(shù) func 。 func 只有能從堆棧上拿到一個(gè)參數(shù)，就是包含有 ud 的 light userdata。當(dāng)有錯(cuò)誤時(shí)， lua_cpcall 返回和 lua_pcall 相同的錯(cuò)誤代碼，并在棧頂留下錯(cuò)誤對(duì)象；否則它返回零，并不會(huì)修改堆棧。所有從 func 內(nèi)返回的值都會(huì)被扔掉。
________________________________________
lua_createtable
void lua_createtable (lua_State *L, int narr, int nrec);
創(chuàng)建一個(gè)新的空 table 壓入堆棧。這個(gè)新 table 將被預(yù)分配 narr 個(gè)元素的數(shù)組空間以及 nrec 個(gè)元素的非數(shù)組空間。當(dāng)你明確知道表中需要多少個(gè)元素時(shí)，預(yù)分配就非常有用。如果你不知道，可以使用函數(shù) lua_newtable。
________________________________________
lua_dump
int lua_dump (lua_State *L, lua_Writer writer, void *data);
把函數(shù) dump 成二進(jìn)制 chunk 。函數(shù)接收棧頂?shù)?Lua 函數(shù)做參數(shù)，然后生成它的二進(jìn)制 chunk 。若被 dump 出來(lái)的東西被再次加載，加載的結(jié)果就相當(dāng)于原來(lái)的函數(shù)。當(dāng)它在產(chǎn)生 chunk 的時(shí)候，lua_dump 通過(guò)調(diào)用函數(shù) writer （參見(jiàn) lua_Writer）來(lái)寫(xiě)入數(shù)據(jù)，后面的 data 參數(shù)會(huì)被傳入 writer 。
最后一次由寫(xiě)入器 (writer) 返回值將作為這個(gè)函數(shù)的返回值返回； 0 表示沒(méi)有錯(cuò)誤。
這個(gè)函數(shù)不會(huì)把 Lua 返回彈出堆棧。
________________________________________
lua_equal
int lua_equal (lua_State *L, int index1, int index2);
如果依照 Lua 中 == 操作符語(yǔ)義，索引 index1 和 index2 中的值相同的話，返回 1 。否則返回 0 。如果任何一個(gè)索引無(wú)效也會(huì)返回 0。
________________________________________
lua_error
int lua_error (lua_State *L);
產(chǎn)生一個(gè) Lua 錯(cuò)誤。錯(cuò)誤信息（實(shí)際上可以是任何類型的 Lua 值）必須被置入棧頂。這個(gè)函數(shù)會(huì)做一次長(zhǎng)跳轉(zhuǎn)，因此它不會(huì)再返回。（參見(jiàn) luaL_error）。
________________________________________
lua_gc
int lua_gc (lua_State *L, int what, int data);
控制垃圾收集器。
這個(gè)函數(shù)根據(jù)其參數(shù) what 發(fā)起幾種不同的任務(wù)：
? LUA_GCSTOP: 停止垃圾收集器。
? LUA_GCRESTART: 重啟垃圾收集器。
? LUA_GCCOLLECT: 發(fā)起一次完整的垃圾收集循環(huán)。
? LUA_GCCOUNT: 返回 Lua 使用的內(nèi)存總量（以 K 字節(jié)為單位）。
? LUA_GCCOUNTB: 返回當(dāng)前內(nèi)存使用量除以 1024 的余數(shù)。
? LUA_GCSTEP: 發(fā)起一步增量垃圾收集。步數(shù)由 data 控制（越大的值意味著越多步），而其具體含義（具體數(shù)字表示了多少）并未標(biāo)準(zhǔn)化。如果你想控制這個(gè)步數(shù)，必須實(shí)驗(yàn)性的測(cè)試 data 的值。如果這一步結(jié)束了一個(gè)垃圾收集周期，返回返回 1 。
? LUA_GCSETPAUSE: 把 data/100 設(shè)置為 garbage-collector pause 的新值（參見(jiàn) §2.10）。函數(shù)返回以前的值。
? LUA_GCSETSTEPMUL: 把 arg/100 設(shè)置成 step multiplier （參見(jiàn) §2.10）。函數(shù)返回以前的值。
________________________________________
lua_getallocf
lua_Alloc lua_getallocf (lua_State *L, void **ud);
返回給定狀態(tài)機(jī)的內(nèi)存分配器函數(shù)。如果 ud 不是 NULL ，Lua 把調(diào)用 lua_newstate 時(shí)傳入的那個(gè)指針?lè)湃?*ud 。
________________________________________
lua_getfenv
void lua_getfenv (lua_State *L, int index);
把索引處值的環(huán)境表壓入堆棧。
________________________________________
lua_getfield
void lua_getfield (lua_State *L, int index, const char *k);
把 t[k] 值壓入堆棧，這里的 t 是指有效索引 index 指向的值。在 Lua 中，這個(gè)函數(shù)可能觸發(fā)對(duì)應(yīng) "index" 事件的元方法（參見(jiàn) §2.8）。
________________________________________
lua_getglobal
void lua_getglobal (lua_State *L, const char *name);
把全局變量 name 里的值壓入堆棧。這個(gè)是用一個(gè)宏定義出來(lái)的：
#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, s)
________________________________________
lua_getmetatable
int lua_getmetatable (lua_State *L, int index);
把給定索引指向的值的元表壓入堆棧。如果索引無(wú)效，或是這個(gè)值沒(méi)有元表，函數(shù)將返回 0 并且不會(huì)向棧上壓任何東西。
________________________________________
lua_gettable
void lua_gettable (lua_State *L, int index);
把 t[k] 值壓入堆棧，這里的 t 是指有效索引 index 指向的值，而 k 則是棧頂放的值。
這個(gè)函數(shù)會(huì)彈出堆棧上的 key （把結(jié)果放在棧上相同位置）。在 Lua 中，這個(gè)函數(shù)可能觸發(fā)對(duì)應(yīng) "index" 事件的元方法（參見(jiàn) §2.8）。
________________________________________
lua_gettop
int lua_gettop (lua_State *L);
返回棧頂元素的索引。因?yàn)樗饕菑?1 開(kāi)始編號(hào)的，所以這個(gè)結(jié)果等于堆棧上的元素個(gè)數(shù)（因此返回 0 表示堆棧為空）。
________________________________________
lua_insert
void lua_insert (lua_State *L, int index);
把棧頂元素插入指定的有效索引處，并依次移動(dòng)這個(gè)索引之上的元素。不要用偽索引來(lái)調(diào)用這個(gè)函數(shù)，因?yàn)閭嗡饕皇钦嬲赶蚨褩Ｉ系奈恢谩?
________________________________________
lua_Integer
typedef ptrdiff_t lua_Integer;
這個(gè)類型被用于 Lua API 接收整數(shù)值。
缺省時(shí)這個(gè)被定義為 ptrdiff_t ，這個(gè)東西通常是機(jī)器能處理的最大整數(shù)類型。
________________________________________
lua_isboolean
int lua_isboolean (lua_State *L, int index);
當(dāng)給定索引的值類型為 boolean 時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_iscfunction
int lua_iscfunction (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè) C 函數(shù)時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_isfunction
int lua_isfunction (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè)函數(shù)（ C 或 Lua 函數(shù)均可）時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_islightuserdata
int lua_islightuserdata (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè) light userdata 時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_isnil
int lua_isnil (lua_State *L, int index);
當(dāng)給定索引的值是 nil 時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_isnumber
int lua_isnumber (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè)數(shù)字，或是一個(gè)可轉(zhuǎn)換為數(shù)字的字符串時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_isstring
int lua_isstring (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè)字符串或是一個(gè)數(shù)字（數(shù)字總能轉(zhuǎn)換成字符串）時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_istable
int lua_istable (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè) table 時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_isthread
int lua_isthread (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè) thread 時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_isuserdata
int lua_isuserdata (lua_State *L, int index);
當(dāng)給定索引的值是一個(gè) userdata （無(wú)論是完整的 userdata 還是 light userdata ）時(shí)，返回 1 ，否則返回 0 。
________________________________________
lua_lessthan
int lua_lessthan (lua_State *L, int index1, int index2);
如果索引 index1 處的值小于索引 index2 處的值時(shí)，返回 1 ；否則返回 0 。其語(yǔ)義遵循 Lua 中的 < 操作符（就是說(shuō)，有可能調(diào)用元方法）。如果任何一個(gè)索引無(wú)效，也會(huì)返回 0 。
________________________________________
lua_load
int lua_load (lua_State *L,
lua_Reader reader,
void *data,
const char *chunkname);
加載一個(gè) Lua chunk 。如果沒(méi)有錯(cuò)誤， lua_load 把一個(gè)編譯好的 chunk 作為一個(gè) Lua 函數(shù)壓入堆棧。否則，壓入出錯(cuò)信息。 lua_load 的返回值可以是：
? 0: 沒(méi)有錯(cuò)誤；
? LUA_ERRSYNTAX: 在預(yù)編譯時(shí)碰到語(yǔ)法錯(cuò)誤；
? LUA_ERRMEM: 內(nèi)存分配錯(cuò)誤。
這個(gè)函數(shù)僅僅加栽 chunk ；而不會(huì)去運(yùn)行它。
lua_load 會(huì)自動(dòng)檢測(cè) chunk 是文本的還是二進(jìn)制的，然后做對(duì)應(yīng)的加載操作（參見(jiàn)程序 luac）。
lua_load 函數(shù)使用一個(gè)用戶提供的 reader 函數(shù)來(lái)讀取 chunk （參見(jiàn) lua_Reader）。 data 參數(shù)會(huì)被傳入讀取器函數(shù)。
chunkname 這個(gè)參數(shù)可以賦予 chunk 一個(gè)名字，這個(gè)名字被用于出錯(cuò)信息和調(diào)試信息（參見(jiàn) §3.8）。
________________________________________
lua_newstate
lua_State *lua_newstate (lua_Alloc f, void *ud);
創(chuàng)建的一個(gè)新的獨(dú)立的狀態(tài)機(jī)。如果創(chuàng)建不了（因?yàn)閮?nèi)存問(wèn)題）返回 NULL 。參數(shù) f 是一個(gè)分配器函數(shù)； Lua 將通過(guò)這個(gè)函數(shù)做狀態(tài)機(jī)內(nèi)所有的內(nèi)存分配操作。第二個(gè)參數(shù) ud ，這個(gè)指針將在每次調(diào)用分配器時(shí)被直接傳入。
________________________________________
lua_newtable
void lua_newtable (lua_State *L);
創(chuàng)建一個(gè)空 table ，并將之壓入堆棧。它等價(jià)于 lua_createtable(L, 0, 0) 。
________________________________________
lua_newthread
lua_State *lua_newthread (lua_State *L);
創(chuàng)建一個(gè)新線程，并將其壓入堆棧，并返回維護(hù)這個(gè)線程的 lua_State 指針。這個(gè)函數(shù)返回的新?tīng)顟B(tài)機(jī)共享原有狀態(tài)機(jī)中的所有對(duì)象（比如一些 table），但是它有獨(dú)立的執(zhí)行堆棧。
沒(méi)有顯式的函數(shù)可以用來(lái)關(guān)閉或銷毀掉一個(gè)線程。線程跟其它 Lua 對(duì)象一樣是垃圾收集的條目之一。
________________________________________
lua_newuserdata
void *lua_newuserdata (lua_State *L, size_t size);
這個(gè)函數(shù)分配分配一塊指定大小的內(nèi)存塊，把內(nèi)存塊地址作為一個(gè)完整的 userdata 壓入堆棧，并返回這個(gè)地址。
userdata 代表 Lua 中的 C 值。完整的 userdata 代表一塊內(nèi)存。它是一個(gè)對(duì)象（就像 table 那樣的對(duì)象）：你必須創(chuàng)建它，它有著自己的元表，而且它在被回收時(shí)，可以被監(jiān)測(cè)到。一個(gè)完整的 userdata 只和它自己相等（在等于的原生作用下）。
當(dāng) Lua 通過(guò) gc 元方法回收一個(gè)完整的 userdata 時(shí)， Lua 調(diào)用這個(gè)元方法并把 userdata 標(biāo)記為已終止。等到這個(gè) userdata 再次被收集的時(shí)候，Lua 會(huì)釋放掉相關(guān)的內(nèi)存。
________________________________________
lua_next
int lua_next (lua_State *L, int index);
從棧上彈出一個(gè) key（鍵），然后把索引指定的表中 key-value（健值）對(duì)壓入堆棧（指定 key 后面的下一 (next) 對(duì)）。如果表中以無(wú)更多元素，那么 lua_next 將返回 0 （什么也不壓入堆棧）。
典型的遍歷方法是這樣的：
/* table 放在索引 't' 處 */
lua_pushnil(L); /* 第一個(gè) key */
while (lua_next(L, t) != 0) {
/* 用一下 'key' （在索引 -2 處） 和 'value' （在索引 -1 處） */
printf("%s - %s\n",
lua_typename(L, lua_type(L, -2)),
lua_typename(L, lua_type(L, -1)));
/* 移除 'value' ；保留 'key' 做下一次疊代 */
lua_pop(L, 1);
}
在遍歷一張表的時(shí)候，不要直接對(duì) key 調(diào)用 lua_tolstring ，除非你知道這個(gè) key 一定是一個(gè)字符串。調(diào)用 lua_tolstring 有可能改變給定索引位置的值；這會(huì)對(duì)下一次調(diào)用 lua_next 造成影響。
lua_Number
typedef double lua_Number;
Lua 中數(shù)字的類型。確省是 double ，但是你可以在 luaconf.h 中修改它。
通過(guò)修改配置文件你可以改變 Lua 讓它操作其它數(shù)字類型（例如：float 或是 long ）。
________________________________________
lua_objlen
size_t lua_objlen (lua_State *L, int index);
返回指定的索引處的值的長(zhǎng)度。對(duì)于 string ，那就是字符串的長(zhǎng)度；對(duì)于 table ，是取長(zhǎng)度操作符 ('#') 的結(jié)果；對(duì)于 userdata ，就是為其分配的內(nèi)存塊的尺寸；對(duì)于其它值，為 0 。
________________________________________
lua_pcall
lua_pcall (lua_State *L, int nargs, int nresults, int errfunc);
以保護(hù)模式調(diào)用一個(gè)函數(shù)。
nargs 和 nresults 的含義與 lua_call 中的相同。如果在調(diào)用過(guò)程中沒(méi)有發(fā)生錯(cuò)誤， lua_pcall 的行為和 lua_call 完全一致。但是，如果有錯(cuò)誤發(fā)生的話， lua_pcall 會(huì)捕獲它，然后把單一的值（錯(cuò)誤信息）壓入堆棧，然后返回錯(cuò)誤碼。同 lua_call 一樣， lua_pcall 總是把函數(shù)本身和它的參數(shù)從棧上移除。
如果 errfunc 是 0 ，返回在棧頂?shù)腻e(cuò)誤信息就和原始錯(cuò)誤信息完全一致。否則，errfunc 就被當(dāng)成是錯(cuò)誤處理函數(shù)在棧上的索引。（在當(dāng)前的實(shí)現(xiàn)里，這個(gè)索引不能是偽索引。）在發(fā)生運(yùn)行時(shí)錯(cuò)誤時(shí)，這個(gè)函數(shù)會(huì)被調(diào)用而參數(shù)就是錯(cuò)誤信息。錯(cuò)誤處理函數(shù)的返回值將被 lua_pcall 作為出錯(cuò)信息返回在堆棧上。
典型的用法中，錯(cuò)誤處理函數(shù)被用來(lái)在出錯(cuò)信息上加上更多的調(diào)試信息，比如棧跟蹤信息 (stack traceback) 。這些信息在 lua_pcall 返回后，因?yàn)闂Ｒ呀?jīng)展開(kāi) (unwound) ，所以收集不到了。
lua_pcall 函數(shù)在調(diào)用成功時(shí)返回 0 ，否則返回以下（定義在 lua.h 中的）錯(cuò)誤代碼中的一個(gè)：
? LUA_ERRRUN: 運(yùn)行時(shí)錯(cuò)誤。
? LUA_ERRMEM: 內(nèi)存分配錯(cuò)誤。對(duì)于這種錯(cuò)，Lua 調(diào)用不了錯(cuò)誤處理函數(shù)。
? LUA_ERRERR: 在運(yùn)行錯(cuò)誤處理函數(shù)時(shí)發(fā)生的錯(cuò)誤。
________________________________________
lua_pop
void lua_pop (lua_State *L, int n);
從堆棧中彈出 n 個(gè)元素。
________________________________________
lua_pushboolean
void lua_pushboolean (lua_State *L, int b);
把 b 作為一個(gè) boolean 值壓入堆棧。
________________________________________
lua_pushcclosure
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
把一個(gè)新的 C closure 壓入堆棧。
當(dāng)創(chuàng)建了一個(gè) C 函數(shù)后，你可以給它關(guān)聯(lián)一些值，這樣就是在創(chuàng)建一個(gè) C closure （參見(jiàn) §3.4）；接下來(lái)無(wú)論函數(shù)何時(shí)被調(diào)用，這些值都可以被這個(gè)函數(shù)訪問(wèn)到。為了將一些值關(guān)聯(lián)到一個(gè) C 函數(shù)上，首先這些值需要先被壓入堆棧（如果有多個(gè)值，第一個(gè)先壓）。接下來(lái)調(diào)用 lua_pushcclosure 來(lái)創(chuàng)建出 closure 并把這個(gè) C 函數(shù)壓到堆棧上。參數(shù) n 告之函數(shù)有多少個(gè)值需要關(guān)聯(lián)到函數(shù)上。 lua_pushcclosure 也會(huì)把這些值從棧上彈出。
________________________________________
lua_pushcfunction
void lua_pushcfunction (lua_State *L, lua_CFunction f);
將一個(gè) C 函數(shù)壓入堆棧。這個(gè)函數(shù)接收一個(gè) C 函數(shù)指針，并將一個(gè)類型為 function 的 Lua 值壓入堆棧。當(dāng)這個(gè)棧定的值被調(diào)用時(shí)，將觸發(fā)對(duì)應(yīng)的 C 函數(shù)。
注冊(cè)到 Lua 中的任何函數(shù)都必須遵循正確的協(xié)議來(lái)接收參數(shù)和返回值（參見(jiàn) lua_CFunction）。
lua_pushcfunction 是作為一個(gè)宏定義出現(xiàn)的：
#define lua_pushcfunction(L,f) lua_pushcclosure(L,f,0)
________________________________________
lua_pushfstring
const char *lua_pushfstring (lua_State *L, const char *fmt, ...);
把一個(gè)格式化過(guò)的字符串壓入堆棧，然后返回這個(gè)字符串的指針。它和 C 函數(shù) sprintf 比較像，不過(guò)有一些重要的區(qū)別：
? 摸你需要為結(jié)果分配空間：其結(jié)果是一個(gè) Lua 字符串，由 Lua 來(lái)關(guān)心其內(nèi)存分配（同時(shí)通過(guò)垃圾收集來(lái)釋放內(nèi)存）。
? 這個(gè)轉(zhuǎn)換非常的受限。不支持 flag ，寬度，或是指定精度。它只支持下面這些： '%%' （插入一個(gè) '%'）， '%s' （插入一個(gè)帶零終止符的字符串，沒(méi)有長(zhǎng)度限制）， '%f' （插入一個(gè) lua_Number）， '%p' （插入一個(gè)指針或是一個(gè)十六進(jìn)制數(shù)）， '%d' （插入一個(gè) int)， '%c' （把一個(gè) int 作為一個(gè)字符插入）。
________________________________________
lua_pushinteger
void lua_pushinteger (lua_State *L, lua_Integer n);
把 n 作為一個(gè)數(shù)字壓棧。
________________________________________
lua_pushlightuserdata
void lua_pushlightuserdata (lua_State *L, void *p);
把一個(gè) light userdata 壓棧。
userdata 在 Lua 中表示一個(gè) C 值。 light userdata 表示一個(gè)指針。它是一個(gè)像數(shù)字一樣的值：你不需要專門(mén)創(chuàng)建它，它也沒(méi)有獨(dú)立的 metatable ，而且也不會(huì)被收集（因?yàn)閺膩?lái)不需要?jiǎng)?chuàng)建）。只要表示的 C 地址相同，兩個(gè) light userdata 就相等。
________________________________________
lua_pushlstring
void lua_pushlstring (lua_State *L, const char *s, size_t len);
把指針 s 指向的長(zhǎng)度為 len 的字符串壓棧。 Lua 對(duì)這個(gè)字符串做一次內(nèi)存拷貝（或是復(fù)用一個(gè)拷貝），因此 s 處的內(nèi)存在函數(shù)返回后，可以釋放掉或是重用于其它用途。字符串內(nèi)可以保存有零字符。
________________________________________
lua_pushnil
void lua_pushnil (lua_State *L);
把一個(gè) nil 壓棧。
________________________________________
lua_pushnumber
void lua_pushnumber (lua_State *L, lua_Number n);
把一個(gè)數(shù)字 n 壓棧。
________________________________________
lua_pushstring
void lua_pushstring (lua_State *L, const char *s);
把指針 s 指向的以零結(jié)尾的字符串壓棧。 Lua 對(duì)這個(gè)字符串做一次內(nèi)存拷貝（或是復(fù)用一個(gè)拷貝），因此 s 處的內(nèi)存在函數(shù)返回后，可以釋放掉或是重用于其它用途。字符串中不能包含有零字符；第一個(gè)碰到的零字符會(huì)認(rèn)為是字符串的結(jié)束。
________________________________________
lua_pushthread
int lua_pushthread (lua_State *L);
把 L 中提供的線程壓棧。如果這個(gè)線程是當(dāng)前狀態(tài)機(jī)的主線程的話，返回 1 。
________________________________________
lua_pushvalue
void lua_pushvalue (lua_State *L, int index);
把堆棧上給定有效處索引處的元素作一個(gè)拷貝壓棧。
________________________________________
lua_pushvfstring
const char *lua_pushvfstring (lua_State *L,
const char *fmt,
va_list argp);
等價(jià)于 lua_pushfstring，不過(guò)是用 va_list 接收參數(shù)，而不是用可變數(shù)量的實(shí)際參數(shù)。
________________________________________
lua_rawequal
int lua_rawequal (lua_State *L, int index1, int index2);
如果兩個(gè)索引 index1 和 index2 處的值簡(jiǎn)單地相等（不調(diào)用元方法）則返回 1 。否則返回 0 。如果任何一個(gè)索引無(wú)效也返回 0 。
________________________________________
lua_rawget
void lua_rawget (lua_State *L, int index);
類似于 lua_gettable，但是作一次直接訪問(wèn)（不觸發(fā)元方法）。
________________________________________
lua_rawgeti
void lua_rawgeti (lua_State *L, int index, int n);
把 t[n] 的值壓棧，這里的 t 是指給定索引 index 處的一個(gè)值。這是一個(gè)直接訪問(wèn)；就是說(shuō)，它不會(huì)觸發(fā)元方法。
________________________________________
lua_rawset
void lua_rawset (lua_State *L, int index);
類似于 lua_settable，但是是作一個(gè)直接賦值（不觸發(fā)元方法）。
________________________________________
lua_rawseti
void lua_rawseti (lua_State *L, int index, int n);
等價(jià)于 t[n] = v，這里的 t 是指給定索引 index 處的一個(gè)值，而 v 是棧定的值。
函數(shù)將把這個(gè)值彈出棧。賦值操作是直接的；就是說(shuō)，不會(huì)觸發(fā)元方法。
________________________________________
lua_Reader
typedef const char * (*lua_Reader) (lua_State *L,
void *data,
size_t *size);
lua_load 用到的讀取器函數(shù)，每次它需要一塊新的 chunk 的時(shí)候， lua_load 就調(diào)用讀取器，每次都會(huì)傳入一個(gè)參數(shù) data 。讀取器需要返回含有新的 chunk 的一塊內(nèi)存的指針，并把 size 設(shè)為這塊內(nèi)存的大小。內(nèi)存塊必須在下一次函數(shù)被調(diào)用之前一直存在。讀取器可以通過(guò)返回一個(gè) NULL 來(lái)指示 chunk 結(jié)束。讀取器可能返回多個(gè)塊，每個(gè)塊可以有任意的大于零的尺寸。
________________________________________
lua_register
void lua_register (lua_State *L,
const char *name,
lua_CFunction f);
把 C 函數(shù) f 設(shè)到全局變量 name 中。它通過(guò)一個(gè)宏定義：
#define lua_register(L,n,f) \
(lua_pushcfunction(L, f), lua_setglobal(L, n))
________________________________________
lua_remove
void lua_remove (lua_State *L, int index);
從給定有效索引處移除一個(gè)元素，把這個(gè)索引之上的所有元素移下來(lái)填補(bǔ)上這個(gè)空隙。不能用偽索引來(lái)調(diào)用這個(gè)函數(shù)，因?yàn)閭嗡饕⒉恢赶蛘鎸?shí)的棧上的位置。
________________________________________
lua_replace
void lua_replace (lua_State *L, int index);
把棧定元素移動(dòng)到給定位置（并且把這個(gè)棧定元素彈出），不移動(dòng)任何元素（因此在那個(gè)位置處的值被覆蓋掉）。
________________________________________
lua_resume
int lua_resume (lua_State *L, int narg);
在給定線程中啟動(dòng)或繼續(xù)一個(gè) coroutine 。
要啟動(dòng)一個(gè) coroutine 的話，首先你要?jiǎng)?chuàng)建一個(gè)新線程（參見(jiàn) lua_newthread ）；然后把主函數(shù)和若干參數(shù)壓到新線程的堆棧上；最后調(diào)用 lua_resume ，把 narg 設(shè)為參數(shù)的個(gè)數(shù)。這次調(diào)用會(huì)在 coroutine 掛起時(shí)或是結(jié)束運(yùn)行后返回。當(dāng)函數(shù)返回時(shí)，堆棧中會(huì)有傳給 lua_yield 的所有值，或是主函數(shù)的所有返回值。如果 coroutine 切換時(shí)，lua_resume 返回 LUA_YIELD ，而當(dāng) coroutine 結(jié)束運(yùn)行且沒(méi)有任何錯(cuò)誤時(shí)，返回 0 。如果有錯(cuò)則返回錯(cuò)誤代碼（參見(jiàn) lua_pcall）。在發(fā)生錯(cuò)誤的情況下，堆棧沒(méi)有展開(kāi)，因此你可以使用 debug API 來(lái)處理它。出錯(cuò)信息放在棧頂。要繼續(xù)運(yùn)行一個(gè) coroutine 的話，你把需要傳給 yield 作結(jié)果的返回值壓入堆棧，然后調(diào)用 lua_resume 。
________________________________________
lua_setallocf
void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
把指定狀態(tài)機(jī)的分配器函數(shù)換成帶上指針 ud 的 f 。
________________________________________
lua_setfenv
int lua_setfenv (lua_State *L, int index);
從堆棧上彈出一個(gè) table 并把它設(shè)為指定索引處值的新環(huán)境。如果指定索引處的值即不是函數(shù)又不是線程或是 userdata ， lua_setfenv 會(huì)返回 0 ，否則返回 1 。
________________________________________
lua_setfield
void lua_setfield (lua_State *L, int index, const char *k);
做一個(gè)等價(jià)于 t[k] = v 的操作，這里 t 是給出的有效索引 index 處的值，而 v 是棧頂?shù)哪莻€(gè)值。
這個(gè)函數(shù)將把這個(gè)值彈出堆棧。跟在 Lua 中一樣，這個(gè)函數(shù)可能觸發(fā)一個(gè) "newindex" 事件的元方法（參見(jiàn) §2.8）。
________________________________________
lua_setglobal
void lua_setglobal (lua_State *L, const char *name);
從堆棧上彈出一個(gè)值，并將其設(shè)到全局變量 name 中。它由一個(gè)宏定義出來(lái)：
#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, s)
________________________________________
lua_setmetatable
int lua_setmetatable (lua_State *L, int index);
把一個(gè) table 彈出堆棧，并將其設(shè)為給定索引處的值的 metatable 。
________________________________________
lua_settable
void lua_settable (lua_State *L, int index);
作一個(gè)等價(jià)于 t[k] = v 的操作，這里 t 是一個(gè)給定有效索引 index 處的值， v 指棧頂?shù)闹?，?k 是棧頂之下的那個(gè)值。
這個(gè)函數(shù)會(huì)把鍵和值都從堆棧中彈出。和在 Lua 中一樣，這個(gè)函數(shù)可能觸發(fā) "newindex" 事件的元方法（參見(jiàn) §2.8）。
________________________________________
lua_settop
void lua_settop (lua_State *L, int index);
參數(shù)允許傳入任何可接受的索引以及 0 。它將把堆棧的棧頂設(shè)為這個(gè)索引。如果新的棧頂比原來(lái)的大，超出部分的新元素將被填為 nil 。如果 index 為 0 ，把棧上所有元素移除。
________________________________________
lua_State
typedef struct lua_State lua_State;
一個(gè)不透明的結(jié)構(gòu)，它保存了整個(gè) Lua 解釋器的狀態(tài)。 Lua 庫(kù)是完全可重入的：它沒(méi)有任何全局變量。（譯注：從 C 語(yǔ)法上來(lái)說(shuō)，也不盡然。例如，在 table 的實(shí)現(xiàn)中用了一個(gè)靜態(tài)全局變量 dummynode_ ，但這在正確使用時(shí)并不影響可重入性。只是萬(wàn)一你錯(cuò)誤鏈接了 lua 庫(kù)，不小心在同一進(jìn)程空間中存在兩份 lua 庫(kù)實(shí)現(xiàn)的代碼的話，多份 dummynode_ 不同的地址會(huì)導(dǎo)致一些問(wèn)題。）所有的信息都保存在這個(gè)結(jié)構(gòu)中。
這個(gè)狀態(tài)機(jī)的指針必須作為第一個(gè)參數(shù)傳遞給每一個(gè)庫(kù)函數(shù)。 lua_newstate 是一個(gè)例外，這個(gè)函數(shù)會(huì)從頭創(chuàng)建一個(gè) Lua 狀態(tài)機(jī)。
________________________________________
lua_status
int lua_status (lua_State *L);
返回線程 L 的狀態(tài)。
正常的線程狀態(tài)是 0 。當(dāng)線程執(zhí)行完畢或發(fā)生一個(gè)錯(cuò)誤時(shí)，狀態(tài)值是錯(cuò)誤碼。如果線程被掛起，狀態(tài)為 LUA_YIELD 。
________________________________________
lua_toboolean
int lua_toboolean (lua_State *L, int index);
把指定的索引處的的 Lua 值轉(zhuǎn)換為一個(gè) C 中的 boolean 值（ 0 或是 1 ）。和 Lua 中做的所有測(cè)試一樣， lua_toboolean 會(huì)把任何不同于 false 和 nil 的值當(dāng)作 1 返回；否則就返回 0 。如果用一個(gè)無(wú)效索引去調(diào)用也會(huì)返回 0 。（如果你想只接收真正的 boolean 值，就需要使用 lua_isboolean 來(lái)測(cè)試值的類型。）
________________________________________
lua_tocfunction
lua_CFunction lua_tocfunction (lua_State *L, int index);
把給定索引處的 Lua 值轉(zhuǎn)換為一個(gè) C 函數(shù)。這個(gè)值必須是一個(gè) C 函數(shù)；如果不是就返回 NULL 。
________________________________________
lua_tointeger
lua_Integer lua_tointeger (lua_State *L, int idx);
把給定索引處的 Lua 值轉(zhuǎn)換為 lua_Integer 這樣一個(gè)有符號(hào)整數(shù)類型。這個(gè) Lua 值必須是一個(gè)數(shù)字或是一個(gè)可以轉(zhuǎn)換為數(shù)字的字符串（參見(jiàn) §2.2.1）；否則，lua_tointeger 返回 0 。
如果數(shù)字不是一個(gè)整數(shù)，截?cái)嘈?shù)部分的方式?jīng)]有被明確定義。
________________________________________
lua_tolstring
const char *lua_tolstring (lua_State *L, int index, size_t *len);
把給定索引處的 Lua 值轉(zhuǎn)換為一個(gè) C 字符串。如果 len 不為 NULL ，它還把字符串長(zhǎng)度設(shè)到 *len 中。這個(gè) Lua 值必須是一個(gè)字符串或是一個(gè)數(shù)字；否則返回返回 NULL 。如果值是一個(gè)數(shù)字，lua_tolstring 還會(huì)把堆棧中的那個(gè)值的實(shí)際類型轉(zhuǎn)換為一個(gè)字符串。（當(dāng)遍歷一個(gè)表的時(shí)候，把 lua_tolstring 作用在鍵上，這個(gè)轉(zhuǎn)換有可能導(dǎo)致 lua_next 弄錯(cuò)。）
lua_tolstring 返回 Lua 狀態(tài)機(jī)中字符串的以對(duì)齊指針。這個(gè)字符串總能保證 （ C 要求的）最后一個(gè)字符為零 ('\0') ，而且它允許在字符串內(nèi)包含多個(gè)這樣的零。因?yàn)?Lua 中可能發(fā)生垃圾收集，所以不保證 lua_tolstring 返回的指針，在對(duì)應(yīng)的值從堆棧中移除后依然有效。
________________________________________
lua_tonumber
lua_Number lua_tonumber (lua_State *L, int index);
把給定索引處的 Lua 值轉(zhuǎn)換為 lua_Number 這樣一個(gè) C 類型（參見(jiàn) lua_Number ）。這個(gè) Lua 值必須是一個(gè)數(shù)字或是一個(gè)可轉(zhuǎn)換為數(shù)字的字符串（參見(jiàn) §2.2.1 ）；否則，lua_tonumber 返回 0 。
________________________________________
lua_topointer
const void *lua_topointer (lua_State *L, int index);
把給定索引處的值轉(zhuǎn)換為一般的 C 指針 (void*) 。這個(gè)值可以是一個(gè) userdata ，table ，thread 或是一個(gè) function ；否則，lua_topointer 返回 NULL 。不同的對(duì)象有不同的指針。不存在把指針再轉(zhuǎn)回原有類型的方法。
這個(gè)函數(shù)通常只為產(chǎn)生 debug 信息用。
________________________________________
lua_tostring
const char *lua_tostring (lua_State *L, int index);
等價(jià)于 lua_tolstring ，而參數(shù) len 設(shè)為 NULL 。
________________________________________
lua_tothread
lua_State *lua_tothread (lua_State *L, int index);
把給定索引處的值轉(zhuǎn)換為一個(gè) Lua 線程（由 lua_State* 代表）。這個(gè)值必須是一個(gè)線程；否則函數(shù)返回 NULL 。
________________________________________
lua_touserdata
void *lua_touserdata (lua_State *L, int index);
如果給定索引處的值是一個(gè)完整的 userdata ，函數(shù)返回內(nèi)存塊的地址。如果值是一個(gè) light userdata ，那么就返回它表示的指針。否則，返回 NULL 。
________________________________________
lua_type
int lua_type (lua_State *L, int index);
返回給定索引處的值的類型，當(dāng)索引無(wú)效時(shí)則返回 LUA_TNONE （那是指一個(gè)指向堆棧上的空位置的索引）。 lua_type 返回的類型是一些個(gè)在 lua.h 中定義的常量： LUA_TNIL ， LUA_TNUMBER ， LUA_TBOOLEAN ， LUA_TSTRING ， LUA_TTABLE ， LUA_TFUNCTION ， LUA_TUSERDATA ， LUA_TTHREAD ， LUA_TLIGHTUSERDATA 。
________________________________________
lua_typename
const char *lua_typename (lua_State *L, int tp);
返回 tp 表示的類型名，這個(gè) tp 必須是 lua_type 可能返回的值中之一。
________________________________________
lua_Writer
typedef int (*lua_Writer) (lua_State *L,
const void* p,
size_t sz,
void* ud);
由 lua_dump 用到的寫(xiě)入器函數(shù)。每次 lua_dump 產(chǎn)生了一塊新的 chunk ，它都會(huì)調(diào)用寫(xiě)入器。傳入要寫(xiě)入的緩存 (p) 和它的尺寸 (sz) ，還有 lua_dump 的參數(shù) data 。
寫(xiě)入器會(huì)返回一個(gè)錯(cuò)誤碼： 0 表示沒(méi)有錯(cuò)誤；別的值均表示一個(gè)錯(cuò)誤，并且會(huì)讓 lua_dump 停止再次調(diào)用寫(xiě)入器。
________________________________________
lua_xmove
void lua_xmove (lua_State *from, lua_State *to, int n);
傳遞 同一個(gè) 全局狀態(tài)機(jī)下不同線程中的值。
這個(gè)函數(shù)會(huì)從 from 的堆棧中彈出 n 個(gè)值，然后把它們壓入 to 的堆棧中。
________________________________________
lua_yield
int lua_yield (lua_State *L, int nresults);
切出一個(gè) coroutine 。
這個(gè)函數(shù)只能在一個(gè) C 函數(shù)的返回表達(dá)式中調(diào)用。如下：
return lua_yield (L, nresults);
當(dāng)一個(gè) C 函數(shù)這樣調(diào)用 lua_yield ，正在運(yùn)行中的 coroutine 將從運(yùn)行中掛起，然后啟動(dòng)這個(gè) coroutine 用的那次對(duì) lua_resume 的調(diào)用就返回了。參數(shù) nresults 指的是堆棧中需要返回的結(jié)果個(gè)數(shù)，這些返回值將被傳遞給 lua_resume 。
3.8 - 調(diào)試接口
Lua 沒(méi)有內(nèi)建的調(diào)試設(shè)施。取而代之的是提供了一些函數(shù)接口和鉤子。利用這些接口，可以做出一些不同類型的調(diào)試器，性能分析器，或是其它一些需要從解釋器中取到“內(nèi)部信息”的工具。
________________________________________
lua_Debug
typedef struct lua_Debug {
int event;
const char *name; /* (n) */
const char *namewhat; /* (n) */
const char *what; /* (S) */
const char *source; /* (S) */
int currentline; /* (l) */
int nups; /* (u) upvalue 個(gè)數(shù) */
int linedefined; /* (S) */
int lastlinedefined; /* (S) */
char short_src[LUA_IDSIZE]; /* (S) */
/* 私有部分 */
其它域
} lua_Debug;
一個(gè)用來(lái)攜帶活動(dòng)中函數(shù)的各種信息的結(jié)構(gòu)。 lua_getstack 僅填寫(xiě)這個(gè)結(jié)構(gòu)中的私有部分，這些部分以后會(huì)用到。調(diào)用 lua_getinfo 則可以填上 lua_Debug 中有用信息的那些域。
lua_Debug 中的各個(gè)域有下列含義：
? source: 如果函數(shù)是定義在一個(gè)字符串中，source 就是這個(gè)字符串。如果函數(shù)定義在一個(gè)文件中， source 是一個(gè)以 '@' 開(kāi)頭的文件名。
? short_src: 一個(gè)“可打印版本”的 source，用于出錯(cuò)信息。
? linedefined: 函數(shù)定義開(kāi)始處的行號(hào)。
? lastlinedefined: 函數(shù)定義結(jié)束處的行號(hào)。
? what: 如果函數(shù)是一個(gè) Lua 函數(shù)，則為一個(gè)字符串 "Lua" ；如果是一個(gè) C 函數(shù)，則為 "C"；如果它是一個(gè) chunk 的主體部分，則為 "main"；如果是一個(gè)作了尾調(diào)用的函數(shù)，則為 "tail" 。別的情況下，Lua 沒(méi)有關(guān)于函數(shù)的別的信息。
? currentline: 給定函數(shù)正在執(zhí)行的那一行。當(dāng)提供不了行號(hào)信息的時(shí)候，currentline 被設(shè)為 -1 。
? name: 給定函數(shù)的一個(gè)合理的名字。因?yàn)?Lua 中的函數(shù)也是一個(gè)值，所以它們沒(méi)有固定的名字：一些函數(shù)可能是全局復(fù)合變量的值，另一些可能僅僅只是被保存在一個(gè) table 中。 lua_getinfo 函數(shù)會(huì)檢查函數(shù)是這樣被調(diào)用的，以此來(lái)找到一個(gè)適合的名字。如果它找不到名字，name 就被設(shè)置為 NULL 。
? namewhat: 結(jié)實(shí) name 域。 namewhat 的值可以是 "global", "local", "method", "field", "upvalue", 或是 "" （空串）。這取決于函數(shù)怎樣被調(diào)用。（Lua 用空串表示其它選項(xiàng)都不符合）
? nups: 函數(shù)的 upvalue 的個(gè)數(shù)。
________________________________________
lua_gethook
lua_Hook lua_gethook (lua_State *L);
返回當(dāng)前的鉤子函數(shù)。
________________________________________
lua_gethookcount
int lua_gethookcount (lua_State *L);
返回當(dāng)前鉤子記數(shù)。
________________________________________
lua_gethookmask
int lua_gethookmask (lua_State *L);
返回當(dāng)前的鉤子掩碼 (mask) 。
________________________________________
lua_getinfo
int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
返回一個(gè)指定的函數(shù)或函數(shù)調(diào)用的信息。
當(dāng)用于取得一次函數(shù)調(diào)用的信息時(shí)，參數(shù) ar 必須是一個(gè)有效的活動(dòng)的記錄。這條記錄可以是前一次調(diào)用 lua_getstack 得到的，或是一個(gè)鉤子 （參見(jiàn) lua_Hook）得到的參數(shù)。
用于獲取一個(gè)函數(shù)的信息時(shí)，可以把這個(gè)函數(shù)壓入堆棧，然后把 what 字符串以字符 '>' 起頭。（這個(gè)情況下，lua_getinfo 從棧頂上彈出函數(shù)。） 例如，想知道函數(shù) f 在哪一行定義的，你可以下下列代碼：
lua_Debug ar;
lua_getfield(L, LUA_GLOBALSINDEX, "f"); /* 取到全局變量 'f' */
lua_getinfo(L, ">S", &ar);
printf("%d\n", ar.linedefined);
what 字符串中的每個(gè)字符都篩選出結(jié)構(gòu) ar 結(jié)構(gòu)中一些域用于填充，或是把一個(gè)值壓入堆棧：
? 'n': 填充 name 及 namewhat 域；
? 'S': 填充 source， short_src， linedefined， lastlinedefined，以及 what 域；
? 'l': 填充 currentline 域；
? 'u': 填充 nups 域；
? 'f': 把正在運(yùn)行中指定級(jí)別處函數(shù)壓入堆棧；（譯注：一般用于獲取函數(shù)調(diào)用中的信息，級(jí)別是由 ar 中的私有部分來(lái)提供。如果用于獲取靜態(tài)函數(shù)，那么就直接把指定函數(shù)重新壓回堆棧，但這樣做通常無(wú)甚意義。）
? 'L': 壓一個(gè) table 入棧，這個(gè) table 中的整數(shù)索引用于描述函數(shù)中哪些行是有效行。（有效行指有實(shí)際代碼的行，即你可以置入斷點(diǎn)的行。無(wú)效行包括空行和只有注釋的行。）
這個(gè)函數(shù)出錯(cuò)會(huì)返回 0 （例如，what 中有一個(gè)無(wú)效選項(xiàng)）。
________________________________________
lua_getlocal
const char *lua_getlocal (lua_State *L, lua_Debug *ar, int n);
從給定活動(dòng)記錄中獲取一個(gè)局部變量的信息。參數(shù) ar 必須是一個(gè)有效的活動(dòng)的記錄。這條記錄可以是前一次調(diào)用 lua_getstack 得到的，或是一個(gè)鉤子 （參見(jiàn) lua_Hook）得到的參數(shù)。索引 n 用于選擇要檢閱哪個(gè)局部變量（ 1 表示第一個(gè)參數(shù)或是激活的第一個(gè)局部變量，以此類推，直到最后一個(gè)局部變量）。 lua_getlocal 把變量的值壓入堆棧并返回它的名字。
以 '(' （正小括號(hào)）開(kāi)始的變量指內(nèi)部變量（循環(huán)控制變量，臨時(shí)變量，C 函數(shù)局部變量）。
當(dāng)索引大于局部變量的個(gè)數(shù)時(shí)，返回 NULL （什么也不壓入）。
________________________________________
lua_getstack
int lua_getstack (lua_State *L, int level, lua_Debug *ar);
獲取解釋器的運(yùn)行時(shí)棧的信息。
這個(gè)函數(shù)用正在運(yùn)行中的給定級(jí)別處的函數(shù)的活動(dòng)記錄來(lái)填寫(xiě) lua_Debug 結(jié)構(gòu)的一部分。 0 級(jí)表示當(dāng)前運(yùn)行的函數(shù)，而 n+1 級(jí)處的函數(shù)就是調(diào)用第 n 級(jí)函數(shù)的那一個(gè)。如果沒(méi)有錯(cuò)誤，lua_getstack 返回 1 ；當(dāng)調(diào)用傳入的級(jí)別大于堆棧深度的時(shí)候，返回 0 。
________________________________________
lua_getupvalue
const char *lua_getupvalue (lua_State *L, int funcindex, int n);
獲取一個(gè) closure 的 upvalue 信息。（對(duì)于 Lua 函數(shù)，upvalue 是函數(shù)需要使用的外部局部變量，因此這些變量被包含在 closure 中。） lua_getupvalue 獲取第 n 個(gè) upvalue ，把這個(gè) upvalue 的值壓入堆棧，并且返回它的名字。 funcindex 指向堆棧上 closure 的位置。（ 因?yàn)?upvalue 在整個(gè)函數(shù)中都有效，所以它們沒(méi)有特別的次序。因此，它們以字母次序來(lái)編號(hào)。）
當(dāng)索引號(hào)比 upvalue 數(shù)量大的時(shí)候，返回 NULL （而且不會(huì)壓入任何東西）對(duì)于 C 函數(shù)，這個(gè)函數(shù)用空串 "" 表示所有 upvalue 的名字。
________________________________________
lua_Hook
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
用于調(diào)試的鉤子函數(shù)類型。
無(wú)論何時(shí)鉤子被調(diào)用，它的參數(shù) ar 中的 event 域都被設(shè)為觸發(fā)鉤子的事件。 Lua 把這些事件定義為以下常量： LUA_HOOKCALL， LUA_HOOKRET, LUA_HOOKTAILRET， LUA_HOOKLINE， and LUA_HOOKCOUNT。除此之外，對(duì)于 line 事件，currentline 域也被設(shè)置。要想獲得 ar 中的其他域，鉤子必須調(diào)用 lua_getinfo。對(duì)于返回事件，event 的正常值可能是 LUA_HOOKRET，或者是 LUA_HOOKTAILRET 。對(duì)于后一種情況，Lua 會(huì)對(duì)一個(gè)函數(shù)做的尾調(diào)用也模擬出一個(gè)返回事件出來(lái)；對(duì)于這個(gè)模擬的返回事件，調(diào)用 lua_getinfo 沒(méi)有什么作用。
當(dāng) Lua 運(yùn)行在一個(gè)鉤子內(nèi)部時(shí)，它將屏蔽掉其它對(duì)鉤子的調(diào)用。也就是說(shuō)，如果一個(gè)鉤子函數(shù)內(nèi)再調(diào)回 Lua 來(lái)執(zhí)行一個(gè)函數(shù)或是一個(gè) chunk ，這個(gè)執(zhí)行操作不會(huì)觸發(fā)任何的鉤子。
________________________________________
lua_sethook
int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);
設(shè)置一個(gè)調(diào)試用鉤子函數(shù)。
參數(shù) f 是鉤子函數(shù)。 mask 指定在哪些事件時(shí)會(huì)調(diào)用：它由下列一組位常量構(gòu)成 LUA_MASKCALL， LUA_MASKRET， LUA_MASKLINE，以及 LUA_MASKCOUNT。參數(shù) count 只在 mask 中包含有 LUA_MASKCOUNT 才有意義。對(duì)于每個(gè)事件，鉤子被調(diào)用的情況解釋如下：
? call hook: 在解釋器調(diào)用一個(gè)函數(shù)時(shí)被調(diào)用。鉤子將于 Lua 進(jìn)入一個(gè)新函數(shù)后，函數(shù)獲取參數(shù)前被調(diào)用。
? return hook: 在解釋器從一個(gè)函數(shù)中返回時(shí)調(diào)用。鉤子將于 Lua 離開(kāi)函數(shù)之前的那一刻被調(diào)用。你無(wú)權(quán)訪問(wèn)被函數(shù)返回出去的那些值。 （譯注：原文 (You have no access to the values to be returned by the function) 如此。但“無(wú)權(quán)訪問(wèn)”一詞值得商榷。某些情況下你可以訪問(wèn)到一些被命名為 (*temporary) 的局部變量，那些索引被排在最后的 (*temporary) 變量指的就是返回值。但是由于 Lua 對(duì)特殊情況做了一些優(yōu)化，比如直接返回一個(gè)被命名的局部變量，那么就找不到對(duì)應(yīng)的 (*temporary) 變量了。本質(zhì)上，返回值一定存在于此刻的局部變量中，并且可以訪問(wèn)它，只是無(wú)法確定是哪些罷了。至于這個(gè)時(shí)候函數(shù)體內(nèi)的其它局部變量，是不保證有效的。進(jìn)入 return hook 的那一刻起，實(shí)際已經(jīng)退出函數(shù)內(nèi)部的運(yùn)行環(huán)節(jié)，返回值占用的局部變量空間以后的部分，都有可能因 hook 本身復(fù)用它們而改變。）
? line hook: 在解釋器準(zhǔn)備開(kāi)始執(zhí)行新的一行代碼時(shí)，或是跳轉(zhuǎn)到這行代碼中時(shí)（即使在同一行內(nèi)跳轉(zhuǎn)）被調(diào)用。（這個(gè)事件僅僅在 Lua 執(zhí)行一個(gè) Lua 函數(shù)時(shí)發(fā)生。）
? count hook: 在解釋器每執(zhí)行 count 條指令后被調(diào)用。（這個(gè)事件僅僅在 Lua 執(zhí)行一個(gè) Lua 函數(shù)時(shí)發(fā)生。）
鉤子可以通過(guò)設(shè)置 mask 為零屏蔽。
________________________________________
lua_setlocal
const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);
設(shè)置給定活動(dòng)記錄中的局部變量的值。參數(shù) ar 與 n 和 lua_getlocal 中的一樣（參見(jiàn) lua_getlocal）。 lua_setlocal 把棧頂?shù)闹蒂x給變量然后返回變量的名字。它會(huì)將值從棧頂彈出。
當(dāng)索引大于局部變量的個(gè)數(shù)時(shí)，返回 NULL （什么也不彈出）。

總結(jié)

以上是生活随笔為你收集整理的LUA教程的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。