lua 5.3 英文手冊 google機器翻譯版

LUA Lua 5.3參考手冊
做者：Roberto Ierusalimschy，Luiz Henrique de Figueiredo，Waldemar Celes

版權全部©2015-2018 Lua.org，PUC-Rio。根據Lua許可條款免費提供 。

內容 · 索引 · 其餘版本
1 - 簡介
Lua是一種功能強大，高效，輕量級，可嵌入的腳本語言。它支持過程編程，面向對象編程，函數編程，數據驅動編程和數據描述。

Lua將簡單的過程語法與基於關聯數組和可擴展語義的強大數據描述結構相結合。Lua是動態類型的，經過使用基於寄存器的虛擬機解釋字節碼來運行，並具備增量垃圾收集的自動內存管理，使其成爲配置，腳本和快速原型設計的理想選擇。

Lua實現爲一個庫，用乾淨的C編寫，這是標準C和C ++的通用子集。Lua發行版包括一個名爲的主機程序lua，它使用Lua庫提供完整的獨立Lua解釋器，用於交互式或批量使用。Lua旨在用做任何須要的程序的強大，輕量級，可嵌入的腳本語言，以及做爲一種功能強大但輕量級且高效的獨立語言。

做爲一種擴展語言，Lua沒有「主要」程序的概念：它嵌入在主機客戶端中，稱爲嵌入程序或簡稱主機。（一般，這個主機是獨立的lua程序。）主機程序能夠調用函數來執行一段Lua代碼，能夠編寫和讀取Lua變量，而且能夠註冊要由Lua代碼調用的C函數。經過使用C函數，能夠擴展Lua以應對各類不一樣的域，從而建立共享語法框架的定製編程語言。

Lua是免費軟件，按照許可證的規定，照常提供，不提供擔保。Lua的官方網站上提供了本手冊中描述的實現www.lua.org。

與任何其餘參考手冊同樣，本文檔在某些地方是乾燥的。有關Lua設計背後的決策的討論，請參閱Lua網站上提供的技術論文。有關Lua編程的詳細介紹，請參閱Roberto的書「 Lua編程」。

2 - 基本概念
本節介紹該語言的基本概念。

2.1 - 價值觀和類型
Lua是一種動態類型語言。這意味着變量沒有類型; 只有價值觀。該語言中沒有類型定義。全部值都有本身的類型。

Lua中的全部值都是一等值。這意味着全部值均可以存儲在變量中，做爲參數傳遞給其餘函數，並做爲結果返回。

Lua中有八種基本類型： nil，boolean，number， string，function，userdata， thread和table。nil類型只有一個值nil，其主要屬性與任何其餘值不一樣; 它一般表明缺少有用的價值。boolean類型有兩個值，false和true。兩個零和假賺了條件爲假; 任何其餘價值都是真的。該類型的號碼錶示整數和實數（浮點）數。類型字符串表示不可變的字節序列。Lua是8位乾淨的：字符串能夠包含任何8位值，包括嵌入的零（' \0'）。Lua也是編碼不可知的; 它沒有假設字符串的內容。

類型號使用兩個內部表示，或兩個子類型，一個稱爲整數，另外一個稱爲float。Lua有關於什麼時候使用每一個表示的明確規則，但它也會根據須要自動轉換它們（參見§3.4.3）。所以，程序員能夠選擇主要忽略整數和浮點數之間的差別，或者假設徹底控制每一個數字的表示。標準Lua使用64位整數和雙精度（64位）浮點數，但您也能夠編譯Lua，以便它使用32位整數和/或單精度（32位）浮點數。對於小型機器和嵌入式系統，整數和浮點數的32位選項特別有吸引力。（見宏LUA_32BITS在文件中luaconf.h。）

Lua能夠調用（和操做）用Lua編寫的函數和用C編寫的函數（參見§3.4.10）。二者都由類型函數表示。

提供 類型userdata以容許任意C數據存儲在Lua變量中。userdata值表示原始內存塊。有兩種用戶數據： 完整用戶數據，一個由Lua管理的內存塊的對象，以及輕用戶數據，它只是一個C指針值。除了賦值和身份測試以外，Userdata在Lua中沒有預約義的操做。經過使用元表，程序員能夠定義完整用戶數據值的操做（參見§2.4）。只能經過C API在Lua中建立或修改Userdata值。這保證了主機程序擁有的數據的完整性。

類型線程表示獨立的執行線程，它用於實現協同程序（參見§2.6）。Lua線程與操做系統線程無關。Lua支持全部系統上的協同程序，甚至是那些自己不支持線程的協同程序。

類型表實現關聯數組，即不只能夠包含數字做爲索引的數組，還能夠包含除nil和NaN 以外的任何Lua值。（非數字是用於表示未定義或不可表示的數值結果的特殊值，例如0/0。）表能夠是異構的 ; 也就是說，它們能夠包含全部類型的值（除了nil）。值爲nil的任何鍵都不被視爲表的一部分。相反，任何不屬於表的鍵都具備關聯值nil。

表是Lua中惟一的數據結構機制; 它們可用於表示普通數組，列表，符號表，集合，記錄，圖形，樹等。爲了表示記錄，Lua使用字段名稱做爲索引。該語言經過提供a.name語法糖來支持這種表示a["name"]。有幾種方便的方法能夠在Lua中建立表（參見§3.4.9）。

與索引同樣，表字段的值能夠是任何類型。特別是，由於函數是第一類值，因此表字段能夠包含函數。所以，表格也能夠帶有方法（見§3.4.11）。

表的索引遵循語言中原始相等的定義。表達式a[i]和a[j] 表示相同的表元素當且僅當i和j原始相等（即，沒有元方法時相等）。特別是，具備整數值的浮點數等於它們各自的整數（例如1.0 == 1）。爲避免歧義，任何具備用做鍵的整數值的浮點數都將轉換爲其各自的整數。例如，若是你寫a[2.0] = true，插入表中的實際鍵將是整數2。（另外一方面，2和「 2」是不一樣的Lua值，所以表示不一樣的表條目。）

表，函數，線程和（完整）用戶數據值是對象：變量實際上不包含這些值，只是對它們的引用。賦值，參數傳遞和函數返回老是操縱對這些值的引用; 這些操做並不意味着任何形式的複製。

庫函數type返回一個描述給定值類型的字符串（參見§6.1）。

2.2 - 環境與全球環境
如將在要討論§3.2和§3.3.3，到自由名稱的任何引用（即，不束縛於任何聲明的名稱）var 在語法翻譯成_ENV.var。並且，每一個塊都在一個名爲_ENV（參見§3.3.2）的外部局部變量的範圍內編譯，所以_ENV它自己永遠不是塊中的自由名稱。

儘管存在這個外部_ENV變量和自由名稱的翻譯 ，但這_ENV是一個徹底規則的名稱。特別是，您可使用該名稱定義新變量和參數。每一個對自由名稱的引用都使用_ENV在程序中該點可見的，遵循Lua的常見可見性規則（參見§3.5）。

用做值的任何表_ENV稱爲環境。

Lua保持着一個稱爲全球環境的傑出環境。該值保存在C註冊表中的特殊索引處（參見§4.5）。在Lua中，全局變量_G用相同的值初始化。（_G從不在內部使用。）

當Lua加載塊時，其_ENVupvalue 的默認值是全局環境（請參閱參考資料load）。所以，默認狀況下，Lua代碼中的自由名稱是指全局環境中的條目（所以，它們也稱爲全局變量）。此外，全部標準庫都加載到全局環境中，而且那裏的一些功能在該環境中運行。您可使用load（或loadfile）加載具備不一樣環境的塊。（在C中，您必須加載塊，而後更改其第一個upvalue的值。）

2.3 - 錯誤處理
由於Lua是一種嵌入式擴展語言，因此全部Lua操做都從宿主程序中的C代碼開始，從Lua庫調用一個函數。（當您使用Lua standalone時，lua應用程序是主程序。）每當編譯或執行Lua塊時發生錯誤，控制權將返回主機，主機能夠採起適當的措施（例如打印錯誤消息）。

Lua代碼能夠經過調用error函數顯式生成錯誤 。若是須要捕獲Lua中的錯誤，可使用pcall或xpcall 以受保護模式調用給定函數。

每當出現錯誤時，都會傳播錯誤對象（也稱爲錯誤消息），其中包含有關錯誤的信息。Lua自己只生成錯誤對象是字符串的錯誤，但程序可能會生成任何值的錯誤做爲錯誤對象。由Lua程序或其主機來處理這樣的錯誤對象。

當您使用xpcall或時lua_pcall，您能夠 在出現錯誤時調用消息處理程序。使用原始錯誤對象調用此函數並返回新的錯誤對象。它在錯誤展開堆棧以前調用，以便它能夠收集有關錯誤的更多信息，例如經過檢查堆棧並建立堆棧回溯。此消息處理程序仍受受保護的調用保護; 因此，消息處理程序中的錯誤將再次調用消息處理程序。若是這個循環持續太長時間，Lua會打破它並返回一個適當的消息。（僅針對常規運行時錯誤調用消息處理程序。在運行終結器時，不會調用內存分配錯誤或錯誤。）

2.4 - Metatables和Metamethods
Lua中的每一個值均可以有一個metatable。此metatable是一個普通的Lua表，它定義了某些特殊操做下原始值的行爲。您能夠經過在其元表中設置特定字段來更改操做行爲的幾個方面。例如，當非數字值是加法的操做數時，Lua檢查__add值的metatable 字段「 」中的函數。若是找到一個，Lua會調用此函數來執行添加。

metatable中每一個事件的鍵是一個字符串，其事件名稱前綴爲兩個下劃線; 相應的值稱爲metamethods。在前面的示例中，鍵是「 __add」，而metamethod是執行添加的函數。除非另有說明，不然metamethods應該是函數值。

您可使用該getmetatable函數查詢任何值的元表。Lua使用原始訪問查詢元數據中的元方法（請參閱參考資料rawget）。所以，爲了檢索ev對象中事件的元方法o，Lua徹底等效於如下代碼：

rawget（getmetatable（o）或{}，「__ ev 」）
您可使用該setmetatable函數替換表的元表。您沒法從Lua代碼更改其餘類型的元表（除非使用調試庫（第6.10節））; 你應該使用C API。

表和完整的userdata具備單獨的元表（儘管多個表和userdata能夠共享其元表）。全部其餘類型的值每種類型共享一個metatable; 也就是說，全部數字都有一個metatable，一個用於全部字符串，等等。默認狀況下，一個值沒有metatable，可是字符串庫爲字符串類型設置了metatable（參見§6.4）。

metatable控制對象在算術運算，按位運算，順序比較，串聯，長度運算，調用和索引中的行爲方式。當用戶數據或表被垃圾收集時，metatable也能夠定義要調用的函數（第2.5節）。

對於一元運算符（否認，長度和按位NOT），計算元方法並使用虛擬的第二個操做數調用，等於第一個操做數。這個額外的操做數只是爲了簡化Lua的內部（經過使這些操做符像二進制操做同樣），而且可能在未來的版本中被刪除。（對於大多數用途，這個額外的操做數是可有可無的。）

接下來給出由元表控制的事件的詳細列表。每一個操做由其相應的鍵標識。

__add： addition（+）操做。若是添加的任何操做數不是數字（也不是對數字強制的字符串），Lua將嘗試調用metamethod。首先，Lua將檢查第一個操做數（即便它是有效的）。若是該操做數沒有定義元方法__add，那麼Lua將檢查第二個操做數。若是Lua能夠找到一個metamethod，它會將兩個操做數做爲參數調用metamethod，而且調用的結果（調整爲一個值）是操做的結果。不然，它會引起錯誤。
__sub： 減法（-）操做。行爲相似於添加操做。
__mul： multiplication（*）操做。行爲相似於添加操做。
__div： division（/）操做。行爲相似於添加操做。
__mod： modulo（%）操做。行爲相似於添加操做。
__pow： exponentiation（^）操做。行爲相似於添加操做。
__unm： 否認（一元-）操做。行爲相似於添加操做。
__idiv： floor division（//）操做。行爲相似於添加操做。
__band： 按位AND（&）操做。相似於加法運算的行爲，除了若是任何操做數既不是整數也不是對整數可強制的值，Lua將嘗試元方法（參見§3.4.3）。
__bor： 按位OR（|）操做。行爲相似於按位AND運算。
__bxor： 按位異或（二進制~）運算。行爲相似於按位AND運算。
__bnot： 按位NOT（一元~）運算。行爲相似於按位AND運算。
__shl： 按位左移（<<）運算。行爲相似於按位AND運算。
__shr： 按位右移（>>）運算。行爲相似於按位AND運算。
__concat： concatenation（..）操做。相似於加法運算的行爲，除了若是任何操做數既不是字符串也不是數字（對於字符串老是可強制的），Lua將嘗試元方法。
__len： length（#）操做。若是對象不是字符串，Lua將嘗試其metamethod。若是存在metame方法，Lua將該對象做爲參數調用，而且調用的結果（始終調整爲一個值）是操做的結果。若是沒有metamethod但對象是表，則Lua使用表長度操做（參見§3.4.7）。不然，Lua會引起錯誤。
__eq： equal（==）操做。相似於加法運算的行爲，除了Lua將僅在被比較的值既是表或兩個完整用戶數據而且它們不是原始相等時嘗試元方法。調用的結果老是轉換爲布爾值。
__lt： 小於（<）操做。行爲相似於加法運算，除了Lua只在被比較的值既不是數字也不是兩個字符串時都會嘗試元方法。調用的結果老是轉換爲布爾值。
__le： 較少的equal（<=）操做。與其餘操做不一樣，不太相等的操做可使用兩個不一樣的事件。首先，Lua __le在兩個操做數中尋找元方法，就像在少於操做中同樣。若是它找不到這樣的元方法，那麼它將嘗試__ltmetame方法，假設a <= b至關於not (b < a)。與其餘比較運算符同樣，結果始終是布爾值。（__lt在未來的版本中能夠刪除此事件的使用;它也比真正的__le元方法慢。）
__index： 索引訪問操做table[key]。當事件table不是表或key不存在時，會發生此事件table。查找了metamethod table。
儘管有這個名字，這個事件的元方法能夠是函數或表。若是它是一個函數，則使用table和key做爲參數調用它，而且調用的結果（調整爲一個值）是操做的結果。若是它是一個表，則最終結果是將該表索引的結果key。（這種索引是常規的，而不是原始的，所以能夠觸發另外一種元方法。）

__newindex： 索引分配table[key] = value。與索引事件同樣，此事件發生在table不是表或key不存在時table。查找了metamethod table。
與索引同樣，此事件的元方法能夠是函數或表。若是它是一個功能，它被稱爲用table，key以及value做爲參數。若是它是一個表，Lua會使用相同的鍵和值對此表進行索引分配。（這項任務是有規律的，不是原始的，所以能夠觸發另外一種元方法。）

每當有一個__newindex元方法時，Lua就不會執行原始賦值。（若是有必要，metamethod自己能夠調用rawset 來進行賦值。）

__call： 通話操做func(args)。當Lua嘗試調用非函數值（即，func不是函數）時，會發生此事件。查找了metamethod func。若是存在，則使用func第一個參數調用元方法，而後調用原始調用（args）的參數。調用的全部結果都是操做的結果。（這是惟一容許多個結果的元方法。）
在將其設置爲某個對象的元表以前，將全部須要的元方法添加到表中是一種很好的作法。特別是，元__gc方法僅在遵循此順序時才起做用（參見§2.5.1）。

由於元表是常規表，因此它們能夠包含任意字段，而不只僅是上面定義的事件名稱。標準庫中的某些函數（例如tostring）使用元表中的其餘字段用於它們本身的目的。

2.5 - 垃圾收集
Lua執行自動內存管理。這意味着您沒必要擔憂爲新對象分配內存或在再也不須要對象時釋放它。Lua經過運行垃圾收集器來自動管理內存，以收集全部死對象 （即再也不可從Lua訪問的對象）。Lua使用的全部內存都受自動管理：字符串，表，用戶數據，函數，線程，內部結構等。

Lua實現了一個增量的標記和掃描收集器。它使用兩個數字來控制其垃圾收集週期：垃圾收集器暫停和垃圾收集器步驟倍增器。二者都使用百分點做爲單位（例如，值100表示​​內部值爲1）。

垃圾收集器暫停控制收集器在開始新循環以前等待的時間。較大的值使收集器不那麼具備攻擊性。小於100的值意味着收集器不會等待開始新的循環。值200表示收集器在開始新循環以前等待使用的總內存加倍。

垃圾收集器步驟乘法器控制收集器相對於內存分配的相對速度。較大的值會使收集器更具侵略性，但也會增長每一個增量步驟的大小。您不該該使用小於100的值，由於它們會使收集器太慢而且可能致使收集器永遠不會完成一個循環。默認值爲200，這意味着收集器以「兩倍」的內存分配速度運行。

若是將步長乘數設置爲一個很是大的數字（大於程序可能使用的最大字節數的10％），則收集器的行爲就像一個世界上的中止收集器。若是而後將暫停設置爲200，則收集器的行爲與舊的Lua版本相同，每次Lua將其內存使用量增長一倍時執行完整集合。

您能夠經過lua_gc在C或collectgarbageLua中調用來更改這些數字。您也可使用這些函數直接控制收集器（例如，中止並從新啓動它）。

2.5.1 - 垃圾收集Metamethods
您能夠爲表設置垃圾收集器元方法，並使用C API爲完整用戶數據設置（參見§2.4）。這些元方法也稱爲終結器。終結器容許您協調Lua的垃圾收集與外部資源管理（例如關閉文件，網絡或數據庫鏈接，或釋放您本身的內存）。

對於要在收集時完成的對象（表或用戶數據），必須將其標記爲最終肯定。在設置metatable時標記對象以進行最終化，而且metatable具備由字符串「 __gc」 索引的字段。請注意，若是在沒有__gc字段的狀況下設置元表，而後在元表中建立該字段，則不會標記該對象以進行最終化。

當標記的對象變爲垃圾時，垃圾收集器不會當即收集它。相反，Lua把它放在一個列表中。收集完成後，Lua會查看該列表。對於列表中的每一個對象，它檢查對象的__gcmetamethod：若是它是一個函數，Lua將該對象做爲其單個參數調用它; 若是metame方法不是函數，Lua就會忽略它。

在每一個垃圾收集週期結束時，對象的終結器按照與該週期中收集的對象被標記爲完成的相反順序進行調用; 也就是說，要調用的第一個終結器是與程序中最後標記的對象相關聯的終結器。每一個終結器的執行能夠在執行常規代碼期間的任什麼時候刻發生。

由於正在收集的對象仍然必須由終結器使用，因此該對象（以及只能經過它訪問的其餘對象）必須由Lua 復活。一般，這種復活是暫時的，而且在下一個垃圾收集週期中釋放對象存儲器。可是，若是終結器將對象存儲在某個全局位置（例如，全局變量），則復活是永久性的。此外，若是終結器再次標記最終化的終結對象，則將在下一個沒法訪問對象的循環中再次調用其終結器。在任何狀況下，僅在GC循環中釋放對象存儲器，其中對象不可到達且未標記爲完成。

當你關閉一個狀態（參見lua_close參考資料）時，Lua按照標記的相反順序調用標記爲完成的全部對象的終結符。若是任何終結器在該階段標記要收集的對象，則這些標記無效。

2.5.2 - 弱表
一個弱表是一個表，它的元素是 弱引用。垃圾收集器忽略弱引用。換句話說，若是對對象的惟一引用是弱引用，則垃圾收集器將收集該對象。

弱表能夠具備弱鍵，弱值或二者。具備弱值的表容許收集其值，但會阻止其鍵的收集。具備弱鍵和弱值的表容許收集鍵和值。在任何狀況下，若是收集了密鑰或值，則從表中刪除整個對。表的弱點__mode由其元表的字段控制 。若是該__mode字段是包含字符' k' 的字符串，則表中的鍵很弱。若是__mode包含' v'，則表中的值很弱。

具備弱鍵和強值的表也稱爲ephemeron表。在ephemeron表中，只有在其密鑰可訪問時，才認爲該值是可到達的。特別是，若是對鍵的惟一引用經過其值，則刪除該對。

表的弱點的任何變化可能僅在下一個收集週期生效。特別是，若是您將弱點更改成更強的模式，Lua可能會在更改生效以前從該表中收集一些項目。

僅從弱表中刪除具備顯式構造的對象。諸如數字和輕C函數之類的值不受垃圾收集的影響，所以不會從弱表中刪除（除非收集它們的相關值）。雖然字符串能夠進行垃圾回收，但它們沒有明確的構造，所以不會從弱表中刪除。

復活的對象（即，最終肯定的對象和僅經過最終肯定的對象可訪問的對象）在弱表中具備特殊行爲。它們在運行終結器以前從弱值中刪除，但在運行終結器後，實際釋放這些對象時，僅在下一個集合中從弱鍵中刪除它們。此行爲容許終結器經過弱表訪問與對象關聯的屬性。

若是在收集週期中復活的對象中存在弱表，則在下一個週期以前可能沒法正確清除它。

2.6 - 協同程序
Lua支持協程，也稱爲協做多線程。Lua中的協程表明一個獨立的執行線程。可是，與多線程系統中的線程不一樣，協程只經過顯式調用yield函數來暫停其執行。

你經過調用建立一個協同程序coroutine.create。它惟一的論點是一個函數，它是協程的主要功能。該create函數只建立一個新的協同程序並返回一個句柄（一個類型爲thread的對象）; 它沒有啓動協程。

你經過調用執行一個協同程序coroutine.resume。當你第一次調用時coroutine.resume，做爲第一個參數傳遞一個返回的線程coroutine.create，協同程序經過調用它的main函數來啓動它的執行。傳遞給的額外參數coroutine.resume做爲參數傳遞給該函數。協程開始運行後，它會一直運行直到它終止或產生。

協程能夠經過兩種方式終止其執行：一般，當其主函數返回時（顯式或隱式地，在最後一條指令以後）; 若是出現無保護錯誤，則異常。在正常終止的狀況下， coroutine.resume返回true，以及coroutine main函數返回的任何值。若是出現錯誤，則coroutine.resume返回false 加上錯誤對象。

一個協程經過調用產生coroutine.yield。當協程生成時，相應的coroutine.resume返回當即返回，即便在嵌套函數調用內發生了收益（也就是說，不在main函數中，而是在main函數直接或間接調用的函數中）。在yield的狀況下，coroutine.resume也返回true，加上傳遞給的任何值coroutine.yield。下次你恢復相同的協程時，它會從它產生的點繼續執行，並調用coroutine.yield返回傳遞給它的任何額外參數coroutine.resume。

就像coroutine.create，該coroutine.wrap函數還建立了一個協程，但它不是返回協程自己，而是返回一個函數，當被調用時，它恢復協程。傳遞給此函數的任何參數都做爲額外的參數coroutine.resume。 coroutine.wrap返回coroutine.resume除第一個（布爾錯誤代碼）以外的全部返回值。不一樣coroutine.resume， coroutine.wrap不會發現錯誤; 任何錯誤都會傳播給調用者。

做爲協同程序如何工做的示例，請考慮如下代碼：

功能foo（a）
print（「foo」，a）
return coroutine.yield（2 * a）
結束

co = coroutine.create（function（a，b）
print（「co-body」，a，b）
本地r = foo（a + 1）
print（「co-body」，r）
本地r，s = coroutine.yield（a + b，ab）
print（「co-body」，r，s）
返回b，「結束」
結束）

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」））
運行它時，它會產生如下輸出：

共同體1 10
foo 2
主要真實4
共同體
主要是真實的11-9
共同體xy
主要真正的10結束
主要的假不能恢復死coroutine
您還能夠建立和操做經過C API協同程序：看功能lua_newthread，lua_resume和lua_yield。

3 - 語言
本節描述了Lua的lexis，語法和語義。換句話說，本節描述了哪些令牌有效，它們如何組合以及它們的組合意味着什麼。

語言結構將使用一般的擴展BNF表示法來解釋，其中{ a }表示0或更多a，而[ a ]表示可選的a。非終端顯示爲非終端，關鍵字顯示爲kword，其餘終端符號顯示爲' = '。Lua的完整語法能夠在 本手冊末尾的§9中找到。

3.1 - 詞彙約定
Lua是一種自由形式的語言。它忽略了空格（包括新行）和詞法元素（標記）之間的註釋，除了名稱和關鍵字之間的分隔符。

Lua中的名稱 （也稱爲標識符）能夠是任何字母，數字和下劃線字符串，不以數字開頭而不是保留字。標識符用於命名變量，表字段和標籤。

如下關鍵字是保留的，不能用做名稱：

並打破其餘的結果
函數goto爲false，若是在
當地沒有或重複返回
而後真實，直到
Lua是一種區分大小寫的語言： and是一個保留字，但And它AND 是兩個不一樣的有效名稱。做爲慣例，程序應避免建立如下劃線開頭的名稱，後跟一個或多個大寫字母（例如_VERSION）。

如下字符串表示其餘標記：

+ - * /％^＃
＆〜| << >> //
==〜= <=> = <> =
（）{} [] ::
; ：，。......
甲短文本字符串 能夠經過匹配單引號或雙引號進行分隔，而且能夠包含下面的C狀的轉義序列：「 \a」（鐘形），「 \b」（退格），「 \f」（形式進料），「 \n」（換行）， ' \r'（回車），' \t'（水平標籤），' \v'（垂直標籤），' \\'（反斜槓），' \"'（引號[雙引號]）和' \''（撇號[單引號]）。反斜槓後跟換行符會在字符串中生成換行符。逃脫序列'\z'跳過如下白色空格字符，包括換行符; 將長文字字符串分解並縮進多行而不將新行和空格添加到字符串內容中特別有用。短文字字符串不能包含未轉義的換行符，也不能包含未造成有效轉義序列的轉義符。

咱們能夠經過其數值（包括嵌入的零）指定短文字字符串中的任何字節。這能夠經過轉義序列來完成，其中XX是正好兩個十六進制數字的序列，或者使用轉義序列，其中ddd是最多三個十進制數字的序列。（請注意，若是一個十進制轉義序列後跟一個數字，則必須使用正好三位數表示。） \xXX\ddd

能夠將Unicode字符的UTF-8編碼插入帶有轉義序列的文字字符串中 （請注意必需的括號），其中XXX是一個表示字符代碼點的一個或多個十六進制數字的序列。 \u{XXX}

也可使用長括號括起來的長格式來定義文字字符串。咱們將n級的開口長支架定義爲開口方括號，後跟n個等號後跟另外一個開口方括號。所以，寫入級別0 [[的開始長括號，將級別1的開始長括號寫爲[=[，依此類推。甲長括號被相似地定義; 例如，級別4的結束長括號寫爲 ]====]。一個長的文字從任何級別的開口長支架開始，並在同一級別的第一個關閉長支架處結束。它能夠包含除同一級別的右括號以外的任何文本。這種括號中的文字能夠運行多行，不解釋任何轉義序列，並忽略任何其餘級別的長括號。任何類型的行結束序列（回車符，換行符，回車後跟換行符，換行符後換行符）都會轉換爲簡單的換行符。

爲方便起見，當開頭長括號後面緊跟換行符時，換行符不包含在字符串中。例如，在使用ASCII的系統中（其中' a'編碼爲97，換行符編碼爲10，' 1'編碼爲49），下面的五個文字字符串表示相同的字符串：

a ='alo \ n123「'
a =「alo \ n123 \」「
a ='\ 97lo \ 10 \ 04923「'
a = [[alo
123" ]]
a = [== [
ALO
123" ] ==]
未受先前規則明確影響的文字字符串中的任何字節都表示自身。可是，Lua打開文件以在文本模式下進行解析，而且系統文件函數可能存在某些控制字符的問題。所以，將非文本數據表示爲帶有非文本字符的顯式轉義序列的帶引號的文字更安全。

甲數字常數（或標記）能夠與一個可選的小數部分和可選的小數指數被寫入，由字母「標記e」或「 E」。Lua也接受十六進制常量，以0x或開頭0X。十六進制常量也接受可選的小數部分加上可選的二進制指數，用字母' p'或' P' 標記。帶小數點或指數的數字常量表示浮點數; 不然，若是其值適合整數，則表示整數。有效整數常量的示例是

3 345 0xff 0xBEBADA
有效浮點常量的示例是

3.0 3.1416 314.16e-2 0.31416E1 34e1
0x0.1E 0xA23p-4 0X1.921FB54442D18P + 1
一個註釋開始用雙連字符（--）的字符串之外的任何地方。若是緊接着的文本--不是開頭長括號，則註釋是一個簡短的註釋，一直運行到行的結尾。不然，它是一個長註釋，直到相應的結束長括號。長註釋常常用於臨時禁用代碼。

3.2 - 變量
變量是存儲值的地方。Lua中有三種變量：全局變量，局部變量和表字段。

單個名稱能夠表示全局變量或局部變量（或函數的形式參數，它是一種特殊的局部變量）：

var :: = Name
名稱表示標識符，如§3.1中所定義。

除非明確聲明爲本地變量名稱，不然任何變量名稱都被假定爲全局變量名稱（參見§3.3.7）。局部變量是詞法範圍的：局部變量能夠經過其範圍內定義的函數自由訪問（參見§3.5）。

在第一次賦值給變量以前，它的值是nil。

方括號用於索引表：

var :: = prefixexp' [ 'exp' ] '
訪問表字段的含義能夠經過元表更改（參見§2.4）。

語法var.Name只是語法糖 var["Name"]：

var :: = prefixexp' 。' 名稱
對全局變量的訪問x 等同於_ENV.x。因爲編譯塊的方式， _ENV永遠不是全局名稱（參見§2.2）。

3.3 - 陳述
Lua支持幾乎常規的語句集，相似於Pascal或C中的語句。該集包括賦值，控制結構，函數調用和變量聲明。

3.3.1 - 塊
塊是一個語句列表，按順序執行：

block :: = {stat}
Lua 有空語句 ，容許您用分號分隔語句，用分號開始一個塊或按順序寫兩個分號：

stat :: =' ; 「
函數調用和賦值能夠以左括號開頭。這種可能性致使了Lua語法的模糊性。請考慮如下片斷：

a = b + c
（打印或io.write）（'完成'）
語法能夠經過兩種方式看到它：

a = b + c（print或io.write）（'done'）

a = b + c; （打印或io.write）（'完成'）
當前解析器老是以第一種方式看到這樣的結構，將開括號解釋爲調用參數的開始。爲避免這種歧義，最好始終在以括號開頭的分號語句以前：

;（打印或io.write）（'完成'）
能夠明確分隔塊以生成單個語句：

stat :: = do block end
顯式塊對於控制變量聲明的範圍頗有用。顯式塊有時也用於在另外一個塊的中間添加一個return語句（參見§3.3.4）。

3.3.2 - 大塊
Lua的編譯單元稱爲塊。從語法上講，塊只是一個塊：

chunk :: = block
Lua將一個塊做爲具備可變數量參數的匿名函數的主體處理（參見§3.4.11）。所以，塊能夠定義局部變量，接收參數和返回值。此外，這種匿名函數被編譯爲外部局部變量的範圍_ENV（見§2.2）。結果函數始終具備_ENV惟一的up值，即便它不使用該變量。

塊能夠存儲在宿主程序內的文件或字符串中。爲了執行一個塊，Lua首先加載它，將塊的代碼預編譯爲虛擬機的指令，而後Lua用虛擬機的解釋器執行編譯的代碼。

塊也能夠預編譯成二進制形式; 詳情請參閱程序luac和功能string.dump。源代碼和編譯形式的程序是能夠互換的; Lua會自動檢測文件類型並採起相應措施（請參閱參考資料load）。

3.3.3 - 分配
Lua容許多項任務。所以，賦值語法定義左側的變量列表和右側的表達式列表。兩個列表中的元素用逗號分隔：

stat :: = varlist' = 'explist
varlist :: = var {' ， 'var}
explist :: = exp {' ， 'exp}
表達式在§3.4中討論。

在賦值以前，將值列表調整爲變量列表的長度。若是值多於所需值，則會丟棄多餘的值。若是值少於所需值，則列表將根據須要擴展爲 nil。若是表達式列表以函數調用結束，則該調用返回的全部值在調整以前輸入值列表（除非將調用括在括號中;請參閱§3.4）。

賦值語句首先計算其全部表達式，而後才執行賦值。所以代碼

我= 3
我，a [i] = i + 1,20
設置a[3]爲20，不會影響，a[4] 由於i在a[i]分配以前評估（到3）。一樣，該行

x，y = y，x
的交流值x和y，和

x，y，z = y，z，x
週期性的置換的值x，y和z。

對全局名稱x = val 的賦值等同於賦值 _ENV.x = val（參見§2.2）。

表字段和全局變量（實際上也是表字段）的賦值的含義能夠經過元表更改（參見§2.4）。

3.3.4 - 控制結構
控制結構 if，while和repeat具備一般的含義和熟悉的語法：

stat :: = while exp do block end
stat :: = 重複阻止直到 exp
stat :: = if exp then block { elseif exp then block} [ else block] end
Lua還有一種for語句，有兩種形式（見§3.3.5）。

控制結構的條件表達式能夠返回任何值。這兩種假和零被認爲是假的。不一樣於nil和false的全部值都被認爲是真的（特別是，數字0和空字符串也是真的）。

在repeat - until循環中，內部塊不以until關鍵字結束，而是僅在條件以後。所以，條件能夠引用循環塊內聲明的局部變量。

將跳轉語句將程序控制的標籤。出於語法緣由，Lua中的標籤也被視爲語句：

stat :: = goto名稱
stat :: =標籤
label :: =' :: 'Name' :: '
標籤在定義它的整個塊中是可見的，除了嵌套塊內，其中定義了具備相同名稱的標籤並在嵌套函數內。只要goto沒有進入局部變量的範圍，它就能夠跳轉到任何可見標籤。

標籤和空語句稱爲void語句，由於它們不執行任何操做。

在休息的語句終止執行 ，同時，重複，或用於循環，跳到循環以後的下一條語句：

stat :: = break
甲休息結束該最內層循環。

該返回語句用來從一功能或一組塊（這是一個匿名功能）返回值。函數能夠返回多個值，所以return語句的語法是

stat :: = return [explist] [' ; 「]
在返回語句只能寫成塊的最後陳述。若是確實須要在塊的中間返回，則可使用顯式內部塊，如在習語中do return end，由於如今返回是其（內部）塊中的最後一個語句。

3.3.5 - 聲明
該對語句有兩種形式：一個數字和一個通用的。

數值爲同時控制變量經過算術級數運行循環重複的代碼塊。它具備如下語法：

stat :: = for Name' = 'exp' ， 'exp [' ， 'exp] do block end
從第一個exp的值開始重複 該塊的名稱，直到它經過第三個exp的步驟經過第二個exp。更確切地說，一個for語句就像

對於v = e1，e2，e3作阻止結束
至關於代碼：

作
本地變種，極限，步驟 = tonumber（E1），tonumber（E2），tonumber（E3）
若是不是（var和limit和step）則error（）end
var = var - step
雖然如此
var = var + step
if（step > = 0且var > limit）或（step <0和var < limit）而後
打破
結束
本地v = var
塊
結束
結束
請注意如下事項：

在循環開始以前，全部三個控制表達式僅被評估一次。它們都必須致使數字。
var,, limit和step是不可見的變量。此處顯示的名稱僅用於說明目的。
若是不存在第三表達式（步驟），則使用步驟1。
您可使用break和goto退出for循環。
循環變量v是循環體的局部變量。若是在循環後須要其值，請在退出循環以前將其分配給另外一個變量。
泛型for語句適用於函數，稱爲迭代器。在每次迭代時，調用迭代器函數以生成新值，在此新值爲nil時中止。泛型for循環具備如下語法：

STAT :: = 對於名稱列表中 explist 不阻止端
名稱列表:: = {名稱「 」名稱}
一個for語句就像

對於var_1，...，explist中的var_n執行塊結束
至關於代碼：

作
local f，s，var = explist
雖然如此
local var_1，...，var_n = f（s，var）
若是var_1 == nil則斷開結束
var = var_1
塊
結束
結束
請注意如下事項：

explist僅評估一次。其結果是迭代器函數，狀態和第一個迭代器變量的初始值。
f,, s和var是不可見的變量。這些名稱僅供參考。
您可使用break來退出for循環。
循環變量var_i是循環的局部變量; 以後，你不能用本身的價值觀爲目的。若是須要這些值，則在斷開或退出循環以前將它們分配給其餘變量。
3.3.6 - 函數調用做爲語句
爲了容許可能的反作用，函數調用能夠做爲語句執行：

stat :: = functioncall
在這種狀況下，全部返回的值都將被丟棄。函數調用在§3.4.10中解釋。

3.3.7 - 本地聲明
局部變量能夠在塊內的任何位置聲明。聲明能夠包括初始分配：

stat :: = local namelist [' = 'explist]
若是存在，初始賦值具備與多賦值相同的語義（參見§3.3.3）。不然，全部變量都用nil初始化。

塊也是一個塊（參見§3.3.2），所以局部變量能夠在任何顯式塊以外的塊中聲明。

局部變量的可見性規則在§3.5中解釋。

3.4 - 表達式
Lua中的基本表達式以下：

exp :: = prefixexp
exp :: = nil | 假 | 真正
exp :: =數字
exp :: = LiteralString
exp :: = functiondef
exp :: = tableconstructor
exp :: =' ... '
exp :: = exp binop exp
exp :: = unop exp
prefixexp :: = var | functioncall | ' （ 'exp' ） '
數字和文字字符串在§3.1中解釋; 變量在§3.2中解釋; 函數定義在§3.4.11中解釋; 函數調用在§3.4.10中解釋; 表構造函數在§3.4.9中解釋。Vararg表達式由三個點（' ...'）表示，只能在直接在vararg函數內部時使用; 它們在§3.4.11中解釋。

二元運算符包括算術運算符（參見§3.4.1），按位運算符（參見§3.4.2），關係運算符（參見§3.4.4），邏輯運算符（參見§3.4.5）和鏈接運算符（參見§） 3.4.6）。一元運算符包括一元減號（見§3.4.1），一元按位NOT（見§3.4.2），一元邏輯非（見§3.4.5）和一元長度運算符（見§3.4.7） 。

函數調用和vararg表達式均可能致使多個值。若是函數調用用做語句（參見§3.3.6），則其返回列表將調整爲零元素，從而丟棄全部返回的值。若是表達式用做表達式列表的最後一個（或惟一）元素，則不進行任何調整（除非表達式括在括號中）。在全部其餘上下文中，Lua將結果列表調整爲一個元素，要麼丟棄除第一個以外的全部值，要麼在沒有值時添加單個nil。

這裏有些例子：

f（） - 調整爲0結果
g（f（），x） - f（）調整爲1
g（x，f（）） - g獲得x加上f（）的全部結果
a，b，c = f（），x - f（）調整爲1結果（c變爲零）
a，b = ... - a獲得第一個vararg參數，b獲得
- 第二個（若是有的話，a和b均可覺得零）
- 沒有相應的vararg論點）

a，b，c = x，f（） - f（）調整爲2個結果
a，b，c = f（） - f（）調整爲3個結果
return f（） - 返回f（）的全部結果
return ... - 返回全部收到的vararg參數
return x，y，f（） - 返回x，y和f（）的全部結果
{f（）} - 建立一個包含f（）全部結果的列表
{...} - 建立一個包含全部vararg參數的列表
{f（），nil} - f（）調整爲1
括在括號中的任何表達式始終只生成一個值。所以，(f(x,y,z))即便f返回多個值， 也始終是單個值。（的值(f(x,y,z))是由所返回的第一值f 或者零，若是f沒有返回任何值。）

3.4.1 - 算術運算符
Lua支持如下算術運算符：

+：另外
-：減法
*：乘法
/：浮動師
//：地板師
%： modulo
^：取冪
-：一元減去
除了取冪和浮點除法以外，算術運算符的工做方式以下：若是兩個操做數都是整數，則操做在整數上執行，結果爲整數。不然，若是兩個操做數都是能夠轉換爲數字的數字或字符串（參見§3.4.3），那麼它們將轉換爲浮點數，操做按照一般的浮點運算規則（一般是IEEE 754標準）執行，結果是浮動。

Exponentiation和float division（/）老是將它們的操做數轉換爲浮點數，結果老是浮點數。Exponentiation使用ISO C函數pow，所以它也適用於非整數指數。

Floor division（//）是一個將商舍入負無窮大的分區，即其操做數的分區。

模數被定義爲將商舍入負無窮大（分層）的除法的餘數。

在整數運算中出現溢出的狀況下，根據二補碼算法的一般規則，全部運算都會迴繞。（換句話說，它們將與模數爲2 64的惟一可表示整數返回到數學結果。）

3.4.2 - 按位運算符
Lua支持如下按位運算符：

&：按位AND
|：按位OR
~：按位異或
>>：右轉
<<：左移
~：一元按位NOT
全部按位運算都將其操做數轉換爲整數（參見§3.4.3），對這些整數的全部位進行操做，併產生整數。

右移和左移都用零填充空位。負位移向另外一個方向移動; 絕對值等於或高於整數中的位數的位移致使零（由於全部位都被移出）。

3.4.3 - 強制和轉換
Lua在運行時提供某些類型和表示之間的一些自動轉換。按位運算符老是將浮點操做數轉換爲整數。Exponentiation和float除法老是將整數操做數轉換爲浮點數。應用於混合數字（整數和浮點數）的全部其餘算術運算將整數操做數轉換爲浮點數; 這被稱爲一般的規則。根據須要，C API還將整數轉換爲浮點數並將浮點數轉換爲整數。此外，字符串鏈接除了字符串以外還接受數字做爲參數。

每當有數字時，Lua也會將字符串轉換爲數字。

在從整數到浮點數的轉換中，若是整數值具備精確的表示形式，那麼就是結果。不然，轉換獲得最接近的較高或最接近的較低可表示值。這種轉換永遠不會失敗。

從float到integer的轉換檢查float是否具備整數的精確表示（即，float具備整數值，而且它在整數表示的範圍內）。若是是，則表示結果。不然，轉換失敗。

從字符串到數字的轉換以下：首先，按照語法和Lua詞法分析器的規則將字符串轉換爲整數或浮點數。（該字符串可能還有前導和尾隨空格以及符號。）而後，結果數（浮點數或整數）將轉換爲上下文所需的類型（浮點數或整數）（例如，強制轉換的操做）。

從字符串到數字的全部轉換都接受點和當前區域設置標記做爲基數字符。（然而，Lua lexer只接受一個點。）

從數字到字符串的轉換使用未指定的人類可讀格式。要徹底控制數字如何轉換爲字符串，請使用format字符串庫中的函數（請參閱參考資料string.format）。

3.4.4 - 關係運算符
Lua支持如下關係運算符：

==：平等
~=：不平等
<：不到
>：大於
<=：更少或相等
>=：更大或更平等
這些運算符老是致使錯誤或真實。

Equality（==）首先比較其操做數的類型。若是類型不一樣，則結果爲false。不然，比較操做數的值。字符串以明顯的方式進行比較。若是它們表示相同的數學值，則數字相等。

經過引用比較表，userdata和線程：只有當兩個對象是同一個對象時才認爲它們是相等的。每次建立新對象（表，用戶數據或線程）時，此新對象都不一樣於之前存在的任何對象。閉包老是等於它本身。具備任何可檢測差別（不一樣行爲，不一樣定義）的閉包老是不一樣的。在不一樣時間建立但沒有可檢測到的差別的閉包能夠被分類爲相同或不一樣（取決於內部緩存細節）。

您可使用「eq」元方法更改Lua比較表和userdata的方式（參見§2.4）。

等式比較不會將字符串轉換爲數字，反之亦然。所以，"0"==0計算結果爲假，並t[0]和t["0"]在表中表示不一樣的條目。

運算符~=剛好是對equality（==）的否認。

訂單操做符的工做方式以下。若是兩個參數都是數字，則根據它們的數學值（無論它們的子類型）進行比較。不然，若是兩個參數都是字符串，則根據當前區域設置比較它們的值。不然，Lua會嘗試調用「lt」或「le」元方法（參見§2.4）。比較a > b被翻譯成b < a 並被a >= b翻譯成b <= a。

遵循IEEE 754標準，NaN被認爲既不小於，也不等於，也不大於任何值（包括其自己）。

3.4.5 - 邏輯運算符
Lua中的邏輯運算符是 和，或者是，而不是。與控制結構同樣（參見§3.3.4），全部邏輯運算符都將false和nil視爲false，將其餘任何內容視爲true。

否認運算符並不老是返回false或true。若是此值爲false或nil，則爲鏈接運算符並返回其第一個參數; 不然，而且返回第二個參數。若是此值與nil和false不一樣，則析取運算符或返回其第一個參數; 不然，或返回其第二個參數。既與和或使用短路評價; 也就是說，僅在必要時評估第二個操做數。這裏有些例子：

10或20 - > 10
10或錯誤（） - > 10
零或「a」 - >「a」
零和10 - >零
false和error（） - > false
假和零 - >假
false或nil - > nil
10和20 - > 20
（在本手冊中， -->表示前面表達式的結果。）

3.4.6 - 鏈接
Lua中的字符串鏈接運算符由兩個點（' ..'）表示。若是兩個操做數都是字符串或數字，則它們將根據§3.4.3中描述的規則轉換爲字符串。不然，__concat調用metamethod（參見§2.4）。

3.4.7 - 長度算子
長度運算符由一元前綴運算符表示#。

字符串的長度是它的字節數（也就是每一個字符是一個字節時字符串長度的一般含義）。

應用於表的長度運算符返回該表中的邊框。表中的邊框t是知足如下條件的任何天然數：

（border == 0或t [border]〜= nil）和t [border + 1] == nil
換句話說，邊框是表中的任何（天然）索引，其中非零值後跟零值（或者當索引1爲零時爲零）。

只有一個邊框的表稱爲序列。例如，該表{10, 20, 30, 40, 50}是一個序列，由於它只有一個邊框（5）。該表{10, 20, 30, nil, 50}有兩個邊框（3和5），所以它不是一個序列。該表{nil, 20, 30, nil, nil, 60, nil} 有三個邊框（0,3和6），因此它也不是一個序列。該表{}是帶邊框0的序列。請注意，非天然鍵不會干擾表是否爲序列。

什麼時候t是序列， #t返回其惟一的邊界，這對應於序列長度的直觀概念。當t不是序列時， #t能夠返回其任何邊界。（確切的一個取決於表的內部表示的細節，而這又取決於表的填充方式和非數字鍵的內存地址。）

表的長度的計算具備保證的最差時間O（log n），其中n是表中最大的天然鍵。

程序能夠經過元方法修改長度運算符對任何值的行爲，可是字符串能夠經過元方法__len修改（參見§2.4）。

3.4.8 - 優先順序
Lua中的運算符優先級遵循下表，從較低優先級到較高優先級：

要麼
和
<> <=> =〜= ==
|
〜
＆
<< >>
..
+ -
* / //％
一元運算符（不是＃ - 〜）
^
像往常同樣，您可使用括號來更改表達式的優先級。鏈接（' ..'）和取冪（' ^'）運算符是右關聯的。全部其餘二元運算符都是左關聯的。

3.4.9 - 表構造函數
表構造函數是建立表的表達式。每次評估構造函數時，都會建立一個新表。構造函數可用於建立空表或建立表並初始化其某些字段。構造函數的通常語法是

tableconstructor :: =' { '[fieldlist]' } '
fieldlist :: = field {fieldsep field} [fieldsep]
field :: =' [ 'exp' ] '' = 'exp | 名稱' = 'exp | EXP
fieldsep :: =' ， '| ' ; 「
表單的每一個字段都會[exp1] = exp2向新表添加一個帶鍵exp1和值的條目exp2。表格的字段name = exp至關於 ["name"] = exp。最後，表單的字段exp等效於 [i] = exp，其中i以1開頭的連續整數。其餘格式的字段不影響此計數。例如，

a = {[f（1）] = g; 「x」，「y」; x = 1，f（x），[30] = 23; 45}
至關於

作
本地t = {}
t [f（1）] = g
t [1] =「x」 - 第1次曝光
t [2] =「y」 - 第二次曝光
tx = 1 - t [「x」] = 1
t [3] = f（x） - 第3個exp
t [30] = 23
t [4] = 45 - 第4次exp
a = t
結束
構造函數中賦值的順序未定義。（此順序僅在有重複鍵時纔有意義。）

若是列表中的最後一個字段具備表單exp ，而且表達式是函數調用或vararg表達式，則此表達式返回的全部值將連續輸入列表（請參見§3.4.10）。

字段列表能夠有一個可選的尾隨分隔符，以方便機器生成的代碼。

3.4.10 - 函數調用
Lua中的函數調用具備如下語法：

functioncall :: = prefixexp args
在函數調用中，首先計算prefixexp和args。若是prefixexp的值具備type 函數，則使用給定的參數調用此函數。不然，調用prefixexp「call」元方法，將prefixexp的值做爲第一個參數，後跟原始調用參數（參見§2.4）。

表格

functioncall :: = prefixexp' ： '名稱args
能夠用來稱呼「方法」。一個調用 是語法糖，除了只評估一次。 v:name(args)v.name(v,args)v

參數具備如下語法：

args :: =' （ '[explist]' ） '
args :: = tableconstructor
args :: = LiteralString
在調用以前計算全部參數表達式。形式的調用是語法糖; 也就是說，參數列表是一個新表。形式 （或或）的調用是語法糖; 也就是說，參數列表是單個文字字符串。 f{fields}f({fields})f'string'f"string"f[[string]]f('string')

表單調用稱爲尾調用。Lua實現了正確的尾調用 （或正確的尾遞歸）：在尾調用中，被調用函數重用調用函數的堆棧條目。所以，程序能夠執行的嵌套尾調用的數量沒有限制。可是，尾調用會刪除有關調用函數的全部調試信息。請注意，尾調用只發生在特定的語法中，其中返回只有一個函數調用做爲參數; 這種語法使調用函數徹底返回被調用函數的返回值。所以，如下示例都不是尾調用： return functioncall

return（f（x）） - 結果調整爲1
返回2 * f（x）
return x，f（x） - 其餘結果
F（X）; 返回 - 結果丟棄
返回x或f（x） - 結果調整爲1
3.4.11 - 功能定義
函數定義的語法是

functiondef :: = function funcbody
funcbody :: =' （ '[parlist]' ） '阻止結束
如下語法糖簡化了函數定義：

stat :: = function funcname funcbody
stat :: = local 函數名稱funcbody
funcname :: = Name {' 。'姓名} [' ： '姓名]
該聲明

函數f（）正文結束
翻譯成

f = function（）正文結束
該聲明

函數tabcf（）正文結束
翻譯成

tabcf = function（）正文結束
該聲明

局部函數f（）體端
翻譯成

當地的f; f = function（）正文結束
不要

局部f = function（）體端
（這僅在函數體包含對的引用時纔有所不一樣f。）

函數定義是可執行表達式，其值具備類型函數。當Lua預編譯一個塊時，它的全部函數體也都被預編譯。而後，每當Lua執行函數定義時，該函數被實例化（或關閉）。此函數實例（或閉包）是表達式的最終值。

參數充當使用參數值初始化的局部變量：

parlist :: = namelist [' ， '' ... '] | ' ... '
調用函數時，參數列表將調整爲參數列表的長度，除非該函數是vararg函數，該...參數由參數列表末尾的三個點（' '）表示。vararg函數不調整其參數列表; 相反，它收集全部額外的參數，並經過vararg表達式將它們提供給函數，也寫成三個點。此表達式的值是全部實際額外參數的列表，相似於具備多個結果的函數。若是在另外一個表達式內或表達式列表的中間使用vararg表達式，則將其返回列表調整爲一個元素。若是表達式用做表達式列表的最後一個元素，則不進行任何調整（除非最後一個表達式括在括號中）。

例如，請考慮如下定義：

函數f（a，b）結束
函數g（a，b，...）結束
函數r（）返回1,2,3結束
而後，咱們從參數到參數以及vararg表達式進行如下映射：

調用參數

f（3）a = 3，b =零
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，... - >（沒有）
g（3,4）a = 3，b = 4，... - >（無）
g（3,4,5,8）a = 3，b = 4，...... - > 5 8
g（5，r（））a = 5，b = 1，...... - > 2 3
使用return語句返回結果（參見§3.3.4）。若是控件到達函數的末尾而沒有遇到return語句，則函數返回時沒有結果。

函數可能返回的值的數量存在系統相關限制。此限制保證大於1000。

在結腸語法用於定義方法，即，具備一個隱含的額外的參數的功能self。所以，聲明

功能tabc：f（params）正文結束
是語法糖

tabcf = function（self，params）body end
3.5 - 可見性規則
Lua是一種詞彙範圍的語言。局部變量的範圍從其聲明後的第一個語句開始，一直持續到包含聲明的最內層塊的最後一個非void語句。請考慮如下示例：

x = 10 - 全局變量
作 - 新塊
local x = x - new'x'，值爲10
print（x） - > 10
x = x + 1
作 - 另外一個塊
局部x = x + 1 - 另外一個'x'
print（x） - > 12
結束
print（x） - > 11
結束
print（x） - > 10（全球一個）
請注意，在聲明中local x = x，聲明的新x聲明還沒有在範圍內，所以第二個x引用外部變量。

因爲詞法範圍規則，局部變量能夠由其範圍內定義的函數自由訪問。內部函數使用的局部變量在內部函數內稱爲upvalue或外部局部變量。

請注意，每次執行本地語句都會定義新的局部變量。請考慮如下示例：

a = {}
本地x = 20
對於i = 1,10作
本地y = 0
a [i] = function（）y = y + 1; 返回x + y結束
結束
循環建立十個閉包（即匿名函數的十個實例）。這些閉包中的每個都使用不一樣的y變量，而它們都共享相同的變量x。

4 - 應用程序接口
本節介紹Lua的C API，即主機程序可用於與Lua通訊的C函數集。全部API函數以及相關類型和常量都在頭文件中聲明lua.h。

即便咱們使用術語「函數」，API中的任何工具也能夠做爲宏提供。除非另有說明，不然全部這些宏都只使用它們的每一個參數一次（除了第一個參數，它老是一個Lua狀態），所以不會產生任何隱藏的反作用。

與大多數C庫同樣，Lua API函數不檢查其參數的有效性或一致性。可是，您能夠經過使用LUA_USE_APICHECK定義的宏編譯Lua來更改此行爲。

Lua庫是徹底可重入的：它沒有全局變量。它將所需的全部信息保存在稱爲Lua狀態的動態結構中。

每一個Lua狀態具備一個或多個線程，其對應於獨立的協做執行線。類型lua_State（儘管名稱）指的是一個線程。（間接地，經過線程，它還指向與線程關聯的Lua狀態。）

必須將指向線程的指針做爲第一個參數傳遞給庫中的每一個函數，除了lua_newstate，它從頭建立一個Lua狀態並返回一個指向新狀態的主線程的指針。

4.1 - 堆棧
Lua使用虛擬堆棧向C傳遞值。此堆棧中的每一個元素表示Lua值（nil，number，string等）。API中的函數能夠經過它們接收的Lua狀態參數訪問此堆棧。

每當Lua調用C時，被調用的函數將得到一個新的堆棧，該堆棧獨立於先前的堆棧和仍處於活動狀態的C函數堆棧。該堆棧最初包含C函數的任何參數，它是C函數能夠存儲臨時Lua值的地方，而且必須將其結果推送回調用者（請參閱參考資料lua_CFunction）。

爲方便起見，API中的大多數查詢操做都不遵循嚴格的堆棧規則。相反，它們能夠經過使用索引引用堆棧中的任何元素：正索引表示絕對堆棧位置（從1開始）; 負索引表示相對於堆棧頂部的偏移量。更具體地說，若是堆棧有n個元素，則索引1表示第一個元素（即，首先被壓入堆棧的元素），索引 n表示最後一個元素; index -1也表示最後一個元素（即頂部的元素），index -n表示第一個元素。

4.2 - 堆棧大小
當您與Lua API交互時，您有責任確保一致性。特別是， 您負責控制堆棧溢出。您可使用該函數lua_checkstack 確保堆棧有足夠的空間來推送新元素。

每當Lua調用C時，它確保堆棧具備至少LUA_MINSTACK額外插槽的空間。 LUA_MINSTACK定義爲20，所以一般您沒必要擔憂堆棧空間，除非您的代碼具備將元素推送到堆棧的循環。

當你在沒有固定數量結果的狀況下調用Lua函數時（參見lua_call參考資料），Lua確保堆棧有足夠的空間容納全部結果，但它不能確保任何額外的空間。因此，在這樣的調用以後推送堆棧中的任何東西以前你應該使用lua_checkstack。

4.3 - 有效和可接受的指數
接收堆棧索引的API中的任何函數僅適用於有效索引或可接受的索引。

甲有效的索引是指存儲可修改的Lua值的位置的索引。它包含1和堆棧頂部（1 ≤ abs(index) ≤ top）加上僞索引之間的堆棧索引，它們表示C代碼可訪問但不在堆棧中的某些位置。僞索引用於訪問註冊表（參見§4.5）和C函數的upvalues（參見§4.4）。

可使用可接受的索引調用不須要特定可變位置但僅須要值（例如，查詢函數）的函數。一個能夠接受的指數能夠是任何有效指標，但它也能夠分配給棧的空間內棧頂以後的任何積極的指標，也就是指數高達堆棧大小。（注意0毫不是可接受的索引。）除非另有說明，不然A​​PI中的函數使用可接受的索引。

可接受的索引用於在查詢堆棧時避免對堆棧頂部進行額外測試。例如，C函數能夠查詢其第三個參數，而無需首先檢查是否存在第三個參數，即無需檢查3是否爲有效索引。

對於可使用可接受索引調用的函數，任何無效索引都被視爲包含虛擬類型的值LUA_TNONE，其行爲相似於nil值。

4.4 - C閉包
當建立C函數時，能夠將一些值與它相關聯，從而建立一個C閉包 （參見參考資料lua_pushcclosure）; 這些值稱爲upvalues，只要調用它，函數就能夠訪問它們。

每當調用C函數時，其upvalues都位於特定的僞索引處。這些僞指數由宏產生 lua_upvalueindex。與函數關聯的第一個upvalue是索引 lua_upvalueindex(1)，依此類推。任何訪問，其中n大於當前函數的upvalues的數量（但不大於256，這是一個加上閉包中upvalues的最大數量），產生一個可接受但無效的索引。 lua_upvalueindex(n)

4.5 - 註冊表
Lua提供了一個註冊表，一個預約義的表，任何C代碼均可以使用它來存儲它須要存儲的任何Lua值。註冊表始終位於僞索引處 LUA_REGISTRYINDEX。任何C庫均可以將數據存儲到此表中，但必須注意選擇與其餘庫使用的鍵不一樣的鍵，以免衝突。一般，您應該使用包含您的庫名稱的字符串做爲鍵，或者使用代碼中具備C對象地址的輕用戶數據，或者您的代碼建立的任何Lua對象。與變量名同樣，如下劃線後跟大寫字母開頭的字符串鍵保留給Lua。

註冊表中的整數鍵由引用機制（請參閱參考資料luaL_ref）和某些預約義值使用。所以，整數鍵不得用於其餘目的。

當您建立新的Lua狀態時，其註冊表會附帶一些預約義的值。這些預約義值使用定義爲常量的整數鍵索引lua.h。定義瞭如下常量：

LUA_RIDX_MAINTHREAD：在此索引處，註冊表具備狀態的主線程。（主線程是與州一塊兒建立的線程。）
LUA_RIDX_GLOBALS：在此索引處，註冊表具備全局環境。
4.6 - C中的錯誤處理
在內部，Lua使用C longjmp工具來處理錯誤。（若是你將它編譯爲C ++，Lua將使用異常; LUAI_THROW在源代碼中搜索詳細信息。）當Lua面臨任何錯誤（例如內存分配錯誤或類型錯誤）時，它會引起錯誤; 也就是說，它會跳遠。一個受保護的環境使用setjmp 設置一個恢復點; 任何錯誤都會跳轉到最近的活動恢復點。

在C函數內部，您能夠經過調用引起錯誤lua_error。

API中的大多數函數都會引起錯誤，例如因爲內存分配錯誤。每一個函數的文檔都指出它是否會引起錯誤。

若是在任何受保護的環境以外發生錯誤，Lua會調用一個panic函數（請參閱參考資料lua_atpanic）而後調用abort，從而退出宿主應用程序。您的恐慌功能能夠經過永不返回來避免這種退出（例如，在Lua外部進行長跳轉到您本身的恢復點）。

顧名思義，恐慌功能是最後的手段。程序應該避免它。做爲通常規則，當Lua使用Lua狀態調用C函數時，它能夠在Lua狀態上執行任何操做，由於它應該已經受到保護。可是，當C代碼在其餘Lua狀態上運行時（例如，函數的Lua參數，存儲在註冊表中的Lua狀態或結果lua_newthread），它應該僅在不會引起錯誤的API調用中使用它們。

panic函數就像是一個消息處理程序同樣運行（參見§2.3）; 特別是，錯誤對象位於堆棧的頂部。可是，沒法保證堆棧空間。要在堆棧上推送任何內容，恐慌功能必須首先檢查可用空間（參見§4.2）。

4.7 - 處理C中的收益率
在內部，Lua使用C longjmp工具來產生協程。所以，若是C函數foo調用API函數而且此API函數經過調用另外一個產生的函數直接或間接地產生，則Lua不能再返回foo，由於longjmp它從C堆棧中移除了它的幀。

爲了不這樣的問題，提出的Lua每當它試圖跨越API調用來產生，除了三個功能錯誤： lua_yieldk，lua_callk，和lua_pcallk。全部這些函數都接收一個continuation函數 （做爲一個名爲的參數k），以便在yield以後繼續執行。

咱們須要設置一些術語來解釋延續。咱們有一個從Lua調用的C函數，咱們將調用原始函數。而後，這個原始函數調用C API中的三個函數之一，咱們將調用callee函數，而後生成當前線程。（這可能發生在被調用函數是lua_yieldk，或者當被調用函數是lua_callk或者lua_pcallk 而且由它們調用的函數產生時）。

假設正在運行的線程在執行被調用函數時產生。線程恢復後，最終將完成運行被調用函數。可是，被調用函數沒法返回到原始函數，由於它在C堆棧中的幀被yield損壞。相反，Lua調用一個continuation函數，它做爲被調用函數的參數給出。顧名思義，延續函數應該繼續原始函數的任務。

做爲說明，請考慮如下功能：

int original_function（lua_State * L）{
... / *代碼1 * /
status = lua_pcall（L，n，m，h）; / *調用Lua * /
... / *代碼2 * /
}
如今咱們想讓Lua代碼運行lua_pcall獲得。首先，咱們能夠像這樣重寫咱們的函數：

int k（lua_State * L，int status，lua_KContext ctx）{
... / *代碼2 * /
}

int original_function（lua_State * L）{
... / *代碼1 * /
返回k（L，lua_pcall（L，n，m，h），ctx）;
}
在上面的代碼中，new函數k是一個 continuation函數（帶有類型lua_KFunction），它應該完成調用後原始函數所作的全部工做lua_pcall。如今，咱們必須通知Lua，k若是執行的Lua代碼lua_pcall以某種方式被中斷（錯誤或讓步），它必須調用，因此咱們在這裏重寫代碼，替換lua_pcall爲lua_pcallk：

int original_function（lua_State * L）{
... / *代碼1 * /
返回k（L，lua_pcallk（L，n，m，h，ctx2，k），ctx1）;
}
注意對continuation的外部顯式調用：Lua僅在須要時調用continuation，即出現錯誤或在yield以後恢復。若是被調用函數正常返回而沒有屈服， lua_pcallk（和lua_callk）也將正常返回。（固然，在這種狀況下，您能夠直接在原始函數內部執行相同的工做，而不是調用延續。）

除了Lua狀態以外，continuation函數還有另外兩個參數：調用的最終狀態加上ctx最初傳遞給的上下文值（）lua_pcallk。（Lua不使用此上下文值;它只將此值從原始函數傳遞給continuation函數。）由於lua_pcallk，狀態是將返回的相同值lua_pcallk，除了它是LUA_YIELD在yield以後執行時（而不是的LUA_OK）。對於lua_yieldk和lua_callk，狀態老是LUA_YIELD在Lua調用延續時。（對於這兩個函數，Lua不會在出現錯誤時調用continuation，由於它們不會處理錯誤。）一樣，在使用時lua_callk，應該使用LUA_OKstatus做爲continuation函數。（對於lua_yieldk直接調用continuation函數沒有多大意義，由於lua_yieldk一般不會返回。）

Lua將延續函數視爲原始函數。continuation函數從原始函數接收相同的Lua堆棧，處於與被調用函數返回時相同的狀態。（例如，在lua_callk函數及其參數從堆棧中刪除並替換爲調用的結果以後）。它也具備相同的upvalues。不管它返回什麼都由Lua處理，就好像它是原始函數的返回同樣。

4.8 - 功能和類型
這裏咱們按字母順序列出C API中的全部函數和類型。每一個函數都有一個這樣的指標： [ - o，+ p，x ]

第一個字段o是函數從堆棧彈出的元素數量。第二個字段p是函數推入堆棧的元素數量。（任何函數在彈出其參數後老是推送其結果。）表單中的字段x|y表示函數能夠推送（或彈出） x或y元素，具體取決於具體狀況; 詢問標記' ?'意味着咱們不能經過僅查看其參數來知道函數彈出/推送的元素數量（例如，它們可能取決於堆棧上的內容）。第三個字段x告訴函數是否可能引起錯誤：' -'表示函數從不引起任何錯誤; ' m'表示該函數可能會引起內存__gc不足錯誤和運行metamethod的錯誤; 「e'表示函數可能引起任何錯誤（它能夠直接或經過元方法運行任意Lua代碼）; ' v'表示該函數可能故意引起錯誤。

lua_absindex
[-0，+ 0， - ]
int lua_absindex（lua_State * L，int idx）;
將可接受的索引idx 轉換爲等效的絕對索引（即，不依賴於堆棧頂部的索引）。

lua_Alloc
typedef void *（* lua_Alloc）（void * ud，
void * ptr，
size_t osize，
size_t nsize）;
Lua使用的內存分配函數的類型。分配器功能必須提供相似realloc但不徹底相同的功能。它的參數是 ud，傳遞給一個不透明的指針lua_newstate; ptr，指向正在分配/從新分配/釋放的塊的指針; osize，塊的原始大小或關於正在分配的內容的一些代碼; 而且nsize，塊的新大小。

若是ptr不是NULL， osize則指向塊的大小ptr，即分配或從新分配時給定的大小。

若是ptr是NULL， osize編碼Lua是分配類型的對象。 osize是任何的 LUA_TSTRING，LUA_TTABLE，LUA_TFUNCTION， LUA_TUSERDATA，或LUA_TTHREAD當（且僅當）Lua是建立該類型的新對象。什麼osize是其餘值，Lua正在爲其餘東西分配內存。

Lua從分配器函數中假定如下行爲：

當nsize爲零時，分配器必須表現得像free 並返回NULL。

當nsize不爲零時，分配器必須表現得像realloc。NULL 當且僅當它不能知足請求時，分配器才返回。Lua假設分配器永遠不會失敗 osize >= nsize。

這是分配器功能的簡單實現。它在輔助庫中使用luaL_newstate。

static void * l_alloc（void * ud，void * ptr，size_t osize，
size_t nsize）{
（空隙）UD; （空隙）osize; /* 未曾用過 */
if（nsize == 0）{
免費（PTR）;
返回NULL;
}
其餘
return realloc（ptr，nsize）;
}
請注意，標準C確保free(NULL)沒有效果， realloc(NULL,size)而且至關於malloc(size)。此代碼假定realloc縮小塊時不會失敗。（雖然標準C不能確保這種行爲，但它彷佛是一個安全的假設。）

lua_arith
[ - （2 | 1），+ 1，e ]
void lua_arith（lua_State * L，int op）;
對堆棧頂部的兩個值（或者在否認的狀況下爲一個值）執行算術或按位運算，頂部的值是第二個操做數，彈出這些值，並推送操做的結果。該函數遵循相應Lua運算符的語義（也就是說，它能夠調用metamethods）。

值op必須是如下常量之一：

LUA_OPADD：執行加法（+）
LUA_OPSUB：執行減法（-）
LUA_OPMUL：執行乘法（*）
LUA_OPDIV：執行浮動除法（/）
LUA_OPIDIV：執行樓層劃分（//）
LUA_OPMOD：執行modulo（%）
LUA_OPPOW：執行取冪（^）
LUA_OPUNM：執行數學否認（一元-）
LUA_OPBNOT：按位執行NOT（~）
LUA_OPBAND：執行按位AND（&）
LUA_OPBOR：執行按位OR（|）
LUA_OPBXOR：執行按位異或（~）
LUA_OPSHL：執行左移（<<）
LUA_OPSHR：執行右移（>>）
lua_atpanic
[-0，+ 0， - ]
lua_CFunction lua_atpanic（lua_State * L，lua_CFunction panicf）;
設置新的恐慌功能並返回舊的功能（參見§4.6）。

lua_call
[ - （nargs + 1），+ nresults，e ]
void lua_call（lua_State * L，int nargs，int nresults）;
調用一個函數。

要調用函數，必須使用如下協議：首先，要調用的函數被壓入堆棧; 而後，函數的參數按直接順序推送; 也就是說，首先推送第一個參數。最後你打電話lua_call; nargs是您推入堆棧的參數數量。調用函數時，全部參數和函數值都從堆棧中彈出。函數返回時，函數結果被壓入堆棧。nresults除非nresults是，不然將結果數量調整爲LUA_MULTRET。在這種狀況下，推送該函數的全部結果; Lua注意返回的值適合堆棧空間，但它不能確保堆棧中有任何額外的空間。函數結果按直接順序壓入堆棧（第一個結果先被推送），所以在調用以後，最後一個結果位於堆棧頂部。

被調用函數內部的任何錯誤都會向上傳播（帶有a longjmp）。

如下示例顯示了宿主程序如何執行與此Lua代碼等效的操做：

a = f（「how」，tx，14）
這是在C：

lua_getglobal（L，「f」）; / *函數被調用* /
lua_pushliteral（L，「how」）; / *第一個參數* /
lua_getglobal（L，「t」）; / *要索引的表* /
lua_getfield（L，-1，「x」）; / *推送結果tx（2nd arg）* /
lua_remove（L，-2）; / *從堆棧中刪除't'* /
lua_pushinteger（L，14）; / *第三個參數* /
lua_call（L，3,1）; / *用3個參數和1個結果調用'f'* /
lua_setglobal（L，「a」）; / *設置全局'a'* /
請注意，上面的代碼是平衡的：在其末尾，堆棧恢復到其原始配置。這被認爲是很好的編程實踐。

lua_callk
[ - （nargs + 1），+ nresults，e ]
void lua_callk（lua_State * L，
int nargs，
結果，
lua_KContext ctx，
lua_KFunction k）;
此函數的行爲與此相似lua_call，但容許被調用的函數產生（參見§4.7）。

lua_CFunction
typedef int（* lua_CFunction）（lua_State * L）;
輸入C函數。

爲了與Lua正確通訊，C函數必須使用如下協議，該協議定義參數和結果的傳遞方式：C函數以直接順序從其堆棧中的Lua接收其參數（首先推送第一個參數）。所以，當函數啓動時， lua_gettop(L)返回函數接收的參數數量。第一個參數（若是有）在索引1處，其最後一個參數在索引處lua_gettop(L)。要將值返回到Lua，C函數只是按順序將它們推入堆棧（首先推送第一個結果），而後返回結果數。Lua將正確地丟棄結果下方堆棧中的任何其餘值。像Lua函數同樣，Lua調用的C函數也能夠返回許多結果。

例如，如下函數接收可變數量的數字參數並返回它們的平均值及其總和：

static int foo（lua_State * L）{
int n = lua_gettop（L）; / *參數數量* /
lua_Number sum = 0.0;
int i;
for（i = 1; i <= n; i ++）{
if（！lua_isnumber（L，i））{
lua_pushliteral（L，「不正確的參數」）;
lua_error（L）;
}
sum + = lua_tonumber（L，i）;
}
lua_pushnumber（L，sum / n）; / *第一個結果* /
lua_pushnumber（L，sum）; / *第二個結果* /
返回2; / *結果數量* /
}
lua_checkstack
[-0，+ 0， - ]
int lua_checkstack（lua_State * L，int n）;
確保堆棧具備至少n額外插槽的空間（也就是說，您能夠安全地將n值推入其中）。若是它沒法知足請求，則返回false，由於它會致使堆棧大於固定的最大大小（一般至少有幾千個元素），或者由於它沒法爲額外空間分配內存。這個函數永遠不會縮小堆棧; 若是堆棧已經有額外插槽的空間，則保持不變。

lua_close
[-0，+ 0， - ]
void lua_close（lua_State * L）;
銷燬給定Lua狀態中的全部對象（調用相應的垃圾收集元方法，若是有的話）並釋放此狀態使用的全部動態內存。在多個平臺中，您可能不須要調用此函數，由於全部資源在宿主程序結束時天然釋放。另外一方面，建立多個狀態的長時間運行的程序（例如守護進程或Web服務器）可能須要在不須要時當即關閉狀態。

lua_compare
[-0，+ 0，e ]
int lua_compare（lua_State * L，int index1，int index2，int op）;
比較兩個Lua值。若是索引處的值index1知足op 與索引處的值進行比較時返回1 index2，則遵循相應Lua運算符的語義（即，它能夠調用metamethods）。不然返回0.若是任何索引無效，則返回0。

值op必須是如下常量之一：

LUA_OPEQ：比較等於（==）
LUA_OPLT：比較小於（<）
LUA_OPLE：比較小於或等於（<=）
lua_concat
[-n，+ 1，e ]
void lua_concat（lua_State * L，int n）;
鏈接n堆棧頂部的值，彈出它們，並將結果保留在頂部。若是n 爲1，則結果是堆棧上的單個值（即函數不執行任何操做）; 若是n爲0，則結果爲空字符串。鏈接是按照Lua的一般語義執行的（參見§3.4.6）。

lua_copy
[-0，+ 0， - ]
void lua_copy（lua_State * L，int fromidx，int toidx）;
將index處的元素複製fromidx 到有效索引中toidx，替換該位置的值。其餘位置的值不受影響。

lua_createtable
[-0，+ 1，m ]
void lua_createtable（lua_State * L，int narr，int nrec）;
建立一個新的空表並將其推入堆棧。參數narr是表格將做爲序列具備多少元素的提示; 參數nrec是表格將包含多少其餘元素的提示。Lua可使用這些提示爲新表預分配內存。當您事先知道該表將包含多少元素時，此預分配對性能頗有用。不然你可使用該功能lua_newtable。

lua_dump
[-0，+ 0， - ]
int lua_dump（lua_State * L，
lua_Writer做家，
無效*數據，
int strip）;
將函數轉儲爲二進制塊。在堆棧頂部接收Lua函數並生成一個二進制塊，若是再次加載，則會產生與轉儲的函數等效的函數。當它生成塊的一部分時， lua_dump調用函數writer（參見lua_Writer）用給定的data 來寫它們。

若是strip爲true，則二進制表示可能不包括有關該函數的全部調試信息，以節省空間。

返回的值是上次調用writer時返回的錯誤代碼; 0表示沒有錯誤。

此函數不會從堆棧中彈出Lua函數。

lua_error
[-1，+ 0，v ]
int lua_error（lua_State * L）;
生成Lua錯誤，使用堆棧頂部的值做爲錯誤對象。此函數執行長跳轉，所以永遠不會返回（請參閱參考資料luaL_error）。

lua_gc
[-0，+ 0，m ]
int lua_gc（lua_State * L，int what，int data）;
控制垃圾收集器。

此函數根據參數的值執行多個任務what：

LUA_GCSTOP： 中止垃圾收集器。
LUA_GCRESTART： 從新啓動垃圾收集器。
LUA_GCCOLLECT： 執行完整的垃圾收集週期。
LUA_GCCOUNT： 返回Lua使用的當前內存量（以KB爲單位）。
LUA_GCCOUNTB： 返回Lua使用的當前內存字節數除以1024的餘數。
LUA_GCSTEP： 執行垃圾收集的增量步驟。
LUA_GCSETPAUSE： 設置data爲收集器暫停的新值（參見§2.5）並返回暫停的先前值。
LUA_GCSETSTEPMUL： 設置data爲收集器的步長乘數的新值（參見§2.5）並返回步長乘數的先前值。
LUA_GCISRUNNING： 返回一個布爾值，告訴收集器是否正在運行（即未中止）。
有關這些選項的更多詳細信息，請參閱collectgarbage。

lua_getallocf
[-0，+ 0， - ]
lua_Alloc lua_getallocf（lua_State * L，void ** ud）;
返回給定狀態的內存分配函數。若是ud不是NULL，則Lua存儲在*ud設置memory-allocator函數時給出的不透明指針中。

lua_getfield
[-0，+ 1，e ]
int lua_getfield（lua_State * L，int index，const char * k）;
將值推送到堆棧t[k]，其中t是給定索引處的值。與Lua同樣，此函數可能觸發「索引」事件的元方法（參見§2.4）。

返回推送值的類型。

lua_getextraspace
[-0，+ 0， - ]
void * lua_getextraspace（lua_State * L）;
返回指向與給定Lua狀態關聯的原始內存區域的指針。該應用程序能夠將此區域用於任何目的; Lua不會將它用於任何事情。

每一個新線程都使用主線程區域的副本初始化此區域。

默認狀況下，此區域具備指向void的指針大小，但您能夠爲此區域從新編譯具備不一樣大小的Lua。（參見LUA_EXTRASPACE在luaconf.h）。

lua_getglobal
[-0，+ 1，e ]
int lua_getglobal（lua_State * L，const char * name）;
將全局值推入堆棧name。返回該值的類型。

lua_geti
[-0，+ 1，e ]
int lua_geti（lua_State * L，int index，lua_Integer i）;
將值推送到堆棧t[i]，其中t是給定索引處的值。與Lua同樣，此函數可能觸發「索引」事件的元方法（參見§2.4）。

返回推送值的類型。

lua_getmetatable
[-0，+（0 | 1）， - ]
int lua_getmetatable（lua_State * L，int index）;
若是給定索引處的值具備metatable，則該函數將該metatable推送到堆棧並返回1.不然，該函數返回0而且不會在堆棧上推送任何內容。

lua_gettable
[-1，+ 1，e ]
int lua_gettable（lua_State * L，int index）;
將值推送到堆棧t[k]，其中t是給定索引k處的值，而且是堆棧頂部的值。

此函數從堆棧中彈出鍵，將結果值推送到其位置。與Lua同樣，此函數可能觸發「索引」事件的元方法（參見§2.4）。

返回推送值的類型。

lua_gettop
[-0，+ 0， - ]
int lua_gettop（lua_State * L）;
返回堆棧中頂部元素的索引。由於索引從1開始，因此此結果等於堆棧中的元素數量; 特別是，0表示空堆棧。

lua_getuservalue
[-0，+ 1， - ]
int lua_getuservalue（lua_State * L，int index）;
將與給定索引處的完整用戶數據關聯的Lua值推入堆棧。

返回推送值的類型。

lua_insert
[-1，+ 1， - ]
void lua_insert（lua_State * L，int index）;
將top元素移動到給定的有效索引中，將此索引上方的元素向上移動到開放空間。沒法使用僞索引調用此函數，由於僞索引不是實際的堆棧位置。

lua_Integer
typedef ... lua_Integer;
Lua中的整數類型。

默認狀況下，此類型是long long（一般爲64位二進制補碼整數），但能夠更改成long或int （一般爲32位二進制補碼整數）。（參見LUA_INT_TYPE在luaconf.h）。

LUA還定義的常量 LUA_MININTEGER和LUA_MAXINTEGER，具備最小和適合於這種類型的最大值。

lua_isboolean
[-0，+ 0， - ]
int lua_isboolean（lua_State * L，int index）;
若是給定索引處的值是布爾值，則返回1，不然返回0。

lua_iscfunction
[-0，+ 0， - ]
int lua_iscfunction（lua_State * L，int index）;
若是給定索引處的值是C函數，則返回1，不然返回0。

lua_isfunction
[-0，+ 0， - ]
int lua_isfunction（lua_State * L，int index）;
若是給定索引處的值是函數（C或Lua），則返回1，不然返回0。

lua_isinteger
[-0，+ 0， - ]
int lua_isinteger（lua_State * L，int index）;
若是給定索引處的值是整數（即，該值是數字並表示爲整數），則返回1，不然返回0。

lua_islightuserdata
[-0，+ 0， - ]
int lua_islightuserdata（lua_State * L，int index）;
若是給定索引處的值是輕用戶數據，則返回1，不然返回0。

lua_isnil
[-0，+ 0， - ]
int lua_isnil（lua_State * L，int index）;
若是給定索引處的值爲nil，則返回1，不然返回0。

lua_isnone
[-0，+ 0， - ]
int lua_isnone（lua_State * L，int index）;
若是給定索引無效，則返回1，不然返回0。

lua_isnoneornil
[-0，+ 0， - ]
int lua_isnoneornil（lua_State * L，int index）;
若是給定索引無效或此索引處的值爲nil，則返回1，不然返回0。

lua_isnumber
[-0，+ 0， - ]
int lua_isnumber（lua_State * L，int index）;
若是給定索引處的值是數字或可轉換爲數字的字符串，則返回1，不然返回0。

lua_isstring
[-0，+ 0， - ]
int lua_isstring（lua_State * L，int index）;
若是給定索引處的值是字符串或數字（老是可轉換爲字符串），則返回1，不然返回0。

lua_istable
[-0，+ 0， - ]
int lua_istable（lua_State * L，int index）;
若是給定索引處的值是表，則返回1，不然返回0。

lua_isthread
[-0，+ 0， - ]
int lua_isthread（lua_State * L，int index）;
若是給定索引處的值是線程，則返回1，不然返回0。

lua_isuserdata
[-0，+ 0， - ]
int lua_isuserdata（lua_State * L，int index）;
若是給定索引處的值是userdata（full或light），則返回1，不然返回0。

lua_isyieldable
[-0，+ 0， - ]
int lua_isyieldable（lua_State * L）;
若是給定的協程能夠產生，則返回1，不然返回0。

lua_KContext
typedef ... lua_KContext;
continuation-function上下文的類型。它必須是數字類型。此類型定義爲什麼intptr_t 時intptr_t可用，以便它也能夠存儲指針。不然，它被定義爲ptrdiff_t。

lua_KFunction
typedef int（* lua_KFunction）（lua_State * L，int status，lua_KContext ctx）;
繼續函數的類型（見§4.7）。

lua_len
[-0，+ 1，e ]
void lua_len（lua_State * L，int index）;
返回給定索引處的值的長度。它等同#於Lua中的' '運算符（參見§3.4.7），而且可能觸發「長度」事件的元方法（參見§2.4）。結果被推到堆棧上。

lua_load
[-0，+ 1， - ]
int lua_load（lua_State * L，
lua_Reader讀者，
無效*數據，
const char * chunkname，
const char * mode）;
加載Lua塊而不運行它。若是沒有錯誤， lua_load則將編譯的塊做爲Lua函數推送到堆棧頂部。不然，它會推送錯誤消息。

返回值爲lua_load：

LUA_OK：沒有錯誤;
LUA_ERRSYNTAX： 預編譯期間的語法錯誤;
LUA_ERRMEM： 內存分配（內存不足）錯誤;
LUA_ERRGCMM： 運行__gcmetamethod時出錯。（此錯誤與正在加載的塊無關。它由垃圾收集器生成。）
該lua_load函數使用用戶提供的reader函數來讀取塊（請參閱參考資料lua_Reader）。該data參數是傳遞給閱讀器功能的不透明值。

該chunkname參數給出了塊的名稱，該名稱用於錯誤消息和調試信息（參見§4.9）。

lua_load自動檢測塊是文本仍是二進制並相應加載（參見程序luac）。該字符串mode在函數中起做用load，另一個NULL值等同於字符串「 bt」。

lua_load 在內部使用堆棧，所以讀取器函數必須始終在返回時保持堆棧不被修改。

若是結果函數具備upvalues，則其第一個upvalue將設置爲LUA_RIDX_GLOBALS註冊表中存儲在index處的全局環境的值（請參閱§4.5）。加載主塊時，此upvalue將是_ENV變量（參見§2.2）。其餘upvalues初始化爲nil。

lua_newstate
[-0，+ 0， - ]
lua_State * lua_newstate（lua_Alloc f，void * ud）;
建立以新的獨立狀態運行的新線程。返回NULL若是它不能建立線程或狀態（因爲內存不足）。參數f是分配器函數; Lua經過此函數爲此狀態進行全部內存分配（請參閱參考資料lua_Alloc）。第二個參數ud是Lua在每一個調用中傳遞給分配器的不透明指針。

lua_newtable
[-0，+ 1，m ]
void lua_newtable（lua_State * L）;
建立一個新的空表並將其推入堆棧。它至關於lua_createtable(L, 0, 0)。

lua_newthread
[-0，+ 1，m ]
lua_State * lua_newthread（lua_State * L）;
建立一個新線程，將其推送到堆棧上，並返回一個指向lua_State該新線程的指針。此函數返回的新線程與原始線程共享其全局環境，但具備獨立的執行堆棧。

沒有顯式函數來關閉或銷燬線程。與任何Lua對象同樣，線程能夠進行垃圾收集。

lua_newuserdata
[-0，+ 1，m ]
void * lua_newuserdata（lua_State * L，size_t size）;
此函數分配具備給定大小的新內存塊，將具備塊地址的新完整用戶數據推入堆棧，並返回此地址。主程序能夠自由使用這個內存。

lua_next
[-1，+（2 | 0），e ]
int lua_next（lua_State * L，int index）;
從堆棧中彈出一個鍵，並從給定索引處的表中推送一個鍵值對（給定鍵以後的「下一個」對）。若是表中沒有更多元素，則lua_next返回0（而且不進行任何操做）。

典型的遍歷以下所示：

/ * table在索引't'的堆棧中* /
lua_pushnil（L）; / *第一把鑰匙* /
while（lua_next（L，t）！= 0）{
/ *使用'key'（在索引-2處）和'value'（在index -1處）* /
printf（「％s - ％s \ n」，
lua_typename（L，lua_type（L，-2）），
lua_typename（L，lua_type（L，-1）））;
/ *刪除'value'; 保持下一次迭代的「關鍵」* /
lua_pop（L，1）;
}
在遍歷表時，不要lua_tolstring直接調用鍵，除非您知道該鍵其實是一個字符串。回想一下，lua_tolstring可能會改變給定索引的值; 這會混淆下一次打電話lua_next。

有關next在遍歷期間修改表的注意事項，請參閱函數。

lua_Number
typedef ... lua_Number;
Lua的浮子類型。

默認狀況下，此類型爲double，但能夠更改成單個float或long double。（參見LUA_FLOAT_TYPE在luaconf.h）。

lua_numbertointeger
int lua_numbertointeger（lua_Number n，lua_Integer * p）;
將Lua float轉換爲Lua整數。該宏假定n具備整數值。若是該值在Lua整數範圍內，則將其轉換爲整數並分配給*p。宏致使一個布爾值，指示轉換是否成功。（請注意，因爲舍入，沒有此宏，此範圍測試可能很難正確執行。）

該宏能夠屢次評估其參數。

lua_pcall
[ - （nargs + 1），+（nresults | 1）， - ]
int lua_pcall（lua_State * L，int nargs，int nresults，int msgh）;
在保護模式下調用函數。

雙方nargs並nresults具備相同的含義在lua_call。若是在通話期間沒有錯誤，則 lua_pcall表現徹底如此lua_call。可是，若是有任何錯誤， lua_pcall捕獲它，在堆棧上推送單個值（錯誤對象），並返回錯誤代碼。就像lua_call， lua_pcall老是從堆棧中刪除函數及其參數。

若是msgh爲0，則堆棧上返回的錯誤對象正是原始錯誤對象。不然，msgh是消息處理程序的堆棧索引 。（此索引不能是僞索引。）若是出現運行時錯誤，將使用錯誤對象調用此函數，而且其返回值將是堆棧返回的對象lua_pcall。

一般，消息處理程序用於向錯誤對象添加更多調試信息，例如堆棧回溯。返回後沒法收集此類信息lua_pcall，由於此時堆棧已解除。

該lua_pcall函數返回如下常量之一（定義lua.h）：

LUA_OK（0）： 成功。
LUA_ERRRUN： 運行時錯誤。
LUA_ERRMEM： 內存分配錯誤。對於此類錯誤，Lua不會調用消息處理程序。
LUA_ERRERR： 運行消息處理程序時出錯。
LUA_ERRGCMM： 運行__gcmetamethod時出錯。對於這樣的錯誤，Lua不會調用消息處理程序（由於這種錯誤一般與被調用的函數無關）。
lua_pcallk
[ - （nargs + 1），+（nresults | 1）， - ]
int lua_pcallk（lua_State * L，
int nargs，
結果，
int msgh，
lua_KContext ctx，
lua_KFunction k）;
此函數的行爲與此相似lua_pcall，但容許被調用的函數產生（參見§4.7）。

lua_pop
[-n，+ 0， - ]
void lua_pop（lua_State * L，int n）;
彈出n堆棧中的元素。

lua_pushboolean
[-0，+ 1， - ]
void lua_pushboolean（lua_State * L，int b）;
將帶有值的布爾值推b送到堆棧。

lua_pushcclosure
[-n，+ 1，m ]
void lua_pushcclosure（lua_State * L，lua_CFunction fn，int n）;
將新的C閉包推入堆棧。

當建立C函數時，能夠將一些值與它相關聯，從而建立一個C閉包（見§4.4）; 而後，只要調用它們，函數就能夠訪問這些值。要將值與C函數關聯，首先必須將這些值壓入堆棧（當存在多個值時，首先按下第一個值）。而後lua_pushcclosure 調用建立C函數並將其推送到堆棧上，並使用參數n告知將與函數關聯的值。 lua_pushcclosure還會從堆棧中彈出這些值。

最大值爲n255。

當n爲零時，此函數建立一個輕C函數，它只是指向C函數的指針。在這種狀況下，它永遠不會引發內存錯誤。

lua_pushcfunction
[-0，+ 1， - ]
void lua_pushcfunction（lua_State * L，lua_CFunction f）;
將C函數推入堆棧。該函數接收一個指向C函數的指針，並將一個Lua值推入堆棧，該類值function在調用時調用相應的C函數。

Lua能夠調用的任何函數都必須遵循正確的協議才能接收其參數並返回其結果（請參閱參考資料lua_CFunction）。

lua_pushfstring
[-0，+ 1，e ]
const char * lua_pushfstring（lua_State * L，const char * fmt，...）;
將格式化的字符串壓入堆棧並返回指向此字符串的指針。它相似於ISO C函數sprintf，但有一些重要的區別：

您沒必要爲結果分配空間：結果是Lua字符串，Lua負責內存分配（以及經過垃圾回收進行解除分配）。
轉換說明符很是有限。沒有標誌，寬度或精度。轉換說明符只能是' %%'（插入字符' %'），' %s'（插入一個以零結尾的字符串，沒有大小限制），' %f'（插入一個lua_Number），' %I'（插入一個lua_Integer），' %p'（插入指針做爲十六進制數字），' %d'（插入一個int），' %c'（插入int一個單字節字符）和' %U'（插入long int一個UTF-8字節序列）。
與其餘推送功能不一樣，此功能會檢查所需的堆棧空間，包括其結果的插槽。

lua_pushglobaltable
[-0，+ 1， - ]
void lua_pushglobaltable（lua_State * L）;
將全局環境推送到堆棧。

lua_pushinteger
[-0，+ 1， - ]
void lua_pushinteger（lua_State * L，lua_Integer n）;
將帶有值的整數n推入堆棧。

lua_pushlightuserdata
[-0，+ 1， - ]
void lua_pushlightuserdata（lua_State * L，void * p）;
將輕的用戶數據推送到堆棧上。

Userdata表示Lua中的C值。甲光用戶數據表明一個指針，一個void*。它是一個值（如數字）：您不建立它，它沒有單獨的元表，也沒有收集（由於它從未建立過）。輕用戶數據等於具備相同C地址的「任何」輕用戶數據。

lua_pushliteral
[-0，+ 1，m ]
const char * lua_pushliteral（lua_State * L，const char * s）;
這個宏至關於lua_pushstring，但只應在使用時使用s文字字符串時使用。

lua_pushlstring
[-0，+ 1，m ]
const char * lua_pushlstring（lua_State * L，const char * s，size_t len）;
按下指向的字符串 s大小len 推入堆棧。Lua生成（或重用）給定字符串的內部副本，所以s能夠在函數返回後當即釋放或重用內存。該字符串能夠包含任何二進制數據，包括嵌入的零。

返回指向字符串內部副本的指針。

lua_pushnil
[-0，+ 1， - ]
void lua_pushnil（lua_State * L）;
將nil值推入堆棧。

lua_pushnumber
[-0，+ 1， - ]
void lua_pushnumber（lua_State * L，lua_Number n）;
將帶有值的浮點數n推入堆棧。

lua_pushstring
[-0，+ 1，m ]
const char * lua_pushstring（lua_State * L，const char * s）;
將指向的以零結尾的字符串壓s 入堆棧。Lua生成（或重用）給定字符串的內部副本，所以s能夠在函數返回後當即釋放或重用內存。

返回指向字符串內部副本的指針。

若是s是NULL，推進nil並返回NULL。

lua_pushthread
[-0，+ 1， - ]
int lua_pushthread（lua_State * L）;
將表示的線程L推入堆棧。若是此線程是其狀態的主線程，則返回1。

lua_pushvalue
[-0，+ 1， - ]
void lua_pushvalue（lua_State * L，int index）;
將給定索引處的元素副本推送到堆棧。

lua_pushvfstring
[-0，+ 1，m ]
const char * lua_pushvfstring（lua_State * L，
const char * fmt，
va_list argp）;
至關於lua_pushfstring，除了它接收一個va_list 而不是可變數量的參數。

lua_rawequal
[-0，+ 0， - ]
int lua_rawequal（lua_State * L，int index1，int index2）;
若是在索引的兩個值，則返回1 index1和 index2是原始地等於（即，不調用__eq元方法）。不然返回0.若是任何索引無效，則返回0。

lua_rawget
[-1，+ 1， - ]
int lua_rawget（lua_State * L，int index）;
相似於lua_gettable，可是進行原始訪問（即沒有metamethods）。

lua_rawgeti
[-0，+ 1， - ]
int lua_rawgeti（lua_State * L，int index，lua_Integer n）;
將值推送到堆棧t[n]，其中t是給定索引處的表。訪問是原始的，也就是說，它不會調用元__index方法。

返回推送值的類型。

lua_rawgetp
[-0，+ 1， - ]
int lua_rawgetp（lua_State * L，int index，const void * p）;
將值推送到堆棧t[k]，其中t是給定索引處的表，而且 k指針p表示爲輕用戶數據。訪問是原始的; 也就是說，它不會調用元__index方法。

返回推送值的類型。

lua_rawlen
[-0，+ 0， - ]
size_t lua_rawlen（lua_State * L，int index）;
返回給定索引處的值的原始「length」：對於字符串，這是字符串長度; 對於表，這是長度運算符（' #'）的結果，沒有metamethods; 對於userdata，這是爲userdata分配的內存塊的大小; 對於其餘值，它爲0。

lua_rawset
[-2，+ 0，m ]
void lua_rawset（lua_State * L，int index）;
相似於lua_settable，可是進行原始分配（即沒有metamethods）。

lua_rawseti
[-1，+ 0，m ]
void lua_rawseti（lua_State * L，int index，lua_Integer i）;
是等價的t[i] = v，其中t是給定索引處的表，而且v是堆棧頂部的值。

此函數彈出堆棧中的值。賦值是原始的，也就是說，它不會調用元__newindex方法。

lua_rawsetp
[-1，+ 0，m ]
void lua_rawsetp（lua_State * L，int index，const void * p）;
相應於，給定索引處的表的t[p] = v位置t是否 p被編碼爲輕用戶數據，而且v是堆棧頂部的值。

此函數彈出堆棧中的值。賦值是原始的，也就是說，它不會調用__newindexmetamethod。

lua_Reader
typedef const char *（* lua_Reader）（lua_State * L，
無效*數據，
size_t * size）;
讀者使用的功能lua_load。每當它須要另外一塊塊時， lua_load調用讀者，傳遞其data參數。讀者必須使用新塊的塊返回指向內存塊的指針並設置size爲塊大小。塊必須存在，直到再次調用reader函數。要發出塊的結束信號，讀卡器必須返回NULL或設置size爲零。讀取器功能能夠返回任何大於零的大小的片斷。

lua_register
[-0，+ 0，e ]
void lua_register（lua_State * L，const char * name，lua_CFunction f）;
將C函數設置f爲全局的新值name。它被定義爲一個宏：

#define lua_register（L，n，f）\
（lua_pushcfunction（L，f），lua_setglobal（L，n））
lua_remove
[-1，+ 0， - ]
void lua_remove（lua_State * L，int index）;
移除給定有效索引處的元素，向下移動此索引上方的元素以填補空白。沒法使用僞索引調用此函數，由於僞索引不是實際的堆棧位置。

lua_replace
[-1，+ 0， - ]
void lua_replace（lua_State * L，int index）;
將頂部元素移動到給定的有效索引中而不移動任何元素（所以替換該給定索引處的值），而後彈出頂部元素。

lua_resume
[ - ？，+？， - ]
int lua_resume（lua_State * L，lua_State * from，int nargs）;
在給定的線程中啓動並恢復協程L。

要啓動協程，你能夠將主函數加上任何參數推送到線程堆棧; 而後你打電話lua_resume，nargs做爲參數的數量。當協同程序暫停或完成其執行時，此調用將返回。返回時，堆棧包含傳遞給的lua_yield全部值，或者包含body函數返回的全部值。 若是協程生成，若是協程完成執行沒有錯誤，則lua_resume返回; LUA_YIELD若是 LUA_OK出現錯誤，則返回錯誤代碼（請參閱參考資料lua_pcall）。

若是出現錯誤，堆棧不會被解除，所以您能夠在其上使用調試API。錯誤對象位於堆棧頂部。

要恢復一個協同程序，你從最後一箇中刪除任何結果lua_yield，只在其堆棧上放置要做爲結果傳遞的值yield，而後調用lua_resume。

該參數from表示正在恢復的協同程序L。若是沒有這樣的協程，則此參數能夠NULL。

lua_rotate
[-0，+ 0， - ]
void lua_rotate（lua_State * L，int idx，int n）;
在有效索引idx 和堆棧頂部之間旋轉堆棧元素。元件n在頂部方向上旋轉的位置爲正n，或者-n在底部的方向上的位置爲負的n。絕對值n不得大於正在旋轉的切片的大小。沒法使用僞索引調用此函數，由於僞索引不是實際的堆棧位置。

lua_setallocf
[-0，+ 0， - ]
void lua_setallocf（lua_State * L，lua_Alloc f，void * ud）;
將給定狀態的分配器功能更改成f 用戶數據ud。

lua_setfield
[-1，+ 0，e ]
void lua_setfield（lua_State * L，int index，const char * k）;
是等價於t[k] = v，其中t是給定索引v處的值，是堆棧頂部的值。

此函數彈出堆棧中的值。與Lua同樣，此函數可能觸發「newindex」事件的元方法（參見§2.4）。

lua_setglobal
[-1，+ 0，e ]
void lua_setglobal（lua_State * L，const char * name）;
從堆棧中彈出一個值並將其設置爲全局的新值name。

lua_seti
[-1，+ 0，e ]
void lua_seti（lua_State * L，int index，lua_Integer n）;
是等價於t[n] = v，其中t是給定索引v處的值，是堆棧頂部的值。

此函數彈出堆棧中的值。與Lua同樣，此函數可能觸發「newindex」事件的元方法（參見§2.4）。

lua_setmetatable
[-1，+ 0， - ]
void lua_setmetatable（lua_State * L，int index）;
從堆棧中彈出一個表，並將其設置爲給定索引處的值的新元表。

lua_settable
[-2，+ 0，e ]
void lua_settable（lua_State * L，int index）;
等價於t[k] = v，t給定索引 v處的值是否爲堆棧頂部k的值，而且是低於頂部的值。

此函數會彈出堆棧中的鍵和值。與Lua同樣，此函數可能觸發「newindex」事件的元方法（參見§2.4）。

lua_settop
[ - ？，+？， - ]
void lua_settop（lua_State * L，int index）;
接受任何索引或0，並將堆棧頂部設置爲此索引。若是新頂部大於舊頂部，則新元素將填充爲nil。若是index爲0，則刪除全部堆棧元素。

lua_setuservalue
[-1，+ 0， - ]
void lua_setuservalue（lua_State * L，int index）;
從堆棧中彈出一個值，並將其設置爲與給定索引處的完整用戶數據關聯的新值。

lua_State
typedef struct lua_State lua_State;
一個不透明的結構，指向一個線程並間接（經過線程）指向Lua解釋器的整個狀態。Lua庫是徹底可重入的：它沒有全局變量。可經過此結構訪問有關州的全部信息。

必須將指向此結構的指針做爲庫中每一個函數的第一個參數傳遞，除了lua_newstate從頭建立Lua狀態。

lua_status
[-0，+ 0， - ]
int lua_status（lua_State * L）;
返回線程的狀態L。

LUA_OK對於正常線程， 狀態能夠是0（），若是線程完成lua_resume帶有錯誤的a的執行，或者LUA_YIELD線程被掛起，則爲錯誤代碼。

您只能在具備狀態的線程中調用函數LUA_OK。您能夠恢復具備狀態的線程LUA_OK （以啓動新的協程）或LUA_YIELD （恢復協程）。

lua_stringtonumber
[-0，+ 1， - ]
size_t lua_stringtonumber（lua_State * L，const char * s）;
將以零結尾的字符串s轉換爲數字，將該數字推入堆棧，並返回字符串的總大小，即其長度加1。根據Lua的詞彙約定，轉換能夠產生整數或浮點數（見§3.1）。該字符串能夠包含前導和尾隨空格以及符號。若是字符串不是有效數字，則返回0而且不進行任何操做。（注意，結果能夠用做布爾值，若是轉換成功，則爲true。）

lua_toboolean
[-0，+ 0， - ]
int lua_toboolean（lua_State * L，int index）;
將給定索引處的Lua值轉換爲C布爾值（0或1）。像Lua中的全部測試同樣，lua_toboolean對於任何不一樣於false和nil的 Lua值， 返回true ; 不然返回false。（若是隻想接受實際的布爾值，請使用lua_isboolean測試值的類型。）

lua_tocfunction
[-0，+ 0， - ]
lua_CFunction lua_tocfunction（lua_State * L，int index）;
將給定索引處的值轉換爲C函數。該值必須是C函數; 不然，返回NULL。

lua_tointeger
[-0，+ 0， - ]
lua_Integer lua_tointeger（lua_State * L，int index）;
至關於lua_tointegerx用isnum等於NULL。

lua_tointegerx
[-0，+ 0， - ]
lua_Integer lua_tointegerx（lua_State * L，int index，int * isnum）;
將給定索引處的Lua值轉換爲有符號整數類型lua_Integer。Lua值必須是整數，或者能夠轉換爲整數的數字或字符串（參見§3.4.3）; 不然，lua_tointegerx返回0。

若是isnum不是NULL，則爲其指示對象分配一個布爾值，指示操做是否成功。

lua_tolstring
[-0，+ 0，m ]
const char * lua_tolstring（lua_State * L，int index，size_t * len）;
將給定索引處的Lua值轉換爲C字符串。若是len不是NULL，則設置*len字符串長度。Lua值必須是字符串或數字; 不然，函數返回NULL。若是值是數字，則lua_tolstring還將 堆棧中的實際值更改成字符串。（在表遍歷期間應用於鍵lua_next 時，此更改會混淆lua_tolstring。）

lua_tolstring返回指向Lua狀態內的字符串的指針。此字符串\0在其最後一個字符以後始終爲零（' '）（如在C中），但在其正文中能夠包含其餘零。

由於Lua具備垃圾收集功能，因此沒法保證返回的指針lua_tolstring 在從堆棧中刪除相應的Lua值後纔有效。

lua_tonumber
[-0，+ 0， - ]
lua_Number lua_tonumber（lua_State * L，int index）;
至關於lua_tonumberx用isnum等於NULL。

lua_tonumberx
[-0，+ 0， - ]
lua_Number lua_tonumberx（lua_State * L，int index，int * isnum）;
將給定索引處的Lua值轉換爲C類型lua_Number（請參閱參考資料lua_Number）。Lua值必須是可轉換爲數字的數字或字符串（參見§3.4.3）; 不然，lua_tonumberx返回0。

若是isnum不是NULL，則爲其指示對象分配一個布爾值，指示操做是否成功。

lua_topointer
[-0，+ 0， - ]
const void * lua_topointer（lua_State * L，int index）;
將給定索引處的值轉換爲通用C指針（void*）。值能夠是userdata，表，線程或函數; 不然，lua_topointer返回NULL。不一樣的對象會給出不一樣的指針。沒法將指針轉換回原始值。

一般，此函數僅用於散列和調試信息。

lua_tostring
[-0，+ 0，m ]
const char * lua_tostring（lua_State * L，int index）;
至關於lua_tolstring用len等於NULL。

lua_tothread
[-0，+ 0， - ]
lua_State * lua_tothread（lua_State * L，int index）;
將給定索引處的值轉換爲Lua線程（表示爲lua_State*）。該值必須是一個線程; 不然，函數返回NULL。

lua_touserdata
[-0，+ 0， - ]
void * lua_touserdata（lua_State * L，int index）;
若是給定索引處的值是完整用戶數據，則返回其塊地址。若是值爲light userdata，則返回其指針。不然，返回NULL。

lua_type
[-0，+ 0， - ]
int lua_type（lua_State * L，int index）;
返回給定有效索引中的值的類型，或者返回LUA_TNONE無效（但可接受）索引的值。返回的類型lua_type是經過在定義的如下常量編碼lua.h： LUA_TNIL（0）， ， ， LUA_TNUMBER， LUA_TBOOLEAN， LUA_TSTRING， ， LUA_TTABLE ， 和 。 LUA_TFUNCTIONLUA_TUSERDATALUA_TTHREADLUA_TLIGHTUSERDATA

lua_typename
[-0，+ 0， - ]
const char * lua_typename（lua_State * L，int tp）;
返回由值編碼的類型的名稱，該值tp必須是返回的值之一lua_type。

lua_Unsigned
typedef ... lua_Unsigned;
未簽名的版本lua_Integer。

lua_upvalueindex
[-0，+ 0， - ]
int lua_upvalueindex（int i）;
返回表示i正在運行的函數的第 - 個up值的僞索引（參見§4.4）。

lua_version
[-0，+ 0， - ]
const lua_Number * lua_version（lua_State * L）;
返回存儲在Lua核心中的版本號（C靜態變量）的地址。使用valid調用時lua_State，返回用於建立該狀態的版本的地址。調用時NULL，返回運行調用的版本的地址。

lua_Writer
typedef int（* lua_Writer）（lua_State * L，
const void * p，
size_t sz，
void * ud）;
使用的writer函數的類型lua_dump。每次它生成另外一塊塊時， lua_dump調用writer，傳遞緩衝區以寫入（p），它的size（sz）和data提供給的參數lua_dump。

編寫器返回錯誤代碼：0表示沒有錯誤; 任何其餘值意味着錯誤並中止lua_dump再次調用編寫器。

lua_xmove
[ - ？，+？， - ]
void lua_xmove（lua_State * from，lua_State * to，int n）;
在相同狀態的不一樣線程之間交換值。

此函數n從堆棧中彈出值from，並將它們推送到堆棧中to。

lua_yield
[ - ？，+？，e ]
int lua_yield（lua_State * L，int nresults）;
此函數至關於lua_yieldk，但沒有延續（參見§4.7）。所以，當線程恢復時，它繼續調用函數調用的函數lua_yield。

lua_yieldk
[ - ？，+？，e ]
int lua_yieldk（lua_State * L，
結果，
lua_KContext ctx，
lua_KFunction k）;
產生一個協程（線程）。

當C函數調用時lua_yieldk，正在運行的協同程序暫停其執行，而且lua_resume對該協程的調用返回。該參數nresults是堆棧中將做爲結果傳遞給的值的數量lua_resume。

當協程再次恢復時，Lua調用給定的continuation函數k繼續執行產生的C函數（參見§4.7）。此延續函數從前一個函數接收相同的堆棧，並n刪除結果並替換爲傳遞給的參數lua_resume。此外，continuation函數接收ctx 傳遞給的值lua_yieldk。

一般，此功能不會返回; 當協程最終恢復時，它繼續執行繼續功能。可是，有一種特殊狀況，即從行內部或計數鉤子中調用此函數時（參見§4.9）。在這種狀況下，lua_yieldk應該調用沒有延續（多是以形式lua_yield）而且沒有結果，而且鉤子應該在調用後當即返回。Lua會產生而且，當協程再次恢復時，它將繼續正常執行觸發鉤子的（Lua）函數。

若是從具備掛起C調用且沒有連續函數的線程調用它，或者從未在恢復（例如，主線程）內運行的線程調用它，則此函數可能引起錯誤。

4.9 - 調試接口
Lua沒有內置的調試工具。相反，它經過函數和鉤子提供了一個特殊的接口。該接口容許構建不一樣類型的調試器，分析器和其餘須要來自解釋器的「內部信息」的工具。

lua_Debug
typedef struct lua_Debug {
int事件;
const char * name; / *（n）* /
const char * namewhat; / *（n）* /
const char * what; / *（S）* /
const char * source; / *（S）* /
int currentline; / *（l）* /
int linedefined; / *（S）* /
int lastlinedefined; / *（S）* /
unsigned char nups; / *（u）upvalues數量* /
unsigned char nparams; / *（u）參數數量* /
char isvararg; / *（u）* /
char istailcall; / *（t）* /
char short_src [LUA_IDSIZE]; / *（S）* /
/ *私人部分* /
其餘領域
} lua_Debug;
用於攜帶關於功能或激活記錄的不一樣信息的結構。 lua_getstack僅填充此結構的私有部分，供之後使用。要填寫lua_Debug有用信息的其餘字段，請致電lua_getinfo。

這些領域lua_Debug具備如下含義：

source： 建立函數的塊的名稱。若是source以' @' 開頭，則表示該函數是在文件名中跟隨' @' 的文件中定義的。若是source以' =' 開頭，則其內容的其他部分以依賴於用戶的方式描述源。不然，函數在字符串中定義，其中 source是該字符串。
short_src：source用於錯誤消息 的「可打印」版本。
linedefined： 函數定義開始的行號。
lastlinedefined： 函數定義結束的行號。
what："Lua"若是函數是Lua函數 的字符串， "C"若是它是C函數， "main"若是它是塊的主要部分。
currentline： 給定函數執行的當前行。若是沒有可用的行信息， currentline則設置爲-1。
name： 給定函數的合理名稱。由於Lua中的函數是一等值，因此它們沒有固定的名稱：某些函數能夠是多個全局變量的值，而其餘函數只能存儲在表字段中。該lua_getinfo函數檢查函數的調用方式以查找合適的名稱。若是找不到名稱，則name設置爲NULL。
namewhat： 解釋這個name領域。的值namewhat能夠是 "global"，"local"，"method"， "field"，"upvalue"，或""（空字符串），根據功能如何被調用。（當沒有其餘選項彷佛適用時，Lua使用空字符串。）
istailcall： 若是尾調用調用此函數調用，則爲true。在這種狀況下，此級別的調用者不在堆棧中。
nups： 函數的upvalues數。
nparams： 函數的固定參數數量（C函數老是0）。
isvararg： 若是函數是vararg函數，則爲true（對於C函數，始終爲true）。
lua_gethook
[-0，+ 0， - ]
lua_Hook lua_gethook（lua_State * L）;
返回當前的鉤子函數。

lua_gethookcount
[-0，+ 0， - ]
int lua_gethookcount（lua_State * L）;
返回當前的掛鉤計數。

lua_gethookmask
[-0，+ 0， - ]
int lua_gethookmask（lua_State * L）;
返回當前的鉤子掩碼。

lua_getinfo
[ - （0 | 1），+（0 | 1 | 2），e ]
int lua_getinfo（lua_State * L，const char * what，lua_Debug * ar）;
獲取有關特定函數或函數調用的信息。

要獲取有關函數調用的信息，該參數ar必須是有效的激活記錄，該記錄由先前調用lua_getstack或做爲鉤子的參數提供（請參閱參考資料lua_Hook）。

要獲取有關函數的信息，請將其推入堆棧並what使用字符' >' 啓動字符串。（在這種狀況下， lua_getinfo從堆棧頂部彈出函數。）例如，要知道函數f定義在哪一行，您能夠編寫如下代碼：

lua_Debug ar;
lua_getglobal（L，「f」）; / *獲取全局'f'* /
lua_getinfo（L，「> S」，＆ar）;
printf（「％d \ n」，ar.linedefined）;
字符串中的每一個字符都會what 選擇ar要填充的結構的某些字段或要在堆棧上推送的值：

' n'：填補領域name和namewhat;
' S「： 填補了領域source，short_src， linedefined，lastlinedefined，和what;
' l'：填補領域currentline;
' t'：填補領域istailcall;
' u「：填補了領域 nups，nparams以及isvararg;
' f'： 將在給定級別運行的函數推入堆棧;
' L'： 將一個表推入堆棧，其索引是函數上有效的行數。（有效的一行是帶有一些相關代碼的行，便可以放置斷點的行。無效行包括空行和註釋。）
若是此選項與選項' f' 一塊兒提供，則在該函數後推送其表。

此函數在出錯時返回0（例如，無效選項what）。

lua_getlocal
[-0，+（0 | 1）， - ]
const char * lua_getlocal（lua_State * L，const lua_Debug * ar，int n）;
獲取有關給定激活記錄或給定函數的局部變量的信息。

在第一種狀況下，參數ar必須是有效的激活記錄，該記錄由先前調用lua_getstack或做爲鉤子的參數填充（請參閱參考資料lua_Hook）。索引n選擇要檢查的局部變量; debug.getlocal有關變量索引和名稱的詳細信息， 請參閱

lua_getlocal 將變量的值壓入堆棧並返回其名稱。

在第二種狀況下，ar必須是NULL而且要檢查的功能必須位於堆棧的頂部。在這種狀況下，只有Lua函數的參數是可見的（由於沒有關於哪些變量是活動的信息）而且沒有值被推入堆棧。

NULL當索引大於活動局部變量的數量時， 返回（而且不進行任何操做）。

lua_getstack
[-0，+ 0， - ]
int lua_getstack（lua_State * L，int level，lua_Debug * ar）;
獲取有關解釋器運行時堆棧的信息。

此函數lua_Debug使用 在給定級別執行的函數的激活記錄的標識來填充結構的一部分。級別0是當前運行的函數，而級別n + 1是調用級別n的函數 （尾部調用除外，它不計入堆棧）。當沒有錯誤時，lua_getstack返回1; 當以大於堆棧深度的級別調用時，它返回0。

lua_getupvalue
[-0，+（0 | 1）， - ]
const char * lua_getupvalue（lua_State * L，int funcindex，int n）;
獲取有關n索引處閉包的第th個值的信息funcindex。它將upvalue的值壓入堆棧並返回其名稱。NULL當索引n大於upvalues的數量時，返回（而且不進行任何操做）。

對於C函數，此函數使用空字符串"" 做爲全部upvalues的名稱。（對於Lua函數，upvalues是函數使用的外部局部變量，所以包含在其閉包中。）

Upvalues沒有特定的順序，由於它們在整個函數中都是活動的。它們以任意順序編號。

lua_Hook
typedef void（* lua_Hook）（lua_State * L，lua_Debug * ar）;
用於調試掛鉤函數的類型。

每當調用一個鉤子時，它的ar參數都將其字段 event設置爲觸發鉤子的特定事件。Lua中識別這些事件與如下常量： LUA_HOOKCALL，LUA_HOOKRET， LUA_HOOKTAILCALL，LUA_HOOKLINE，和LUA_HOOKCOUNT。此外，對於線事件，currentline也設置該字段。要獲取任何其餘字段的值ar，鉤子必須調用lua_getinfo。

對於呼叫事件，event能夠是LUA_HOOKCALL正常值，或者LUA_HOOKTAILCALL，對於尾部呼叫; 在這種狀況下，將沒有相應的返回事件。

當Lua正在運行一個鉤子時，它會禁用對鉤子的其餘調用。所以，若是一個鉤子回調Lua來執行一個函數或一個塊，那麼這個執行就會在沒有任何鉤子調用的狀況下發生。

鉤子函數不能延續，也就是說，他們不能打電話lua_yieldk， lua_pcallk或lua_callk與非空k。

鉤子函數能夠在如下條件下產生：只有count和line事件能夠產生; 爲了屈服，一個鉤子函數必須lua_yield用nresults等於零的方式完成它的執行調用（也就是說，沒有值）。

lua_sethook
[-0，+ 0， - ]
void lua_sethook（lua_State * L，lua_Hook f，int mask，int count）;
設置調試掛鉤功能。

參數f是鉤子函數。 mask指定要在其事件的鉤將被稱爲：它是由常量的位OR造成 LUA_MASKCALL， LUA_MASKRET， LUA_MASKLINE，和LUA_MASKCOUNT。該count參數僅在掩碼包含時纔有意義LUA_MASKCOUNT。對於每一個事件，將調用鉤子，以下所述：

調用鉤子：在解釋器調用函數時調用。在函數獲取其參數以前，在Lua進入新函數以後調用該鉤子。
當解釋器從函數返回時，將調用返回鉤子：在Lua離開函數以前調用該鉤子。沒有標準方法來訪問函數返回的值。
當解釋器即將開始執行新的代碼行時，或者當它在代碼中跳回（甚至到同一行）時，調用行鉤子：。（此事件僅在Lua執行Lua函數時發生。）
count hook：在解釋器執行每條count指令後調用 。（此事件僅在Lua執行Lua函數時發生。）
經過設置mask爲零來禁用掛鉤。

lua_setlocal
[ - （0 | 1），+ 0， - ]
const char * lua_setlocal（lua_State * L，const lua_Debug * ar，int n）;
設置給定激活記錄的局部變量的值。它將堆棧頂部的值分配給變量並返回其名稱。它還會彈出堆棧中的值。

NULL當索引大於活動局部變量的數量時， 返回（而且不彈出任何內容）。

參數ar和n函數同樣lua_getlocal。

lua_setupvalue
[ - （0 | 1），+ 0， - ]
const char * lua_setupvalue（lua_State * L，int funcindex，int n）;
設置閉包的upvalue的值。它將堆棧頂部的值分配給upvalue並返回其名稱。它還會彈出堆棧中的值。

NULL當索引n大於upvalues的數量時， 返回（而且不彈出任何內容）。

參數funcindex和n函數同樣lua_getupvalue。

lua_upvalueid
[-0，+ 0， - ]
void * lua_upvalueid（lua_State * L，int funcindex，int n）;
返回n 從索引處的閉包編號的upvalue的惟一標識符funcindex。

這些惟一標識符容許程序檢查不一樣的閉包是否共享up值。共享upvalue的Lua閉包（即訪問相同的外部局部變量）將爲這些upvalue索引返回相同的id。

參數funcindex和n函數同樣lua_getupvalue，但n不能大於upvalues的數量。

lua_upvaluejoin
[-0，+ 0， - ]
void lua_upvaluejoin（lua_State * L，int funcindex1，int n1，
int funcindex2，int n2）;
使n1Lua中關閉索引個的upvalue funcindex1 指n2Lua中封個的upvalue的索引funcindex2。

5 - 輔助庫
所述輔助庫提供了幾個方便的功能的接口下用的Lua。雖然基本API爲C和Lua之間的全部交互提供了原始函數，但輔助庫爲某些常見任務提供了更高級別的函數。

輔助庫中的全部函數和類型都在頭文件中定義lauxlib.h並具備前綴luaL_。

輔助庫中的全部函數都構建在基本API之上，所以它們不提供任何沒法使用該API的功能。可是，使用輔助庫可確保代碼更加一致。

輔助庫中的幾個函數在內部使用一些額外的堆棧槽。當輔助庫中的函數使用少於五個插槽時，它不會檢查堆棧大小; 它只是假設有足夠的插槽。

輔助庫中的幾個函數用於檢查C函數參數。由於錯誤消息是爲參數（例如，「 bad argument #1」）格式化的，因此不該將這些函數用於其餘堆棧值。

luaL_check* 若是不知足檢查，則 調用的函數始終會引起錯誤。

5.1 - 功能和類型
這裏咱們按字母順序列出輔助庫中的全部函數和類型。

luaL_addchar
[ - ？，+？，m ]
void luaL_addchar（luaL_Buffer * B，char c）;
將字節添加c到緩衝區B （請參閱參考資料luaL_Buffer）。

luaL_addlstring
[ - ？，+？，m ]
void luaL_addlstring（luaL_Buffer * B，const char * s，size_t l）;
將s帶有length 的字符串添加l到緩衝區B （請參閱參考資料luaL_Buffer）。該字符串能夠包含嵌入的零。

luaL_addsize
[ - ？，+？， - ]
void luaL_addsize（luaL_Buffer * B，size_t n）;
添加到緩衝區B（請參閱luaL_Buffer）n先前複製到緩衝區的長度字符串（請參閱參考資料luaL_prepbuffer）。

luaL_addstring
[ - ？，+？，m ]
void luaL_addstring（luaL_Buffer * B，const char * s）;
將指向的以零結尾的字符串添加s 到緩衝區B （請參閱參考資料luaL_Buffer）。

luaL_addvalue
[-1，+？，m ]
void luaL_addvalue（luaL_Buffer * B）;
將堆棧頂部的值添加到緩衝區B （請參閱參考資料luaL_Buffer）。彈出價值。

這是字符串緩衝區上惟一能夠（而且必須）使用堆棧上的額外元素調用的函數，這是要添加到緩衝區的值。

luaL_argcheck
[-0，+ 0，v ]
void luaL_argcheck（lua_State * L，
int cond，
int arg，
const char * extramsg）;
檢查是否cond屬實。若是不是，則使用標準消息引起錯誤（請參閱參考資料luaL_argerror）。

luaL_argerror
[-0，+ 0，v ]
int luaL_argerror（lua_State * L，int arg，const char * extramsg）;
arg 使用包含extramsg做爲註釋的標準消息 引起報告帶有調用它的C函數的參數問題的錯誤：

壞參數＃ARG爲' funcname的 '（extramsg）
此功能永不返回。

luaL_Buffer
typedef struct luaL_Buffer luaL_Buffer;
輸入字符串緩衝區。

字符串緩衝區容許C代碼逐個構建Lua字符串。其使用模式以下：

首先聲明一個b類型的變量luaL_Buffer。
而後經過調用初始化它luaL_buffinit(L, &b)。
而後將字符串片斷添加到緩衝區中，調用任何luaL_add*函數。
經過電話結束luaL_pushresult(&b)。此調用將最終字符串保留在堆棧頂部。
若是事先知道結果字符串的總大小，能夠像這樣使用緩衝區：

首先聲明一個b類型的變量luaL_Buffer。
而後初始化它並sz經過調用預先分配一個大小的空間luaL_buffinitsize(L, &b, sz)。
而後將字符串複製到該空間。
經過調用完成luaL_pushresultsize(&b, sz)，其中sz將被複制到該空間中的結果字符串的總大小。
在其正常操做期間，字符串緩衝區使用可變數量的堆棧槽。所以，在使用緩衝區時，您不能假設您知道堆棧頂部的位置。只要該使用是平衡的，您就能夠在連續調用緩衝區操做之間使用堆棧; 也就是說，當您調用緩衝區操做時，堆棧與前一個緩衝區操做以後的級別處於同一級別。（此規則的惟一例外是luaL_addvalue。）在luaL_pushresult初始化緩衝區後調用堆棧返回其級別，並在其頂部加上最後一個字符串。

luaL_buffinit
[-0，+ 0， - ]
void luaL_buffinit（lua_State * L，luaL_Buffer * B）;
初始化緩衝區B。此功能不分配任何空間; 緩衝區必須聲明爲變量（請參閱參考資料luaL_Buffer）。

luaL_buffinitsize
[ - ？，+？，m ]
char * luaL_buffinitsize（lua_State * L，luaL_Buffer * B，size_t sz）;
至關於序列 luaL_buffinit，luaL_prepbuffsize。

luaL_callmeta
[-0，+（0 | 1），e ]
int luaL_callmeta（lua_State * L，int obj，const char * e）;
稱之爲元方法。

若是索引處的對象obj具備metatable而且此metatable具備字段e，則此函數將調用此字段做爲其惟一參數傳遞對象。在這種狀況下，此函數返回true並將調用返回的值推送到堆棧。若是沒有metatable或沒有metamethod，則此函數返回false（不在堆棧上推送任何值）。

luaL_checkany
[-0，+ 0，v ]
void luaL_checkany（lua_State * L，int arg）;
檢查函數是否在位置具備任何類型（包括nil）的參數arg。

luaL_checkinteger
[-0，+ 0，v ]
lua_Integer luaL_checkinteger（lua_State * L，int arg）;
檢查函數參數arg是否爲整數（或能夠轉換爲整數）並將此整數強制轉換爲a lua_Integer。

luaL_checklstring
[-0，+ 0，v ]
const char * luaL_checklstring（lua_State * L，int arg，size_t * l）;
檢查函數參數arg是否爲字符串並返回該字符串; 若是l不NULL填充*l 字符串的長度。

此函數用於lua_tolstring獲取其結果，所以該函數的全部轉換和警告都適用於此處。

luaL_checknumber
[-0，+ 0，v ]
lua_Number luaL_checknumber（lua_State * L，int arg）;
檢查函數參數arg是否爲數字並返回此數字。

luaL_checkoption
[-0，+ 0，v ]
int luaL_checkoption（lua_State * L，
int arg，
const char * def，
const char * const lst []）;
檢查函數參數arg是否爲字符串，並在數組中搜索此字符串lst （必須以NULL結尾）。返回找到字符串的數組中的索引。若是參數不是字符串或者找不到字符串，則引起錯誤。

若是def不是NULL，則該函數def在沒有參數arg或此參數爲nil時用做默認值。

這是將字符串映射到C枚舉的有用函數。（Lua庫中一般的慣例是使用字符串而不是數字來選擇選項。）

luaL_checkstack
[-0，+ 0，v ]
void luaL_checkstack（lua_State * L，int sz，const char * msg）;
將堆棧大小增長到top + sz元素，若是堆棧沒法增加到該大小，則會引起錯誤。 msg是一個附加到錯誤消息的NULL文本（或沒有其餘文本）。

luaL_checkstring
[-0，+ 0，v ]
const char * luaL_checkstring（lua_State * L，int arg）;
檢查函數參數arg是否爲字符串並返回此字符串。

此函數用於lua_tolstring獲取其結果，所以該函數的全部轉換和警告都適用於此處。

luaL_checktype
[-0，+ 0，v ]
void luaL_checktype（lua_State * L，int arg，int t）;
檢查函數參數是否arg具備類型t。請參閱參見lua_type類型的編碼t。

luaL_checkudata
[-0，+ 0，v ]
void * luaL_checkudata（lua_State * L，int arg，const char * tname）;
檢查函數參數是否arg是類型的用戶數據tname（請參閱luaL_newmetatable參考資料）並返回用戶數據地址（請參閱參考資料lua_touserdata）。

luaL_checkversion
[-0，+ 0，v ]
void luaL_checkversion（lua_State * L）;
檢查運行調用的核心，建立Lua狀態的核心以及進行調用的代碼是否都使用相同版本的Lua。還要檢查運行調用的核心和建立Lua狀態的核心是否使用相同的地址空間。

luaL_dofile
[-0，+？，e ]
int luaL_dofile（lua_State * L，const char * filename）;
加載並運行給定的文件。它被定義爲如下宏：

（luaL_loadfile（L，filename）|| lua_pcall（L，0，LUA_MULTRET，0））
若是沒有錯誤，則返回false;若是出現錯誤，則返回true。

luaL_dostring
[-0，+？， - ]
int luaL_dostring（lua_State * L，const char * str）;
加載並運行給定的字符串。它被定義爲如下宏：

（luaL_loadstring（L，str）|| lua_pcall（L，0，LUA_MULTRET，0））
若是沒有錯誤，則返回false;若是出現錯誤，則返回true。

luaL_error
[-0，+ 0，v ]
int luaL_error（lua_State * L，const char * fmt，...）;
引起錯誤。錯誤消息格式由fmt 加上任何額外的參數給出，遵循相同的規則lua_pushfstring。若是此信息可用，它還會在消息開頭添加文件名和發生錯誤的行號。

這個函數永遠不會返回，但它是在C函數中使用它的習慣用法。 return luaL_error(args)

luaL_execresult
[-0，+ 3，m ]
int luaL_execresult（lua_State * L，int stat）;
此函數爲標準庫（os.execute和io.close）中的過程相關函數生成返回值。

luaL_fileresult
[-0，+（1 | 3），m ]
int luaL_fileresult（lua_State * L，int stat，const char * fname）;
該功能用於在標準庫文件有關的功能（生成的返回值io.open，os.rename，file:seek等等）。

luaL_getmetafield
[-0，+（0 | 1），m ]
int luaL_getmetafield（lua_State * L，int obj，const char * e）;
e從索引處的對象的元表 推送到堆棧的字段，obj並返回推送值的類型。若是對象沒有metatable，或者metatable沒有此字段，則不推送任何內容並返回LUA_TNIL。

luaL_getmetatable
[-0，+ 1，m ]
int luaL_getmetatable（lua_State * L，const char * tname）;
將與tname 註冊表中的名稱關聯的元表推送到堆棧（請參閱參考資料luaL_newmetatable）（若是沒有與該名稱關聯的元表，則爲nil）。返回推送值的類型。

luaL_getsubtable
[-0，+ 1，e ]
int luaL_getsubtable（lua_State * L，int idx，const char * fname）;
確保值t[fname]（其中t是index 處的值）idx是一個表，並將該表推送到堆棧上。若是找到前一個表，則返回true，若是建立新表，則返回false。

luaL_gsub
[-0，+ 1，m ]
const char * luaL_gsub（lua_State * L，
const char * s，
const char * p，
const char * r）;
建立字符串的副本s替換字符串出現的任何p 以字符串r。將結果字符串壓入堆棧並返回它。

luaL_len
[-0，+ 0，e ]
lua_Integer luaL_len（lua_State * L，int index）;
返回給定索引處的值的「長度」做爲數字; 它至關於#Lua中的' '運算符（見§3.4.7）。若是操做的結果不是整數，則引起錯誤。（這種狀況只能經過元方法發生。）

luaL_loadbuffer
[-0，+ 1， - ]
int luaL_loadbuffer（lua_State * L，
const char * buff，
size_t sz，
const char * name）;
至關於luaL_loadbufferx用mode等於NULL。

luaL_loadbufferx
[-0，+ 1， - ]
int luaL_loadbufferx（lua_State * L，
const char * buff，
size_t sz，
const char * name，
const char * mode）;
將緩衝區加載爲Lua塊。此函數用於lua_load加載buff大小指向的緩衝區中的塊sz。

此函數返回與之相同的結果lua_load。 name是塊名稱，用於調試信息和錯誤消息。該字符串mode在函數中起做用lua_load。

luaL_loadfile
[-0，+ 1，m ]
int luaL_loadfile（lua_State * L，const char * filename）;
至關於luaL_loadfilex用mode等於NULL。

luaL_loadfilex
[-0，+ 1，m ]
int luaL_loadfilex（lua_State * L，const char * filename，
const char * mode）;
將文件加載爲Lua塊。此函數用於lua_load在名爲的文件中加載塊filename。若是filename是NULL，則從標準輸入加載。若是以a開頭，則忽略文件中的第一行#。

該字符串mode在函數中起做用lua_load。

此函數返回與結果相同的結果lua_load，但它有LUA_ERRFILE 與文件相關的錯誤的額外錯誤代碼（例如，它沒法打開或讀取文件）。

由於lua_load，這個函數只加載塊; 它沒有運行它。

luaL_loadstring
[-0，+ 1， - ]
int luaL_loadstring（lua_State * L，const char * s）;
將字符串加載爲Lua塊。此函數用於lua_load將塊加載到以零結尾的字符串中s。

此函數返回與之相同的結果lua_load。

此外lua_load，此功能僅加載塊; 它沒有運行它。

luaL_newlib
[-0，+ 1，m ]
void luaL_newlib（lua_State * L，const luaL_Reg l []）;
建立一個新表並在列表中註冊函數l。

它實現爲如下宏：

（luaL_newlibtable（L，l），luaL_setfuncs（L，l，0））
數組l必須是實際數組，而不是指向它的指針。

luaL_newlibtable
[-0，+ 1，m ]
void luaL_newlibtable（lua_State * L，const luaL_Reg l []）;
建立一個新的表，其大小已通過優化，能夠存儲數組中的全部條目l （但實際上並不存儲它們）。它旨在與luaL_setfuncs （見luaL_newlib）一塊兒使用。

它做爲宏實現。數組l必須是實際數組，而不是指向它的指針。

luaL_newmetatable
[-0，+ 1，m ]
int luaL_newmetatable（lua_State * L，const char * tname）;
若是註冊表已經有鑰匙tname，返回0。不然，建立一個新的表被用做用戶數據一元表，增長了這個新表一對__name = tname，添加到註冊表一對[tname] = new table，並返回1（入門__name使用經過一些錯誤報告功能。）

在這兩種狀況下，都會將與tname註冊表中關聯的最終值推送到堆棧。

luaL_newstate
[-0，+ 0， - ]
lua_State * luaL_newstate（void）;
建立一個新的Lua狀態。它lua_newstate使用基於標準C realloc函數的分配器進行調用，而後設置一個恐慌函數（參見§4.6），該函數在發生致命錯誤時將錯誤消息輸出到標準錯誤輸出。

返回新狀態，或者NULL是否存在內存分配錯誤。

luaL_openlibs
[-0，+ 0，e ]
void luaL_openlibs（lua_State * L）;
將全部標準Lua庫打開到給定狀態。

luaL_opt
[-0，+ 0，e ]
T luaL_opt（L，func，arg，dflt）;
該宏定義以下：

（lua_isnoneornil（L，（arg））？（dflt）：func（L，（arg）））
換句話說，若是參數arg爲零或不存在，則宏將致使默認值dflt。不然，它會致使func 使用state L和參數index arg做爲參數調用的結果。請注意，它dflt僅在須要時評估表達式。

luaL_optinteger
[-0，+ 0，v ]
lua_Integer luaL_optinteger（lua_State * L，
int arg，
lua_Integer d）;
若是函數參數arg是整數（或可轉換爲整數），則返回此整數。若是此參數不存在或爲零，則返回d。不然，會引起錯誤。

luaL_optlstring
[-0，+ 0，v ]
const char * luaL_optlstring（lua_State * L，
int arg，
const char * d，
size_t * l）;
若是函數參數arg是字符串，則返回此字符串。若是此參數不存在或爲零，則返回d。不然，會引起錯誤。

若是l不是NULL，則*l用結果的長度填充位置。若是結果是NULL （僅返回時可能d和d == NULL），它的長度被認爲是零。

此函數用於lua_tolstring獲取其結果，所以該函數的全部轉換和警告都適用於此處。

luaL_optnumber
[-0，+ 0，v ]
lua_Number luaL_optnumber（lua_State * L，int arg，lua_Number d）;
若是函數參數arg是數字，則返回此數字。若是此參數不存在或爲零，則返回d。不然，會引起錯誤。

luaL_optstring
[-0，+ 0，v ]
const char * luaL_optstring（lua_State * L，
int arg，
const char * d）;
若是函數參數arg是字符串，則返回此字符串。若是此參數不存在或爲零，則返回d。不然，會引起錯誤。

luaL_prepbuffer
[ - ？，+？，m ]
char * luaL_prepbuffer（luaL_Buffer * B）;
至關於luaL_prepbuffsize 預約義的大小LUAL_BUFFERSIZE。

luaL_prepbuffsize
[ - ？，+？，m ]
char * luaL_prepbuffsize（luaL_Buffer * B，size_t sz）;
返回一個大小空間的地址sz ，您能夠在其中複製要添加到緩衝區的字符串B （請參閱參考資料luaL_Buffer）。將字符串複製到此空間後，必須luaL_addsize使用字符串的大小調用 以將其實際添加到緩衝區。

luaL_pushresult
[ - ？，+ 1，m ]
void luaL_pushresult（luaL_Buffer * B）;
完成緩衝區的使用，B將最終字符串留在堆棧頂部。

luaL_pushresultsize
[ - ？，+ 1，m ]
void luaL_pushresultsize（luaL_Buffer * B，size_t sz）;
至關於序列luaL_addsize，luaL_pushresult。

luaL_ref
[-1，+ 0，m ]
int luaL_ref（lua_State * L，int t）;
在索引的表中 建立並返回堆棧頂部對象的引用t（並彈出對象）。

引用是惟一的整數鍵。只要您不手動將整數鍵添加到表中t，就 luaL_ref能夠確保它返回的鍵的惟一性。您能夠r 經過調用檢索引用引用的對象lua_rawgeti(L, t, r)。函數luaL_unref釋放引用及其關聯對象。

若是堆棧頂部的對象爲nil，則 luaL_ref返回常量LUA_REFNIL。LUA_NOREF保證常量與返回的任何引用不一樣luaL_ref。

luaL_Reg
typedef struct luaL_Reg {
const char * name;
lua_CFunction func;
} luaL_Reg;
輸入要註冊的函數數組 luaL_setfuncs。 name是函數名稱，func是指向函數的指針。任何數組都luaL_Reg必須以兩個name和func都是的sentinel條目結束NULL。

luaL_requiref
[-0，+ 1，e ]
void luaL_requiref（lua_State * L，const char * modname，
lua_CFunction openf，int glb）;
若是modname還沒有出現package.loaded，則調用openf帶有字符串modname做爲參數的函數並將調用結果設置爲package.loaded[modname]，就像調用該函數同樣require。

若是glb是，則還將模塊存儲到全局modname。

在堆棧上留下模塊的副本。

luaL_setfuncs
[-nup，+ 0，m ]
void luaL_setfuncs（lua_State * L，const luaL_Reg * l，int nup）;
將數組中的全部函數l （請參閱luaL_Reg）註冊到堆棧頂部的表中（在可選的upvalues下面，請參閱下一個）。

當nup不爲零時，建立全部函數共享nupupvalues，必須先將其推送到庫表頂部的堆棧上。註冊後，這些值將從堆棧中彈出。

luaL_setmetatable
[-0，+ 0， - ]
void luaL_setmetatable（lua_State * L，const char * tname）;
將堆棧頂部對象的元表設置爲與tname 註冊表中的名稱關聯的元表（請參閱參考資料luaL_newmetatable）。

luaL_Stream
typedef struct luaL_Stream {
文件* f;
lua_CFunction closef;
} luaL_Stream;
文件句柄的標準表示，由標準I / O庫使用。

文件句柄實現爲完整的用戶數據，並調用metatable LUA_FILEHANDLE （其中LUA_FILEHANDLE是一個帶有實際metatable名稱的宏）。metatable由I / O庫建立（請參閱luaL_newmetatable）。

此userdata必須以結構開頭luaL_Stream; 它能夠包含此初始結構後的其餘數據。字段f指向相應的C流（或者它能夠NULL指示未徹底建立的句柄）。字段closef指向Lua函數，當句柄關閉或收集時，將調用該函數來關閉流; 此函數接收文件句柄做爲其惟一參數，而且必須返回true（若是成功）或nil加錯誤消息（若是出錯）。一旦Lua調用此字段，它就會將字段值更改成NULL 表示句柄已關閉。

luaL_testudata
[-0，+ 0，m ]
void * luaL_testudata（lua_State * L，int arg，const char * tname）;
此功能的做用相似於luaL_checkudata，可是，當測試失敗時，它返回NULL而不是引起錯誤。

luaL_tolstring
[-0，+ 1，e ]
const char * luaL_tolstring（lua_State * L，int idx，size_t * len）;
將給定索引處的任何Lua值轉換爲合理格式的C字符串。生成的字符串被壓入堆棧並由函數返回。若是len不是NULL，該函數也設置*len字符串長度。

若是該值具備帶__tostring字段的元表，則luaL_tolstring使用值做爲參數調用相應的元方法，並將調用的結果用做其結果。

luaL_traceback
[-0，+ 1，m ]
void luaL_traceback（lua_State * L，lua_State * L1，const char * msg，
int level）;
建立並推送堆棧的回溯L1。若是msg不是NULL，則在追溯開始時附加。該level參數指示啓動回溯的級別。

luaL_typename
[-0，+ 0， - ]
const char * luaL_typename（lua_State * L，int index）;
返回給定索引處的值類型的名稱。

luaL_unref
[-0，+ 0， - ]
void luaL_unref（lua_State * L，int t，int ref）;
ref從索引中的表中 釋放引用t （請參閱參考資料luaL_ref）。該條目將從表中刪除，以即可以收集引用的對象。該參考ref也被釋放以便再次使用。

若是ref是LUA_NOREF或LUA_REFNIL， luaL_unref什麼也不作。

luaL_where
[-0，+ 1，m ]
void luaL_where（lua_State * L，int lvl）;
將一個字符串壓入堆棧，以識別lvl調用堆棧中控件的當前位置。一般，此字符串具備如下格式：

chunkname：currentline：
級別0是運行功能，級別1是調用運行功能的功能等。

此函數用於構建錯誤消息的前綴。

6 - 標準圖書館
標準的Lua庫提供了直接經過C API實現的有用功能。其中一些功能爲語言提供基本服務（例如，type和getmetatable）; 其餘人提供對「外部」服務的訪問（例如，I / O）; 和其餘能夠在Lua自己實現，可是很是有用或具備值得在C中實現的關鍵性能要求（例如，table.sort）。

全部庫都經過官方C API實現，並做爲單獨的C模塊提供。目前，Lua擁有如下標準庫：

基礎圖書館（§6.1）;
協程庫（§6.2）;
包庫（§6.3）;
字符串操做（第6.4節）;
基本的UTF-8支持（§6.5）;
表操做（第6.6節）;
數學函數（§6.7）（sin，log等）;
輸入和輸出（§6.8）;
操做系統設施（§6.9）;
調試設施（§6.10）。
除了基本庫和包庫以外，每一個庫都將其全部功能做爲全局表的字段或其對象的方法提供。

要訪問這些庫，C主機程序應調用該luaL_openlibs函數，該函數將打開全部標準庫。或者，宿主程序能夠經過 luaL_requiref調用 luaopen_base（對於基本庫）， luaopen_package（對於包庫）， luaopen_coroutine（對於協程庫）， luaopen_string（對於字符串庫）， luaopen_utf8（對於UTF8庫）， luaopen_table（對於表庫）， luaopen_math（用於數學庫）， luaopen_io（用於I / O庫）， luaopen_os（用於操做系統庫）和luaopen_debug（用於調試庫）。這些函數在中聲明lualib.h。

6.1 - 基本功能
基本庫爲Lua提供核心功能。若是您未在應用程序中包含此庫，則應仔細檢查是否須要爲其某些工具提供實現。

assert (v [, message])
error若是其參數的v值爲false（即，nil或false），則 調用; 不然，返回其全部參數。若是出錯， message則爲錯誤對象; 缺席時，默認爲「 assertion failed!」

collectgarbage ([opt [, arg]])
此函數是垃圾收集器的通用接口。它根據第一個參數執行不一樣的功能opt：

「 collect」： 執行完整的垃圾收集週期。這是默認選項。
「 stop」： 中止自動執行垃圾收集器。收集器將僅在顯式調用時運行，直到調用從新啓動它。
「 restart」： 從新啓動垃圾收集器的自動執行。
「 count」： 返回Lua使用的總內存（以KB爲單位）。該值具備小數部分，所以它乘以1024得出Lua使用的確切字節數（溢出除外）。
「 step」： 執行垃圾收集步驟。步驟「大小」由arg。控制。若是值爲零，則收集器將執行一個基本（不可分割）步驟。對於非零值，收集器將執行，就好像Lua已分配了該內存量（以KB爲單位）。若是步驟完成收集週期，則返回true。
「 setpause」： 設置arg爲收集器暫停的新值（參見§2.5）。返回暫停的先前值。
「 setstepmul」： 設置arg爲收集器的步長乘數的新值（參見§2.5）。返回step的先前值。
「 isrunning」： 返回一個布爾值，告訴收集器是否正在運行（即未中止）。
dofile ([filename])
打開指定文件並將其內容做爲Lua塊執行。在不帶參數的狀況下調用時， dofile執行標準輸入（stdin）的內容。返回塊返回的全部值。若是出現錯誤，dofile請將錯誤傳播給其調用方（即，dofile不以受保護模式運行）。
error (message [, level])
終止最後一個被調用的受保護函數，並message做爲錯誤對象返回。功能error永不迴歸。
一般，error若是消息是字符串，則在消息開頭添加有關錯誤位置的一些信息。該level參數指定如何獲得錯誤的位置。對於級別1（默認值），錯誤位置是error調用函數的位置 。級別2將錯誤指向調用的函數的位置error; 等等。傳遞0級可避免向消息添加錯誤位置信息。

_G
保存全局環境的全局變量（不是函數）（參見§2.2）。Lua自己不使用這個變量; 改變其價值不會影響任何環境，反之亦然。
getmetatable (object)
若是object沒有metatable，則返回nil。不然，若是對象的metatable具備__metatable字段，則返回關聯的值。不然，返回給定對象的元表。

ipairs (t)
返回三個值（迭代器函數，表t和0）以便構造

對於i，v在ipairs（t）身體結束
將迭代鍵值對（1,t[1]），（2,t[2]），...，直到第一個零值。

load (chunk [, chunkname [, mode [, env]]])
加載一塊。

若是chunk是字符串，則塊是此字符串。若是chunk是一個函數， load重複調用它來獲取塊塊。每次調用chunk必須返回一個與先前結果鏈接的字符串。返回空字符串，nil或no值表示塊的結尾。

若是沒有語法錯誤，則將編譯的塊做爲函數返回; 不然，返回nil加上錯誤消息。

若是結果函數具備up值，則將第一個upvalue設置爲env（若是給出該參數）的值，或者設置爲全局環境的值。其餘upvalues初始化爲nil。（當你加載一個主塊時，結果函數將老是隻有一個upvalue，即_ENV變量（參見§2.2）。可是，當你加載一個從函數建立的二進制塊（參見參考資料）時string.dump，生成的函數能夠有一個任意數字upvalues。）全部upvalues都是新鮮的，也就是說，它們不與任何其餘函數共享。

chunkname用做錯誤消息和調試信息的塊名稱（參見§4.9）。若是不存在，則默認爲chunk，若是chunk是字符串，則爲「 =(load)」。

字符串mode控制塊是文本仍是二進制（即預編譯塊）。它能夠是字符串「 b」（僅二進制塊），「 t」（僅文本塊）或「 bt」（二進制和文本）。默認值爲「 bt」。

Lua不檢查二進制塊的一致性。惡意製做的二進制塊可能會使解釋器崩潰。

loadfile ([filename [, mode [, env]]])
相似於load，但filename 若是沒有給出文件名，則從文件或標準輸入中獲取塊。

next (table [, index])
容許程序遍歷表的全部字段。它的第一個參數是一個表，它的第二個參數是該表中的索引。 next返回表的下一個索引及其關聯值。當使用nil做爲其第二個參數調用時， next返回初始索引及其關聯值。使用最後一個索引調用時，或者在空表中使用nil時， next返回nil。若是第二個參數不存在，則將其解釋爲nil。特別是，您可使用next(t)檢查表是否爲空。

未指定索引的枚舉順序， 即便對於數字索引也是如此。（要遍歷表中數字順序，使用一個數值爲）。

next若是在遍歷期間將任何值分配給表中不存在的字段，則 行爲未定義。可是，您能夠修改現有字段。特別是，您能夠清除現有字段。

pairs (t)
若是t有一個metamethod __pairs，請使用tas參數調用它，並返回調用的前三個結果。

不然，返回三個值：next函數，表t和nil，以便構造

對於k，v成對（t）作身體結束
將遍歷表的全部鍵值對t。

有關next在遍歷期間修改表的注意事項，請參閱函數。

pcall (f [, arg1, ···])
調用f在保護模式下使用給定參數運行。這意味着內部的任何錯誤 f都不會傳播; 相反，pcall捕獲錯誤並返回狀態代碼。它的第一個結果是狀態代碼（布爾值），若是調用成功且沒有錯誤，則爲true。在這種狀況下，pcall也會在第一個結果以後返回調用的全部結果。若是有任何錯誤，則pcall返回false加上錯誤消息。

print (···)
接收任意數量的參數並將其值打印到stdout，使用該tostring函數將每一個參數轉換爲字符串。 print不是用於格式化輸出，而只是做爲顯示值的快速方法，例如用於調試。要徹底控制輸出，請使用string.format和io.write。
rawequal (v1, v2)
檢查是否v1等於v2，而不調用__eqmetamethod。返回一個布爾值。
rawget (table, index)
獲取實際值table[index]，而不調用__indexmetamethod。 table必須是一張桌子; index多是任何價值。
rawlen (v)
返回對象的長度，該對象v必須是表或字符串，而不調用元__len方法。返回一個整數。
rawset (table, index, value)
設置table[index]to 的實際值value，而不調用__newindexmetamethod。 table必須是一個表， index任何不一樣於nil和NaN的value值，以及任何Lua值。
此函數返回table。

select (index, ···)
若是index是數字，則返回參數號後面的全部參數index; 從末尾開始的負數索引（-1是最後一個參數）。不然，index必須是字符串"#"，並select返回它收到的額外參數的總數。

setmetatable (table, metatable)
設置給定表的元表。（要從Lua代碼更改其餘類型的元表，必須使用調試庫（第6.10節）。）若是metatable爲nil，則刪除給定表的元表。若是原始元表具備__metatable字段，則會引起錯誤。

此函數返回table。

tonumber (e [, base])
當使用no調用時base， tonumber嘗試將其參數轉換爲數字。若是參數已是數字或可轉換爲數字的字符串，則tonumber返回此數字; 不然，它返回零。

根據Lua的詞彙約定，字符串的轉換能夠產生整數或浮點數（見§3.1）。（該字符串可能包含前導和尾隨空格以及符號。）

當調用時base，則e必須是一個字符串，在該基數中被解釋爲整數。鹼能夠是2至36之間的任何整數，包括端值。在10以上的基數中，字母' A'（大寫或小寫）表明10，' B'表明11，依此類推，' Z'表明35.若是字符串e不是給定基數中的有效數字，則函數返回零。

tostring (v)
接收任何類型的值並將其轉換爲人類可讀格式的字符串。（要徹底控制數字的轉換方式，請使用string.format。）
若是metatable v有一個__tostring字段，則tostring使用vas參數調用相應的值，並使用調用的結果做爲結果。

type (v)
返回其惟一參數的類型，編碼爲字符串。該函數的可能結果是「 nil」（字符串，而不是值nil），「 number」，「 string」，「 boolean」，「 table」，「 function」，「 thread」和「 userdata」。
_VERSION
一個全局變量（不是函數），它包含一個包含正在運行的Lua版本的字符串。此變量的當前值爲「 Lua 5.3」。

xpcall (f, msgh [, arg1, ···])
此函數相似於pcall，但它設置了一個新的消息處理程序msgh。

6.2 - 協同操做
該庫包含操做協同程序的操做，這些操做來自表格內部coroutine。關於協同程序的通常描述見§2.6。

coroutine.create (f)
用身體建立一個新的協同程序f。 f必須是一個功能。返回這個新的協同程序，一個具備類型的對象"thread"。

coroutine.isyieldable ()
當正在運行的協程能夠產生時返回true。

若是一個正在運行的協程不是主線程而且它不在非屈服C函數內，那麼它是能夠獲得的。

coroutine.resume (co [, val1, ···])
開始或繼續執行協同程序co。第一次你恢復一個協程，它開始運行它的身體。值val1，...做爲參數傳遞給body函數。若是協程已經產生， resume從新啓動它; 值val1，...做爲yield的結果傳遞。

若是協同程序運行沒有任何錯誤，則 resume返回true加上傳遞給的任何值yield （當協同程序產生時）或正文函數返回的任何值（當協程終止時）。若是有任何錯誤，則 resume返回false加上錯誤消息。

coroutine.running ()
返回正在運行的協同程序加上一個布爾值，當正在運行的協同程序是主程序時，返回true。

coroutine.status (co)
返回coroutine的狀態co，做爲字符串： "running"，若是協同程序正在運行（即，它被調用status）; "suspended"若是協程暫停通話yield，或者它尚未開始運行; "normal"若是協程是活動的但沒有運行（也就是說，它已經恢復了另外一個協同程序）; 而"dead"若是協程完成其身體功能，或者若是它已中止錯誤。

coroutine.wrap (f)
用身體建立一個新的協同程序f。 f必須是一個功能。返回一個函數，每次調用它時都會恢復協同程序。傳遞給函數的任何參數都表現爲額外的參數resume。返回與resume第一個布爾值相同的返回值。若是出現錯誤，則傳播錯誤。

coroutine.yield (···)
暫停執行調用協程。任何參數yield都做爲額外結果傳遞給resume。

6.3 - 模塊
包庫提供了在Lua中加載模塊的基本工具。它直接在全局環境中導出一個函數： require。其餘全部內容都在表格中導出package。

require (modname)
加載給定的模塊。該函數首先查看package.loaded表以肯定是否modname已加載。若是是，則require返回存儲在的值package.loaded[modname]。不然，它會嘗試爲模塊找到加載程序。

要查找裝載程序，請 require按package.searchers順序進行操做。經過更改此序列，咱們能夠更改require模塊的查找方式。如下說明基於默認配置package.searchers。

第一次require查詢package.preload[modname]。若是它有一個值，則該值（必須是函數）是加載器。不然require使用存儲的路徑搜索Lua加載程序package.path。若是失敗，它將使用存儲的路徑搜索C加載程序package.cpath。若是這也失敗了，它會嘗試一個多功能的加載器（參見參考資料package.searchers）。

找到 require加載器後，使用兩個參數調用加載器： modname一個額外的值取決於它如何獲取加載器。（若是加載器來自文件，則此額外值是文件名。）若是加載器返回任何非零值， require則將返回的值賦給package.loaded[modname]。若是加載器未返回非零值且未向其分配任何值package.loaded[modname]，則爲此條目require指定true。不管如何，require返回最終值package.loaded[modname]。

若是加載或運行模塊時出現任何錯誤，或者沒法找到模塊的任何加載程序，則會require引起錯誤。

package.config
描述包的一些編譯時配置的字符串。該字符串是一系列行：

第一行是目錄分隔符字符串。\對於Windows，默認爲' '，/對於全部其餘系統，默認爲' ' 。
第二行是分隔路徑中模板的字符。默認爲' ;'。
第三行是標記模板中替換點的字符串。默認爲' ?'。
第四行是一個字符串，在Windows中的路徑中，由可執行文件的目錄替換。默認爲' !'。
第五行是在構建luaopen_函數名時忽略其後的全部文本的標記。默認爲' -'。
package.cpath
require搜索C加載程序 所使用的路徑。

Lua初始化C路徑package.cpath的方式與初始化Lua路徑的方式相同package.path，使用環境變量LUA_CPATH_5_3或環境變量LUA_CPATH，或者定義的默認路徑luaconf.h。

package.loaded
用於require控制已加載哪些模塊的表。當您須要模塊modname且 package.loaded[modname]不是false時， require只需返回存儲在那裏的值。

這個變量只是對真實表的引用; 對此變量的賦值不會更改使用的表require。

package.loadlib (libname, funcname)
動態連接主機程序與C庫libname。

若是funcname是「 *」，則它僅連接到庫，使庫導出的符號可用於其餘動態連接庫。不然，它funcname在庫中查找函數並將此函數做爲C函數返回。因此，funcname必須遵循lua_CFunction原型（見lua_CFunction）。

這是一個低級功能。它徹底繞過了封裝和模塊系統。require與之不一樣，它不執行任何路徑搜索，也不會自動添加擴展。 libname必須是C庫的完整文件名，包括必要時的路徑和擴展名。 funcname必須是C庫導出的確切名稱（可能取決於使用的C編譯器和連接器）。

標準C不支持此功能。所以，它僅適用於某些平臺（Windows，Linux，Mac OS X，Solaris，BSD以及支持該dlfcn標準的其餘Unix系統）。

package.path
require搜索Lua加載程序 所使用的路徑。

在啓動時，若是未定義這些環境變量，Lua會使用環境變量LUA_PATH_5_3或環境變量的值LUA_PATH或使用定義的默認路徑初始化此變量luaconf.h。;;環境變量值中的任何「 」都將替換爲默認路徑。

package.preload
用於存儲特定模塊的加載器的表（請參閱參考資料require）。

這個變量只是對真實表的引用; 對此變量的賦值不會更改使用的表require。

package.searchers
用於require控制如何加載模塊的表。

該表中的每一個條目都是一個搜索器功能。在查找模塊時， require按升序調用每一個搜索器，模塊名稱（給定的參數require）做爲其惟一參數。該函數能夠返回另外一個函數（模塊加載器）加上一個將傳遞給該加載器的額外值，或一個字符串解釋爲何它沒有找到該模塊（或者若是它沒有什麼可說的則爲nil）。

Lua使用四個搜索器函數初始化此表。

第一個搜索者只是在package.preload表中尋找一個裝載機 。

第二個搜索器使用存儲在的路徑查找加載器做爲Lua庫package.path。搜索按功能中的描述完成package.searchpath。

第三個搜索器使用變量給出的路徑查找加載器做爲C庫package.cpath。一樣，搜索按功能中的描述完成package.searchpath。例如，若是C路徑是字符串

「./?.so;./?.dll;/usr/local/?/init.so」
對於模塊搜索foo 將嘗試打開這些文件./foo.so，./foo.dll以及/usr/local/foo/init.so以該順序。一旦找到C庫，該搜索者首先使用動態連接工具將應用程序與庫連接。而後它嘗試在庫中找到一個C函數用做加載器。此C函數的名稱是luaopen_與模塊名稱的副本鏈接的字符串「 」，其中每一個點由下劃線替換。此外，若是模塊名稱具備連字符，則刪除其後綴（幷包括）第一個連字符後的後綴。例如，若是模塊名稱是a.b.c-v2.1，則函數名稱將爲luaopen_a_b_c。

第四個搜索者嘗試一體化裝載機。它在C路徑中搜索庫以獲取給定模塊的根名稱。例如，在須要時a.b.c，它將搜索C庫a。若是找到，它會查看子模塊的打開函數; 在咱們的例子中，那將是luaopen_a_b_c。使用此工具，程序包能夠將多個C子模塊打包到一個單獨的庫中，每一個子模塊保持其原始的打開功能。

除第一個（預加載）以外的全部搜索者都返回了找到模塊的文件名的額外值，如返回的那樣package.searchpath。第一個搜索者沒有返回額外的值。

package.searchpath (name, path [, sep [, rep]])
搜索給定name的給定path。

路徑是包含由分號分隔的一系列模板的字符串 。對於每一個模板，該函數用一個副本替換模板中的每一個詢問標記（若是有的話），name 其中全部出現的sep （默認爲一個點）被rep （系統的目錄分隔符，默認狀況下）替換，而後嘗試打開生成的文件名。

例如，若是路徑是字符串

「./?.lua;./?.lc;/usr/local/?/init.lua」
對於名稱搜索foo.a 將嘗試打開這些文件 ./foo/a.lua，./foo/a.lc以及 /usr/local/foo/a/init.lua以該順序。

返回它能夠在讀取模式下打開的第一個文件的結果名稱（在關閉文件以後），若是沒有成功則返回nil加錯誤消息。（此錯誤消息列出了它嘗試打開的全部文件名。）

6.4 - 字符串操做
該庫提供了字符串操做的通用函數，例如查找和提取子字符串以及模式匹配。在Lua中索引字符串時，第一個字符位於位置1（而不是0，如在C中）。容許指數爲負數，並從字符串末尾解釋爲向後索引。所以，最後一個字符位於-1，依此類推。

字符串庫在表中提供其全部功能 string。它還爲__index字段指向表的字符串設置元string表。所以，您能夠在面向對象的樣式中使用字符串函數。例如，string.byte(s,i) 能夠寫成s:byte(i)。

字符串庫採用單字節字符編碼。

string.byte (s [, i [, j]])
返回字符的內部數字代碼s[i]， s[i+1]，... s[j]。默認值爲i1; jis 的默認值i。這些指數按照相同的功能規則進行修正string.sub。
數字代碼不必定是跨平臺可移植的。

string.char (···)
接收零個或多個整數。返回一個長度等於參數個數的字符串，其中每一個字符的內部數字代碼等於其對應的參數。
數字代碼不必定是跨平臺可移植的。

string.dump (function [, strip])
返回包含給定函數的二進制表示（二進制塊）的load字符串，以便稍後此字符串返回該函數的副本（但具備新的upvalues）。若是strip是真值，則二進制表示可能不包括有關函數的全部調試信息，以節省空間。

具備upvalues的函數只保存其upvalue數。當（從新）加載時，這些upvalues接收包含nil的新實例。（您可使用調試庫以適合您須要的方式序列化和從新加載函數的upvalues。）

string.find (s, pattern [, init [, plain]])
在字符串中查找pattern（見§6.4.1） 的第一個匹配項 s。若是找到匹配項，則find返回s 該事件開始和結束的索引 ; 不然，它返回零。第三個可選的數字參數init指定從哪裏開始搜索; 它的默認值是1，能夠是負數。做爲第四個可選參數的值爲trueplain 會關閉模式匹配工具，所以該函數執行一個簡單的「查找子串」操做，沒有任何字符pattern被視爲魔術。注意，若是plain給出，那麼也init必須給出。

若是模式具備捕獲，則在成功匹配中，在兩個索引以後也返回捕獲的值。

string.format (formatstring, ···)
返回其可變數量的參數的格式化版本，遵循其第一個參數（必須是字符串）中給出的描述。格式字符串遵循與ISO C函數相同的規則sprintf。惟一的區別是選項/修飾符 *，h，L，l，n，和p不支持，而且有一個額外的選項，q。

該q選項在雙引號之間格式化一個字符串，必要時使用轉義序列，以確保Lua解釋器能夠安全地回讀它。例如，電話

string.format（'％q'，'帶有「引號」的字符串和\ n新行'）
可能會產生字符串：

「帶引號的字符串\」和\
新隊」
選項 A，a，E，e，f， G，和g全部指望一個數字做爲論據。選項c，d， i，o，u，X，並x 期待一個整數。當使用C89編譯器編譯Lua時，選項A和a（十六進制浮點數）不支持任何修飾符（標誌，寬度，長度）。

Option s須要一個字符串; 若是它的參數不是一個字符串，它將按照相同的規則轉換爲一個tostring。若是該選項具備任何修飾符（標誌，寬度，長度），則字符串參數不該包含嵌入的零。

string.gmatch (s, pattern)
返回一個迭代器函數，每次調用它時，都會返回字符串中的下一個捕獲pattern（參見§6.4.1）s。若是pattern指定沒有捕獲，則在每次調用中生成整個匹配。
例如，如下循環將遍歷字符串中的全部單詞s，每行打印一個：

s =「來自Lua的你好世界」
對於string.gmatch（s，「％a +」）中的w
打印（W）
結束
下一個示例key=value將給定字符串中的全部對收集到表中：

t = {}
s =「from = world，to = Lua」
for k，v in string.gmatch（s，「（％w +）=（％w +）」）do
t [k] = v
結束
對於此函數，^模式開頭的插入符號不能用做錨點，由於這會阻止迭代。

string.gsub (s, pattern, repl [, n])
返回一個副本，s 其中（參見§6.4.1）的全部（或第一個n，若是給定的）出現已被替換爲由其指定的替換字符串，能夠是字符串，表或函數。 還返回第二個值，即發生的匹配總數。該名稱來自Global SUBstitution。 patternreplgsubgsub
若是repl是字符串，則其值用於替換。字符 %能夠做爲轉義字符：任何序列中repl的形式的，具備d 1和9之間，表明着的值d個捕獲的子字符串。序列表明整場比賽。序列表明單一 。 %d%0%%%

若是repl是表，則使用第一個捕獲做爲鍵來查詢每一個匹配的表。

若是repl是函數，則每次匹配發生時都會調用此函數，並按順序將全部捕獲的子字符串做爲參數傳遞。

在任何狀況下，若是模式指定沒有捕獲，那麼它的行爲就像整個模式在捕獲中同樣。

若是表查詢或函數調用返回的值是字符串或數字，則將其用做替換字符串; 不然，若是它是假或零，則沒有替換（即原始匹配保留在字符串中）。

這裏有些例子：

x = string.gsub（「hello world」，「（％w +）」，「％1％1」）
- > x =「hello hello world world」

x = string.gsub（「hello world」，「％w +」，「％0％0」，1）
- > x =「hello hello world」

x = string.gsub（「來自Lua的hello world」，「（％w +）％s *（％w +）」，「％2％1」）
- > x =「世界你好Lua from」

x = string.gsub（「home = $ HOME，user = $ USER」，「％$（％w +）」，os.getenv）
- > x =「home = / home / roberto，user = roberto」

x = string.gsub（「4 + 5 = $ return 4 + 5 $」，「％$（.-）％$」，函數
返回負載（）
結束）
- > x =「4 + 5 = 9」

local t = {name =「lua」，version =「5.3」}
x = string.gsub（「$ name- $ version.tar.gz」，「％$（％w +）」，t）
- > x =「lua-5.3.tar.gz」
string.len (s)
接收一個字符串並返回其長度。空字符串的""長度爲0.嵌入的零計數，所以"a\000bc\000"長度爲5。
string.lower (s)
接收一個字符串並返回此字符串的副本，全部大寫字母都更改成小寫。全部其餘字符保持不變。大寫字母的定義取決於當前的語言環境。
string.match (s, pattern [, init])
在字符串中查找（見§6.4.1） 的第一個匹配項 。若是找到一個，則返回模式中的捕獲; 不然它返回零。若是指定no capture，則返回整個匹配。第三個可選的數字參數指定從哪裏開始搜索; 它的默認值是1，能夠是負數。 patternsmatchpatterninit
string.pack (fmt, v1, v2, ···)
返回一個二進制字符串，其中包含根據格式字符串打包的值v1（v2等，以二進制形式序列化）fmt（參見§6.4.2）。

string.packsize (fmt)
返回由string.pack 給定格式生成的字符串的大小。格式字符串不能包含可變長度選項' s'或' z'（參見§6.4.2）。

string.rep (s, n [, sep])
返回一個字符串，該字符串是n由字符串s分隔的字符串副本的串聯sep。默認值爲sep空字符串（即沒有分隔符）。若是n不是正數，則返回空字符串。
（請注意，只需調用此功能，便可輕鬆耗盡機器的內存。）

string.reverse (s)
返回一個s反轉字符串的字符串。
string.sub (s, i [, j])
返回從中s開始的子字符串i 並繼續直到j; i而且j能夠是否認的。若是j不存在，則假定它等於-1（與字符串長度相同）。特別是，調用string.sub(s,1,j)返回s 帶有length 的前綴j，string.sub(s, -i)（對於正數i）返回s 帶有length 的後綴i。
若是在負指數的轉換以後 i小於1，則將其校訂爲1.若是j大於字符串長度，則將其校訂爲該長度。若是在這些更正以後 i大於j，則該函數返回空字符串。

string.unpack (fmt, s [, pos])
根據格式字符串 返回打包在字符串中的值s（請參閱參考資料）（參見§6.4.2）。可選標記從哪裏開始讀入（默認爲1）。在讀取值以後，此函數還返回第一個未讀字節的索引。 string.packfmtposss

string.upper (s)
接收一個字符串並返回此字符串的副本，並將全部小寫字母更改成大寫。全部其餘字符保持不變。小寫字母的定義取決於當前的語言環境。
6.4.1 - 模式
在Lua圖案經過按期串，其經過模式匹配功能解釋爲圖案描述 string.find， string.gmatch， string.gsub，和string.match。本節介紹這些字符串的語法和含義（即它們匹配的內容）。

角色類：
甲字符類用於表示一組字符。在描述字符類時容許如下組合：

x :( 其中 x不是魔術字符之一 ^$()%.[]*+-?）表明字符 x自己。
.:(一個點）表明全部字符。
%a：表明全部字母。
%c：表示全部控制字符。
%d：表明全部數字。
%g：表示除空格外的全部可打印字符。
%l：表示全部小寫字母。
%p：表示全部標點字符。
%s：表示全部空格字符。
%u：表示所有大寫字母。
%w：表明全部字母數字字符。
%x：表示全部十六進制數字。
%x:(其中x是任何非字母數字字符）表示字符x。這是逃避魔法角色的標準方法。任何非字母數字字符（包括全部標點字符，甚至是非魔法字符）均可以在%用於在模式中表示自身時加上' '。
[set]： 表示集合中全部字符的並集的類。能夠經過使用' -' 以升序分隔範圍的結束字符來指定一系列字符。上述全部類%x也能夠用做集合中的組件。集合中的全部其餘字符表明本身。例如，[%w_]（或[_%w]）表示全部字母數字字符加下劃線， [0-7]表示八進制數字，並[0-7%l%-]表示八進制數字加上小寫字母加上' -'字符。
您能夠將一個右方括號放在一個集合中，方法是將其做爲集合中的第一個字符。您能夠經過將連字符定位爲集合中的第一個或最後一個字符來將連字符放入集合中。（對於這兩種狀況，您也可使用轉義。）

範圍和類之間的交互未定義。所以，模式喜歡[%a-z]或[a-%%] 沒有意義。

[^set]： 表示set的補碼，其中set如上所述。
對於由單個字母（%a，%c等）表示的全部類，相應的大寫字母表示類的補充。例如，%S表示全部非空格字符。

字母，空格和其餘字符組的定義取決於當前區域設置。特別是，該課程[a-z]可能不等同於%l。

圖案項目：
甲圖案項能夠是

單個字符類，匹配類中的任何單個字符;
單個字符類後跟' *'，它匹配類中零個或多個字符的重複。這些重複項老是匹配最長的序列;
單個字符類後跟' +'，它匹配類中一個或多個重複的字符。這些重複項老是匹配最長的序列;
單個字符類後跟' -'，它也匹配類中零個或多個字符的重複。與' *' 不一樣，這些重複項老是匹配最短的序列;
單個字符類後跟' ?'，它匹配類中零個或一個字符。若是可能，它老是匹配一次;
%n，n爲1到9之間; 這樣的項匹配一個等於第n個捕獲字符串的子字符串（見下文）;
%bxy，其中x和y是兩個不一樣的字符; 這樣的項目相匹配，與開頭的字符串 X，結尾 ÿ，而且其中X和Ÿ是平衡的。這意味着，若是一個讀取由左到右，數串+1爲X和-1的Ÿ，結束ÿ是第一Ÿ當計數到達0舉例來講，該項目%b()匹配與平衡的括號表達式。
%f[set]，一種前沿模式 ; 這樣的項匹配任何位置的空字符串，使得下一個字符屬於set ，而前一個字符不屬於set。集合集如前所述進行解釋。主題的開頭和結尾都被處理爲好像是' \0'。
圖案：
甲圖案是圖案項的序列。^模式開頭的插入符號在主題字符串的開頭處錨定匹配。$模式末尾的' '將主題字符串末尾的匹配錨定在一塊兒。在其餘位置，' ^'和' $'沒有特殊含義並表明本身。

捕獲：
模式能夠包含括在括號中的子模式; 他們描述了捕獲。當匹配成功時，存儲（捕獲）與捕獲匹配的主題字符串的子串以供未來使用。捕獲根據其左括號進行編號。例如，在模式中"(a*(.)%w(%s*))"，字符串匹配的一部分"a*(.)%w(%s*)"被存儲爲第一次捕獲（所以具備數字1）; 字符匹配「 .」用數字2捕獲，匹配「 %s*」 的部分用數字3表示。

做爲特殊狀況，空捕獲()捕獲當前字符串位置（數字）。例如，若是咱們"()aa()"在字符串上應用模式"flaaap"，則會有兩個捕獲：3和5。

6.4.2 - 打包和解包的格式字符串
的第一個參數string.pack， string.packsize以及string.unpack 是一個格式字符串，它描述告終構的佈局正在建立或讀取。

格式字符串是一系列轉換選項。轉換選項以下：

<：設置小端
>：設大端
=：設置本機端
![n]：將最大對齊設置爲n （默認爲本機對齊）
b：有符號的字節（char）
B：無符號字節（char）
h：簽名short（原生大小）
H：未簽名short（原生大小）
l：簽名long（原生大小）
L：未簽名long（原生大小）
j： alua_Integer
J： alua_Unsigned
T： a size_t（原生大小）
i[n]：int帶n字節的簽名（默認爲本機大小）
I[n]：int帶n字節的無符號（默認爲本機大小）
f： a float（原生大小）
d： a double（原生大小）
n： alua_Number
cn：具備n字節的固定大小的字符串
z：一個以零結尾的字符串
s[n]：一個字符串，其長度編碼爲帶n字節的無符號整數（默認爲a size_t）
x：填充的一個字節
Xop：根據選項對齊的空項op （不然將被忽略）
' ':(空格）被忽略了
（「 」表示可選的整數。）除了填充，空格和配置（選項「 」），每一個選項對應一個參數（in ）或一個結果（in ）。 [n]xX <=>!string.packstring.unpack

對於選項「 」，「 」，「 」和「 」， 能夠是1到16之間的任何整數。全部積分選項檢查溢出; 檢查給定值是否適合給定的大小; 檢查讀取值是否適合Lua整數。 !nsninInnstring.packstring.unpack

任何格式字符串都以「 !1=」 爲前綴，即最大對齊爲1（無對齊）和本機字節序開始。

對齊的工做原理以下：對於每一個選項，格式得到額外的填充，直到數據以偏移量開始，該偏移量是選項大小和最大對齊之間的最小值的倍數; 此最小值必須是2的冪。選項「 c」和「 z」不對齊; 選項「 s」跟隨其起始整數的對齊。

全部填充都用零填充string.pack （並忽略string.unpack）。

6.5 - UTF-8支持
該庫爲UTF-8編碼提供基本支持。它在表格中提供了全部功能utf8。除了處理編碼以外，該庫不提供對Unicode的任何支持。任何須要字符含義的操做（如字符分類）都在其範圍以外。

除非另有說明，不然全部指望字節位置做爲參數的函數都假定給定位置是字節序列的開頭或者加上主題字符串的長度。與字符串庫中同樣，負索引從字符串的末尾開始計算。

utf8.char (···)
接收零個或多個整數，將每一個整數轉換爲其對應的UTF-8字節序列，並返回一個字符串，其中包含全部這些序列的串聯。
utf8.charpattern
假設主題是有效的UTF-8字符串 ，模式（字符串，而不是函數）「 [\0-\x7F\xC2-\xF4][\x80-\xBF]*」（參見§6.4.1），它剛好匹配一個UTF-8字節序列。
utf8.codes (s)
返回值以便構造

for p，c in utf8.codes（s）作body end
將迭代字符串中的全部字符s，其中p包括c每一個字符的位置（以字節爲單位）和代碼點。若是它遇到任何無效的字節序列，則會引起錯誤。

utf8.codepoint (s [, i [, j]])
從s 字節位置i和j（包括二者）之間的全部字符返回代碼點（做爲整數）。默認i值爲1，而jis爲i。若是它遇到任何無效的字節序列，則會引起錯誤。
utf8.len (s [, i [, j]])
返回字符串中s 以位置i和j（包括二者）之間開始的UTF-8字符數。默認i值爲1，for j爲-1。若是找到任何無效的字節序列，則返回false值加上第一個無效字節的位置。
utf8.offset (s, n [, i])
返回 從（從位置開始計數）的n第 - 字符編碼開始的位置（以字節爲單位） 。負數在位置以前獲取字符。當爲非負數時，默認值爲1 ，不然，從字符串末尾獲取第-th個字符的偏移量 。若是指定的字符既不在主題中也不在其結尾以後，則該函數返回nilsiniin#s + 1utf8.offset(s, -n)n。
做爲一種特殊狀況，當n爲0時，該函數返回包含i-th字節的字符編碼的開始s。

此函數假定這s是一個有效的UTF-8字符串。

6.6 - 表操做
該庫提供了表操做的通用函數。它在表格中提供了全部功能table。

請記住，只要操做須要表的長度，關於長度運算符的全部警告都適用（參見§3.4.7）。全部函數都忽略做爲參數給出的表中的非數字鍵。

table.concat (list [, sep [, i [, j]]])
給定一個列表，其中全部元素都是字符串或數字，返回字符串list[i]..sep..list[i+1] ··· sep..list[j]。默認值爲sep空字符串，默認i值爲1，默認j值爲is #list。若是i大於j，則返回空字符串。

table.insert (list, [pos,] value)
插入元件value在位置pos中list，上移的元素 list[pos], list[pos+1], ···, list[#list]。posis 的默認值#list+1，以便在列表末尾table.insert(t,x)插入一個調用。 xt

table.move (a1, f, e, t [,a2])
將元素從表移動a1到表a2，執行等效於如下多個賦值： a2[t],··· = a1[f],···,a1[e]。默認a2是a1。目標範圍能夠與源範圍重疊。要移動的元素數必須符合Lua整數。

返回目標表a2。

table.pack (···)
返回一個新表，其中全部參數都存儲在鍵1,2等中，並帶有n帶參數總數的字段「 」。請注意，結果表可能不是序列。

table.remove (list [, pos])
從list位置處的元素中刪除pos，返回已刪除元素的值。當pos是1和1之間的整數時#list，它會向下移動元素 list[pos+1], list[pos+2], ···, list[#list] 並擦除元素list[#list]; pos當#list爲0時，索引也能夠爲0，或#list + 1; 在這些狀況下，該功能會刪除該元素list[pos]。

posis 的默認值#list，以便調用table.remove(l)刪除列表的最後一個元素l。

table.sort (list [, comp])
排序列出一個給定的順序元素，就地，從list[1]到list[#list]。若是comp給定，那麼它必須是一個接收兩個列表元素的函數，而且當第一個元素必須在最後一個順序中的第二個元素以前時返回true（這樣，在排序以後， i < j暗示not comp(list[j],list[i])）。若是comp沒有給出，則使用標準Lua運算符<。

請注意，該comp函數必須對列表中的元素定義嚴格的部分順序; 也就是說，它必須是不對稱和傳遞的。不然，可能沒法進行有效排序。

排序算法不穩定：按給定順序認爲相等的元素可能會經過排序改變其相對位置。

table.unpack (list [, i [, j]])
返回給定列表中的元素。這個功能至關於

返回列表[i]，列表[i + 1]，...，列表[j]
默認狀況下，i是1而且j是#list。

6.7 - 數學函數
該庫提供基本的數學函數。它在表中提供了它的全部功能和常量math。帶有註釋「 integer/float」的函數給出整數參數的整數結果和浮點（或混合）參數的浮點結果。舍入函數（math.ceil，math.floor和math.modf）在結果適合整數範圍時返回整數，不然返回浮點數。

math.abs (x)
返回絕對值x。（整數/浮點）

math.acos (x)
返回x（以弧度表示）的反餘弦值。

math.asin (x)
返回x（以弧度表示）的反正弦值。

math.atan (y [, x])
返回y/x（以弧度表示）的反正切，但使用兩個參數的符號來查找結果的象限。（它也正確處理x零的狀況。）

默認值爲x1，以便調用math.atan(y) 返回反正切y。

math.ceil (x)
返回大於或等於的最小整數值x。

math.cos (x)
返回餘弦x（假設爲弧度）。

math.deg (x)
將角度x從弧度轉換爲度數。

math.exp (x)
返回值e x （其中e是天然對數的基數）。

math.floor (x)
返回小於或等於的最大整數值x。

math.fmod (x, y)
返回的除法的餘數x由y 該舍入到零商。（整數/浮點）

math.huge
浮點值HUGE_VAL，一個大於任何其餘數值的值。

math.log (x [, base])
返回x給定基數的對數。默認base值爲e （以便函數返回天然對數x）。

math.max (x, ···)
根據Lua運算符返回具備最大值的參數<。（整數/浮點）

math.maxinteger
一個整數，具備整數的最大值。
math.min (x, ···)
根據Lua運算符返回具備最小值的參數<。（整數/浮點）

math.mininteger
具備整數最小值的整數。
math.modf (x)
返回的整數部分x和小數部分x。它的第二個結果老是浮動。

math.pi
π 的值。

math.rad (x)
將角度x從度數轉換爲弧度。

math.random ([m [, n]])
當不帶參數調用時，返回一個在[0,1）範圍內具備均勻分佈的僞隨機浮點數 。當與兩個整數稱爲m和n， math.random返回與在範圍內均勻分佈的僞隨機整數[M，N] 。（值nm不能爲負數，必須符合Lua整數。）調用math.random(n)等效於math.random(1,n)。

此函數是C提供的underling僞隨機生成器函數的接口。

math.randomseed (x)
設置x爲僞隨機生成器的「種子」：相等的種子生成相等的數字序列。

math.sin (x)
返回x（假設爲弧度）的正弦值。

math.sqrt (x)
返回的平方根x。（您也可使用表達式x^0.5計算此值。）

math.tan (x)
返回x（假設爲弧度）的正切值。

math.tointeger (x)
若是值x可轉換爲整數，則返回該整數。不然，返回nil。

math.type (x)
返回「 integer」if x是整數，「 float」若是是浮點數，則返回nil，若是x不是數字則返回nil。

math.ult (m, n)
返回一個布爾值，當且僅當整數m低於整數n時，纔將它們做爲無符號整數進行比較。

6.8 - 輸入和輸出設施
I / O庫爲文件操做提供了兩種不一樣的樣式。第一個使用隱式文件句柄; 也就是說，有設置默認輸入文件和默認輸出文件的操做，全部輸入/輸出操做都在這些默認文件上。第二種樣式使用顯式文件句柄。

使用隱式文件句柄時，全部操做都由表提供io。使用顯式文件句柄時，操做io.open返回文件句柄，而後全部操做都做爲文件句柄的方法提供。

該表io還提供了由C它們的一般含義三個預約義的文件句柄： io.stdin，io.stdout，和io.stderr。I / O庫永遠不會關閉這些文件。

除非另有說明，不然全部I / O函數在失敗時返回nil（加上做爲第二個結果的錯誤消息和做爲第三個結果的系統相關錯誤代碼），而且成功時某些值與nil不一樣。在非POSIX系統中，錯誤消息和錯誤代碼的計算可能不是線程安全的，由於它們依賴於全局C變量errno。

io.close ([file])
至關於file:close()。若是沒有file，則關閉默認輸出文件。

io.flush ()
至關於io.output():flush()。

io.input ([file])
使用文件名調用時，它會打開命名文件（在文本模式下），並將其句柄設置爲默認輸入文件。使用文件句柄調用時，它只是將此文件句柄設置爲默認輸入文件。當不帶參數調用時，它返回當前的默認輸入文件。

若是出現錯誤，此函數會引起錯誤，而不是返回錯誤代碼。

io.lines ([filename, ···])
在讀取模式下打開給定的文件名，並返回一個file:lines(···)與打開的文件相似的迭代器函數。當迭代器函數檢測到文件結束時，它不返回任何值（完成循環）並自動關閉文件。

調用io.lines()（沒有文件名）至關於io.input():lines("*l"); 也就是說，它遍歷默認輸入文件的行。在這種狀況下，迭代器在循環結束時不會關閉文件。

若是出現錯誤，此函數會引起錯誤，而不是返回錯誤代碼。

io.open (filename [, mode])
此函數以字符串中指定的模式打開文件mode。若是成功，它將返回一個新的文件句柄。

該mode字符串能夠是下列任何一項：

「 r」：讀取模式（默認值）;
「 w」：寫模式;
「 a」：追加模式;
「 r+」：更新模式，保留全部之前的數據;
「 w+」：更新模式，刪除全部之前的數據;
「 a+」：追加更新模式，保留之前的數據，只容許在文件末尾寫入。
該mode字符串也能夠有一個「 b」末，這是須要在某些系統中以二進制方式打開該文件。

io.output ([file])
與此相似io.input，但在默認輸出文件上運行。

io.popen (prog [, mode])
此功能取決於系統，並不是在全部平臺上均可用。

prog在一個單獨的進程中 啓動程序並返回一個文件句柄，您可使用該句柄從該程序讀取數據（若是mode是"r"，默認）或將數據寫入該程序（若是mode是"w"）。

io.read (···)
至關於io.input():read(···)。

io.tmpfile ()
若是成功，則返回臨時文件的句柄。此文件在更新模式下打開，並在程序結束時自動刪除。

io.type (obj)
檢查是否obj是有效的文件句柄。"file"若是obj是打開的文件句柄，"closed file"則返回字符串，若是obj是關閉的文件句柄，則返回nil，若是obj不是文件句柄， 則返回nil。

io.write (···)
至關於io.output():write(···)。

file:close ()
關閉file。請注意，文件在其句柄被垃圾回收時會自動關閉，但這會花費不可預測的時間。

關閉建立的文件句柄時io.popen， file:close返回返回的相同值os.execute。

file:flush ()
保存全部書面數據file。

file:lines (···)
返回一個迭代器函數，每次調用它時，都會根據給定的格式讀取文件。若是沒有給出格式，則使用「 l」做爲默認值。做爲一個例子，建設

for c in file：lines（1）do body end
將從當前位置開始迭代文件的全部字符。與io.lines此不一樣，此函數在循環結束時不會關閉文件。

若是出現錯誤，此函數會引起錯誤，而不是返回錯誤代碼。

file:read (···)
file根據給定格式 讀取文件，指定要讀取的內容。對於每種格式，函數返回一個字符串或帶有讀取字符的數字，若是沒法讀取具備指定格式的數據，則返回nil。（在後一種狀況下，該函數不讀取後續格式。）在沒有格式的狀況下調用時，它使用讀取下一行的默認格式（見下文）。

可用的格式是

「 n」： 按照Lua的詞彙慣例讀取數字並將其做爲浮點數或整數返回。（數字能夠有前導空格和符號。）此格式始終讀取最長輸入序列，該序列是數字的有效前綴; 若是該前綴不造成有效數字（例如，空字符串，「 0x」或「 3.4e-」），則將其丟棄而且函數返回nil。
「 a」： 從當前位置開始讀取整個文件。在文件末尾，它返回空字符串。
「 l」： 讀取跳過行尾的下一行，在文件末尾返回nil。這是默認格式。
「 L」： 讀取保留行尾字符（若是存在）的下一行，在文件末尾返回nil。
number： 讀取最多爲此字節數的字符串，在文件末尾返回 nil。若是number爲零，則它不讀取任何內容並返回空字符串，或者在文件末尾返回 nil。
格式「 l」和「 L」僅應用於文本文件。

file:seek ([whence [, offset]])
設置並獲取從文件開頭開始測量的文件位置，offset加上由字符串指定的基數加上的位置whence，以下所示：

「 set」： base是位置0（文件的開頭）;
「 cur」：基數是當前位置;
「 end」： base是文件的結尾;
若是成功，則seek返回最終文件位置，以文件開頭的字節爲單位。若是seek失敗，則返回nil，加上描述錯誤的字符串。

whenceis 的默認值"cur"，而且for offset爲0.所以，調用file:seek()返回當前文件位置，而不更改它; 調用file:seek("set")將位置設置爲文件的開頭（並返回0）; 而且調用file:seek("end")將位置設置爲文件的末尾，並返回其大小。

file:setvbuf (mode [, size])
設置輸出文件的緩衝模式。有三種可用模式：

「 no」： 沒有緩衝; 任何輸出操做的結果當即出現。
「 full」： 徹底緩衝; 僅當緩衝區已滿或明確flush顯示文件時才執行輸出操做（請參閱參考資料io.flush）。
「 line」： 行緩衝; 輸出被緩衝，直到輸出換行或某些特殊文件（例如終端設備）有任何輸入。
對於最後兩種狀況，size 指定緩衝區的大小（以字節爲單位）。默認值是合適的大小。

file:write (···)
將每一個參數的值寫入file。參數必須是字符串或數字。

若是成功，此函數返回file。不然返回nil加上描述錯誤的字符串。

6.9 - 操做系統設施
該庫經過表實現os。

os.clock ()
返回程序使用的CPU時間（以秒爲單位）的近似值。

os.date ([format [, time]])
返回包含日期和時間的字符串或表，根據給定的字符串進行格式化format。

若是time參數存在，則表示要格式化的時間（os.time有關此值的說明，請參閱函數）。不然，date格式化當前時間。

若是format以' !' 開頭，則日期格式爲協調世界時。在這個可選字符以後，if format是字符串「 *t」，而後date返回一個包含如下字段的表： year，month（1-12），day（1-31）， hour（0-23），min（0-59），sec（0-61 ）， wday（工做日，1-7，星期日是1）， yday（一年中的一天，1-366），和isdst（夏令時標誌，布爾值）。若是信息不可用，則可能不存在該最後一個字段。

若是format不是「 *t」，則將date日期做爲字符串返回，根據與ISO C函數相同的規則進行格式化strftime。

在不帶參數的狀況下調用時， date返回依賴於主機系統和當前語言環境的合理日期和時間表示。（更具體地說，os.date()至關於os.date("%c")。）

在非POSIX系統中，因爲它依賴於C函數gmtime和C函數，所以該函數可能不是線程安全的localtime。

os.difftime (t2, t1)
返回t1不時t2 （以秒爲單位）的差別（其中時間是返回的值os.time）。在POSIX，Windows和其餘一些系統中，這個值剛好是t2-t1。

os.execute ([command])
此功能至關於ISO C功能system。它傳遞command給操做系統shell執行。 若是命令成功終止，則第一個結果爲true，不然爲nil。在第一個結果以後，函數返回一個字符串加一個數字，以下所示：

「 exit」： 命令正常終止; 如下數字是命令的退出狀態。
「 signal」： 命令被一個信號終止; 如下數字是終止命令的信號。
在沒有a的狀況下調用時command， os.execute若是shell可用，則返回一個true的布爾值。

os.exit ([code [, close]])
調用ISO C函數exit來終止宿主程序。若是code爲true，則返回狀態爲EXIT_SUCCESS; 若是code爲false，則返回狀態爲EXIT_FAILURE; 若是code是數字，則返回的狀態爲此數字。做爲默認值code是真。

若是可選的第二個參數close爲true，則在退出以前關閉Lua狀態。

os.getenv (varname)
返回流程環境變量的值，若是未定義變量varname，則返回nil。

os.remove (filename)
使用給定名稱刪除文件（或POSIX系統上的空目錄）。若是此函數失敗，則返回nil，加上描述錯誤和錯誤代碼的字符串。不然，它返回true。

os.rename (oldname, newname)
重命名指定的文件或目錄oldname來newname。若是此函數失敗，則返回nil，加上描述錯誤和錯誤代碼的字符串。不然，它返回true。

os.setlocale (locale [, category])
設置程序的當前區域設置。 locale是一個依賴於系統的字符串，用於指定語言環境; category是可選的字符串描述改變哪一類： "all"，"collate"，"ctype"， "monetary"，"numeric"，或"time"; 默認類別是"all"。該函數返回新語言環境的名稱，若是沒法知足請求，則返回nil。

若是locale是空字符串，則將當前語言環境設置爲實現定義的本機語言環境。若是locale是字符串「 C」，則將當前語言環境設置爲標準C語言環境。

當使用nil做爲第一個參數調用時，此函數僅返回給定類別的當前語言環境的名稱。

因爲它依賴於C函數，該函數可能不是線程安全的setlocale。

os.time ([table])
返回不帶參數調用的當前時間，或表示給定表指定的本地日期和時間的時間。此表必須包含字段year,, month和day，而且可能包含字段 hour（默認值爲12）， min（默認值爲0）， sec（默認值爲0）和isdst（默認值爲nil）。其餘字段將被忽略。有關這些字段的說明，請參閱該os.date函數。

這些字段中的值不須要在其有效範圍內。例如，若是sec是-10，則表示從其餘字段指定的時間起-10秒; 若是hour是1000，則表示從其餘字段指定的時間開始+1000小時。

返回的值是一個數字，其含義取決於您的系統。在POSIX，Windows和其餘一些系統中，此數字計算自某個給定開始時間（「epoch」）以來的秒數。在其它系統中，意思是未指定，而且經過返回的數字time只能用於做爲參數 os.date和os.difftime。

os.tmpname ()
返回一個文件名，該文件名可用於臨時文件。該文件必須在使用前顯式打開，並在再也不須要時顯式刪除。

在POSIX系統中，此功能還會建立具備該名稱的文件，以免安全風險。（在獲取名稱和建立文件之間的時間內，其餘人可能會建立具備錯誤權限的文件。）您仍然必須打開文件才能使用它並將其刪除（即便您不使用它）。

若是可能，您可能更喜歡使用io.tmpfile，它會在程序結束時自動刪除文件。

6.10 - 調試庫
該庫爲Lua程序提供調試接口（第4.9節）的功能。使用此庫時應當心謹慎。它的一些功能違反了關於Lua代碼的基本假設（例如，函數本地的變量不能從外部訪問; Lua代碼不能更改用戶數據元表; Lua程序不會崩潰），所以可能危及其餘安全代碼。此外，此庫中的某些功能可能很慢。

該庫中提供了此庫中的全部函數debug。全部在線程上運行的函數都有一個可選的第一個參數，它是要操做的線程。默認值始終是當前線程。

debug.debug ()
與用戶一塊兒進入交互模式，運行用戶輸入的每一個字符串。使用簡單的命令和其餘調試工具，用戶能夠檢查全局和局部變量，更改其值，計算表達式等。僅包含單詞的行cont結束此功能，以便調用者繼續執行。

請注意，命令debug.debug不會在詞法上嵌套在任何函數中，所以沒法直接訪問局部變量。

debug.gethook ([thread])
返回線程的當前掛鉤設置，做爲三個值：當前掛鉤函數，當前掛鉤掩碼和當前掛鉤計數（由debug.sethook函數設置）。

debug.getinfo ([thread,] f [, what])
返回包含函數信息的表。你能夠直接給出函數，或者你能夠給一個數字做爲值f，這意味着f在給定線程的調用堆棧級別運行的函數：level 0是當前函數（getinfo自己）; 級別1是調用的函數getinfo （尾部調用除外，它不依賴於堆棧）; 等等。若是f數字大於活動函數的數量，則getinfo返回nil。

返回的表能夠包含返回的全部字段lua_getinfo，字符串what描述要填寫的字段。默認設置what是獲取全部可用信息，但有效行表除外。若是存在，則選項' f'添加以func函數自己命名的字段。若是存在，則選項' L'添加一個以activelines有效行表命名的字段。

例如debug.getinfo(1,"n").name，若是能夠找到合理的名稱，則表達式返回當前函數的名稱，表達式debug.getinfo(print) 返回一個表，其中包含有關該print函數的全部可用信息。

debug.getlocal ([thread,] f, local)
此函數返回局部變量的名稱和值local，其中函數的索引f位於堆棧級別。此函數不只訪問顯式局部變量，還訪問參數，臨時變量等。

第一個參數或局部變量具備索引1，依此類推，遵循它們在代碼中聲明的順序，僅計算當前函數範圍內活動的變量。負指數是指vararg論證; -1是第一個vararg參數。若是沒有給定索引的變量，則函數返回nil，並在調用超出範圍的級別時引起錯誤。（您能夠調用debug.getinfo以檢查級別是否有效。）

以' ('（左括號）開頭的變量名稱表示沒有已知名稱的變量（內部變量，如循環控制變量，以及保存沒有調試信息的塊中的變量）。

該參數f也能夠是函數。在這種狀況下，getlocal只返回函數參數的名稱。

debug.getmetatable (value)
若是沒有 metatable，則返回給定value 或nil的metatable。

debug.getregistry ()
返回註冊表（參見§4.5）。

debug.getupvalue (f, up)
此函數返回upvalue的名稱和值以及up函數的索引f。該函數返回nil若是給定索引沒有upvalue，則。

以' ('（左括號）開頭的變量名稱表示沒有已知名稱的變量（來自沒有調試信息的塊保存的變量）。

debug.getuservalue (u)
返回與之關聯的Lua值u。若是u不是完整的用戶數據，則返回nil。

debug.sethook ([thread,] hook, mask [, count])
將給定函數設置爲鉤子。字符串mask和數字count描述什麼時候調用掛鉤。字符串掩碼能夠具備如下字符的任意組合，具備給定含義：

' c'：每次Lua調用一個函數時都會調用該鉤子;
' r'：每次Lua從函數返回時調用鉤子;
' l'：每次Lua進入新的代碼行時都會調用該鉤子。
此外，與count零不一樣，在每一個count指令以後也會調用鉤子。

當沒有參數調用時， debug.sethook關閉鉤子。

當鉤被調用時，它的第一個參數是描述已經觸發了呼叫事件的字符串： "call"（或"tail call"） "return"， "line"和"count"。對於行事件，鉤子還將新行號做爲其第二個參數。在鉤子內部，您能夠getinfo使用級別2 調用以獲取有關正在運行的函數的更多信息（級別0是getinfo函數，級別1是鉤子函數）。

debug.setlocal ([thread,] level, local, value)
此函數將值賦給value局部變量，並在堆棧local級別使用函數的索引level。若是沒有給定索引的局部變量，則函數返回nil，並在level超出範圍調用時引起錯誤。（您能夠調用getinfo以檢查級別是否有效。）不然，它返回局部變量的名稱。

debug.getlocal有關變量索引和名稱的更多信息， 請參閱。

debug.setmetatable (value, table)
將給定的metatable設置爲給value定table （能夠爲nil）。退貨value。

debug.setupvalue (f, up, value)
此函數分配值value與索引的upvalue up的功能f。若是給定索引沒有upvalue，則函數返回nil。不然，它返回upvalue的名稱。

debug.setuservalue (udata, value)
將給定value值設置爲與給定關聯的Lua值udata。 udata必須是完整的用戶數據。

退貨udata。

debug.traceback ([thread,] [message [, level]])
若是message存在但既不是字符串也不是nil，則此函數返回message而不進行進一步處理。不然，它返回一個字符串，其中包含調用堆棧的回溯。可選message字符串附加在回溯的開頭。可選level數字指示啓動回溯的級別（默認值爲1，函數調用traceback）。

debug.upvalueid (f, n)
返回n 從給定函數編號的upvalue的惟一標識符（做爲light userdata）。

這些惟一標識符容許程序檢查不一樣的閉包是否共享up值。共享upvalue的Lua閉包（即訪問相同的外部局部變量）將爲這些upvalue索引返回相同的id。

debug.upvaluejoin (f1, n1, f2, n2)
使n1Lua閉包f1 的n2-th upvalue 引用Lua閉包的-th upvalue f2。

7 - Lua Standalone
儘管Lua被設計爲擴展語言，但要嵌入到主機C程序中，它也常常被用做獨立語言。Lua做爲一種獨立語言的解釋器，簡單地稱爲lua標準分發。獨立解釋器包括全部標準庫，包括調試庫。它的用法是：

lua [options] [script [args]]
選項是：

-e stat：執行字符串統計 ;
-l mod： 「requires」 mod並將結果賦給global @ mod ;
-i：運行腳本後進入交互模式;
-v：打印版本信息;
-E：忽略環境變量;
--：中止處理選項;
-：stdin做爲文件執行並中止處理選項。
處理lua完選項後，運行給定的腳本。在不帶參數的狀況下調用時， lua其行爲lua -v -i 與標準輸入（stdin）是終端時的行爲相同lua -。

在沒有選項-E的狀況下調用時，解釋器在運行任何參數以前檢查環境變量LUA_INIT_5_3 （或者LUA_INIT若是未定義版本化名稱）。若是變量內容具備格式，則執行該文件。不然，執行字符串自己。 @filenamelualua

當使用選項調用時-E，除了忽略以外LUA_INIT，Lua還會忽略和的值，LUA_PATH並LUA_CPATH設置package.path和中package.cpath 定義的默認路徑的值 luaconf.h。

除了-i和以外，全部選項都按順序處理-E。例如，像一個調用

$ lua -e'a = 1'-e'print（a）'script.lua
將首先設置a爲1，而後打印值a，最後運行script.lua沒有參數的文件。（這$是shell提示符。您的提示可能有所不一樣。）

在運行任何代碼以前，請 lua在名爲的全局表中收集全部命令行參數arg。腳本名稱轉到索引0，腳本名稱轉到索引1後的第一個參數，依此類推。腳本名稱以前的任何參數（即解釋器名稱及其選項）都轉到負索引。例如，在通話中

$ lua -la b.lua t1 t2
表格是這樣的：

arg = {[ - 2] =「lua」，[ - 1] =「 - la」，
[0] =「b.lua」，
[1] =「t1」，[2] =「t2」}
若是調用中沒有腳本，則解釋器名稱將轉到索引0，而後是其餘參數。例如，電話

$ lua -e「print（arg [1]）」
將打印「 -e」。若是有一個腳本，該腳本調用參數 arg[1]，...， arg[#arg]。（就像Lua中的全部塊同樣，腳本被編譯爲vararg函數。）

在交互模式下，Lua反覆提示並等待一條線。讀完一行後，Lua首先嚐試將該行解釋爲表達式。若是成功，則打印其值。不然，它將該行解釋爲語句。若是您編寫了不完整的語句，則解釋程序會經過發出不一樣的提示來等待其完成。

若是全局變量_PROMPT包含字符串，則其值將用做提示。一樣，若是全局變量_PROMPT2包含字符串，則其值將用做輔助提示符（在不完整語句期間發出）。

若是腳本中存在未受保護的錯誤，則解釋程序會將錯誤報告給標準錯誤流。若是錯誤對象不是字符串但具備元方法__tostring，則解釋器會調用此元方法來生成最終消息。不然，解釋器將錯誤對象轉換爲字符串並向其添加堆棧跟蹤。

正常完成後，口譯員關閉其主要的Lua狀態（見lua_close）。該腳本能夠經過調用os.exit終止來避免此步驟。

爲了容許在Unix系統中使用Lua做爲腳本解釋器，獨立解釋器跳過塊的第一行（若是它開始）#。所以，Lua腳本能夠經過使用chmod +x和 #!形式製做成可執行程序，如

＃！的/ usr / local / bin目錄/ LUA
（固然，Lua解釋器的位置可能與您的機器不一樣。若是在您的機器lua中PATH，那麼

＃！/ usr / bin / env lua
是一個更便攜的解決方案。）

8 - 與先前版本不兼容
這裏咱們列出了將程序從Lua 5.2移動到Lua 5.3時可能會發現的不兼容性。您能夠經過使用適當的選項編譯Lua來避免一些不兼容性（請參閱文件luaconf.h）。可是，未來將刪除全部這些兼容性選項。

Lua版本老是能夠以不暗示程序中源代碼更改的方式更改C API，例如常量的數值或做爲宏的函數實現。所以，您不該該假設二進制文件在不一樣的Lua版本之間是兼容的。使用新版本時，始終從新編譯Lua API的客戶端。

一樣，Lua版本老是能夠改變預編譯塊的內部表示; 預編譯的塊在不一樣的Lua版本之間不兼容。

官方發佈中的標準路徑可能會在不一樣版本之間發生變化

8.1 - 語言的變化
Lua 5.2和Lua 5.3之間的主要區別在於引入了數字的整數子類型。儘管此更改不該影響「正常」計算，但某些計算（主要涉及某種溢出的計算）可能會產生不一樣的結果。
您能夠經過強制數字爲浮點數來修正這些差別（在Lua 5.2中，全部數字都是浮點數），特別是用結尾寫入常量.0 或使用x = x + 0.0轉換變量。（此建議僅用於快速修復偶然的不兼容性;它不是良好編程的通常準則。對於良好的編程，使用須要浮點數的浮點數和須要整數的整數。）

若是float .0看起來像一個整數，那麼將float轉換爲字符串如今會爲結果添加一個後綴。（例如，float 2.0將打印爲2.0，而不是2。）當您須要特定的數字格式時，應始終使用顯式格式。
（形式上這不是不兼容的，由於Lua沒有指定如何將數字格式化爲字符串，但某些程序採用特定格式。）

垃圾收集器的世代模式已被刪除。（這是Lua 5.2中的一個實驗性功能。）
8.2 - 圖書館的變化
該bit32庫已被棄用。很容易須要兼容的外部庫，或者更好的是，用適當的按位操做替換它的功能。（請記住，bit32對32位整數進行操做，而Lua 5.3中的按位運算符對Lua整數進行操做，默認狀況下爲64位。）
表庫如今尊重用於設置和獲取元素的元方法。
該ipairs迭代器如今尊重元方法及其__ipairs元方法已被棄用。
選項名稱中io.read沒有首字母' *'。爲了兼容性，Lua將繼續接受（並忽略）此角色。
下面的功能已廢棄的數學庫： atan2，cosh，sinh，tanh，pow， frexp，和ldexp。您能夠替換math.pow(x,y)使用x^y; 您能夠替換math.atan2使用math.atan，如今接受一個或兩個參數; 你能夠替換math.ldexp(x,exp)使用x * 2.0^exp。對於其餘操做，您可使用外部庫或在Lua中實現它們。
使用的C加載器的搜索器require 改變了它處理版本化名稱的方式。如今，版本應該在模塊名稱以後（在大多數其餘工具中一般）。爲了兼容性，若是根據新樣式找不到打開的函數，那個搜索者仍會嘗試舊格式。（Lua 5.2已經按照這種方式工做，但它沒有記錄這一變化。）
該調用collectgarbage("count")如今只返回一個結果。（您能夠從第一個結果的小數部分計算第二個結果。）
8.3 - API的變化
延續函數如今做爲參數接收它們須要經過的內容lua_getctx，所以lua_getctx已被刪除。相應地調整您的代碼。
函數lua_dump有一個額外的參數，strip。使用0做爲此參數的值以獲取舊行爲。
功能注入/項目無符號整數（lua_pushunsigned，lua_tounsigned，lua_tounsignedx， luaL_checkunsigned，luaL_optunsigned）就被拋棄了。使用帶有類型轉換的簽名等效項。
宏項目非默認的整數類型（luaL_checkint，luaL_optint，luaL_checklong，luaL_optlong）就被拋棄了。在lua_Integer類型轉換中使用它們的等價物（或者，若是可能，lua_Integer在代碼中使用）。
9 - Lua的完整語法
如下是擴展BNF中Lua的完整語法。與擴展BNF中同樣，{A}表示0或更多As，而[A]表示可選A.（有關運算符優先級，請參見§3.4.8 ;有關終端Name，Numeral和LiteralString的說明，請參閱§ 3.1。）

chunk :: = block

block :: = {stat} [retstat]

stat :: =' ;'|
varlist' = 'explist |
functioncall |
標籤|
休息 |
轉到名稱|
不要阻止結束 |
而 exp 會阻止結束 |
重複阻止直到 exp |
若是 exp 而後阻塞{ elseif exp 而後阻止} [ else block] end |
for Name' = 'exp' ， 'exp [' ， 'exp] do block end |
對於名稱列表中 explist不要阻止結束 |
function funcname funcbody |
local 函數名稱funcbody |
本地名單[' = 'explist]

retstat :: = return [explist] [' ; 「]

label :: =' :: 'Name' :: '

funcname :: = Name {' 。'姓名} [' ： '姓名]

varlist :: = var {' ， 'var}

var :: = Name | prefixexp' [ 'exp' ] '| prefixexp' 。' 名稱

namelist :: = Name {' ， 'Name}

explist :: = exp {' ， 'exp}

exp :: = nil | 假 | 是的 | 數字| LiteralString | ' ... '| functiondef |
prefixexp | tableconstructor | exp binop exp | unop exp

prefixexp :: = var | functioncall | ' （ 'exp' ） '

functioncall :: = prefixexp args | prefixexp' ： '名稱args

args :: =' （ '[explist]' ） '| tableconstructor | LiteralString

functiondef :: = function funcbody

funcbody :: =' （ '[parlist]' ） '阻止結束

parlist :: = namelist [' ， '' ... '] | ' ... '

tableconstructor :: =' { '[fieldlist]' } '

fieldlist :: = field {fieldsep field} [fieldsep]

field :: =' [ 'exp' ] '' = 'exp | 名稱' = 'exp | EXP

fieldsep :: =' ， '| ' ; 「

binop :: =' + '| ' - '| ' * '| ' / '| ' // '| ' ^ '| ' ％ '|
' ＆ '| ' 〜 '| ' | '| ' >> '| ' << '| ' .. '|
' < '| ' <= '| ' > '| ' > = '| ' == '| ' 〜= '|
和 | 要麼

unop :: =' - '| 不是 | ' ＃ '| ' 〜 '

最後更新：tue jun 26 13:16:37 -03 2018