函数有两种用途：
- 完成指定任务，此时函数作为调用语句使用。
- 计算并返回值，此时函数作为赋值语句的表达式使用。
function fn(arguments-list)
statements-list
end
调用函数时，如果参数列表为空，必须使用()表明是函数调用。
print(os.date())
当函数只有一个参数且参数是字符串或表构造式时,()是可选的。
print "hello world"
dofile "main.lua"
print [[a multi-line message]]
fn{x=10, y=20}
type{}
在Lua中函数都是function类型的对象
- 可被比较
- 可赋值给一个变量
- 可传递给函数
- 可从函数中返回
- 可作为table表中的键
函数定义
Lua使用关键字function定义函数
function fn(arg）
-- function body...
end
函数定义的语法会定义一个全局函数，名为fn，全局函数本质上是函数类型的值赋给全局变量。
函数变量式
fn = function(arg)
-- function body...
end
由于函数定义本质上是变量赋值，变量的定义总是应放置在变量使用之前，所以函数的定义也需要放置在函数调用之前。
local function fn(arg)
-- function body...
end
local fn = function(arg)
-- function body...
end
如果参数列表为空，必须使用()表明函数调用。
定义函数并调用
-- 定义函数
function fn()
print("hello function")
end
-- 调用函数
fn()
在定义函数时要注意
- 利用名字来解释函数，变量的目的使人通过名字就能看出函数、变量的作用。
- 每个函数的长度要尽量控制在一个屏幕内，一样就能看明白。
- 让代码自己说话，最好是不需要注释。
由于函数定义等价于变量赋值，因此也可以将函数名替换为Lua表中的某个字段。
-- 这种形式的函数定义不能使用local修饰符，因为不存在定义新的局部变量了。
foo.bar = function()
-- function body...
end
function foo.bar()
-- function body ...
end
案例：接收两个参数，计算加减乘除的结果，并输出到屏幕。
function fn(i,j)
return i+j, i-j, i*j, i/j, i%j;
end
a,b,c,d,e = fn(10,5)
print(a,b,c,d,e) -- 15 5 50 2.0 0
函数参数
按值传递
Lua函数的参数大部分是按值传递的，值传递就是调用函数时，实参把它的值通过赋值运算传递给形参，然后形参的改变和实参就没有关系了。在这个过程中，实参是通过它在参数表中的位置与形参匹配起来的。
local function swap(x,y)
local tmp = x
x = y
y = tmp
print(x,y)
end
在调用函数时，若形参个数和实参个数不同时，Lua会自动调整实参个数。调整规则：
若实参个数大于形参个数，从左向右，多余的实参被忽略。若实参个数小于形参个数，从左向右，没有实参初始化的形参会被初始化为nil。
变长参数
https://moonbingbing.gitbooks.io/openresty-best-practices/content/lua/function_parameter.html
若定义一个函数，参数个数不固定，应该怎么办呢？这就涉及到Lua中函数的可变参数。
-- Lua中三个点表示函数的参数个数不确定，可以改变，即可变参数。
function fn(...)
end
return关键字只能出现在语句块的结尾，也就是说，在end之前，或者是else之前，或者是until之前。
function fn(x)
return x*x*x;
end
n = fn(5)
print(n) -- 125
function fn(x)
if x<10 then
return x*x*x
else
return x*x
end
end
n = fn(5)
print(n)-- 125
函数基础
Lua中函数是一种对语句和表达式进行抽象的主要机制。
Lua中函数即可完成某项特定的任务，一条函数调用可视为一条语句。
$ lua
> a = match.sin(3) + math.cos(10)
> print(a)
-0.69795152101659
> print(os.date())
02/04/18 17:42:52
Lua函数也可以只做一些计算并返回结果，可视为一句表达式。
$ lua
> print(8*9, 9/8)
72 1.125
无论哪种用法都需将参数放入一对圆括号中。即使调用函数时没有参数，也必须写出一对空括号。对此规则只有一种特殊的例外情况：一个函数若只有一个参数，并且此参数是一个字面量字符串或table构造式，那么圆括号便是可有可无的。
$ lua
> print "hello world"
> dofile "test.lua"
> print [[a multi-line message]]
函数只有一个参数，且参数是一个table构造式，则圆括号可有可无。
> f{x=10, y=20}
> f({x=10, y=20})
> type{}
> type({})
Lua为面向对象式的调用也提供了一种特殊的语法 - 冒号操作符。
> obj.foo(obj, arg)
-- 冒号操作符使调用obj.foo时将obj隐含地作为函数的第一个函数
> obj:foo(arg)
Lua程序即可使用以Lua编写的函数，也可调用以C语言编写的函数。
function add(params)
local sum=0;
for k,v in ipairs(params) do
sum=sum+v
end
return sum
end
print(add({1,2,3}))
在这种语法中，一个函数定义具有一个名词（函数名）、一些列参数（参数表）、一个函数体（一系列语句）。
形式参数（parameter）的使用方式与局部变量非常类似，它们是由调用函数时的实际参数（argument）初始化的。
调用函数时提供的实参数量可与形参数量不同，Lua会自动调整实参数量，以匹配参数表的要求。这项调整与多重赋值（multiple assignment）很相似，即“若实参多于形参，则舍弃多于实参；若实参不足，则多余形参初始化为nil”。
function fn(a,b)
print(a,b);
end
fn(1) -- 1 nil
fn(1,2) -- 1 2
fn(1,2,3) -- 1 2
虽然这种调整行为会导致一些编程错误，但它也是很有用的，尤其是对于默认实参的应用。
function incCount(n)
n = n or 1 -- 函数以1作为默认实参
count = count + n
print(n, count)
end
fn() -- attempt to perform arithmetic on a nil value (global 'count')
多重返回值
Lua函数具有一项非常与众不同的特征，允许函数返回多个结果。
Lua的几个预定义函数就是返回多个值的，string.find()用于在字符串中定位一个模式（pattern），该函数允许在字符串中找到指定的模式，将返回匹配的起始字符和结尾字符的索引。
startstr,endstr = string.find("hello lua", "lua")
print(startstr, endstr) -- 7 9
以Lua编写的函数同样可以返回多个结果，只需在return关键字后列出所有的返回值即可。
例如：查找数组中最大元素并返回该元素的位置
function max(tbl)
local index = 1
local value = tbl[index]
for i,v in ipairs(tbl) do
if(v > value) then
index = i
value = v
end
end
return index,value
end
print(max{9,2,12,8,3,9})-- 3 12
Lua会调整函数返回值数量以适应不同的调用情况
- 若将函数调用作为一条单独语句时，Lua会丢弃函数的所有返回值。
- 所将函数作为表达式的一部分来调用时，Lua只保留函数的第一个返回值。只有当一个函数调用是“一系列表达式”中最后一个元素或仅有一个元素时，才能获得它的所有返回值。
-- test
local tbl = {9,2,12,8,3,9}
local a = max(tbl)
print(a) -- 3
local a,b = max(tbl)
print(a, b) -- 3 12
local a,b,c = max(tbl)
print(a,b,c)-- 3 12 nil
local a,b,c = 1, max(tbl)
print(a,b,c)-- 1 3 12
local a,b,c,d = 1,max(tbl),0
print(a,b,c,d) -- 1 3 0 nil
这里所谓的“一系列表达式”，在Lua中表现为4种情况
- 多重赋值
- 函数调用时传入的实参列表
-
table的构造式 -
return语句
在多重赋值中，若函数调用是最后的或仅有的一个表达式，那么Lua会保留其尽可能多的返回值，用于匹配赋值变量。若函数没有返回值或没有足够多的返回值，那么Lua会用nil来补充缺失的值。若函数调用不是一些列表达式的最后一个元素，那么将只产生一个值。
当函数调用作为另一个函数调用的最后一个或仅有的实参时，第一个函数所有返回值都将作为实参传入第二个函数。
function fn1()
end
function fn2()
return 1
end
function fn3()
return 1,2
end
print(fn1())
print(fn2()) -- 1
print(fn3()) -- 1 2
print(fn2(),2) -- 1 2
print(fn2()..'x') -- 1x
table构造式可以完整地接收一个函数调用的所有结果，即不会有任何数量方面的调整。
function fn1()
end
function fn2()
return 1
end
function fn3()
return 1,2
end
tbl1 = {fn1()} -- 相当于 tbl1={}
tbl2 = {fn2()} -- 相当于 tbl2={1}
tbl3 = {fn3()} -- 相当于 tbl3={1,2}
不过这种行为只有当一个函数调用作为最后一个元素时才会发生，而在其他位置上的函数调用总是只缠身给一个结果值。
function fn1()
end
function fn2()
return 1
end
function fn3()
return 1,2
end
tbl = {fn1(), fn2(), fn3(), 4}
print(tbl[1], tbl[2], tbl[3], tbl[4]) -- nil 1 1 4
最后一种情况是return语句，诸如return fn()这样的语句将返回fn的所有返回值。
function fn1()
end
function fn2()
return 1
end
function fn3()
return 1,2
end
function fn(i)
if i==1 then return fn1()
elseif i==2 then return fn2()
elseif i==3 then return fn3()
end
end
print(fn(1), fn(2), fn(3)) -- nil 1 1 2
-- 将函数调用放入一对圆括号中，从而迫使它只返回一个结果。
print((fn(1)), (fn(2)), (fn(3))) -- nil 1 2
注意return语句后面的内容不需要圆括号，在该位置上书写圆括号会导致不同的行为。
return (fn(3)) -- 只返回一个值，而无关于fn()返回几个值
关于多重返回值还要介绍一个特殊函数 unpack，unpack接收一个数组作为参数，并从下标1开始返回该数组的所有元素。
-- lua5.2+中全局unpack函数已被移除，并被table.unpack替代。
local unpack = unpack or table.unpack
x,y,z = unpack{1,2,3}
print(x,y,z) -- 1 2 3
unpack的一项重要用户体现在“泛型调用（generic call）”机制中，泛型调用机制可动态地以任何实参来调用任何函数。
-- lua5.2+中全局unpack函数已被移除，并被table.unpack替代。
local unpack = unpack or table.unpack
fn = string.find
tbl = {'hello lua', 'lua'}
print(fn(unpack(tbl))) -- 7 9
变长参数
Lua函数可接受可变数量的参数，和C语言类似。在函数参数列表中使用...表示函数有可变的参数。
Lua将函数的参数放在一个叫做arg的表中，除了参数外，arg表中还有一个域n表示参数的个数。
function dump(...)
local str = ""
for i,v in ipairs(arg) do
str = str .. tostring(v).."\t"
end
return str.."\n"
end
例如：只想要string.find返回的第二个值，典型的方法是使用虚变量_。
local _, x = string.find(str, pattern)
Lua中的函数还可以接受不同数量的实参
例如：返回所有参数的总和
function sum(...)
local sum=0
for i,v in ipairs{...} do
sum = sum + v
end
return sum
end
print(sum(1,2,3,4)) -- 10
参数中3个点...表示函数可接收不同数量的实参，当函数被调用时，它的所有参数都会被收集到一起。这部分收集起来的实参称为函数的“变长参数（variable arguments）”。函数要访问它的变长参数时，仍需要3个点。但不同的是，此时这个3个点是作为一个表达式来使用的。
function fn(...)
local x,y,z = ...
print(x,y,z)
end
fn(1,2) -- 1 2 nil
fn(1,2,3) -- 1 2 3
表达式...的行为类似于一个具有多重返回值的函数，它返回的是当前函数的所有变量参数。
function fwrite(fmt, ...)
return io.write(string.format(fmt, ...))
end
fwrite("%s %s %s", 1, 2, 3) -- 1 2 3
Lua中迭代函数参数时，可使用...参数收集到一个table中，但变参中函数非法的nil时，可使用select函数将其过滤掉。
function filter(...)
for i=1, select("#", ...) do
local arg = select(i, ...)
if arg ~= nil then
print(arg)
end
end
end
-- test
test(1,nil,2,3)-- 1 2 3
具名实参
Lua的函数参数是和位置相关的，调用时会按顺序依次传递给形式参数。有时候，使用名字制定参数是很有用的（命名参数）。
Lua中的参数传递机制和是具有“位置性”的，也就是说在调用函数时，实参时通过它在参数表中的位置与形参匹配起来。
function rename(tbl)
print(tbl, tbl.oriname, tbl.newname)
end
rename{oriname="ori.lua", newname="new.lua"}
Lua中特殊的函数调用语法，当实参只有一个table构造式时，函数调用中的圆括号是可有可无的。
function rename(arg)
return os.rename(arg.old, arg.new)
end
第一类值
Lua中的函数是带有词法定界（lexical scoping）的第一类值（first-class values）。
"第一类值"是指在Lua中函数和其他值（数值、字符串...）一样，函数可以被存储在变量中，可以存放在表中，可以作为函数的参数，也可以作为函数的返回值。
“词法界定”是指被嵌套的函数可以访问其他外部函数中的变量，这一特性给Lua提供了强大的编程能力。
Lua中关于函数难以理解的是“函数是可以没有名字的，也就是匿名的。”，但提到函数名时，实际上是说以一个指向函数的变量，和其他类型值得变量是一样的。
Lua中函数作为“第一类值”，表示函数可以存储在变量中，可通过参数传递给其他函数，还可作为其他函数的返回值。由于函数在Lua中是一种“第一类值”，所以不仅可将其存储在全局变量中，还可存储在局部变量甚至table的字段中。
Lua中函数是一种“第一类值（First-Class Value）”，它们具有特定的词法域（Lexical Scoping）。
“第一类值”是什么意思呢？这表示在Lua中函数与其他传统类型的值具有相同的权利。函数可存储到变量中或table中，可作为实参传递给其他函数，还可作为其他函数的返回值。
“词法域”是什么意思呢？这是指一个函数可以嵌套在另一个函数中，内部的函数可访问外部函数的变量。这项听起来平凡的特性将给语言带来极大的能力，因为它允许在Lua中应用各种函数式语言（functional-language）中强大的编程技术。
a = {p = print}
a.p('hello') -- hello
print = math.sin
a.p(print(1)) -- 0.8414709848079
sin = a.p
sin(10,20) -- 10 20
Lua对函数式编程（functional programming）提供了良好的支持
在Lua中有一个很容易混淆概念是，函数与所有其他值一样都是匿名的，即它们都没有名称。当讨论一个函数名时，实际上是在讨论一个持有某函数的变量。这与其他变量持有各种值的一个道理，可以以多种方式来操作这些变量。
如果说函数是值的话，那是否可以说函数就是由一些表达式创建的呢？是的，事实上在Lua中最常见的是函数编写方式。
function fn(x)
return 2*x
end
-- 简化书写“语法糖”
fn = function(x) return 2*x end
一个函数定义实际就是一条语句，更准确地说是一条赋值语句，这条语句创建了一种类型为“函数”的值。
可将表达式function(x) <body> end视为一种函数的构造式，类似table的构造式{}一样。将这种函数构造式的结果称为一个“匿名函数”，虽然一般情况下，会将函数赋予全局变量，即给予其一个名称。但在某些特殊情况下，仍会需要用到匿名函数。
Lua即可以调用以自身Lua语言编写的函数，又可以调用以C语言编写的函数。
table库提供了一个函数table.sort，它接收一个table并对其中的元素排序。向这种函数就必须支持各种各样可能的排序规则。sort函数并没有提供所有排序准则，而是提供了一个可选的参数，所谓“次序函数（order function）”。这个函数接收两个元素，并返回在有序情况下第一个元素是否已排在第二个元素之前。
local tbl = {
{name="ip1", ip="210.26,30,34"},
{name="ip2", ip="210.26,30,33"},
{name="ip3", ip="210.26,30,12"},
}
table.sort(tbl, function(x,y)
return x.name > y.name
end)
for k,v in pairs(tbl) do
print(v.name) --ip3 ip2 ip1
end
像sort这样的函数，接收另一个函数作为实参，称其为“高阶函数（higher-order function）”。高阶函数是一种强大的编程机制，应用匿名函数来创建高阶函数所需的实参则可以带来更大的灵活性。但请记住，高阶函数并没有什么特权。Lua强调将函数视为“第一类值”，所以高阶函数只是一种基于该观点的应用体现而已。
例如：关于导数的高阶函数
function derivative(fn, delta)
delta = delta or 1e-4
return function(x)
return (fn(x+delta)-fn(x))/delta
end
end
fn = derivative(math.sin)
print(math.cos(10), fn(10)) // -0.83907152907645 -0.83904432662041
闭包函数
当一个函数内部嵌套另一个函数定义时，内部的函数体可以访问外部函数的局部变量，这种特征称之为“词法界定”。词法界定加上第一类函数在编程语言中是一个功能强大的工具。
若将函数写在另一个函数何内，那么这个位于内部的函数便可访问外部函数中的局部变量，这项特征称之为“词法域”。
例如：根据每个学生的年级来对它们姓名进行由高到低的排序
local userlist = {
{username="mary", score=81},
{username="shiva", score=92},
{username="seth", score=65}
}
table.sort(userlist, function(x, y)
return x.score > y.score
end)
for k,v in pairs(userlist) do
print(k, v.username, v.score)
end
--[[
1 shiva 92
2 mary 81
3 seth 65
--]]
创建函数完成操作
function sort_by_grade(names, grades)
table.sort(names,
function(a,b)
return grades[a] > grades[b]
end
);
end
names = {"alice", "peter", "paul", "mary"}
grades = {alice=10, peter=5, paul=9, mary=2}
sort_by_grade(names,grades)
for key,val in pairs(names) do
print(key, val, grades[val])
end
有趣的是，传递给sort匿名函数可以访问参数grades，而grades是外部函数sort_by_grade的局部变量。在这个匿名函数内部，grades即不是全局变量也不是局部变量，将其称为一个非局部的变量（non-local variable）或upvalues或“外部的局部变量（external local variable）”。为什么在Lua中允许这种访问呢？原因在于函数是“第一类值”。
function count()
local i = 0
return function()
i = i + 1
return i
end
end
cnt = count()
print(cnt()) -- 1
print(cnt()) -- 2
print(cnt()) -- 3
匿名函数访问了一个“非局部的变量i，i变量用于保持一个计数器。Lua会以closure的概念来正确地处理这种情况。简单来说，一个closure就是一个函数加上该函数所需访问的所有“非局部的变量”。如果再次调用count()，那么它会创建一个新的局部变量i，从而也将得到一个新的closure。
技术上来讲，闭包指的是值而不是函数，函数仅仅是闭包的原型声明，尽管如此，在不会导致混淆的情况下，使用术语函数代指闭包。
从技术上讲，Lua中只有closure，而不存在函数。因此，函数本身就是一种特殊的closure。不过只要不会引起混淆，仍将采用术语函数来指代closure。
在许多场合中closure都是一种很有价值的工具，例如：可作为sort类高阶函数的参数。closure对于创建其他函数也很有价值。这种机制使Lua可混合在函数式编程世界中久经考验的编程技术。另外closure对于回调函数也很有用。
例如，假设有一个传统的GUI工具包可以创建按钮，每个按钮都有一个回调函数，每当用户按下按钮是GUI工具包都会调用这些回调函数。再假设，基于此要做一个十进制计算器，其中需要10个数字按钮，你会发现这些按钮之间的区别其实并不大，仅需在按下不同按钮时稍微不同的操作就可以了。
-- 创建按钮
function digitButton(digit)
return Button{label=tostring(digit), action=function() add_to_display(digit) end}
end
假设Button是工具包中一个用于创建新按钮的函数，label是按钮的标签，action是回调closure，每当按钮按下时就会调用它。回调一般发生在digitButton函数执行完后，那时局部变量digit已经超出了作用范围，但closure仍可以访问到这个变量。
closure在另一种情况中也非常有用，例如在Lua中函数是存储在普通变量中的，因此可以轻易地重新定义某些函数，甚至是重新定义那些预定义的函数。这也是Lua相当灵活的原因之一。
通常当重新定义一个函数时，需要在新的实现中调用原来的那个函数。举例来说，假设要重新定义函数sin，使其参数能使用角度来替代原先的弧度。那么这个新函数就必须得转换它的实参，并调用原来的sin函数完成真正的计算。
oldSin = math.oldSin
math.sin = function(x)
return oldSin(x*math.pi/180)
end
还有一种更彻底的做法
do
local oldSin = math.sin
local k = math.pi/180
math.sin = function(x)
return oldSin(x*k)
end
end
将老版本的sin保存到一个私有变量，现在只有通过新版本的sin才能访问到它。
可以使用同样的技术来创建一个安全的运行环境，即所谓的沙盒（sandbox）。当执行一些未受信任的代码时就需要一个安全的运行环境，例如在服务器中执行那些从Internet上接收到的代码。
举例来说，如果要限制一个程序访问文件的话，只需要使用closure来重新定义函数io.open()即可。
do
local oldOpen = io.open
local accessOK = function(filename,mode)
-- 检查访问权限
end
io.open =function(filename, mode)
if accessOK(filename, mode) then
return oldOpen(filename,mode)
else
return nil,"access denied"
end
end
end
经过重新定义后，一个函数就只能通过受限版本来调用原来那个未受限的open()函数了。将原来不安全的版本保存到closure的一个私有变量中，从而使得外部再也无法直接访问到原来的版本了。
通过这种技术，可以再Lua的语言层面上就构建出一个安全的运行环境，且不失建议性和灵活性。相对于提供一套大而全的解决方案，Lua提供的则是一套“元机制（meta-mechanism）”，因此可以根据特定的安全需要来创建一个安全的运行环境。
非全局的函数
由于函数是一种“第一类值”，因此一个显而易见的推论是，函数不仅可以存储在全局变量中，也可以存储在table的字段中和局部变量中。
Lua中大部分库采用将函数存储在table字段中这种机制。若要在Lua中创建这种函数，只需将常规的函数语法和table语法结合即可。
Lib = {}
Lib.foo = function(x,y)
return x+y
end
Lib.bar = function(x,y)
return x-y
end
当然，也可使用构造式：
Lib = {
foo=function(x,y) return x+y end,
bar=function(x,y) return x-y end
}
只要将一个函数存储到一个局部变量中，即得到一个局部函数（local function），也就是说该函数只能在某个特定的作用域中使用。
对于程序包（package）而言，这种函数定义是非常有用的，因为Lua是将每个特定程序块（chunk）作为一个函数来处理的，所以在一个程序块中声明的函数就是局部函数，这些局部函数只在该程序块中可见。词法域确保了程序包中的其他函数可以使用这些局部函数。
local fn = function(arg)
-- function body
end
local func = function(arg)
fn()
end
对于局部函数的定义，Lua支持一种特殊的语法糖：
local function fn(arg)
-- function body
end
在定义递归的局部函数中，有一个特别之处需要注意。
local face = function(n)
if n==0 then
return 1
else
-- 错误的递归调用
-- 当Lua编译到函数体中调用fact(n-1)的地方时，由于局部的fact尚未定义完毕。
-- 因此这句表达式其实调用了一个全局的fact，而非此函数本身。
return n*face(n-1)
end
end
--[[结局方案：可以先定义一个局部变量，然后再定义函数本身。--]]
local fact
fact = function(n)
if n==0 then return 1
else return n*fact(n-1)
end
end
--[[
现在函数中的fact调用就表示了局部变量，即使在函数定义时，这个局部变量的值尚未完成定义，但之后在函数执行时，fact则肯定拥有了正确的值。
--]]
当Lua展开局部函数定义的“语法糖”时，并不是使用基础函数定义语法。而是对于局部函数定义：
local function fn(<args>) <function body> end
Lua将其展开为
local fn
fn = function(<args>) <function body> end
因此，使用此种语法定义递归函数不会产生错误：
local function fact(n)
if n==0 then return 1
else return n*fact(n-1)
end
end
当然，这个技巧对于间接递归的函数而言是无效的。对于间接递归的情况下，必须使用一个明确的向前声明（Forward Declaration）：
local fn,func -- 向前声明
function func()
fn()
end
function fn()
func()
end
--[[
注意，别把第二个函数定义为"local function fn"。
如果那样的话，Lua会创建一个全新的局部变量fn。
而将原来声明的fn（func函数中所引用的那个）置于未定义状态。
--]]
尾调用
Lua函数有一个有趣的特征，那就是Lua支持“尾调用消除（tail-call elimination）”。
所谓“尾调用（tail call）”就是一种类似于goto()的函数调用，当一个函数调用是另一个函数的最后一个动作时，该调用才算是一条“尾调用”。
function fn(x)
return func(x)
end
--[[
当fn()函数调用完func()函数之后就再无其他事情可做了
因此在这种情况下，程序就不需要返回那个“尾调用”所在的函数了。
所以在“尾调用”之后，程序也不需要保存任何关于该函数的栈（stack）信息。
当func()函数返回时，执行控制权可以直接返回给调用fn()函数的那个点上。
有些语言实现（例如Lua解释器）可以得益于这个特点，使得在进行尾调用时不耗费任何栈空间。
将这种实现称之为支持“尾调用消除”。
--]]
由于“尾调用”不会耗费栈空间，所以一个程序可以拥有无数嵌套的“尾调用”。
function fn(n)
if n>0 then
return fn(n-1)
end
end
--[[
在调用fn()函数时，传入任何数字n作为参数都不会造成栈溢出。
--]]
有一点需要注意的是，当想要受益于“尾调用消除”时，务必要确定当前的调用时一条“尾调用”。判断的准则是“一个函数在调用完另一个函数之后，是否就无其他事情需要做了”。有些看似“尾调用”的代码，其实都违背了这条准则。
function fn(x)
func(x)
end
--[[
当调用完func()函数后，fn()函数并不能立即返回，它还需丢弃func()函数返回的临时结果。
--]]
Lua中，只有return <func>(<args>)这样的调用形式才算是一条“尾调用”。
return fn(x)+1 -- 必须做一次加法
return x or fn(x) -- 必须调整为一个返回值
return (g(x)) -- 必须调整为一个返回值
Lua在调用前对<func>及其参数求值，所以它们可以是任意复杂的表达式。
return x[i].fn(x[j]+a*b, i+j)
一条“尾调用”就好比是一条goto语句。因此，在Lua中“尾调用”的一大应用就是编写“状态机（state machine）”。这种程序通常以一个函数来表示一个状态，改变状态就是goto（或调用）到另一个特定的函数和。
例如：一个简单的迷宫游戏中，一个迷宫有几间房间，每间房中最多有东南西北4扇门。用户在每一步异动中都需要输入一个移动的方向。如果在某个方向上有门，那么用户可以进入相应的房间。不然，程序就打印一条警告。游戏的目标就是让用户从最初的房间走到最终的房间。
这个游戏就是典型的状态机，其中当前房间就是一个状态。可以将迷宫的每间房实现为一个函数，并使用“尾调用”来实现从一间房移动到另一件。
function room1()
local move = io.read()
if move=='south' then
return room3()
elseif move=="east" then
return room2()
else
print("invalid move")
return room1()
end
end
function room2()
local move = io.read()
if move=='south' then
return room4()
elseif move=='west' then
return room1()
else
print('invalid move')
return room2()
end
end
function room3()
local move=io.read()
if move=='north' then
return room1()
elseif move=='ease' then
return room4()
else
print("invalid move")
return room3()
end
end
function room4()
print("congratulations")
end
-- 调用初始房间来开始游戏
room1()
--[[
若没有“尾调用消除”，每次用户的异动都会创建一个新的栈层（stack level）
异动若干步后就有可能会导致栈溢出
“尾调用消除”则对用户异动的次数没有任何限制
因为每次异动实际上都只是完成一条goto语句到另一个函数，而非传统的函数调用。
--]]
对于简单的游戏而言，或许觉得将程序设计为数据驱动的会更好一些，其中将房间和异动记录在table中。不过，如果游戏中每间房间都有各自特殊的情况的话，采用这种状态机的设计则更为合适。
Lua迭代器与闭包
迭代器是一种可以遍历(iterate over)集合中所有元素的机制。在Lua中通常将迭代器表示为函数，每次调用函数即返回集合中的“下一个”元素。
每个迭代器都需要在每次成功调用之间保持一些状态，这样才能知道它所在的位置及如何步进到下一个位置。闭包(closure)对于这类任务提供极佳的支持，一个闭包就是一种可以访问其外部嵌套环境中的局部变量的函数。
对于闭包而言，这些变量就可用于在成功调用之间保持状态值，从而使闭包可以记住它在一次遍历中所在的位置。
当然，为了创建一个新的闭包，还必须创建它的“非局部变量(non-local variable)”。因此，一个闭包结构通常涉及到两个函数：闭包本身和一个用于创建该闭包的工厂函数。
-- 为列表编写简单的迭代器，与ipaires不同的是该迭代器并不是返回每个元素的索引，而是返回元素的值。
-- values是一个工厂，每当调用这个工厂时，就创建一个新的闭包(迭代器本身)。这个闭包将它的状态保存在其外部变量tbl和i中。
function values(tbl)
local i=0
return function()
i = i+1
return tbl[i]
end
end
-- 每当调用这个迭代器时，它就从列表tbl中返回下一个值。
-- 直到最后一个元素返回后，迭代器就会返回nil，以此表示迭代器的结束。
tbl={1,2,3,4}
iter = values(tbl) -- 创建迭代器
while true do
local el = iter() -- 调用迭代器
if el==nil then
break
end
print(el)
end
然而，使用泛型for则更为简单，你会发现泛型for正是为这种迭代而设计的。
function values(tbl)
local i=0
return function()
i = i+1
return tbl[i]
end
end
-- 泛型for为一次迭代循环做了所有的薄记工作。
-- 它在内部保存了迭代器函数，因此不再需要iter变量。
-- 它在每次新迭代时调用迭代器，并在迭代器返回nil时结束循环。
tbl={1,2,3,4}
for el in values(tbl) do
print(el)
end
需求：遍历当前输入文件中所有单词的迭代器
为完成这样的遍历，需要保持两个值：当前行的内容、当前行所处的位置。有了这些信息就可以不断产生下一个单词。迭代器函数的主要部分使用 string.find在当前行中以当前位置作为起始来所搜索一个单词。使用模式%w+来描述一个单词，它用于匹配一个或多个的文字/数字字符。如果string.find找到了一个单词，迭代器就会将当前位置更新为该单词之后的第一个字符，并返回该单词。否认则，它就读取新的一行并反复这个搜索过程。若没有剩余的行，则返回nil表示迭代的结束。
function allwords()
local line = io.read()
local pos = 1
return function()
while line do
local s,e = string.find(line, "%w+", pos)
if s then
pos = e+1
return string.sub(line,s,e)
else
line = io.read()
pos = 1
end
end
return nil
end
end
for word in allwords() do
print(word)
end
