|
#
1. 基础字符串函数：
字符串库中有一些函数非常简单，如：
1). string.len(s) 返回字符串s的长度；
2). string.rep(s,n) 返回字符串s重复n次的结果；
3). string.lower(s) 返回s的副本，其中所有的大写都被转换为了小写形式，其他字符不变；
4). string.upper(s) 和lower相反，将小写转换为大写；
5). string.sub(s,i,j) 提取字符串s的第i个到第j个字符。Lua中，第一个字符的索引值为1，最后一个为-1，以此类推，如：
print(string.sub("[hello world]",2,-2)) --输出hello world
6). string.format(s,...) 返回格式化后的字符串，其格式化规则等同于C语言中printf函数，如：
print(string.format("pi = %.4f",math.pi)) --输出pi = 3.1416
7). string.char(...) 参数为0到多个整数，并将每个整数转换为对应的字符。然后返回一个由这些字符连接而成的字符串，如：
print(string.char(97,98,99)) --输出abc
8). string.byte(s,i) 返回字符串s的第i个字符的Ascii值，如果没有第二个参数，缺省返回第一个字符的Ascii值。
print(string.byte("abc")) --输出97
print(string.byte("abc",-1)) --输出99
由于字符串类型的变量都是不可变类型的变量，因此在所有和string相关的函数中，都无法改变参数中的字符串值，而是生成一个新值返回。
2. 模式匹配函数：
Lua的字符串库提供了一组强大的模式匹配函数，如find、match、gsub和gmatch。
1). string.find函数：
在目标字符串中搜索一个模式，如果找到，则返回匹配的起始索引和结束索引，否则返回nil。如： 1 s = "hello world"
2 i, j = string.find(s,"hello")
3 print(i, j) --输出1 5
4 i, j = string.find(s,"l")
5 print(i, j) --输出3 3
6 print(string.find(s,"lll")) --输出nil string.find函数还有一个可选参数，它是一个索引，用于告诉函数从目标字符串的哪个位置开始搜索。主要用于搜索目标字符串中所有匹配的子字符串，且每次搜索都从上一次找到的位置开始。如： 1 local t = {}
2 local i = 0
3 while true do
4 i = string.find(s,"\n",i+1)
5 if i == nil then
6 break
7 end
8 t[#t + 1] = i
9 end 2). string.match函数：
该函数返回目标字符串中和模式字符串匹配的部分。如： 1 date = "Today is 2012-01-01"
2 d = string.match(date,"%d+\-%d+\-%d+")
3 print(d) --输出2012-01-01 3). string.gsub函数：
该函数有3个参数，目标字符串、模式和替换字符串。基本用法是将目标字符串中所有出现模式的地方替换为替换字符串。如：
print(string.gsub("Lua is cute","cute","great")) --输出Lua is great
该函数还有可选的第4个参数，即实际替换的次数。
print(string.gsub("all lii","l","x",1)) --输出axl lii
print(string.gsub("all lii","l","x",2)) --输出axx lii
函数string.gsub还有另一个结果，即实际替换的次数。
count = select(2, string.gsub(str," "," ")) --输出str中空格的数量
4). string.gmatch函数：
返回一个函数，通过这个返回的函数可以遍历到一个字符串中所有出现指定模式的地方。如： 1 words = {}
2 s = "hello world"
3 for w in string.gmatch(s,"%a+") do
4 print(w)
5 words[#words + 1] = w
6 end
7 --输出结果为：
8 --hello
9 --world 3. 模式：
下面的列表给出了Lua目前支持的模式元字符； | 模式元字符 | 描述 | | . | 所有字符 | | %a | 字母 | | %c | 控制字符 | | %d | 数字 | | %l | 小写字母 | | %p | 标点符号 | | %s | 空白字符 | | %u | 大写字母 | | %w | 字母和数字字符 | | %x | 十六进制数字 | | %z | 内部表示为0的字符 |
这些元字符的大写形式表示它们的补集，如%A，表示所有非字母字符。
print(string.gsub("hello, up-down!","%S",".")) --输出hello..up.down. 4
上例中的4表示替换的次数。
除了上述元字符之外，Lua还提供了另外几个关键字符。如：( ) . % + - * ? [ ] ^ $
其中%表示转义字符，如%.表示点(.)，%%表示百分号(%)。
方括号[]表示将不同的字符分类，即可创建出属于自己的字符分类，如[%w_]表示匹配字符、数字和下划线。
横线(-)表示连接一个范围，比如[0-9A-Z]
如果^字符在方括号内，如[^\n]，表示除\n之外的所有字符，即表示方括号中的分类的补集。如果^不在方括号内，则表示以后面的字符开头，$和它正好相反，表示以前面的字符结束。如：^Hello%d$，匹配的字符串可能为Hello1、Hello2等。
在Lua中还提供了4种用来修饰模式中的重复部分，如：+(重复1次或多次)、*(重复0次或多次)、-(重复0次或多次)和?(出现0或1次)。如：
print(string.gsub("one, and two; and three","%a+","word")) --输出word, word word; word word
print(string.match("the number 1298 is even","%d+")) --输出1298
星号(*)和横线(-)的主要差别是，星号总是试图匹配更多的字符，而横线则总是试图匹配最少的字符。
4. 捕获(capture)：
捕获功能可根据一个模式从目标字符串中抽出匹配于该模式的内容。在指定捕获是，应将模式中需要捕获的部分写到一对圆括号内。对于具有捕获的模式，函数string.match会将所有捕获到的值作为单独的结果返回。即它会将目标字符串切成多个捕获到的部分。如： 1 pair = "name = Anna"
2 key,value = string.match(pair,"(%a+)%s*=%s*(%a+)")
3 print(key,value) --输出name anna
4
5 date = "Today is 2012-01-02"
6 y,m,d = string.match(date,"(%d+)\-(%d+)\-(%d+)")
7 print(y,m,d) --输出2012 01 02 还可以对模式本身使用捕获。即%1表示第一个捕获，以此类推，%0表示整个匹配，如： 1 print(string.gsub("hello Lua","(.)(.)","%2%1")) --将相邻的两个字符对调，输出为ehll ouLa
2 print(string.gsub("hello Lua!","%a","%0-%0")) --输出为h-he-el-ll-lo-o L-Lu-ua-a!
5. 替换：
string.gsub函数的第三个参数不仅可以是字符串，也可以是函数或table，如果是函数，string.gsub会在每次找到匹配时调用该函数，调用时的参数就是捕获到的内容，而该函数的返回值则作为要替换的字符串。当用一个table来调用时，string.gsub会用每次捕获到的内容作为key，在table中查找，并将对应的value作为要替换的字符串。如果table中不包含这个key，那么string.gsub不改变这个匹配。如：
1 function expand(s)
2 return (string.gsub(s,"$(%w+)",_G))
3 end
4
5 name = "Lua"; status = "great"
6 print(expand("$name is $status, isn't it?")) --输出 Lua is great, isn't it?
7 print(expand("$othername is $status, isn't it?")) --输出 $othername is great, isn't it?
8
9 function expand2(s)
10 return (string.gsub(s,"$(%w+)",function(n) return tostring(_G[n]) end))
11 end
12
13 print(expand2("print = $print; a = $a")) --输出 print = function: 002B77C0; a = nil
Lua中的table就是一种对象，但是如果直接使用仍然会存在大量的问题，见如下代码： 1 Account = {balance = 0}
2 function Account.withdraw(v)
3 Account.balance = Account.balance - v
4 end
5 --下面是测试调用函数
6 Account.withdraw(100.00) 在上面的withdraw函数内部依赖了全局变量Account，一旦该变量发生改变，将会导致withdraw不再能正常的工作，如： 1 a = Account; Account = nil
2 a.withdraw(100.00) --将会导致访问空nil的错误。 这种行为明显的违反了面向对象封装性和实例独立性。要解决这一问题，我们需要给withdraw函数在添加一个参数self，他等价于Java/C++中的this，见如下修改： 1 function Account.withdraw(self,v)
2 self.balance = self.balance - v
3 end
4 --下面是基于修改后代码的调用：
5 a1 = Account; Account = nil
6 a1.withdraw(a1,100.00) --正常工作。 针对上述问题，Lua提供了一种更为便利的语法，即将点(.)替换为冒号(:)，这样可以在定义和调用时均隐藏self参数，如: 1 function Account:withdraw(v)
2 self.balance = self.balance - v
3 end
4 --调用代码可改为：
5 a:withdraw(100.00)
1. 类：
Lua在语言上并没有提供面向对象的支持，因此想实现该功能，我们只能通过table来模拟，见如下代码及关键性注释：
 1 --[[
2 在这段代码中，我们可以将Account视为class的声明，如Java中的：
3 public class Account
4 {
5 public float balance = 0;
6 public Account(Account o);
7 public void deposite(float f);
8 }
9 --]]
10 --这里balance是一个公有的成员变量。
11 Account = {balance = 0}
12
13 --new可以视为构造函数
14 function Account:new(o)
15 o = o or {} --如果参数中没有提供table，则创建一个空的。
16 --将新对象实例的metatable指向Account表(类)，这样就可以将其视为模板了。
17 setmetatable(o,self)
18 --在将Account的__index字段指向自己，以便新对象在访问Account的函数和字段时，可被直接重定向。
19 self.__index = self
20 --最后返回构造后的对象实例
21 return o
22 end
23
24 --deposite被视为Account类的公有成员函数
25 function Account:deposit(v)
26 --这里的self表示对象实例本身
27 self.balance = self.balance + v
28 end
29
30 --下面的代码创建两个Account的对象实例
31
32 --通过Account的new方法构造基于该类的示例对象。
33 a = Account:new()
34 --[[
35 这里需要具体解释一下，此时由于table a中并没有deposite字段，因此需要重定向到Account，
36 同时调用Account的deposite方法。在Account.deposite方法中，由于self(a对象)并没有balance
37 字段，因此在执行self.balance + v时，也需要重定向访问Account中的balance字段，其缺省值为0。
38 在得到计算结果后，再将该结果直接赋值给a.balance。此后a对象就拥有了自己的balance字段和值。
39 下次再调用该方法，balance字段的值将完全来自于a对象，而无需在重定向到Account了。
40 --]]
41 a:deposit(100.00)
42 print(a.balance) --输出100
43
44 b = Account:new()
45 b:deposit(200.00)
46 print(b.balance) --输出200
2. 继承：
继承也是面向对象中一个非常重要的概念，在Lua中我们仍然可以像模拟类那样来进一步实现面向对象中的继承机制，见如下代码及关键性注释：
1 --需要说明的是，这段代码仅提供和继承相关的注释，和类相关的注释在上面的代码中已经给出。
2 Account = {balance = 0}
3
4 function Account:new(o)
5 o = o or {}
6 setmetatable(o,self)
7 self.__index = self
8 return o
9 end
10
11 function Account:deposit(v)
12 self.balance = self.balance + v
13 end
14
15 function Account:withdraw(v)
16 if v > self.balance then
17 error("Insufficient funds")
18 end
19 self.balance = self.balance - v
20 end
21
22 --下面将派生出一个Account的子类，以使客户可以实现透支的功能。
23 SpecialAccount = Account:new() --此时SpecialAccount仍然为Account的一个对象实例
24
25 --派生类SpecialAccount扩展出的方法。
26 --下面这些SpecialAccount中的方法代码(getLimit/withdraw)，一定要位于SpecialAccount被Account构造之后。
27 function SpecialAccount:getLimit()
28 --此时的self将为对象实例。
29 return self.limit or 0
30 end
31
32 --SpecialAccount将为Account的子类，下面的方法withdraw可以视为SpecialAccount
33 --重写的Account中的withdraw方法，以实现自定义的功能。
34 function SpecialAccount:withdraw(v)
35 --此时的self将为对象实例。
36 if v - self.balance >= self:getLimit() then
37 error("Insufficient funds")
38 end
39 self.balance = self.balance - v
40 end
41
42 --在执行下面的new方法时，table s的元表已经是SpecialAccount了，而不再是Account。
43 s = SpecialAccount:new{limit = 1000.00}
44 --在调用下面的deposit方法时，由于table s和SpecialAccount均未提供该方法，因此访问的仍然是
45 --Account的deposit方法。
46 s:deposit(100)
47
48
49 --此时的withdraw方法将不再是Account中的withdraw方法，而是SpecialAccount中的该方法。
50 --这是因为Lua先在SpecialAccount(即s的元表)中找到了该方法。
51 s:withdraw(200.00)
52 print(s.balance) --输出-100
3. 私密性：
私密性对于面向对象语言来说是不可或缺的，否则将直接破坏对象的封装性。Lua作为一种面向过程的脚本语言，更是没有提供这样的功能，然而和模拟支持类与继承一样，我们仍然可以在Lua中通过特殊的编程技巧来实现它，这里我们应用的是Lua中的闭包函数。该实现方式和前面两个示例中基于元表的方式有着很大的区别，见如下代码示例和关键性注释：
1 --这里我们需要一个闭包函数作为类的创建工厂
2 function newAccount(initialBalance)
3 --这里的self仅仅是一个普通的局部变量，其含义完全不同于前面示例中的self。
4 --这里之所以使用self作为局部变量名，也是为了方便今后的移植。比如，以后
5 --如果改为上面的实现方式，这里应用了self就可以降低修改的工作量了。
6 local self = {balance = initialBalance} --这里我们可以将self视为私有成员变量
7 local withdraw = function(v) self.balance = self.balance - v end
8 local deposit = function(v) self.balance = self.balance + v end
9 local getBalance = function() return self.balance end
10 --返回对象中包含的字段仅仅为公有方法。事实上，我们通过该种方式，不仅可以实现
11 --成员变量的私有性，也可以实现方法的私有性，如：
12 --local privateFunction = function() --do something end
13 --只要我们不在输出对象中包含该方法的字段即可。
14 return {withdraw = withdraw, deposit = deposit, getBalance = getBalance}
15 end
16
17 --和前面两个示例不同的是，在调用对象方法时，不再需要self变量，因此我们可以直接使用点(.)，
18 --而不再需要使用冒号(:)操作符了。
19 accl = newAccount(100.00)
20 --在函数newAccount返回之后，该函数内的“非局部变量”表self就不再能被外部访问了，只能通过
21 --该函数返回的对象的方法来操作它们。
22 accl.withdraw(40.00)
23 print(acc1.getBalance()) 事实上，上面的代码只是给出一个简单的示例，在实际应用中，我们可以将更多的私有变量存放于上例的局部self表中。
Lua采用了基于垃圾收集的内存管理机制，因此对于程序员来说，在很多时候内存问题都将不再困扰他们。然而任何垃圾收集器都不是万能的，在有些特殊情况下，垃圾收集器是无法准确的判断是否应该将当前对象清理。这样就极有可能导致很多垃圾对象无法被释放。为了解决这一问题，就需要Lua的开发者予以一定程度上的配合。比如，当某个table对象被存放在容器中，而容器的外部不再有任何变量引用该对象，对于这样的对象，Lua的垃圾收集器是不会清理的，因为容器对象仍然引用着他。如果此时针对该容器的应用仅限于查找，而不是遍历的话，那么该对象将永远不会被用到。事实上，对于这样的对象我们是希望Lua的垃圾收集器可以将其清理掉的。见如下代码： 1 a = {}
2 key = {}
3 a[key] = 1
4 key = {}
5 a[key] = 2
6 collectgarbage()
7 for k,v in pairs(a) do
8 print(v)
9 end
10 --输出1和2 在执行垃圾收集之后，table a中的两个key都无法被清理，但是对value等于1的key而言，如果后面的逻辑不会遍历table a的话，那么我们就可以认为该对象内存泄露了。在Lua中提供了一种被称为弱引用table的机制，可以提示垃圾收集器，如果某个对象，如上面代码中的第一个table key，只是被弱引用table引用，那么在执行垃圾收集时可以将其清理。
Lua中的弱引用表提供了3中弱引用模式，即key是弱引用、value是弱引用，以及key和value均是弱引用。不论是哪种类型的弱引用table，只要有一个key或value被回收，那么它们所在的整个条目都会从table中删除。
一个table的弱引用类型是通过其元表的__mode字段来决定的。如果该值为包含字符"k"，那么table就是key弱引用，如果包含"v"，则是value若引用，如果两个字符均存在，就是key/value弱引用。见如下代码： 1 a = {}
2 b = {__mode = "k"}
3 setmetatable(a,b)
4 key = {}
5 a[key] = 1
6 key = {}
7 a[key] = 2
8 collectgarbage()
9 for k,v in pairs(a) do
10 print(v)
11 end
12 --仅仅输出2 在上面的代码示例中，第一个key在被存放到table a之后，就被第二个key的定义所覆盖，因此它的唯一引用来自key弱引用表。事实上，这种机制在Java中也同样存在，Java在1.5之后的版本中也提供了一组弱引用容器，其语义和Lua的弱引用table相似。
最后需要说明的是，Lua中的弱引用表只是作用于table类型的变量，对于其他类型的变量，如数值和字符串等，弱引用表并不起任何作用。
1. 备忘录(memoize)函数：
用“空间换时间”是一种通用的程序运行效率优化手段，比如：对于一个普通的Server，它接受到的请求中包含Lua代码，每当其收到请求后都会调用Lua的loadstring函数来动态解析请求中的Lua代码，如果这种操作过于频率，就会导致Server的执行效率下降。要解决该问题，我们可以将每次解析的结果缓存到一个table中，下次如果接收到相同的Lua代码，就不需要调用loadstirng来动态解析了，而是直接从table中获取解析后的函数直接执行即可。这样在有大量重复Lua代码的情况下，可以极大的提高Server的执行效率。反之，如果有相当一部分的Lua代码只是出现一次，那么再使用这种机制，就将会导致大量的内存资源被占用而得不到有效的释放。在这种情况下，如果使用弱引用表，不仅可以在一定程度上提升程序的运行效率，内存资源也会得到有效的释放。见如下代码： 1 local results = {}
2 setmetatable(results,{__mode = "v"}) --results表中的key是字符串形式的Lua代码
3 function mem_loadstring(s)
4 local res = results[s]
5 if res == nil then
6 res = assert(loadstring(s))
7 results[s] = res
8 end
9 return res
10 end
从Lua 5.1开始，我们可以使用require和module函数来获取和创建Lua中的模块。从使用者的角度来看，一个模块就是一个程序库，可以通过require来加载，之后便得到一个类型为table的全局变量。此时的table就像名字空间一样，可以访问其中的函数和常量，如： 1 require "mod"
2 mod.foo()
3 local m2 = require "mod2"
4 local f = mod2.foo
5 f() 1. require函数：
require函数的调用形式为require "模块名"。该调用会返回一个由模块函数组成的table，并且还会定义一个包含该table的全局变量。在使用Lua中的标准库时可以不用显示的调用require，因为Lua已经预先加载了他们。
require函数在搜素加载模块时，有一套自定义的模式，如：
?;?.lua;c:/windows/?;/usr/local/lua/?/?.lua
在上面的模式中，只有问号(?)和分号(;)是模式字符，分别表示require函数的参数(模块名)和模式间的分隔符。如：调用require "sql"，将会打开以下的文件：
sql
sql.lua
c:/windows/sql
/usr/local/lua/sql/sql.lua
Lua将require搜索的模式字符串放在变量package.path中。当Lua启动后，便以环境变量LUA_PATH的值来初始化这个变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。如果require无法找到与模块名相符的Lua文件，就会找C程序库。C程序库的搜索模式存放在变量package.cpath中。而这个变量则是通过环境变量LUA_CPATH来初始化的。
2. 编写模块的基本方法：
见如下代码和关键性注释： 1 --将模块名设置为require的参数，这样今后重命名模块时，只需重命名文件名即可。
2 local modname = ...
3 local M = {}
4 _G[modname] = M
5
6 M.i = {r = 0, i = 1} --定义一个模块内的常量。
7 function M.new(r,i) return {r = r, i = i} end
8 function M.add(c1,c2)
9 return M.new(c1.r + c2.r,c1.i + c2.i)
10 end
11
12 function M.sub(c1,c2)
13 return M.new(c1.r - c2.r,c1.i - c2.i)
14 end
15 --返回和模块对应的table。
16 return M
3. 使用环境：
仔细阅读上例中的代码，我们可以发现一些细节上问题。比如模块内函数之间的调用仍然要保留模块名的限定符，如果是私有变量还需要加local关键字，同时不能加模块名限定符。如果需要将私有改为公有，或者反之，都需要一定的修改。那又该如何规避这些问题呢？我们可以通过Lua的函数“全局环境”来有效的解决这些问题。见如下修改的代码和关键性注释： 1 --模块设置和初始化。这一点和上例一致。
2 local modname = ...
3 local M = {}
4 _G[modname] = M
5
6 --声明这个模块将会用到的全局函数，因为在setfenv之后将无法再访问他们，
7 --因此需要在设置之前先用本地变量获取。
8 local sqrt = mat.sqrt
9 local io = io
10
11 --在这句话之后就不再需要外部访问了。
12 setfenv(1,M)
13
14 --后面的函数和常量定义都无需模块限定符了。
15 i = {r = 0, i = 1}
16 function new(r,i) return {r = r, i = i} end
17 function add(c1,c2)
18 return new(c1.r + c2.r,c1.i + c2.i)
19 end
20
21 function sub(c1,c2)
22 return new(c1.r - c2.r,c1.i - c2.i)
23 end
24 --返回和模块对应的table。
25 return M
4. module函数：
在Lua 5.1中，我们可以用module(...)函数来代替以下代码，如：
1 local modname = ...
2 local M = {}
3 _G[modname] = M
4 package.loaded[modname] = M
5 --[[
6 和普通Lua程序块一样声明外部函数。
7 --]]
8 setfenv(1,M) 由于在默认情况下，module不提供外部访问，必须在调用它之前，为需要访问的外部函数或模块声明适当的局部变量。然后Lua提供了一种更为方便的实现方式，即在调用module函数时，多传入一个package.seeall的参数，如：
module(...,package.seeall)
摘要: Lua中提供的元表是用于帮助Lua数据变量完成某些非预定义功能的个性化行为，如两个table的相加。假设a和b都是table，通过元表可以定义如何计算表达式a+b。当Lua试图将两个table相加时，它会先检查两者之一是否有元表，然后检查该元表中是否存在__add字段，如果有，就调用该字段对应的值。这个值就是所谓的“元方法”，这个函数用于计算table的和。&n... 阅读全文
Lua将其所有的全局变量保存在一个常规的table中，这个table被称为“环境”。它被保存在全局变量_G中。
1. 全局变量声明：
Lua中的全局变量不需要声明就可以使用。尽管很方便，但是一旦出现笔误就会造成难以发现的错误。我们可以通过给_G表加元表的方式来保护全局变量的读取和设置，这样就能降低这种笔误问题的发生几率了。见如下示例代码： 1 --该table用于存储所有已经声明过的全局变量名
2 local declaredNames = {}
3 local mt = {
4 __newindex = function(table,name,value)
5 --先检查新的名字是否已经声明过，如果存在，这直接通过rawset函数设置即可。
6 if not declaredNames[name] then
7 --再检查本次操作是否是在主程序或者C代码中完成的，如果是，就继续设置，否则报错。
8 local w = debug.getinfo(2,"S").what
9 if w ~= "main" and w ~= "C" then
10 error("attempt to write to undeclared variable " .. name)
11 end
12 --在实际设置之前，更新一下declaredNames表，下次再设置时就无需检查了。
13 declaredNames[name] = true
14 end
15 print("Setting " .. name .. " to " .. value)
16 rawset(table,name,value)
17 end,
18
19 __index = function(_,name)
20 if not declaredNames[name] then
21 error("attempt to read undeclared variable " .. name)
22 else
23 return rawget(_,name)
24 end
25 end
26 }
27 setmetatable(_G,mt)
28
29 a = 11
30 local kk = aa
31
32 --输出结果为：
33 --[[
34 Setting a to 11
35 lua: d:/test.lua:21: attempt to read undeclared variable aa
36 stack traceback:
37 [C]: in function 'error'
38 d:/test.lua:21: in function <d:/test.lua:19>
39 d:/test.lua:30: in main chunk
40 [C]: ?
41 --]]
2. 非全局的环境：
全局环境存在一个刚性的问题，即它的修改将影响到程序的所有部分。Lua 5为此做了一些改进，新的特征可以支持每个函数拥有自己独立的全局环境，而由该函数创建的closure函数将继承该函数的全局变量表。这里我们可以通过setfenv函数来改变一个函数的环境，该函数接受两个参数，一个是函数名，另一个是新的环境table。第一个参数除了函数名本身，还可以指定为一个数字，以表示当前函数调用栈中的层数。数字1表示当前函数，2表示它的调用函数，以此类推。见如下代码：
1 a = 1
2 setfenv(1,{})
3 print(a)
4
5 --输出结果为：
6 --[[
7 lua: d:/test.lua:3: attempt to call global 'print' (a nil value)
8 stack traceback:
9 d:/test.lua:3: in main chunk
10 [C]: ?
11 --]] 为什么得到这样的结果呢？因为print和变量a一样，都是全局表中的字段，而新的全局表是空的，所以print调用将会报错。
为了应对这一副作用，我们可以让原有的全局表_G作为新全局表的内部表，在访问已有全局变量时，可以直接转到_G中的字段，而对于新的全局字段，则保留在新的全局表中。这样即便是函数中的误修改，也不会影响到其他用到全局变量(_G)的地方。见如下代码： 1 a = 1
2 local newgt = {} --新环境表
3 setmetatable(newgt,{__index = _G})
4 setfenv(1,newgt)
5 print(a) --输出1
6
7 a = 10
8 print(a) --输出10
9 print(_G.a) --输出1
10 _G.a = 20
11 print(a) --输出10 最后给出的示例是函数环境变量的继承性。见如下代码： 1 function factory()
2 return function() return a end
3 end
4 a = 3
5 f1 = factory()
6 f2 = factory()
7 print(f1()) --输出3
8 print(f2()) --输出3
9
10 setfenv(f1,{a = 10})
11 print(f1()) --输出10
12 print(f2()) --输出3
Lua中的table不是一种简单的数据结构，它可以作为其它数据结构的基础。如数组、记录、线性表、队列和集合等，在Lua中都可以通过table来表示。
1. 数组：
使用整数来索引table即可在Lua中实现数组。因此，Lua中的数组没有固定的大小，如： 1 a = {}
2 for i = 1, 1000 do
3 a[i] = 0
4 end
5 print("The length of array 'a' is " .. #a)
6 --The length of array 'a' is 1000 在Lua中，可以让任何数作为数组的起始索引，但通常而言，都会使用1作为其起始索引值。而且很多Lua的内置功能和函数都依赖这一特征，因此在没有充分理由的前提下，尽量保证这一规则。下面的方法是通过table的构造器来创建并初始化一个数组的，如：
squares = {1, 4, 9, 16, 25}
2. 二维数组：
在Lua中我们可以通过两种方式来利用table构造多维数组。其中，第一种方式通过“数组的数组”的方式来实现多维数组的，即在一维数组上的每个元素也同样为table对象，如： 1 mt = {}
2 for i = 1, N do
3 mt[i] = {}
4 for j = 1, M do
5 mt[i][j] = i * j
6 end
7 end 第二种方式是将二维数组的索引展开，并以固定的常量作为第二维度的步长，如： 1 mt = {}
2 for i = 1, N do
3 for j = 1, M do
4 mt[(i - 1) * M + j] = i * j
5 end
6 end
3. 链表：
由于table是动态的实体，所以在Lua中实现链表是很方便的。其中，每个结点均以table来表示，一个“链接”只是结点中的一个字段，该字段包含对其它table的引用，如：
1 list = nil
2 for i = 1, 10 do
3 list = { next = list, value = i}
4 end
5
6 local l = list
7 while l do
8 print(l.value)
9 l = l.next
10 end
4. 队列与双向队列：
在Lua中实现队列的简单方法是使用table库函数insert和remove。但是由于这种方法会导致后续元素的移动，因此当队列的数据量较大时，不建议使用该方法。下面的代码是一种更高效的实现方式，如：
1 List = {}
2
3 function List.new()
4 return {first = 0, last = -1}
5 end
6
7 function List.pushFront(list, value)
8 local first = list.first - 1
9 list.first = first
10 list[first] = value
11 end
12
13 function List.pushBack(list, value)
14 local last = list.last + 1
15 list.last = last
16 list[last] = value
17 end
18
19 function List.popFront(list)
20 local first = list.first
21 if first > list.last then
22 error("List is empty")
23 end
24 local value = list[first]
25 list[first] = nil
26 list.first = first + 1
27 return value
28 end
29
30 function List.popBack(list)
31 local last = list.last
32 if list.first > last then
33 error("List is empty")
34 end
35 local value = list[last]
36 list[last] = nil
37 list.last = last - 1
38 return value
39 end
5. 集合和包(Bag)：
在Lua中用table实现集合是非常简单的，见如下代码：
reserved = { ["while"] = true, ["end"] = true, ["function"] = true, }
if not reserved["while"] then
--do something
end
在Lua中我们可以将包(Bag)看成MultiSet，与普通集合不同的是该容器中允许key相同的元素在容器中多次出现。下面的代码通过为table中的元素添加计数器的方式来模拟实现该数据结构，如：
1 function insert(bag, element)
2 bag[element] = (bag[element] or 0) + 1
3 end
4
5 function remove(bag, element)
6 local count = bag[element]
7 bag[element] = (count and count > 1) and count - 1 or nil
8 end
6. StringBuilder：
如果想在Lua中将多个字符串连接成为一个大字符串的话，可以通过如下方式实现，如：
1 local buff = ""
2 for line in io.lines() do
3 buff = buff .. line .. "\n"
4 end 上面的代码确实可以正常的完成工作，然而当行数较多时，这种方法将会导致大量的内存重新分配和内存间的数据拷贝，由此而带来的性能开销也是相当可观的。事实上，在很多编程语言中String都是不可变对象，如Java，因此如果通过该方式多次连接较大字符串时，均会导致同样的性能问题。为了解决该问题，Java中提供了StringBuilder类，而Lua中则可以利用table的concat方法来解决这一问题，见如下代码： 1 local t = {}
2 for line in io.lines() do
3 t[#t + 1] = line .. "\n"
4 end
5 local s = table.concat(t)
6
7 --concat方法可以接受两个参数，因此上面的方式还可以改为：
8 local t = {}
9 for line in io.lines() do
10 t[#t + 1] = line
11 end
12 local s = table.concat(t,"\n")
1. 数据文件：
我们可以利用Lua中table的构造式来定义一种文件格式，即文件中的数据是table构造并初始化的代码，这种方式对于Lua程序而言是非常方便和清晰的，如：
Entry { "Stephen Liu", "Male", "Programmer", "BS" }
Entry { "Jerry Tian", "Male", "Programmer", "BS" }
需要注意的是，Entry{<code>}等价于Entry({<code>})，对于上面的数据条目，如果我们能够定义一个合适的Entry函数，就可以让这些数据成为我们Lua代码的一部分了。见如下代码及其注释： 1 local count = 0
2 --这里预先定义了Entry函数，以便在执行dofile中的数据代码时，可以找到匹配的该函数。
3 function Entry() count = count + 1 end
4 dofile("d:/lua_data.conf")
5 print("number of entries: " .. count)
6
7 --输出结果为：
8 --number of entries: 2 相比于上面数据文件的格式，我们还可以定义一种更为清晰的“自描述的数据”格式，其中每项数据都伴随一个表示其含义的简短描述。采用这样的格式，即便今后数据项发生了变化，我们仍然可以在改动极小的情况下保持向后的兼容性。见如下数据格式和相关的代码：
Entry { name = "Stephen Liu", gender = "Male", job = "Programmer", education = "BS" }
Entry { name = "Jerry Tian", gender = "Male", job = "Programmer", education = "BS" } 1 local personInfo = {}
2 function Entry(b)
3 --这里将table对象b的name字段值作为personInfo的key信息。
4 if b.name then
5 personInfo[b.name] = true
6 end
7 end
8
9 dofile("d:/lua_data.conf")
10 for name in pairs(personInfo) do
11 print(name)
12 end
13
14 --输出结果为：
15 --Jerry Tian
16 --Stephen Liu 可以看出这些代码片段都采用了事件驱动的做法。Entry函数作为一个回调函数，在执行dofile时为数据文件中的每个条目所调用。
Lua不仅运行速度快，而且编译速度也快。这主要是因为Lua在设计之初就将数据描述作为Lua的主要应用之一所致。
2. 序列化：
相信有Java或C#开发经验的人对于这一术语并不陌生。就是将数据对象转换为字节流后在通过IO输出到文件或网络，读取的时候再将这些数据重新构造为与原始对象具有相同值的新对象。或者我们也可以将一段可执行的Lua代码作为序列化后的数据格式。比如：varname = <expr>，这里的<expr>表示计算变量varname的表达式。下面的示例代码用于序列化无环的table： 1 function serialize(o)
2 if type(o) == "number" then
3 io.write(o)
4 elseif type(o) == "string" then
5 --string.format函数的"%q"参数可以转义字符串中的元字符。
6 io.write(string.format("%q",o))
7 elseif type(o) == "table" then
8 io.write("{\n")
9 --迭代table中的各个元素，同时递归的写出各个字段的value。
10 --由此可以看出，这个简单例子可以支持嵌套的table。
11 for k,v in pairs(o) do
12 --这样做是为了防止k中包含非法的Lua标识符。
13 io.write(" ["); serialize(k); io.write("] = ")
14 serialize(v)
15 io.write(",\n")
16 end
17 io.write("}\n")
18 else
19 error("cannot serialize a " .. type(o))
20 end
21 end
1. 编译：
Lua中提供了dofile函数，它是一种内置的操作，用于运行Lua代码块。但实际上dofile只是一个辅助函数，loadfile才是真正的核心函数。相比于dofile，loadfile只是从指定的文件中加载Lua代码块，然后编译这段代码块，如果有编译错误，就返回nil，同时给出错误信息，但是在编译成功后并不真正的执行这段代码块。因此，我们可以将dofile实现为： 1 function dofile(filename)
2 local f = assert(loadfile(filename))
3 return f()
4 end 这里如果loadfile执行失败，assert函数将直接引发一个错误。通过dofile的代码，我们还可以看出，如果打算多次运行一个文件中的Lua代码块，我们可以只执行loadfile一次，之后多次运行它返回的结果即可，这样就可以节省多次编译所带来的开销。这一点也是loadfile和dofile在性能上的区别。
Lua中还提供了另外一种动态执行Lua代码的方式，即loadstring函数。顾名思义，相比于loadfile，loadstring的代码源来自于其参数中的字符串，如：
f = loadstring("i = i + 1")
此时f就变成了一个函数，每次调用时就执行"i = i + 1"，如： 1 i = 0
2 f()
3 print(i) --将输出1
4 f()
5 print(i) --将输出2 loadstring确实是一个功能强大的函数，但是由此而换来的性能开销也是我们不得不考虑的事情。所以对于很多常量字符串如果仍然使用loadstring方式，那就没有太大意义了，如上面的例子f = loadstring("i = i + 1")，因为我们完全可以通过f = function () i = i + 1 end的形式取而代之。而后者的执行效率要远远高于前者。毕竟后者只编译一次，而前者则在每次调用loadstring时均被编译。对于loadstring，我们还需要注意的是，该函数总是在全局环境中编译它的字符串，因此它将无法文件局部变量，而是只能访问全局变量，如： 1 i = 32
2 local i = 0
3 f = loadstring("i = i + 1; print(i)")
4 g = function() i = i + 1; print(i) end
5 f() --f函数中的i为全局变量i，因此输出33
6 g() --g函数中的i为局部变量i，因此输出1 对于loadstring返回的函数，如果需要对一个表达式求值，则必须在其之前添加return，这样才能构成一条语句，返回表达式的值，如： 1 i = 32
2 f = loadstring("i = i + 1; return i * 2")
3 print(f()) --输出66
4 print(f()) --输出68。由于loadstring返回的就是正规的函数，因此可以被反复调用。 Lua将所有独立的程序块视为一个匿名函数的函数体，并且该匿名函数还具有可变长实参，因此在调用loadstring时，可以为其传递参数，如： 1 local i = 30
2 --下面的...表示变长实参，将值赋给局部变量x。
3 local f = assert(loadstring("local x = ...; return (x + 10) * 2"))
4 for i = 1, 20 do
5 print(string.rep("*",f(i)))
6 end
2. C代码：
上一小节介绍的是动态加载Lua代码，而事实上，Lua本身也支持动态加载C动态库中的代码，要完成该操作，我们需要借助于Lua内置的系统函数package.loadlib。该函数有两个字符串参数，分别是动态库的全文件名和该库包含的函数名称，典型的调用代码如下：
local path = "/usr/local/lib/test.so"
local f = package.loadlib(path,"test_func")
由于loadlib是非常底层的函数，因为在调用时必须提供完整的路径名和函数名称。
3. 错误：
Lua作为一种嵌入式脚本语言，在发生错误时，不应该只是简单的退出或崩溃。相反，一旦有错误发生，Lua就应该结束当前程序块并返回到应用程序。
在Lua中我们可以通过error()函数获取错误消息，如：
print "enter a number:"
n = io.read("*number")
if not n then error("invalid input") end
上面代码中的最后一行我们可以通过Lua提供的另外一个内置函数assert类辅助完成，如：
print "enter a number:"
n = assert(io.read("*number"),"invalid input")
assert函数将检查其第一个参数是否为true，如果是，则简单的返回该参数，否则就引发一个错误。第二个参数是可选字符串。
对于所有的编程语言而言，错误处理都是一个非常重要的环节。在实际的开发中，没有统一的指导原则，只能是在遇到问题后，经过缜密的分析在结合当时的应用场景，最后结合自己的经验再给出错误的具体处理方式。在有些情况下，我们可以直接返回错误码，而在另外一些情况下，则需要直接抛出错误，让开发者能够快速定位导致错误的代码源。
4. 错误处理与异常：
Lua提供了错误处理函数pcall，该函数的第一个参数为需要“保护执行”的函数，如果该函数执行失败，pcall将返回false及错误信息，否则返回true和函数调用的返回值。见如下代码：
1 function foo()
2 local a = 10
3 print(a[2])
4 end
5
6 r, msg = pcall(foo)
7 if r then
8 print("This is ok.")
9 else
10 print("This is error.")
11 print(msg)
12 end
13 --输出结果为：
14 --This is error.
15 --d:/test.lua:3: attempt to index local 'a' (a number value) 我们也可以给pcall函数直接传递匿名函数，如： 1 r, msg = pcall(function() error({code = 121}) end)
2 if r then
3 print("This is ok.")
4 else
5 print("This is error.")
6 print(msg.code)
7 end
8 --输出结果为：
9 --This is error.
10 --121
5. 错误消息与追溯：
通常在错误发生时，希望得到更多的调试信息，而不是只有发生错误的位置。至少等追溯到发生错误时和函数调用情况，显示一个完整的函数调用栈轨迹。要完成这一功能，我们需要使用Lua提供的另外一个内置函数xpcall。该函数除了接受一个需要被调用的函数之外，还接受第二个参数，即错误处理函数。当发生错误时，Lua会在调用栈展开前调用错误处理函数。这样，我们就可以在这个函数中使用debug库的debug.traceback函数，它会根据调用栈来构建一个扩展的错误消息。如：
1 function errorFunc()
2 local a = 20
3 print(a[10])
4 end
5
6 function errorHandle()
7 print(debug.traceback())
8 end
9
10 if xpcall(errorFunc,errorHandle) then
11 print("This is OK.")
12 else
13 print("This is error.")
14 end
15
16 --输出结果为：
17 --[[stack traceback:
18 d:/test.lua:7: in function <d:/test.lua:6>
19 d:/test.lua:3: in function <d:/test.lua:1>
20 [C]: in function 'xpcall'
21 d:/test.lua:10: in main chunk
22 [C]: ?
23 This is error.
24 --]]
一、函数：
在Lua中函数的调用方式和C语言基本相同，如：print("Hello World")和a = add(x, y)。唯一的差别是，如果函数只有一个参数，并且该参数的类型为字符串常量或table的构造器，那么圆括号可以省略，如print "Hello World"和f {x = 20, y = 20}。
Lua为面对对象式的调用也提供了一种特殊的语法--冒号操作符。表达式o.foo(o,x)的另一种写法是o:foo(x)。冒号操作符使调用o.foo时将o隐含的作为函数的第一个参数。
Lua中函数的声明方式如下：
function add(a)
local sum = 0
for i, v in ipairs(a) do
sum = sum + v
end
return sum
end
在以上声明中，包含了函数名(add)，参数列表(a)，以及函数体。需要说明的是，Lua中实参和形参的数量可以不一致，一旦出现这种情况，Lua的处理规则等同于多重赋值，即实参多于形参，多出的部分被忽略，如果相反，没有被初始化的形参的缺省值为nil。
1. 多重返回值：
Lua支持返回多个结果值。如： 1 s,e = string.find("Hello Lua users","Lua")
2 print("The begin index is " .. s .. ", the end index is " .. e .. ".");
3 -- The begin index is 7, the end index is 9. 以上的代码示例只是演示了如何获取Lua函数的多个返回值，下面的示例将给出如何声明返回多个值的Lua函数。如： 1 function maximum(a)
2 local mi = 1
3 local m = a[mi]
4 for i, val in ipairs(a) do
5 if val > m then
6 mi,m = i,val
7 end
8 end
9 return m,mi
10 end
11 print(maximum{8,10,23,12,5})
12 --23 3 Lua会调整一个函数的返回值数量以适应不同的调用情况。若将函数调用作为一条单独语句时，Lua会丢弃函数的所有返回值。若将函数作为表达式的一部分来调用时，Lua只保留函数的第一个返回值。只有当一个函数调用是一系列表达式中的最后一个元素时，才能获得所有返回值。这里先给出三个样例函数，如：
function foo0() end
function foo1() return "a" end
function foo2() return "a","b" end | 示例代码 | 结果 | 注释 | | x,y = foo2() | x = "a", y = "b" | 函数调用时最后的(或仅有的)一个表达式，Lua会保留其尽可能多的返回值，用于匹配赋值变量。 | | x = foo2() | x = "a", 返回值"b"被忽略 | | x,y,z = 10,foo2() | x = 10, y = "a", z = "b" | | x,y = foo0() | x = nil, y = nil | 如果一个函数没有返回值或者没有足够多的返回值，那么Lua会用nil来填补。 | | x,y = foo1() | x = "a", y = nil | | x,y,z = foo2() | x = "a", y = "b", z = nil | | x,y = foo2(),20 | x = "a", y = 20 | 如果一个函数调用不是一系列表达式的最后一个元素，那么将只产生一个值。 | | x,y = foo0(),20,30 | x = nil, y = 20, 30被忽略。 | | print(foo0()) | | 当一个函数调用左右另一个函数调用的最后一个实参时，第一个函数的所有返回值都将作为实参传入第二个函数。 | | print(foo1()) | a | | print(foo2()) | a b | | print(foo2(),1) | a 1 | | t = {foo0()} | t = {} --空table | table构造器可以完整的接收一个函数调用的所有结果，即不会有任何数量方面的调整。 | | t = {foo1()} | t = {"a"} | | t = {foo2()} | t = {"a", "b"} | | t = { foo0(), foo2(), 4} | t[1] = nil, t[2] = "a", t[3] = 4 | 如果函数调用不是作为最后一个元素，那么只返回函数的第一个结果值。 | | print((foo2())) | a | 如果函数调用放入圆括号中，那么Lua将只返回该函数的第一个结果值。 |
最后一个需要介绍的是Lua中unpack函数，该函数将接收数组作为参数，并从下标1开始返回该数组的所有元素。如：
/> lua
> print(unpack{10,20,30})
10 20 30
> a,b = unpack{10,20,30}
> print(a,b)
10 20
> string.find(unpack{"hello","ll"}) --等同于string.find("hello","ll")
在Lua中unpack函数是用C语言实现的。为了便于理解，下面给出在Lua中通过递归实现一样的效果，如： 1 function unpack(t,i)
2 i = i or 1
3 if t[i] then
4 return t[i], unpack(t,i + 1)
5 end
6 end
2. 变长参数：
Lua中的函数可以接受不同数量的实参，其声明和使用方式如下：
1 function add(...)
2 local s = 0
3 for i, v in ipairs{...} do
4 s = s + v
5 end
6 return s
7 end
8 print(add(3,4,5,6,7))
9 --输出结果为：25 解释一下，函数声明中的(...)表示该函数可以接受不同数量的参数。当这个函数被调用时，所有的参数都被汇聚在一起，函数中访问它时，仍需用3个点(...)。但不同的是，此时这3个点将作为表达式来使用，如{...}表示一个由所有变参构成的数组。在含有变长参数的函数中个，同样可以带有固定参数，但是固定参数一定要在变长参数之前声明，如：
function test(arg1,arg2,...)
...
end
关于Lua的变长参数最后需要说明的是，由于变长参数中可能包含nil值，因此再使用类似获取table元素数量(#)的方式获取变参的数量就会出现问题。如果要想始终获得正确的参数数量，可以使用Lua提供的select函数，如： 1 for i = 1, select('#',...) do --这里'#'值表示让select返回变参的数量(其中包括nil)。
2 local arg = select(i, ...) --这里的i表示获取第i个变参，1为第一个。
3 --do something
4 end
3. 具名实参：
在函数调用时，Lua的传参规则和C语言相同，并不真正支持具名实参。但是我们可以通过table来模拟，比如：
function rename(old,new)
...
end
这里我们可以让上面的rename函数只接收一个参数，即table类型的参数，与此同时，该table对象将含有old和new两个key。如：
function rename(arg)
local old = arg.old
local new = arg.new
...
end
这种修改方式有些类似于JavaBean，即将多个参数合并为一个JavaBean。然而在使用时，Lua的table存在一个天然的优势，即如果函数只有一个参数且为string或table类型，在调用该函数时，可以不用加圆括号，如：
rename {old = "oldfile.txt", new = "newfile.txt"}
二、深入函数：
在Lua中函数和所有其它值一样都是匿名的，即它们都没有名称。在使用时都是操作持有该函数的变量，如：
a = { p = print }
a.p("Hello World")
b = print
b("Hello World")
在声明Lua函数时，可以直接给出所谓的函数名，如：
function foo(x) return 2 * x end
我们同样可以使用下面这种更为简化的方式声明Lua中的函数，如：
foo = function(x) return 2 * x end
因此，我们可以将函数理解为由语句构成的类型值，同时将这个值赋值给一个变量。由此我们可以将表达式"function(x) <body> end"视为一种函数的构造式，就想table的{}一样。我们将这种函数构造式的结果称为一个"匿名函数"。下面的示例显示了匿名函数的方便性，它的使用方式有些类似于Java中的匿名类，如：
table.sort(test_table,function(a,b) return (a.name > b.name) end)
1. closure(闭合函数)：
若将一个函数写在另一个函数之内，那么这个位于内部的函数便可以访问外部函数中的局部变量，见如下示例：
1 function newCounter()
2 local i = 0
3 return function() --匿名函数
4 i = i + 1
5 return i
6 end
7 end
8 c1 = newCounter()
9 print("The return value of first call is " .. c1())
10 print("The return value of second call is " .. c1())
11 --输出结果为：
12 --The return value of first call is 1
13 --The return value of second call is 2 在上面的示例中，我们将newCounter()函数称为闭包函数。其函数体内的局部变量i被称为"非局部变量"，和普通局部变量不同的是该变量被newCounter函数体内的匿名函数访问并操作。再有就是在函数newCounter返回后，其值仍然被保留并可用于下一次计算。再看一下下面的调用方式。 1 function newCounter()
2 local i = 0
3 return function() --匿名函数
4 i = i + 1
5 return i
6 end
7 end
8 c1 = newCounter()
9 c2 = newCounter()
10 print("The return value of first call with c1 is " .. c1())
11 print("The return value of first call with c2 is " .. c2())
12 print("The return value of second call with c1 is " .. c1())
13 --输出结果为：
14 --The return value of first call with c1 is 1
15 --The return value of first call with c2 is 1
16 --The return value of second call with c1 is 2 由此可以推出，Lua每次在给新的闭包变量赋值时，都会让不同的闭包变量拥有独立的"非局部变量"。下面的示例将给出基于闭包的更为通用性的用法： 1 do
2 --这里将原有的文件打开函数赋值给"私有变量"oldOpen，该变量在块外无法访问。
3 local oldOpen = io.open
4 --新增一个匿名函数，用于判断本次文件打开操作的合法性。
5 local access_OK = function(filename,mode) <检查访问权限> end
6 --将原有的io.open函数变量指向新的函数，同时在新函数中调用老函数以完成真正的打开操作。
7 io.open = function(filename,mode)
8 if access_OK(filename,mode) then
9 return oldOpen(filename,mode)
10 else
11 return nil,"Access denied"
12 end
13 end
14 end 上面的这个例子有些类似于设计模式中装饰者模式。
2. 非全局函数：
从上一小节中可以看出，Lua中的函数不仅可以直接赋值给全局变量，同时也可以赋值给其他类型的变量，如局部变量和table中的字段等。事实上，Lua库中大多数table都带有函数，如io.read、math.sin等。这种写法有些类似于C++中的结构体。如：
Lib = {}
Lib.add = function(x,y) return x + y end
Lib.sub = function(x,y) return x - y end
或者是在table的构造式中直接初始化，如：
Lib = { add = function(x,y) return x + y end,
sub = function(x,y) return x - y end
}
除此之外，Lua还提供另外一种语法来定义此类函数，如：
Lib = {}
function Lib.add(x,y) return x + y end
function Lib.sub(x,y) return x - y end
对于Lua中的局部函数，其语义在理解上也是非常简单的。由于Lua中都是以程序块作为执行单元，因此程序块内的局部函数在程序块外是无法访问的，如： 1 do
2 local f = function(x,y) return x + y end
3 --do something with f.
4 f(4,5)
5 end 对于这种局部函数，Lua还提供另外一种更为简洁的定义方式，如：
local function f(x,y) return x + y end
该写法等价于：
local f
f = function(x,y) return x + y end
3. 正确的尾调用：
在Lua中支持这样一种函数调用的优化，即“尾调用消除”。我们可以将这种函数调用方式视为goto语句，如：
function f(x) return g(x) end
由于g(x)函数是f(x)函数的最后一条语句，在函数g返回之后，f()函数将没有任何指令需要被执行，因此在函数g()返回时，可以直接返回到f()函数的调用点。由此可见，Lua解释器一旦发现g()函数是f()函数的尾调用，那么在调用g()时将不会产生因函数调用而引起的栈开销。这里需要强调的是，尾调用函数一定是其调用函数的最后一条语句，否则Lua不会进行优化。然而事实上，我们在很多看似是尾调用的场景中，实际上并不是真正的尾调用，如：
function f(x) g(x) end --没有return语句的明确提示
function f(x) return g(x) + 1 --在g()函数返回之后仍需执行一次加一的指令。
function f(x) return x or g(x) --如果g()函数返回多个值，该操作会强制要求g()函数只返回一个值。
function f(x) return (g(x)) --原因同上。
在Lua中，只有"return <func>(<args>)"形式才是标准的尾调用，至于参数中(args)是否包含表达式，由于表达式的执行是在函数调用之前完成的，因此不会影响该函数成为尾调用函数。
|