使用 Lua 編寫可嵌入式腳本

Lua 提供了高級抽象，卻又沒失去與硬件的關(guān)聯(lián)

將此頁作為電子郵件發(fā)送

級別: 初級

Martin Streicher (martin.streicher@linux-mag.com), 首席編輯, Linux Magazine

2006 年 6 月 12 日

雖然編譯性編程語言和腳本語言各自具有自己獨特的優(yōu)點，但是如果我們使用這兩種類型的語言來編寫大型的應(yīng)用程序會是什么樣子呢？Lua 是一種嵌入式腳本語言，它非常小，速度很快，功能卻非常強(qiáng)大。在創(chuàng)建其他配置文件或資源格式（以及與之對應(yīng)的解析器）之前，請嘗試一下 Lua。

盡管諸如 Perl、Python、PHP 和 Ruby 之類的解釋性編程語言日益被 Web 應(yīng)用程序廣泛地采納 —— 它們已經(jīng)長期用來實現(xiàn)自動化系統(tǒng)管理任務(wù) —— 但是諸如 C、C++ 之類的編譯性編程語言依然是必需的。編譯性編程語言的性能是腳本語言所無法企及的（只有手工調(diào)優(yōu)的匯編程序的性能才能超過它），有些軟件 —— 包括操作系統(tǒng)和設(shè)備驅(qū)動程序 —— 只能使用編譯代碼來高效地實現(xiàn)。實際上，當(dāng)軟件和硬件需要進(jìn)行無縫地連接操作時，程序員本能地就會選擇 C 編譯器：C 非常基礎(chǔ)，距離 “原始金屬材料非常近” —— 即可以操作硬件的很多特性 —— 并且 C 的表現(xiàn)力非常強(qiáng)大，可以提供高級編程結(jié)構(gòu)，例如結(jié)構(gòu)、循環(huán)、命名變量和作用域。

然而，腳本語言也有自己獨特的優(yōu)點。例如，當(dāng)某種語言的解釋器被成功移植到一種平臺上以后，使用這種語言編寫的大量腳本就可以不加任何修改在這種新平臺上運行 —— 它們沒有諸如系統(tǒng)特定的函數(shù)庫之類的依賴限制。（我們可以考慮一下 Microsoft® Windows® 操作系統(tǒng)上的許多 DLL 文件和 UNIX® 及 Linux® 上的很多 libcs）。另外，腳本語言通常都還會提供高級編程構(gòu)造和便利的操作，程序員可以使用這些功能來提高生產(chǎn)效率和靈活性。另外，使用解釋語言來編程的程序員工作的速度更快，因為這不需要編譯和鏈接的步驟。C 及其類似語言中的 “編碼、編譯、鏈接、運行” 周期縮減成了更為緊湊的 “編寫腳本、運行”。

Lua 新特性

與其他腳本語言一樣，Lua 也有自己的一些特性：

• Lua 類型。在 Lua 中，值可以有類型，但是變量的類型都是動態(tài)決定的。nil、布爾型、數(shù)字 和 字符串 類型的工作方式與我們期望的一樣。
  • Nil 是值為 nil 的一種特殊類型，用來表示沒有值。
  • 布爾型的值可以是 true 和 false 常量。（Nil 也可以表示 false，任何非 nil 的值都表示 true。）
  • Lua 中所有的數(shù)字都是雙精度的（不過我們可以非常簡便地編寫一些代碼來實現(xiàn)其他數(shù)字類型）。
  • 字符串是定長字符數(shù)組。（因此，要在一個字符串后面附加上字符，必須對其進(jìn)行拷貝。）
• 表、函數(shù) 和線程 類型都是引用。每個都可以賦值給一個變量，作為參數(shù)傳遞，或作為返回值從函數(shù)中返回。例如，下面是一個存儲函數(shù)的例子：
  
  

  -- example of an anonymous function -- returned as a value -- see http://www.tecgraf.puc-rio.br/~lhf/ftp/doc/hopl.pdf function add(x) return function (y) return (x + y) end end f = add(2) print(type(f), f(10)) function 12

  
  
• Lua 線程。線程是通過調(diào)用內(nèi)嵌函數(shù) coroutine.create(f) 創(chuàng)建的一個協(xié)同例程 (co-routine)，其中 f 是一個 Lua 函數(shù)。線程不會在創(chuàng)建時啟動；相反，它是在創(chuàng)建之后使用 coroutine.resume(t) 啟動的，其中 t 就是一個線程。每個協(xié)同例程都必須使用 coroutine.yield() 偶爾獲得其他協(xié)同例程的處理器。
• 賦值語句。Lua 允許使用多種賦值語句，可以先對表達(dá)式進(jìn)行求值，然后再進(jìn)行賦值。例如，下面的語句：
  
  

  i = 3 a = {1, 3, 5, 7, 9} i, a[i], a[i+1], b = i+1, a[i+1], a[i] print (i, a[3], a[4], b, I)

  
  會生成 4 7 5 nil nil。如果變量列表的個數(shù)大于值列表的個數(shù)，那么多出的變量都被賦值為 nil；因此，b 就是 nil。如果值的個數(shù)多于變量的個數(shù)，那么多出的值部分就會簡單地丟棄。在 Lua 中，變量名是大小寫敏感的，這可以解釋為什么 I 的值是 nil。
• 塊（Chunk）。 塊 可以是任何 Lua 語句序列。塊可以保存到文件中，或者保存到 Lua 程序中的字符串中。每個塊都是作為一個匿名函數(shù)體來執(zhí)行的。因此，塊可以定義局部變量和返回值。
• 更酷的東西。Lua 具有一個標(biāo)記-清理垃圾收集器。在 Lua 5.1 中，垃圾收集器是以增量方式工作的。Lua 具有完整的詞法閉包（這與 Scheme 類似，而與 Python 不同）。Lua 具有可靠的尾部調(diào)用語義（同樣，這也與 Scheme 類似，而與 Python 不同）。

在 Programming in Lua 和 Lua-users wiki （鏈接請參見后面的 參考資料 部分）中可以找到更多 Lua 代碼的例子。

在所有的工程任務(wù)中，要在編譯性語言和解釋性語言之間作出選擇，就意味著要在這種環(huán)境中對每種語言的優(yōu)缺點、權(quán)重和折中進(jìn)行評測，并接受所帶來的風(fēng)險。

回頁首

在兩個世界之間最好地進(jìn)行混合

如果您希望充分利用這兩個世界的優(yōu)點，應(yīng)該怎樣辦呢，是選擇最好的性能還是選擇高級強(qiáng)大的抽象？更進(jìn)一步說，如果我們希望對處理器密集且依賴于系統(tǒng)的算法和函數(shù)以及與系統(tǒng)無關(guān)且很容易根據(jù)需要而進(jìn)行修改的單獨邏輯進(jìn)行優(yōu)化，那又當(dāng)如何呢？

對高性能代碼和高級編程的需要進(jìn)行平衡是 Lua（一種可嵌入式腳本語言）要解決的問題。在需要時我們可以使用編譯后的代碼來實現(xiàn)底層的功能，然后調(diào)用 Lua 腳本來操作復(fù)雜的數(shù)據(jù)。由于 Lua 腳本是與編譯代碼獨立的，因此我們可以單獨修改這些腳本。使用 Lua，開發(fā)周期就非常類似于 “編碼、編譯、運行、編寫腳本、編寫腳本、編寫腳本 ...”。

例如，Lua Web 站點 “使用” 頁面（請參見 參考資料）列出了主流市場上的幾個計算機(jī)游戲，包括 World of Warcraft 和（家用版的）Defender，它們集成 Lua 來實現(xiàn)很多東西，從用戶界面到敵人的人工智能都可以。Lua 的其他應(yīng)用程序包括流行的 Linux 軟件更新工具 apt-rpm 的擴(kuò)展機(jī)制，還有 “Crazy Ivan” Robocup 2000 冠軍聯(lián)賽的控制邏輯。這個頁面上的很多推薦感言都對 Lua 的小巧與杰出性能贊不絕口。

回頁首

開始使用 Lua

Lua 5.0.2 版本是撰寫本文時的最新版本，不過最近剛剛發(fā)布了 5.1 版本。您可以從 lua.org 上下載 Lua 的源代碼，在 Lua-users wiki（鏈接請參見 參考資料）上可以找到預(yù)先編譯好的二進(jìn)制文件。完整的 Lua 5.0.2 核心文件中包括了標(biāo)準(zhǔn)庫和 Lua 編譯器，不過只有 200KB 大小。

如果您使用的是 Debian Linux，那么可以以超級用戶的身份運行下面的命令來快速安裝 Lua 5.0：

# apt-get install lua50
                            

本文中給出的例子都是在 Debian Linux Sarge 上運行的，使用的是 Lua 5.0.2 和 2.4.27-2-686 版本的 Linux 內(nèi)核。

在系統(tǒng)上安裝好 Lua 之后，我們可以首先來試用一下單獨的 Lua 解釋器。（所有的 Lua 應(yīng)用程序必須要嵌入到宿主應(yīng)用程序中。解釋器只是一種特殊類型的宿主，對于開發(fā)和調(diào)試工作來說非常有用。）創(chuàng)建一個名為 factorial.lua 的文件，然后輸入下面的代碼：

-- defines a factorial function
                            function fact (n)
                            if n == 0 then
                            return 1
                            else
                            return n * fact(n-1)
                            end
                            end
                            print("enter a number:")
                            a = io.read("*number")
                            print(fact(a))
                            

factorial.lua 中的代碼 —— 更確切地說是任何 Lua 語句序列 —— 都稱為一個塊，這在上面的 Lua 特性 中已經(jīng)進(jìn)行了介紹。要執(zhí)行剛才創(chuàng)建的代碼塊，請運行命令 lua factorial.lua：

$ lua factorial.lua
                            enter a number:
                            10
                            3628800
                            

或者像在其他解釋性語言中一樣，我們可以在代碼頂部添加一行 “標(biāo)識符”（#!），使這個腳本變成可執(zhí)行的，然后像單獨命令一樣來運行這個文件：

$ (echo '#! /usr/bin/lua'; cat factorial.lua) > factorial
                            $ chmod u+x factorial
                            $ ./factorial
                            enter a number:
                            4
                            24
                            

回頁首

Lua 語言

Lua 具有現(xiàn)代腳本語言中的很多便利：作用域，控制結(jié)構(gòu)，迭代器，以及一組用來處理字符串、產(chǎn)生及收集數(shù)據(jù)和執(zhí)行數(shù)學(xué)計算操作的標(biāo)準(zhǔn)庫。在 Lua 5.0 Reference Manual 中有對 Lua 語言的完整介紹（請參見 參考資料）。

在 Lua 中，只有值 具有類型，而變量的類型是動態(tài)決定的。Lua 中的基本類型（值）有 8 種： nil，布爾型，數(shù)字，字符串，函數(shù)，線程，表 以及 用戶數(shù)據(jù)。前 6 種類型基本上是自描述的（例外情況請參見上面的 Lua 特性 一節(jié)）；最后兩個需要一點解釋。

Lua 表

在 Lua 中，表是用來保存所有數(shù)據(jù)的結(jié)構(gòu)。實際上，表是 Lua 中惟一的 數(shù)據(jù)結(jié)構(gòu)。我們可以將表作為數(shù)組、字典（也稱為散列 或聯(lián)合數(shù)組）、樹、記錄，等等。

與其他編程語言不同，Lua 表的概念不需要是異構(gòu)的：表可以包含任何類型的組合，也可以包含類數(shù)組元素和類字典元素的混合體。另外，任何 Lua 值 —— 包括函數(shù)或其他表 —— 都可以用作字典元素的鍵值。

要對表進(jìn)行瀏覽，請啟動 Lua 解釋器，并輸入清單 1 中的黑體顯示的代碼。

$ lua
                            > -- create an empty table and add some elements
                            > t1 = {}
                            > t1[1] = "moustache"
                            > t1[2] = 3
                            > t1["brothers"] = true
                            > -- more commonly, create the table and define elements
                            > all at once
                            > t2 = {[1] = "groucho", [3] = "chico", [5] = "harpo"}
                            > t3 = {[t1[1]] = t2[1], accent = t2[3], horn = t2[5]}
                            > t4 = {}
                            > t4[t3] = "the marx brothers"
                            > t5 = {characters = t2, marks = t3}
                            > t6 = {["a night at the opera"] = "classic"}
                            > -- make a reference and a string
                            > i = t3
                            > s = "a night at the opera"
                            > -- indices can be any Lua value
                            > print(t1[1], t4[t3], t6[s])
                            moustache   the marx brothers classic
                            > -- the phrase table.string is the same as table["string"]
                            > print(t3.horn, t3["horn"])
                            harpo   harpo
                            > -- indices can also be "multi-dimensional"
                            > print (t5["marks"]["horn"], t5.marks.horn)
                            harpo   harpo
                            > -- i points to the same table as t3
                            > = t4[i]
                            the marx brothers
                            > -- non-existent indices return nil values
                            > print(t1[2], t2[2], t5.films)
                            nil     nil     nil
                            >  -- even a function can be a key
                            > t = {}
                            > function t.add(i,j)
                            >> return(i+j)
                            >> end
                            > print(t.add(1,2))
                            3
                            > print(t['add'](1,2))
                            3
                            >  -- and another variation of a function as a key
                            > t = {}
                            > function v(x)
                            >> print(x)
                            >> end
                            > t[v] = "The Big Store"
                            > for key,value in t do key(value) end
                            The Big Store
                            

正如我們可能期望的一樣，Lua 還提供了很多迭代器函數(shù)來對表進(jìn)行處理。全局變量 table 提供了這些函數(shù)（是的，Lua 包就是表）。有些函數(shù)，例如 table.foreachi()，會期望一個從 1（數(shù)字 1）開始的連續(xù)整數(shù)范圍：

> table.foreachi(t1, print)
                            1 moustache
                            2 3
                            

另外一些函數(shù)，例如 table.foreach()，會對整個表進(jìn)行迭代：

> table.foreach(t2,print)
                            1       groucho
                            3       chico
                            5       harpo
                            > table.foreach(t1,print)
                            1       moustache
                            2       3
                            brothers        true
                            

盡管有些迭代器對整數(shù)索引進(jìn)行了優(yōu)化，但是所有迭代器都只簡單地處理 (key, value) 對。

現(xiàn)在我們可以創(chuàng)建一個表 t，其元素是 {2, 4, 6, language="Lua", version="5", 8, 10, 12, web="www.lua.org"}，然后運行 table.foreach(t, print) 和 table.foreachi(t, print)。

用戶數(shù)據(jù)

由于 Lua 是為了嵌入到使用另外一種語言（例如 C 或 C++）編寫的宿主應(yīng)用程序中，并與宿主應(yīng)用程序協(xié)同工作，因此數(shù)據(jù)可以在 C 環(huán)境和 Lua 之間進(jìn)行共享。正如 Lua 5.0 Reference Manual 所說，userdata 類型允許我們在 Lua 變量中保存任意的 C 數(shù)據(jù)。我們可以認(rèn)為 userdata 就是一個字節(jié)數(shù)組 —— 字節(jié)可以表示指針、結(jié)構(gòu)或宿主應(yīng)用程序中的文件。

用戶數(shù)據(jù)的內(nèi)容源自于 C，因此在 Lua 中不能對其進(jìn)行修改。當(dāng)然，由于用戶數(shù)據(jù)源自于 C，因此在 Lua 中也沒有對用戶數(shù)據(jù)預(yù)定義操作。不過我們可以使用另外一種 Lua 機(jī)制來創(chuàng)建對 userdata 進(jìn)行處理的操作，這種機(jī)制稱為 元表（metatable）。

元表

由于表和用戶數(shù)據(jù)都非常靈活，因此 Lua 允許我們重載這兩種類型的數(shù)據(jù)的操作（不能重載其他 6 種類型）。元表 是一個（普通的）Lua 表，它將標(biāo)準(zhǔn)操作映射成我們提供的函數(shù)。元表的鍵值稱為事件；值（換而言之就是函數(shù)）稱為元方法。

函數(shù) setmetatable() 和 getmetatable() 分別對對象的元表進(jìn)行修改和查詢。每個表和 userdada 對象都可以具有自己的元表。

例如，添加操作對應(yīng)的事件是 __add。我們可以推斷這段代碼所做的事情么？

-- Overload the add operation
                            -- to do string concatenation
                            --
                            mt = {}
                            function String(string)
                            return setmetatable({value = string or ''}, mt)
                            end
                            -- The first operand is a String table
                            -- The second operand is a string
                            -- .. is the Lua concatenate operator
                            --
                            function mt.__add(a, b)
                            return String(a.value..b)
                            end
                            s = String('Hello')
                            print((s + ' There ' + ' World!').value )
                            

這段代碼會產(chǎn)生下面的文本：

Hello There World!
                            

函數(shù) String() 接收一個字符串 string，將其封裝到一個表（{value = s or ''}）中，并將元表 mt 賦值給這個表。函數(shù) mt.__add() 是一個元方法，它將字符串 b 添加到在 a.value 中找到的字符串后面 b 次。這行代碼 print((s + ' There ' + ' World!').value ) 調(diào)用這個元方法兩次。

__index 是另外一個事件。__index 的元方法每當(dāng)表中不存在鍵值時就會被調(diào)用。下面是一個例子，它記住 (memoize) 函數(shù)的值：

-- code courtesy of Rici Lake, rici@ricilake.net
                            function Memoize(func, t)
                            return setmetatable(
                            t or {},
                            {__index =
                            function(t, k)
                            local v = func(k);
                            t[k] = v;
                            return v;
                            end
                            }
                            )
                            end
                            COLORS = {"red", "blue", "green", "yellow", "black"}
                            color = Memoize(
                            function(node)
                            return COLORS[math.random(1, table.getn(COLORS))]
                            end
                            )
                            

將這段代碼放到 Lua 解釋器中，然后輸入 print(color[1], color[2], color[1])。您將會看到類似于 blue black blue 的內(nèi)容。

這段代碼接收一個鍵值 node，查找 node 指定的顏色。如果這種顏色不存在，代碼就會給 node 賦一個新的隨機(jī)選擇的顏色。否則，就返回賦給 node 的顏色。在前一種情況中，__index 元方法被執(zhí)行一次以分配一個顏色。后一種情況比較簡單，所執(zhí)行的是快速散列查找。

Lua 語言提供了很多其他功能強(qiáng)大的特性，所有這些特性都有很好的文檔進(jìn)行介紹。在碰到問題或希望與專家進(jìn)行交談時，請連接 Lua Users Chat Room IRC Channel（請參見 參考資料）獲得非常熱心的支持。

回頁首

嵌入和擴(kuò)展

除了語法簡單并且具有功能強(qiáng)大的表結(jié)構(gòu)之外，Lua 的強(qiáng)大功能使其可以與宿主語言混合使用。由于 Lua 與宿主語言的關(guān)系非常密切，因此 Lua 腳本可以對宿主語言的功能進(jìn)行擴(kuò)充。但是這種融合是雙贏的：宿主語言同時也可以對 Lua 進(jìn)行擴(kuò)充。舉例來說，C 函數(shù)可以調(diào)用 Lua 函數(shù)，反之亦然。

Lua 與宿主語言之間的這種共生關(guān)系的核心是宿主語言是一個虛擬堆棧。虛擬堆棧與實際堆棧類似，是一種后進(jìn)先出（LIFO）的數(shù)據(jù)結(jié)構(gòu)，可以用來臨時存儲函數(shù)參數(shù)和函數(shù)結(jié)果。要從 Lua 中調(diào)用宿主語言的函數(shù)（反之亦然），調(diào)用者會將一些值壓入堆棧中，并調(diào)用目標(biāo)函數(shù)；被調(diào)用的函數(shù)會彈出這些參數(shù)（當(dāng)然要對類型和每個參數(shù)的值進(jìn)行驗證），對數(shù)據(jù)進(jìn)行處理，然后將結(jié)果放入堆棧中。當(dāng)控制返回給調(diào)用程序時，調(diào)用程序就可以從堆棧中提取出返回值。

實際上在 Lua 中使用的所有的 C 應(yīng)用程序編程接口（API）都是通過堆棧來進(jìn)行操作的。堆棧可以保存 Lua 的值，不過值的類型必須是調(diào)用程序和被調(diào)用者都知道的，特別是向堆棧中壓入的值和從堆棧中彈出的值更是如此（例如 lua_pushnil() 和 lua_pushnumber()。

清單 2 給出了一個簡單的 C 程序（節(jié)選自 參考資料 中 Programming in Lua 一書的第 24 章），它實現(xiàn)了一個很小但卻功能完善的 Lua 解釋器。

 1 #include <stdio.h>
                            2 #include <lua.h>
                            3 #include <lauxlib.h>
                            4 #include <lualib.h>
                            5
                            6 int main (void) {
                            7   char buff[256];
                            8   int error;
                            9   lua_State *L = lua_open();   /* opens Lua */
                            10   luaopen_base(L);             /* opens the basic library */
                            11   luaopen_table(L);            /* opens the table library */
                            12   luaopen_io(L);               /* opens the I/O library */
                            13   luaopen_string(L);           /* opens the string lib. */
                            14   luaopen_math(L);             /* opens the math lib. */
                            15
                            16   while (fgets(buff, sizeof(buff), stdin) != NULL) {
                            17     error = luaL_loadbuffer(L, buff, strlen(buff), "line") ||
                            18             lua_pcall(L, 0, 0, 0);
                            19     if (error) {
                            20       fprintf(stderr, "%s", lua_tostring(L, -1));
                            21       lua_pop(L, 1);  /* pop error message from the stack */
                            22     }
                            23   }
                            24
                            25   lua_close(L);
                            26   return 0;
                            27 }
                            

第 2 行到第 4 行包括了 Lua 的標(biāo)準(zhǔn)函數(shù)，幾個在所有 Lua 庫中都會使用的方便函數(shù)以及用來打開庫的函數(shù)。第 9 行創(chuàng)建了一個 Lua 狀態(tài)。所有的狀態(tài)最初都是空的；我們可以使用 luaopen_...() 將函數(shù)庫添加到狀態(tài)中，如第 10 行到第 14 行所示。

第 17 行和 luaL_loadbuffer() 會從 stdin 中以塊的形式接收輸入，并對其進(jìn)行編譯，然后將其放入虛擬堆棧中。第 18 行從堆棧中彈出數(shù)據(jù)并執(zhí)行之。如果在執(zhí)行時出現(xiàn)了錯誤，就向堆棧中壓入一個 Lua 字符串。第 20 行訪問棧頂（棧頂?shù)乃饕秊?-1）作為 Lua 字符串，打印消息，然后從堆棧中刪除該值。

使用 C API，我們的應(yīng)用程序也可以進(jìn)入 Lua 狀態(tài)來提取信息。下面的代碼片段從 Lua 狀態(tài)中提取兩個全局變量：

..
                            if (luaL_loadfile(L, filename) || lua_pcall(L, 0, 0, 0))
                            error(L, "cannot run configuration file: %s", lua_tostring(L, -1));
                            lua_getglobal(L, "width");
                            lua_getglobal(L, "height");
                            ..
                            width = (int) lua_tonumber(L, -2);
                            height = (int) lua_tonumber(L, -1);
                            ..
                            

請再次注意傳輸是通過堆棧進(jìn)行的。從 C 中調(diào)用任何 Lua 函數(shù)與這段代碼類似：使用 lua_getglobal() 來獲得函數(shù)，將參數(shù)壓入堆棧，調(diào)用 lua_pcall()，然后處理結(jié)果。如果 Lua 函數(shù)返回 n 個值，那么第一個值的位置在堆棧的 -n 處，最后一個值在堆棧中的位置是 -1。

反之，在 Lua 中調(diào)用 C 函數(shù)也與之類似。如果您的操作系統(tǒng)支持動態(tài)加載，那么 Lua 可以根據(jù)需要來動態(tài)加載并調(diào)用函數(shù)。（在必須使用靜態(tài)加載的操作系統(tǒng)中，可以對 Lua 引擎進(jìn)行擴(kuò)充，此時調(diào)用 C 函數(shù)時需要重新編譯 Lua。）

回頁首

結(jié)束語

Lua 是一種學(xué)習(xí)起來容易得難以置信的語言，但是它簡單的語法卻掩飾不了其強(qiáng)大的功能：這種語言支持對象（這與 Perl 類似），元表使表類型具有相當(dāng)程度的可伸展性，C API 允許我們在腳本和宿主語言之間進(jìn)行更好的集成和擴(kuò)充。Lua 可以在 C、C++、C#、Java™ 和 Python 語言中使用。

在創(chuàng)建另外一個配置文件或資源格式（以及相應(yīng)的處理程序）之前，請嘗試一下 Lua。Lua 語言及其社區(qū)非常健壯，具有創(chuàng)新精神，隨時準(zhǔn)備好提供幫助。

回頁首

參考資料

• 您可以參閱本文在 developerWorks 全球站點上的 英文原文。
  
  
• Reference manual for Lua 5.0 介紹了 Lua 語言的完整知識。
  
  
• Roberto Ierusalimschy 所著的 Programming in Lua（Roberto Ierusalimschy，2003 年）是學(xué)習(xí)如何使用 Lua 有效地進(jìn)行編碼的非常有用的資源。
  
  
• 請參閱 Lua-users wiki 中的 library of Lua 教程，學(xué)習(xí)如何使用 Lua 的特性。
  
  
• 請參閱 使用 Lua 的項目列表。
  
  
• 在 developerWorks Linux 專區(qū) 可以找到為 Linux 開發(fā)人員準(zhǔn)備的更多資源。
  
  
• 隨時關(guān)注 developerWorks 技術(shù)事件和網(wǎng)絡(luò)廣播。

• 下載 Lua 5.0.2 或 Lua 5.1 源代碼，從頭開始編譯 Lua。
  
  
• 在 Lua-users wiki 上，瀏覽很多預(yù)先構(gòu)建的、可安裝的 Lua 二進(jìn)制文件。
  
  
• 在 LuaForge 上可以找到大量的代碼庫，包括很多語言綁定和專門的計算庫。
  
  
• 訂購免費的 SEK for Linux ，這有兩張 DVD，包括最新的 IBM for Linux 試用軟件，包括 DB2®、Lotus®、Rational®、Tivoli® 和 WebSphere®。
  
  
• 在您的下一個開發(fā)項目中采用 IBM 試用軟件，這可以從 developerWorks 直接下載。
  
  

• 通過參與 developerWorks blogs 加入 developerWorks 社區(qū)。
  
  

關(guān)于作者

		Martin Streicher 是 Linux Magazine 的首席編輯。他在普渡大學(xué)獲得了計算機(jī)碩士學(xué)位，自 1982 年以來，就一直在使用 Pascal、C、Perl、Java 以及（最近使用的）Ruby 編程語言編寫類 Unix 系統(tǒng)。