常用程式語言的比較 (一) : 註解

會想到整理常用程式語言的比較是因為最近看到幾本 Java 的書, 幾年前接觸 Python 後就把 Java 拋棄了, 主要是因為母公司 Sun 被 Oracle 買去, 而我非常厭惡 Oracle 的老闆 Larry Ellison. 其次是 Java 到第七版之後 (我用不到的) 功能越來越多, 體型也越趨龐大, 比起 Python 可說是龐然大物, 而且程式要經過編譯不似 Python 隨寫隨跑那般輕盈好用.

但這幾天反思, 以前花了那麼多時間學習 Java 如今卻輕易拋棄實在可惜. 隨著學習的語言越來越多, 語言干擾現象無可避免, 不如利用比較語法的方式做個複習整理, 恢復一些 Java 功力. 以前學每個語言是縱深求精, 比較語言差異則是橫斷求廣.

我學過的程式語言有 Javascript, Java, PHP, Python, Lua (淺嚐), 正在學習的有 R, C, Julia, 以及 Go 語言. 程式語言的語法結構其實差異不大, 該有的功能幾乎每家都有, 只是支援的資料型態不同, 寫法與效能不同, 好用度不同而已. 本篇首先來比較各語言的註解方式, 各家的註解語法整理如下表 :

程式語言	單行註解	多行註解
Python	#這是單行註解	'''  這是多行註解  '''
Javascript	//這是單行註解	/*  這是多行註解  */
Java	//這是單行註解	/*  這是多行註解  */
PHP	//這是單行註解	/*  這是多行註解  */
R	//這是單行註解	無
C	//這是單行註解	/*  這是多行註解  */
GO	//這是單行註解	/*  這是多行註解  */
Julia	#這是單行註解	無
Lua	--這是單行註解	--[[  這是多行註解  ]]

可見 R 與 Julia 都沒有多行註解語法, 而 Java/Javascript/PHP/C/GO 等泛 C 族語言的註解語法相同. Python 與 Lua 則獨樹一幟與眾不同.

好書 : 松本行弘談程式世界的未來

偶然機會在網路上看到這本書的電子版, 搜尋市圖網站發現有收藏此書就借來看看. 其實我只是想知道, 身為 Ruby 創造者的松本行弘如何看待同樣是 Dynamic Scripting 語言的 Lua. 這兩個語言有一個共通點 : Lua 是唯一起源於南美洲的程式語言; 而 Ruby 則是唯一起源於亞洲的語言, 我很好奇一個語言的設計者會怎麼看另外一個語言.

Source : 金石堂

松本行弘在本書的 3-5 節談到 Lua, 重點摘要如下 :

1. Lua 的特徵是考慮到嵌入應用程式的通用指令稿語言, 與其想法類似的還有 Tcl, 不過 Lua 比 Tcl 更接近於通用語言. Lua 與 Tcl 為此目的都將語言規格都限制在非常小的程度, 例如 Tcl 只有字串這一個資料型別, 而 Lua 則使用一種表格結構來實作其所支持的資料型態. 
2. Lua 在實作上完全以 ANSI C 撰寫, 實現了極高的可移植性, Lua 的虛擬機器以高速聞名. 
3. Lua 的數值資料型別全部用浮點數儲存, 沒有整數 (Perl 也是如此). 而使用者資料型別 (User Data) 用在以 C 語言等擴充 Lua 功能時, 例如檔案 I/O 就是利用 User Data 達成.
4. Lua 的函式是頭等物件 (first class), 即與數值等其他資料型別一樣, 可以存入物件, 當成引數傳遞, 或作為傳回值等. 
5. Lua 最具特徵的資料型別是表格, 可實現其他語言中的 array(陣列), hash(關聯式陣列), object(物件) 等結構, 是萬能資料型別. PHP 也是 array 與 hash 合而為一, 而 Javascript 雖然也有關聯式陣列, 但與陣列是獨立的資料結構.
   array={1,2,3}     --陣列
   print(array[1])    --輸出 1
   hash={x=1,y=2,z=3}   --關聯式陣列
   array["x"]=1    --array 與 hash 混合 (賦值方法一)
   array.y=2         --array 與 hash 混合 (賦值方法二)
   print(#array)    --輸出 3 (陣列長度運算子 # 不會將 hash 元素算在內)
6. Lua 表格用法需特別注意的地方有兩點 : 一是表格當陣列使用時, 其索引是從 1 起算的 (以前的 FORTRAN 與 PASCAL 也是), 而 C 語言及其徒子徒孫都從 0 起算, 很容易搞錯. 其次是 # 運算子只能計算表格中以陣列方式儲存之元素, 不包括關聯式陣列元素. 
7. Lua 原始設計本來並非以物件導向為目標, 它的物件導向是以 metatable (詮釋表格) 方式實現的. Lua 的物件與類別是以表格來實作, 而方法是用函式來實作. 使用 metatable 好像可以看到物件的內臟一樣, 與早期 Perl 的物件導向類似. 
8. 以嵌入式用途為設計目標的 Lua 核心相當簡潔, 沒有基本資料型別以外的東西, 只有表格操作, 一些數學函數, 載入套件的功能, 以及包含樣式比對功能的字串, 函式庫只有檔案輸出入而已, 比起附帶大量功能的 Ruby 來說, 實在非常貧弱. 不過 Lua 很容易以 C 擴充功能, 內建的功能不過是拿來描述邏輯. 
9. 同樣是作為嵌入式用途的 Tcl 語言, 由於附屬的 GUI 函式庫 Tk 相當成功, 反而常被拿來當作 GUI 開發語言, 相較之下, Lua 似乎還是比較能不忘初衷, 主要以嵌入其他程式為主. 
10. Lua 直譯器的資料結構統一歸納在名為 lua_state 的結構裡, 一個 process 可以擁有許多直譯器, 因此要讓遊戲裡的每個角色都擁有個別的直譯器也是可行的. 在 multi-thread 環境下, 各個 thread 也都能擁有直譯器, 可把多核處理器的效能發揮到極限.
11. Lua 在垃圾收集方面也下了許多功夫, 採用遞增收集演算法 (Incremental GC, 將垃圾收集工作細分, 逐一執行, 將中斷時間限縮在一定值內, 避免影響即時性) 盡量縮短中斷時間. 因為在遊戲這種對即時性要求很高的環境下, 垃圾收集機制會使遊戲中斷, 導致無法操作, 即使只有一秒也會影響玩家的感覺. 
12. 以前 Cisco 路由器是內嵌 Tcl, 但現在的趨勢卻是 Lua.
13. 在嵌入式應用上, Ruby 可能比不上 Lua. 雖說要將 Ruby 嵌入其他語言不是不可能 (例如 RPG 製作大師), 但卻不是 Ruby 擅長之事, 特別是 Ruby 沒有統一表現直譯器的結構, 使得一個 process 只能擁有一個直譯器, 無法達到 Lua 那樣可協調多個直譯器, 配置到多個 thread 的功能.  
14. 隨著嵌入式硬體性能提升, 軟體複雜化, Lua 這類小規模執行環境, 為嵌入其他程式而設計的語言, 今後將有越來越多發揮的機會. 
15. 這幾年程式語言不斷進化, 其中最劃時代的, 應該是 Chrome 內的 Javascript V8 引擎與 LuaJIT (Lua 的高速實作), 這兩個語言都具備了動態語言方便開發與令人驚異的執行速度, 甚至超越實作得較差的編譯式語言. 

松本行弘看來還蠻公道地評論了自家的 Ruby 與活躍在嵌入式世界的 Lua, 雖然口裡還是說對 Ruby 非常有信心, 但也承認了 Lua 在嵌入式方面無可取代的優勢. 我個人是覺得 Ruby 雖然以方便快速開發著稱, Lua 在這方面也不遑多讓啊! 只是還沒出現 "Lua on Rails" 這樣的框架罷了. Ruby 若不是 Ruby on Rails, 恐怕也沒有這麼風光吧!  Ruby on Rails 的特徵如下 :

• 完全 MVC 架構
• 排除設定檔 (XML)
• 採用簡潔語法
• 活用 Metaprogramming
• 大膽擴充 Ruby 核心

除了 Lua 外, 松本也介紹並評價了 Go, Dart, Coffeescript 等語言.

Go 語言是 Google 力推的新語言 (靜態), 主要考量是要充分發揮多核心的 CPU 性能並解決 C/C++ 的缺點, 因此 Go 語言具備了設計 Concurrent 平行處理程式的能力 (電信業界採用的 Erlang 也具有設計平行處理程式的能力, 但那已是誕生於 1987 年的老語言了, 而且很奇怪, 這是個沒有迴圈的語言哩!).

Dart 語言是結構化又靈活的 Web 語言, 最大特徵是具有可省略的靜態型別. 其設計動機是為了取代 Javascript, 因為 Javascript 有下列缺點 :

• 無法對應功能豐富的網路應用程式
• 難以高速化
• 無法支援多核與 GPU
• 無法修正

但 Javascript 仍在進化, 而且擁有極多使用者社群, Dart 要達成目的恐怕有很大困難吧!

Coffeescript 的出現也是基於對 Javascript 的不滿, Javascript 語法因為太簡單, 使程式變得冗長. 而 Coffeescript 是 "為了撰寫 Javascript 而生的便利語言". Coffeescript 程式執行前要先用 Coffeescript 編譯器 (也是用 Javascript 寫的) 轉成 Javascript 程式, 然後執行此 Javascript 程式. 其語法受到 Ruby 與 Python 的強烈影響 (特別是 Python), 語法比單純過頭的 Javascript 稍微複雜. (奇怪, 居然還有人嫌語法太簡單的!)

松本也提到了與 FORTRAN, COBOL 並稱為 "古代三大程式語言" 的 Lisp, 此語言是創立者 John McCarthy 從所設計的 lambda 演算法進化而來的, 是從數學誕生的語言, 特點是以清單 (list) 結構來操作運算, 這使其廣泛應用在人工智慧領域, 其運算式充滿了許多小括弧, 閱讀起來蠻吃力的. 而我們熟知的虛擬機器與垃圾收集機制也是 Lisp 最早提出並實作出來的, 我都一直以為這是 Java 帶來的創新呢!

松本觀察程式語言的進化方向, 認為最重要的是抽象化 (黑箱化), 例如將處理過程命名就是重點之一, 抽象化的好處是程式設計者不用涉入太多語言的內部細節, 抽象化的自然演進結果之一就是物件導向, 物件就是抽象化的資料. 但也有刻意不要物件化的語言, 例如 Lisp 創立者 Paul Graham 發展的 Arc 語言就是. 松本曾對其學生出過 "預測 20 年後的語言" 這樣的作業, 大多數人預測 :

• 能更簡單寫出程式的語言
• 能以自然語言對電腦下令

這也是我的期望. 我認為 Lua 蠻符合第一個期待.

這本書其實還談了非常多東西, 有些比較深入探討語言設計與實作的太艱深, 看不懂 (比如閉包我也覺得非常難以駕馭). 但較淺顯的例如 Big data 常用的資料庫 NoSQL, 摩爾定律, 非阻塞式 I/O 的 node.js 等等, 蠻有可看性的, 從語言設計者的觀點來看語言的特質, 自然有不同的光景.

三本 Corona 的好書

在市圖找到兩本介紹 Corona SDK 的好書, Corona 主要是用來開發手機 App 遊戲的平台, 其成名是因為一個 14 歲小男孩使用它設計了一款名為 Bubble Ball 的遊戲, 不僅成功在 App Store 上架, 還打敗了當時最紅的 Angry Bird 遊戲. 我是因為學習 Lua 才注意到這個軟體的, 因為 Corona 的草稿語言就是使用 Lua, 因為 Lua 具有輕量與高效率的優點.

1. 10 天做好 App : Corona SDK 超直覺遊戲開發攻略 (PCuSER 出版, 魏巍, 左營)

此書作者德文系畢業, 出過唱片, 做過 DJ, 並非資訊電機科班出身, 一般人很難想像竟能短時間內學會 App 設計, 原來靠的是 Corona SDK 這個好用的工具. 厲害的是, 作者在 Google Play 與 App Store 上架的 App 從企劃, 設計, 到圖案, 音樂等元素, 全部自己包下了, 可謂全能型 App 設計者. 其個人網站如下 :

# http://appsgaga.com/

這本書沒有附光碟, 範例程式可從下列網址下載 :

# http://goo.gl/Yzau1I

作者 2014 年出的第二本 Corona 書為實作篇 :

2. 10天做好APP【實作進化版】：Corona SDK跨平台遊戲開發攻略，不懂程式也沒差！(小港)

3. Corona SDK 跨平台 App 開發設計實戰 (博碩, 白乃遠, 河堤)

此書提供 8 個經典範例, 說明如何使用 Corona SDK 快速開發, 並對於 Google Play 與 App Store 上架程序有專章介紹.

2017-03-03 補充 :

最近在鄉下的市圖分館找到另一本 Corona 的書 :

# 利用 Corona 一次開發跨平台手機 App 桌面程式

這本書比上面的都還厚, 內容很豐富.

關於 Corona SDK 與 Lua 開發工具 Koneki

前天去河堤分館還書時, 看到這本博碩出版的 "遊戲自己做-Corona SDK 跨平台 App 開發設計實戰", 感覺似曾相識, 好像以前借過, 但當時還不知道 Lua 的妙用, 覺得還要學另一種語言很累, 所以翻一翻就還了. 最近因為 NodeMCU 的關係突然注意到 Lua, 發現其實 Lua 很簡單易學呀! 所以又再借回來看.

仔細翻閱後發現, 原來 Corona 主要是設計 Android 與 iOS 遊戲之用. 但拿來設計一般 App 也當然是可以的. 而且 Corona 整合了許多 API, 可以調用各種功能來實現手機平板的應用程式, 加上 Lua 簡單易學, 遠比用原生碼或 HTML5+Javascript 辛苦 coding 要快速簡單多了.

使用 Corona 開發跨平台 App 需先下載 Corona SDK, 請先到 Corona 網站以 Email 註冊, 收取認證信點擊認證超連結後即可登入下載頁面 :

# http://developer.coronalabs.com/user/login?destination=downloads/coronasdk

按右上方的 Download 即可下載, 目前是 2015.2646 版本的安裝檔 CoronaSDK-2015.2646.msi (約 53M), 執行時預設安裝位置為 C:\Program Files (x86)\Corona Labs\Corona SDK\, 為了設定方便, 建議修改為 D:\Corona\Corona SDK. 我的 Inhon 筆電因為整個 SSD 都給 C 碟, 沒有 D 碟, 而創見 64G 插卡是 E 碟, Corona SDK 必須安裝在 Local Drive, 所以只好裝在 C 碟.

安裝完畢會在桌面出現一個 Corona Simulator, 點擊執行會先彈出登入視窗, 必須先輸入先前註冊之 Email 與密碼才能進入模擬器畫面, 編輯好的 App 必須透過連網至 Corona 公司才能進行模擬與發佈.

由於 Corona SDK 只是一個模擬器, 沒有提供 Lua 語言編輯開發工具, 雖然可以使用一般的記事本, 但操作較麻煩. 這本書建議使用 Koneki 這個免費的 Eclipse 專案來開發, Koneki 是以 Eclipse 為平台的 M2M (Machine to Machine) 應用程式開發工具, 內嵌了 Lua 解譯器, 具有 Lua 語法提示, 而且按 Run 執行 App 時會自動啟動 Corona SDK 模擬器, 可以提升專案開發的方便性. 因為Koneki 是以 Eclipse 為核心的, 所以也要先下載安裝 JDK 才行.

# 下載 JDK
# WHAT IS KONEKI?
# 下載 Koneki Lua Development Tool (約 73M)

注意, Koneki 有分 32/64 位元, 必須依據 JDK 是 32/64 位元選擇相同位元的 Koneki, 否則無法啟動 Koneki, 會出現 "fail to load jni shared library jvm.dll" 錯誤. 因為我的 JDK 是 32 位元, 所以 Koneki 也要選擇 32 位元才行.

解壓縮 Koneki 可放在 D:\Koneki 下, 點擊 LuaDevelopmentTools.exe 就會啟動 Koneki 了 :

啟動後 Koneki 會先詢問 Workspace, 因為我們將 Corona SDK 安裝在 D:\Corona 下, 所以把 Workspace 改為 D:\Corona, 所有的專案是放在此目錄下 :

然後從 "File/New/Lua project" 新增一個專案 :

這樣就會產生一個專案了 :

20150905 補充 :

今天在 ACER D260 小筆電安裝 Corona 完開啟時出現下列畫面 :

原來顯示卡必須支援 OpenGL 至少 2.1 版, 否則無法做到精緻繪圖, 我這 D260 可能沒有, 按 Cancel 仍可開啟 Corona. 啟動 Corona 後須先登錄, 但一個免費帳號只能在一台機器登錄, 除非在我的 Inhon 筆電登出, 所以只好用 Yahoo mail 再去申請一個帳號.

Lua 學習筆記 (一) : 基本語法

最近花了一點時間來學 Lua, 作為學習 NodeMCU 的準備. Lua 目前在 TIOBE 排行第 34, 雖然屬於後段班, 但由於核心以 C 語言寫成, 編譯後僅 100KB 左右, 啟動速度快, 執行效率高, 可利用 C/C++ 擴展, 不僅可嵌入到其他程式語言裡, 還能嵌入到硬體晶片中, 非常適合用來處理 C 不擅長的部分 (例如陣列與字串), 在過去早已廣泛被各類線上遊戲採用為腳本語言, 我認為低價的 NodeMCU 平台的出現, 會使 Lua 在物聯網的應用發展中漸漸受到重視, 因為它跟 C/C++ 太麻吉啦!

Lua 語言是巴西里約熱內盧 Pontifical Catholic University 大學的科技軟體開發學院 (Tecgraf) 教授 Roberto Ierusalimschy , Luiz Henrique de Figueiredo, 以及 Waldemar Celes 所設計的. Tecgraf 學院與巴西石油公司有合作開發關係, Tecgraf 協助石油公司開發圖形顯示與地質探勘專案軟體, 先後創造了 DEL 與 SOL 兩種資料驅動語言. Roberto 教授以這兩種語言為基礎, 研發出一個更完整, 具備可嵌入與可攜性的簡易語言. 由於 SOL 在葡萄牙語意思為太陽 (Sun), 所以在朋友建議下將這新語言命名為 Lua, 葡語為月亮 (Moon) 之意. 自 1993 年 Lua 1.0 發布以來, 歷經多次改版, 納入 prototype-based 的物件導向功能與事件驅動機制 (與 Javascript 類似) 等. 1996 年 Roberto 教授在美國 Dr. Dobb's Journal 期刊 (以微電腦軟體為主軸) 發表了一篇標題為 "Lua: an Extensible Embedded Language" 的文章, Lua 才開始踏出巴西走向世界, 許多遊戲軟體如 LucasArts 與 World of Warcraft (魔獸世界) 紛紛改用 Lua 作為 Scripting 語言, 知名手機遊戲開發工具 Corona 與 Moai 也是以 Lua 作為腳本語言, 甚至連 TCP/IP 軟體 Wireshark 與網路入侵檢測軟體 Snort 也內嵌了 Lua, 顯示 Lua 的簡單易學與強大功能正吸引全世界開發者的注意, 詳參 :

# A brief history of Lua
# The Evolution of Lua (PDF)
# Lua as a Configuration And Data Exchange Language (PDF)
# Wiki : Category:Lua-scripted video games
# Wiki : Lua (programming language)

在 Windows 上操作 Lua 請參考 :

# Lua 解譯器的用法

Lua 語言特色摘要如下 :

1. Lua 是動態語言 (Dynamic) :
   亦即它是在執行時期 (Runtime) 才做型別檢查, 所以宣告變數時不需要宣告其資料型別, 而且執行中可任意變換其型別. 其他知名的語言如 Javascript, PHP, Python, Ruby 等都是動態語言. 而 Java 與 C 等靜態語言則是在編譯時期就做型別檢查, 宣告變數時必須同時指定其資料型別, 而且宣告後不能再更換為其他型別, 若賦予之資料與宣告型別不符就會產生編譯錯誤.
   參考 :
   # 靜態語言 vs. 動態語言的比較
2. Lua 是弱型別語言 (Weak typing) :
   弱型別語言允許一個變數在相對應的記憶體區域中可以存放不同類型的資料, 而強型別語言則不可以. 弱型別語言的型別推斷功能可以進行較大程度的隱性 (自動) 型別轉換, 反之, 強型別語言的自動型別轉換則較少, 強弱是相對的, 並非絕對. 注意, 動態語言不一定是弱型別語言, 例如動態語言的 Python 與 Ruby 就屬於強型別語言; 而靜態語言的 Java 也有自動型別轉換, 但是屬於強型別語言.
   參考 :
   # Wiki 類型系統
   # JavaScript 語言核心（4）弱型別的代價 
3. Lua 擴展能力強 (Extensible) :
   Lua 的核心非常精簡小巧, 語法簡潔優美, 類似簡化的英文, 其強大的功能來自於易擴展性, 主要是透過以 Lua 本身內建或用 C/C++ 編寫的外部函式庫來達成, 也具有 Java, Fortran, Smalltalk, Ada 的 API 介面來擴展函式庫. 
4. Lua 可嵌入其他語言中 (Embedable) :
   Lua 可以嵌入到 C/C++, Java, C#, Python, Ruby, Perl 等其他語言中, 做為其函式庫使用. 而且 Lua 可以雙向呼叫 (bi-directional), 亦即可由 Lua 呼叫宿主語言函式, 也可以由宿主語言呼叫 Lua 函式, 一般腳本語言通常只專注在呼叫外部函式庫. 
5. Lua 是跨平台語言 (Portable) :
   Lua 以 ANSI C/C++ 語言編寫而成, 可在多數作業系統上執行, 甚至在嵌入式系統如手機 Android 與 iPhone, 遊戲機 PSP, PS3, 甚至以 WiFi 晶片 ESP8266 為基礎的 NodeMCU 上也可以執行, 可移植性極高.   

Lua 的優勢是執行速度快, 語法簡單學習曲線不陡峭. 以下摘要整理 Lua 程式的基本語法, 主要參考下列資料 :

# Programming in Lua (first edition) (線上電子書)
# Learn Lua in X minutes (PDF)
# Lua Tutorial (Lua Users)
# Lua Tutorial (TutorialPoints)
# Lua Tutorial (Youtube)
# [Lua] 語法筆記
# [Lua] Table使用手冊
# 看影片學 Lua 程式設計
# Scripting系統概論與Lua簡介

1. 區塊 (chunk 或 block) :
   Lua 程式的一段陳述 (statement) 稱為 chunk, 它可以是指一條指令, 也可以是一群指令. 例如 :
   
   a=100
   print(a)
   
   或者
   
   a=100 print(a)
   
   每條指令間不須像 Javascript 或 PHP 那樣用分號結尾, 直接跳行即可, 但用分號結尾也是可以的 (行尾的分號對 Lua 而言是可有可無的, optional), 例如 :
   
   a=100;
   print(a);
   
   但如果兩條敘述要寫在同一行就必須用分號隔開 (不是用逗號), 例如 :
   
   a=100; print(a)
   
   最常見的區塊是函數 (function end), 迴圈 (for end, while end, repeat end), 判斷 (if end), 以及匿名區塊 (do end), 在這四種區塊內的變數都是自成一個單元, 享有相同的作用域或環境 (scope, context) :
   
   function function1()
     --do something
   end
   
   for a=1, 100, 5 do
     --do something
   end
   
   if a<=10 do
     --do something
   end
   
   do
     --do something
   end
   
   注意, 在 Lua 解譯器的交談模式中, 每一行完整的指令就是一個 chunk, 所以這一行定義的區域變數跳到下一行時是新的一個 chunk, 已經超出其作用域 (scope) 而無法存取, 執行的結果將不受上一行區域變數之影響. 此問題可用 do end 區塊解決, 包含在此區塊內的陳述都屬於同一 chunk. 
2. 程式註解 :
   Lua 使用開頭的兩個 dash (--) 作為單行註解符號 (一直到行尾), 例如 :
   
   --這是單行註解行
   
   多行註解則是使用兩個 dash 與雙中括號 --[[ 開頭, 一直到下一個雙中括號為止, 所包含的區域解譯器會略過不予處理 :
   
   --[[這是
   多行
   註解]]
   
   例如下列範例 test.lua :
   
   --[[
   print ("Hello World!")
   ]]
   print ("Hello World!")
   
   執行此程式只會印出一行 "Hello World!", 因為第一個 print 指令被註解掉了不會執行.
   在程式開發過程中, 為了除錯方便常會使用多行註解來控制某一段程式是否要執行, 測試完畢後又要把 --[[ 與 ]] 分別去掉, 有個取巧的辦法可以解決此麻煩, 就是在結尾中括號前也加上雙 dash :
   
   --[[
   print ("Hello World!")
   --]]
   print ("Hello World!")
   
   這樣當要取消註解, 讓原先被註解掉的程式碼恢復執行時, 只要在註解開頭處再加一個 dash 即可 (因為 ---[[ 中前面的兩個 dash 把這行變成單行註解, 迫使結尾的 --] 單飛為單行註解, 多行註解破功) :
   
   ---[[
   print ("Hello World!")
   --]]
   print ("Hello World!")
   
   這樣註解頭失去多行註解功能, 而註解尾變成單行註解, 不用刻意去除. 這個程式會印出兩行 "Hello World!".
   但中括號有時令人覺得眼花撩亂, 一律使用 -- 其實會比較整齊與單純. 
3. 識別字 (Identifier) 與保留字 :
   識別字用來指派變數或函式名稱, Lua 識別字的限制與 Javascript 一樣, 只能使用英文字母, 數字, 以及底線之組合, 但是第一個字元不可以是數字, 所以 2au 不是合法的識別字. 此外雖然可以用底線開頭, 但是因為 Lua 解譯器內部使用以底線開頭的變數, 特別是用底線開頭, 後面是大寫字母組成的識別字, 例如 _VERSION (這是 Lua 特殊用途的保留字), 所以最好不要用底線開頭來命名變數, 以免與系統衝突.
   
   另外, Lua 有 22 個保留字, 這些都不能拿來當識別字 :
   
   local nil not
   or and
   if then else elseif
   for end in do while until repeat break
   true false
   function return
   goto
   
   其中 nil 即 Javascript 或 PHP 的 null 或 NULL, 即無值之意. 被設為 nil 的變數會在記憶體管理下一次掃描時被垃圾回收而消失. 相較於 Javascript 有 29 個保留字, Python 的 33 個, Java 的 50 個, PHP 的 53 個, 而 C# 高達 87 個, Lua 卻只有 22 個, 可見 Lua 有多精簡.
   
   Lua 是有分大小寫的 (case-sensitive), 所以 and 是保留字不能用, 但 AND, And 卻是合法的識別字.
4. 全域變數與區域變數 :
   只要不是用 local 宣告的變數都是全域變數, 即使它位於函數或迴圈等區塊中, 例如 :
   
   a=100
   
   全域變數一經賦值後就會一直存在記憶體中, 直到被設為 nil 才會被記憶體管理回收. 存取未賦值的全域變數會得到 nil. 全域變數實際上會放在名為 _G 的特殊表格中 (Table, 即關聯式陣列, 是 Lua 唯一的資料結構, 所有的變數, 函式都是以 table 來儲存), 安全性較高.
   
   區域變數是以 local 宣告的變數, 其作用域 (scope) 僅限於所在之區塊 (block) 內, 例如在函式, 分岐控制, 迴圈或 do end 結構中使用的變數應該宣告用 local 宣告為區域變數. 區塊中的區域變數會掩蓋同名的全域變數 (即不會存取到同名之全域變數), 意即更改區域變數之值不會影響全域變數的值. 當程式區塊執行結束時, 區塊內的區域變數就會被記憶體管理自動回收 (因此不需要刻意在區塊末尾將其設為 nil). 唯一的例外是, 如果全域變數有參考到區域變數, 則此區域變數不會隨著區塊結束而被回收, 例如 :
   
   a=1
   function myfunc()
     local b=2
     a=b      --全域變數 a 參考到區域變數 b
   end
   myfunc()
   print(b)   --輸出 nil (無法存取到區域變數)
   print(a)   --輸出 2
   
   由於全域變數 a 在函數內參照了區域變數 b, 使得 b 被全域化, 因此在呼叫函數 myfunc() 後, 原本是區域變數的 b 無法正常地被垃圾回收而留存在記憶體中 (但在上層全域卻看不到), 成為垃圾回收的漏網之魚. 這種參照方式要盡可能避免, 否則可能因 memory leak 造成程式崩潰.
   
   除非必要不要使用全域變數, 要盡量使用區域變數, 因為它的執行速度比較快, 而且在記憶體運用上也較有效率, 當它到達作用域盡頭時就會失去作用而被記憶體管理自動回收. 因為當 Lua 解譯一個變數時, 如果它前面有 local 標示為區域變數, 則解譯器會在目前的區域中尋找此變數, 找不到就是 nil; 如果沒有 local, 就會往上一層去找, 直到最上層為止, 找不到才是 nil, 因此全域變數要花較多時間尋找, 會影響執行效率, 所以除非是必要的全域變數, 盡量使用區域變數. 例如 :
   
   local a=1
   local b=2
   if a print(a)      --> 輸出 1
     local a=10      -- then 區塊內的區域變數, 不影響外面的區域變數 a
     print(a)           --> 輸出 10
   end
   print(a)             --> 輸出 1
   print(b)             --> 輸出 2
   
5. 多重指派 (multiple assignment) :
   Lua 跟 Python 一樣具有多重指派語法, 可以在一個陳述中同時為多個變數賦值, 各變數以逗號隔開, 例如在交談模式中 :
   
   > do
   >> local a,b,c=1,2,3
   >> print(a,b,c)
   >> end
   1  2  3
   
   但如果賦值不足, 則未賦值之變數預設為 nil, 例如 :
   
   > do
   >> local a,b,c=1,2
   >> print(a,b,c)
   >> end
   1  2  nil
   
   若賦值超過變數之數目, 多出來的值會被視而不見略過. 多重指派讓資料交換變得很簡潔, 只需要一條指令即可 :
   
   local a,b=1,2
   a,b=b,a   --交換後 a=2, b=1
6. 資料型態 (data types) 與運算子 :
   Lua 是動態弱型別語言, 其變數是無型態的 (typeless), 宣告時不需要指定資料型態, 但變數的值當然有型態, 因為解譯器是靠值的資料型態來動態地配置記憶體.
   Lua 有八種資料型態 :
   
   (1). nil  (無值)
   (2). boolean (布林)
   (3). number (數值)
   (4). string (字串)
   (5). table (表格, 關聯式陣列)
   (6). function (函式)
   (7). thread (執行緒)
   (8). userdata (使用者資料)
   
   前面六種都是其他語言中常見的型態, 而 thread 與 userdata 則較特殊. 事實上這八種資料都是使用 table 來實作的, 因為 table 是 Lua 唯一的資料結構. 使用者定義資料 userdata 是記憶體中的一個區塊, 用來給 C 函式透過 API 存取資料, Lua 無法建立或操控此資料. 而 thread 是用來指派一個例外的獨立執行緒, 但這與一般作業系統的 thread 不同, Lua 不支援真正的多執行緒 (先佔式記憶體分享, 因為 ANSI C 不提供), 不過 Lua 透過 coroutine 提供非先佔式或非記憶體分享多執行緒. 而 thread 就是 coroutine 與低層 API 的組合.
   
   Lua 有一個內建函數 type() 可用來檢測變數的資料類型, 例如 :
   
   print(type(1))          --輸出 number
   print(type("Tony"))  --輸出 string
   t={}        
   print(type(t))           --輸出 nil (因為是個空的表格)
   t={name="tony"}
   print(type(t))           --輸出 table
   
   以下整理最常用的字串, 數值, 布林值, 與無值 nil.
   
   (1) nil
   
   nil 相當於 Javascript 的 null, 表示一個變數無值, 即尚未初始化. 一個變數只宣告而未賦值, 預設就是 nil. 全域變數一經宣告就會存在於記憶體中, 除非我們把它設為 nil 才會被垃圾收集機制刪除.
   
   (2). boolean
   
   在 Javascript 中 true 與 1, false 與 0 是同義的, 但在 Lua 卻不同, Lua 的布林值只有 true 與 false 兩種, 1/0 並非 true/false 的別名, 配合 not, and 與 or 運算用在條件控制的邏輯判斷上. 但 Lua 的條件控制並非只能依賴這兩個布林值, boolean 以外的型態都可以用在邏輯判斷, 但除了 false 與 nil 在邏輯上為假外, 其他均為真, 例如 :
   
   b=0.22
   if (b) then print("true")   --> 印出 true
   else print("false")        
   end
   
   但是要注意, Lua 的 and 與 or 運算結果有點特別, 採用所謂 shortcut evaluation (捷徑估值法), 其傳回值不一定是 true 或 false, 而是取決於第一個運算元. 如果 and 運算的第一個運算元是 false 或 nil, 就直接傳回第一個運算元 (即 false 或 nil); 否則傳回第二運算元, 例如 :
   
   print(nil and 5)               --> 印出 nil  (第一個是 nil/false 就傳回 nil/false)
   print(false and "OK")     --> 印出 false  (第一個是 nil/false 就傳回 nil/false)
   print(2.2 and "OK")        --> 印出 OK (第一個不是 nil/false 就傳回第二個)
   
   其次, 如果 or 運算的第一個運算元是 nil 或 false, 就直接傳回第二個運算元, 否則就傳回第一個運算元, 例如 :
   
   print(nil or 5)                  --> 印出 5  (第一個是 nil/false 就傳回第二個)
   print(false or "OK")        --> 印出 OK  (第一個是 nil/false 就傳回第二個)
   print(2.2 or "OK")           --> 印出 2.2  (第一個不是 nil/false 就傳回自己)
   
   運算元最好只使用 true, false/nil 來進行運算, 以免邏輯判斷出現非預期結果.
   
   與布林值有關的除了邏輯運算外還有關係運算子 :
   
   > (大於) < (小於) >= (大於等於)  <= (小於等於) == (等於) ~= (不等於)
   
   與其他語言比較不同的是 Lua 用 ~= 表示不等於 (C/Java/PHP 等使用 !=), 例如 :
   
   if (nil ~= false) then print("不相等") end   --> 印出 不相等
   if (2.2>0) then print("正數") end                --> 印出 正數
   
   注意, 資料型態不同的變數不能使用關係運算子加以比較, 特別是比大小運算子 ( >, <, >=, <=) 會出現錯誤訊息. 例如 :
   
   > if ("OK">0) then print("正數") end
   stdin:1: attempt to compare number with string
   stack traceback:
            stdin:1: in main chunk
            [C]: in ?
   
   必須是相同資料型態才能進行含有大小的比較, 例如 :
   
   if ("smart">"rich") then print("smart is better")    --> 印出 smart is better
   else print("rich is better")
   end
   
   而 == 與 ~= 這兩個與大小無關的運算即使資料型態不同也不會出現錯誤, 例如 :
   
   if ("knowledge" == 0) then print("idiot")
   else print("expert") end    --輸出 "expert"
   
   事實上, == 與 ~= 運算會先去看兩個運算元資料型態是否相同, 然後再去比較其內容. 前者 == 會先看資料型態是否相同, 如果不同就直接傳回 false (不用比內容啦!), 型態相同才去比較內容, 相同傳回 true, 不同傳回 false, 例如 :
   
   if 1==true then  --資料類型不同傳回 false
     print("same")
   else
     print("different")   --輸出 different
   end
   
   if ("power" == "power") then print("power is power")
   else print("power is not power") end   --輸出 "power is power"
   
   if ("knowledge" == "power") then print("knowledge is power")
   else print("knowledge is not power") end   --輸出 "knowledge is not power"
   
   而 ~= 運算只要型態不同, 就直接傳回 true 了; 若型態相同才去比內容, 相同傳回 false, 不同傳回 true, 例如 :
   
   if ("money" ~= 0) then print("have money")
   else print("have no money") end   --輸出 "have money"
   
   if ("knowledge" ~= "power") then print("knowledge is not power")
   else print("knowledge is power") end   --輸出 "knowledge is not power"
   
   對於 table, function 等物件, 變數儲存的是參考 (指向實際的資料儲存位置), == 與 ~= 運算比較的是其參考, 例如 :
   
   t1={1,2,3}
   t2={1,2,3}
   if t1==t2 then print("same")
   else print("different")  --輸出 different (t1 與 t2 是不同參考)
   end
   t3=t1   --複製參考, t3 與 t1 指向同一個 table
   if t1==t3 then print("same")  --輸出 same
   else print("different")
   end
   
   上例之 t1 與 t2 雖然內容相同, 但參考不同, 故 t1==t2 運算傳回 false, 而 t3=t1 是複製參考, 兩者指向同一個 table, 故 t1==t3 傳回 true.
   
   (3). number
   
   數值方面, 可以使用 10/16 進位整數, 小數, 科學表示法來表示, 但 Lua 並沒有整數型態, Lua 的數值一律使用雙準度浮點數儲存 (IEEE 754). 例如 :
   
   print(2000)          --> 印出 2000
   print(3.14159)     --> 印出 3.14159
   print(2e3)            --> 印出 2000.0
   print(2E-2)          --> 印出 0.02
   
   雖然使用浮點數來表示整數, 但在 Lua 不會產生進為誤差 (rounding errors).
   
   科學表示法的指數用 e 或 E 都可以. 如果要表示 16 進位數, 數值就要以 0x 或 0X 開頭, 例如 :
   
   print(0xff)          --> 印出 255
   
   數值的運算子有如下七個 :
   
   + (加) - (減) * (乘) / (除) % (餘數) ^ (次方) - (單元運算, 負數), 例如 :
   
   print(1/2)       --> 印出 0.5
   print(5%3)     --> 印出 2
   print(2^10)    --> 印出 1024.0
   print(-2)         --> 印出 -2
   
   當字串與數字混合運算時, Lua 會進行自動轉型, 將數字字串轉成數字再運算, 例如 :
   
   print(1+"100")     --輸出 101.0
   print(1+".1")        --輸出 1.1
   
   (4). string
   
   Lua 的字串與 Java 一樣是不可變的 (immutable), 對字串的操作事實上是產生另外一個新字串. 字串的用法跟 Javacript 或 PHP 類似, 可用雙引號或單引號括起來, 除此之外, 也可以用兩個中括號對 (主要用在跨行的長字串), 例如 :
   
   a="Hello"
   b='World'
   print(a,b)                          --> 印出 Hello   World
   print([[Hello World!]])    --> 印出 Hello   World!
   
   如果字串中有引號時, 只要秉持成對 (matching) 與替換 (alternate) 原則就不會弄錯, 例如 :
   
   print("This is Tony's book.")   --> 印出 This is Tony's book.
   
   這裡所有格必須用單引號, 因此整個字串要用雙引號括起來. 如果用單引號就會出錯 :
   
   print('This is Tony's book.')   --> 錯誤! stdin:1: ')' expected near 's'
   
   如果堅持用單引號, 則所有格必須用倒斜線跳脫 :
   
   print('This is Tony\'s book.')   --> 印出 This is Tony's book.
   
   或者乾脆用雙重中括號免得麻煩 :
   
   print([[This is Tony's book.]])   --> 印出 This is Tony's book.
   
   常用的跳脫字元如下 :
   
   \" : 雙引號
   \' : 單引號
   \n : 換行
   \r : 回車
   \\ : 倒斜線
   
   字串也可以用 ASCII 編碼來表示 (如果覺得這樣很有趣, 又不會太麻煩的話), 例如 ABC 的 ASCII 編碼以十進位表示分別為 65, 66, 67, 所以要印出 "ABC" 可以用倒斜線跳脫 ASCII 碼來表示 :
   
   print("\65\66\67")     --> 印出 ABC
   
   也可以用十六進位表示, 但要加一個小寫 x (不能用大寫 X) :
   
   print("\x41\x42\x43")     --> 印出 ABC
   
   參考 : Wiki : ASCII
   
   對於可能會超過一行長字串, 為了編輯的方便需要拆成數行時, Lua 提供兩個方式來輸入長字串, 第一個是用 [[ 與 ]] 符號來包圍一塊長字串區域, 例如 :
   
   a=[[This is a very
                       very
                       very ...
                               long story.]]
   print(a)
   
   印出的結果與編輯時的樣子相同, 會保留所有的空格.
   第二個方法是用跳脫字元 \z 來串接長字串, 例如 :
   
   a="This is a very \z
                      very \z
                      very ... \z
                             long story."
   print(a)    --> 印出 This is a very very very ... long story.
   
   可見使用 \z 不會保留空格, \z 會直接串接到下一行的非空白字元.
   
   Lua 取得字串長度是在字串前面加個 "#", 例如 :
   
   print(#"ABC")          --> 印出 3
   a="Hello World!"
   print(#a)                  --> 印出 12
   
   也可以使用內建的 string.len() 函式, 例如 :
   
   print(string.len("Hello World!"))    --> 印出 12
   
   至於串接字串, 有別於 Javacript 用加號, PHP 用點號, Lua 是用連續兩個點號來串接字串, 例如 :
   
   print("Hello".." ".."World!")     --> 印出 Hello World!
   
   由於 Lua 是弱型態語言, 當數值字串進行數值運算時會自動進行型態轉換, 例如 :
   
   print("12" + 3)            --> 印出 15, 會先將 "12" 轉成 12 再加 3.
   print("4.5e25" * "3")    --> 印出 1.35e+026
   
   但如果不是數值字串, 就會無法轉成數值而發生錯誤, 例如 :
   
   > print("1 hundred" + 900)   --> 1 hundred 不是數值
   stdin:1: attempt to perform arithmetic on a string value
   stack traceback:
           stdin:1: in main chunk
           [C]: in ?
   
   反之, 當數值進行字串運算時, Lua 也會自動將數值先轉成字串再運算, 例如 :
   
   print(20 .. 15)   --> 印出 2015
   
   注意, 這裡數值與字串串接運算符 .. 之間必須有一個空格, 否則第一個點會被認為是小數點而產生 malformed number 錯誤.
   
   以上是數值與字串的隱性型別轉換, 顯性的轉換則是利用 tonumber() 與 tostring() 函式, 例如 :
   
   if (tonumber("2e2") == 200) then print("match") end     --> 印出 match
   if (tonumber("10.5") == 10.5) then print("match") end    --> 印出 match
   
   (5). Table (表格)
   
   Lua 的 table 其實就是關聯式陣列 (associative array), 這是 Lua 唯一的資料結構, 所有的資料型態都是用 table 來實作的, 例如全域變數就是儲存在名為 _G 的特殊表格中, 宣告一個全域變數 a="123" 其實跟 _G["a"]="123" 是一樣的. 在其他語言中常見的陣列 (array), 串列 (list), 紀錄 (record), 佇列 (queue), 或集合 (set) 等, Lua 都用 table 來實現.
   Lua 的 table 是用大括號來宣告的 :
   
   t={}    --> 宣告一個空的表格
   
   表格是一種關聯式陣列, 所以可以用數字當索引, 也可以用字串當索引, 事實上, 在 Lua 中除了 nil 外, 任何值都可以當 Table 的索引, 例如 :
   
   t={}
   t[0]="peter"
   t[2]=23
   t["2"]=45                        -- 這跟 t[2] 無關
   t["gender"]="female"
   print(t[2])     --輸出 23
   print(t["2"])    --輸出 45
   print(t["age"])   --輸出 nil (無此元素不會出現錯誤, 而是認為新元素賦值 nil)
   
   當然也可以在宣告時同時賦值, 例如 :
   
   t={[0]="peter", [2]=23, ["gender"]="female"}     -- 注意喲, 索引必須用中括號
   
   如果索引名稱符合識別字限制 (英數字與底線組合, 不以數字開頭), 則中括號與引號可以省略, 例如 :
   
   t={name="peter", age=23, gender="female", _class=0}
   
   所以, 索引 a 與 ["a"] 是同樣的意思, 下列宣告前後都是同一元素, 後者的會蓋掉前者 :
   
   t={["a"]=123, a=456}
   print(t["a"])    --> 印出 456 (被覆蓋了)     
   
   Table 的最後一個元素若跟著逗號是允許的, 例如 :
   
   t={1,2,3,}
   
   這對於以迴圈自動產生 Table 元素非常方便, 因為不需要花功夫去除最後一個逗號.        
   
   雖然都是關聯式陣列, 但 Lua 的 table 跟 PHP 的關聯式陣列在索引的使用上是不一樣的, 以數值當索引時, PHP 只能用 0 與正整數當索引, 而 table 的索引則不限於整數, 可以是任何數值, 可用實數, 也可以是布林值, 例如 :
   
   t={}
   t[2.2]="too small"
   t[2.2e10]="too big"
   t[-199.99]="negative"
   t[true]=true
   t[false]=false
   
   對於字串索引, Lua 也提供點符號來存取表格, 這跟物件或紀錄 (record) 的用法是一樣的, 例如 :
   
   t={}
   t.name="peter"                  -- 相當於 t["name"]
   t.age=23                            -- 相當於 t["age"]
   t.gender="female"            -- 相當於 t["gender"]
   t._ID1="S1122334455"    -- 相當於 t["_ID1"]
   
   注意, 這裡點後面的欄位名稱受識別字命名法規範, 亦即只能用英文字母, 底線與數字之組合, 而且不能用數字開頭, 例如 t.2xy 是不合法的.
   這種點符號最容易讓人誤解之處是, 點後面的欄位名稱是個字串, t.a 意思是 t["a"], 而不是t[a], t.a 的 a 就是字串 "a", 而 t[a] 的 a 是指一個變數 a, 所以 t[a] 的索引決定於 a 變數的值, 例如 :
   
   t={}
   a="x"
   t[a]=1             -- 即 t["x"]=1
   print(t.a)         --> 印出 nil (因為 t.a 就是 t["a"], 並未定義故為 nil)
   print(t[a])       --> 印出 1 (因為此 a 為變數, t[a] 即 t["x"], 已設為 1)
   
   如果要用 table 來實作一般的陣列, 而非關聯式陣列, 那就略過索引的指定, 直接把元素的值放在中括號內即可, 例如 :
   
   t={1, 2, 3}
   print(t[0])         --> 印出 nil
   print(t[1])         --> 印出 1
   print(t[2])         --> 印出 2
   print(t[3])         --> 印出 3
   
   如果要知道陣列長度 (即有幾個元素), 跟取得字串長度一樣, 使用 # 運算子即可 :
   
   t={"a", "b", "c", 1, 2, 1.7e-34}
   print(#t)     --> 印出 6
   
   但要注意的是, 存取元素時, 索引是從 1 開始算的, 而不是像 Javascript 或 PHP 那樣是從 0 開始, 因為在不指定索引的情況下, Lua 的整數索引預設是從 1 開始數的, 這在 Lua 是普遍的法則. 要不, 你就得自行指定索引 (愛從哪開始就從哪開始) :
   
   t={[0]=1, [1]=2, [2]=3}
   print(t[0])         --> 印出 1
   print(t[1])         --> 印出 2
   print(t[2])         --> 印出 3
   print(t[3])         --> 印出 nil (未定義)
   
   但這樣就失去懶人的目的了.
   
   Lua 允許使用負數做為陣列索引, 但是 # 運算子卻只能計算索引為 1 起始的整數索引元素, 例如 :
   
   t={}
   for i=-5,5 do
     t[i]=i
   end
   print(#t)   --輸出 5
   
   表格的元素也是可以是另一個表格, 謂之巢狀表格, 而且可以要多深就有多深, 例如 :
   
   t={name="peter", im={qq="1234567890", skype="aaa"}}
   print(t.im.qq)                  --> 印出 1234567890
   print(t["im"]["skype"])   --> 印出 aaa
   
   可以用 key 或 index 兩種方式來存取巢狀表格的元素.
   
   表格的元素也可以由函數的傳回值來產生, 例如 :
   
   function odd()
     return 2,4,6,8,10   --傳回多值
   end
   t={odd()}     --表格的元素由 odd() 函數產生
   print(table.unpack(t))   --輸出 2      4      6      8      10
   
   上例中先呼叫自訂的 odd() 函數, 用其傳回值來當元素, 再呼叫 table.unpack() 函數來拆解表格.
   
   (6) function (函式)
   
   Lua 的函數跟 table 一樣是個物件, 它其實是用 table 建構的. Lua 提供豐富的內建函數, 也可以利用 function 保留字來自定函式以便將演算邏輯抽象化 (abstract). 內建函數中最常用的是 print(), 用來在螢幕上輸出資料. 上面範例都只用了一個參數, 實際上 print() 可以接受多個參數, 各參數用逗號隔開, 輸出時各參數會以 tab 隔開 (8 個空格), 例如 :
   
   name="tony"
   print("Name=", name)   --輸出 "Name=    tony"
   print(1,2,3,"abc")    --輸出 "1       2       3     abc"
   
   Lua 的函式屬於第一級函式 (first-class function), 亦即, 函式可以像數值或字串等一般的值一樣被指派給一個變數儲存在資料結構中, 例如 :
   
   a=print    --將系統函數 print() 指派給變數 a
   a("ok")    --輸出 ok
   
   函數也可以當作引數傳遞給另外一個函式, 或者被當成回傳值傳回給呼叫者, 當然也就具有閉包 (closure) 性質了. 除了 Lua 外, 其他具有 first-class function 功能的語言有 Python, PHP, Javascript, 以及 Ruby 等.
   
   # Wiki : first-class function
   
   函式的宣告包括 scope(=local, 可有可無), function name, argument(可有可無), body, return value (可有可無), 與 Javascript/PHP 不同的是, Lua 語法用 end 標誌函式終點, 不用大括號 (已被用在 table) :
   
   scope name(arguments)
       body
       return values
   end
   
   當傳入比宣告之參數還要多的引數時, 多餘的引數會被丟棄; 反之, 若傳入之引數比參數少, 那些沒有傳入引數之參數值預設為 nil. 例如 :
   
   function f(x,y)
      print(x,y)
   end
   
   則 :
   
   f(1,2,3,4)         --輸出 1   2   
   f(1)                  --輸出 1   nil
   
   函數即使沒有參數, 呼叫它時也需要小括弧, 例如 func1(), 但有一個例外, 就是當函數只有一個參數而且此參數是字串或表格時, 可以不用小括弧, 例如 :
   
   print "I love you"         --輸出 I love you
   print {name="Tony"}    --輸出 table: 0075e350
   
   Lua 函數不能像 PHP 那樣在參數列中賦予參數預設值, 不過可以用 or 運算子來模擬預設值, 例如 :
   
   function inv(a)
      local a=a or 0   --用 or 模擬預設值=0
      return -a
   end
   print(inv())      --輸出 0
   print(inv(2))    --輸出 -2
   
   此例中的自訂函數 inv() 會回傳相反數, 當沒有傳入參數時, 區域變數 a 為 nil, 照 or 運算規則, 若第一運算元為 false/nil, 就傳回第二運算元 0, 達到模擬預設值目的.
   
   Lua 的函數還有一個其他語言所沒有的特性, 就是 Lua 函數可以傳回多個回傳值. 例如內建函數 string.find() 就會傳回兩個整數值, 此函數用來在字串中尋找子字串, 其兩個傳回值分別代表所找到之第一個子字串之開始與結束索引, 例如 :
   
   str="LuaLua"
   print(string.find(str, "Lua"))     --輸出 1       3
   s, e=string.find(str, "Lua")   --利用多重指派取得兩個傳回值
   print(s, e)   --輸出 1      3
   
   在自訂函數中傳回多值時, 各值以逗號隔開即可, 呼叫時用多重指派取得各傳回值, 例如 :
   
   function myfunc() {
     local a, b, c, d
     --do somthing
     return a,b,c,d
   end
   w,x,y,z=myfunc()
   
   Lua 函數也提供不定長度參數功能 (variadic), 參數列使用 ... 來表示一個不確定長度的串列, 它相當於是一個會傳回多值得函數, 可以用 print(...) 顯示其傳回值, 例如 :
   
   function sum(...)
     local s=0
     for i,v in ipairs{...} do   --呼叫內建函數 ipairs() 拆解陣列 {...}
        s=s+v
     end
     return s
   end
   print(sum(1,2,3,4,5))     --輸出 15
   
   Lua 沒有直接支援名稱引數 (named argument), 但是可以用表格來模擬, 例如 :
   
   function profile(args)
     print(args.name)
     print(args.gender)
     print(args.age)
     print(args.phone)
   end
   profile({name="Tony",gender="male",age=50,phone="0911092288"})
   
   因參數為表格或字串時, 函數呼叫可以略去小括弧, 故下面這樣也可以 :
   profile{name="Tony",gender="male",age=50,phone="0911092288"}
7. 運算子的優先順序 :
   在不用小括弧限制之下, Lua 運算子的優先順序如下 :
   
   

   順序	運算子
   1 (最低)	or
   2	and
   3	< > <= >= ~= ==
   4	..
   5	+ - (減)
   6	* / %
   7	not # -(負)
   8 (最高)	^

8. 流程控制 :
   (1). 判斷 :
   Lua 的判斷式語法如下 :
   
   

   判斷式	語法	範例
   單向  (單條件)	if 條件式 then     敘述  end	if score >= 60 then    print ("及格")  end
   雙向  (單條件)	if 條件式 then     敘述  else     敘述  end	if score >= 60 then    print ("及格")  else    print ("不及格")  end
   巢狀  (多條件)	if 條件式 then     敘述   elseif 條件式 then     敘述  else     敘述  end	if score >= 90 then    print ("優等") elseif score >= 80 and score < 90 then    print ("甲等")  elseif score >= 70 and score < 80 then    print ("乙等")  else    print ("丙等")  end

   
   (2). 迴圈 :
   Lua 只有 for 與 while 兩種迴圈, 沒有 do while 迴圈. 注意 while 迴圈必須控制條件式設定終止條件, 以免成為無窮迴圈. 如果要拜訪表格元素, 可以使用內建函數 pairs() 來取得每一組鍵-值對.
   
   

   迴圈	語法	範例
   for 迴圈  (確定次數)	for 起始值, 終止值 do     敘述  end	local sum=0  for i=1,10 do    sum=sum + i  end
   for 迴圈  (遍歷表格)	for key,value in pairs(表格) do     敘述  end	local t={name="Tony",age=50}  for key,value in pairs(t) do    print(key, value)  end
   while 迴圈 (不確定次數)	while 條件式 do     敘述     條件運算式  end	local sum=0 local i=1  while i <= 10 do    sum=sum + i   i=i + 1  end  print(sum)

以上 Lua 語法摘要也參考了下列幾本書籍 :

1. Learn Lua for iOS Game Development (Apress, 2012) 
2. Learn Corona SDK Game Development (Apress, 2013)
3. Corona SDK Mobile Game Development, 2nd Edition (Packt, 2015)

其他參考資料 :

# App開發新選擇—Corona SDK
# https://coronalabs.com/
# http://getmoai.com/
# http://www.cocos2d-x.org/
# Creating standalone Lua executables

Lua 解譯器的用法

因為 NodeMCU 使用 Lua 語言編寫, 因此對 Lua 解譯器用法做了些測試, 整理如下, 首先下載目前最新版 Lua 5.3 :

# Lua source code download
# Lua binary for Windows
# Download lua-5.3_Win32_bin.zip (293.9 kB)

解開後會有四個檔案 :

其中 luac53.exe 是 Lua 的編譯器 (Compiler), 用來編譯原始碼; 而 lua53.exe 與 wlua53.exe 則是解譯器, 我們常用的是 lua53.exe 這個程式, 它是 console 輸出版, 點擊執行時會進入 Lua 交談模式, 可以直接執行 Lua 命令 :

在交談模式下, 也可以用 = 號代表 print 指令, 例如 :

E:\Lua>lua
Lua 5.3.0  Copyright (C) 1994-2015 Lua.org, PUC-Rio
> =("Hello World!")
Hello World!
> =a
nil
> a=100
> =a
100
>

當然我們可以把程式寫成 test1.lua 檔案如下 :

print ("Hello World!")
print (a)
a=100
print (a)

然後開啟命令提示字元視窗用 lua53.exe 執行 :

D:\lua-5.3_Win32_bin>lua53.exe test1.lua
Hello World!
nil
100

但如果用 wlua53.exe 去執行的話就不會顯示結果, 因為 wlua53.exe 不會輸出結果到 console, 適用於不需顯示輸出之用. 例如參考下列網站 :

# Lua - File I/O

寫一個 test2.lua 如下 :

file=io.open("result.txt", "a")
io.output(file)
io.write("Hello World!")
io.close(file)
print ("Hello World!")

如果用 wlua53.exe 執行, 螢幕不會顯示任何結果 :

D:\lua-5.3_Win32_bin>wlua53.exe test2.lua

D:\lua-5.3_Win32_bin>

但是檢查 result.txt 檔案, 只有一筆 Hello World! :

Hello World!

如果使用 lua53.exe 來執行, 螢幕會輸出最後那個 print 指令 :

D:\lua-5.3_Win32_bin>lua53.exe test2.lua
Hello World!

D:\lua-5.3_Win32_bin>

檢查 result.txt 檔案, 仍然只有一筆 Hello World!, 因為 print 是輸出到 console 的.

當然我們可以在控制台的環境變數 path 中指定 Lua 執行檔位置, 這樣在任何資料夾下面都能執行 Lua 程式了 :

如果嫌 lua53.exe 與 wlua53.exe 太長, 也可以把版本號 53 去掉 (但 lua53.dll 的 53 不可以去掉, 因為其它三個執行檔內部必須呼叫此動態連結檔), 變成 lua.exe 與 wlua.exe, 這樣以後只要敲 lua 就可以了 :

D:\lua-5.3_Win32_bin>lua test2.lua
Hello World!

經過設定 path 後, 就能在任何資料夾下面執行 lua, 如果不指定要執行的程式, 就會顯示版本資訊後出現大於提示號 >, 進入 Lua 的交談模式 :

C:\Users\yhhuang>lua
Lua 5.3.0  Copyright (C) 1994-2015 Lua.org, PUC-Rio
> print ("Hello World!")
Hello World!

在直譯器交談模式下, 如果輸入的指令不完整就按 Enter, 則提示號會變成兩個大於, 等輸入完整後才會執行, 如下所示 :

D:\lua>LUA
Lua 5.3.0  Copyright (C) 1994-2015 Lua.org, PUC-Rio
> print(
>> "Hello World!"
>> )
Hello World!
>

按 Ctrl+C 或輸入 os.exit() 就可以跳出交談模式, 回到 DOS 命令模式了 (在 Linux/Unix 是 Ctrl+D).

其實不用進 Lua 交談模式, 直接在 DOS 命令提示字元視窗就可以下 Lua 指令, 只要加一個 -e 參數即可 :

D:\>lua -e "print('ok')"

Lua 語言之父 Roberto Ierusalimschy 為巴西 Pontifical Catholic University of Rio de Janeiro 教授, 版本提示號後面出現的 PUC-Rio 就是該大學的簡稱 (Rio 表示位於里約熱內盧), 詳參 :

# Lua 的創造者 -- 巴西的 Tecgraf 組織與 Roberto Ierusalimschy 教授

至於 Lua 的程式編輯器, 用記事本就可以了, 但因多年來習慣使用 EditPlus, 所以我也下載了 Lua 的語法, 雖然是 5.1 版的, 但 Lua 到五版後就很穩定了, 所以沒啥差異 :

# 下載 EditPlus 的 Lua 語法檔