Lua基础 函数（二）

转自：http://blog.csdn.net/wzzfeitian/article/details/8701747

在Lua中，你可以像使用number和string一样使用function。可以将function存储到变量中，存储到table中，可以当作函数参数传递，可以作为函数的返回值。

在Lua中，function跟其他值一样，也是匿名的。function被作为一个值存储在变量中，下面这个例子有点2，可以帮助理解：

[plain]  view plain copy

1. a = {p = print}  
2. a.p("Hello World")  --> Hello World  
3. print = math.sin    -- 'print' now refers to the sin function  
4. a.p(print(1))       --> 0.841470  
5. sin = a.p           -- 'sin' now refers to the print function  
6. sin(10, 20)         --> 10 20  

创建函数的表达式

[plain]  view plain copy

1. function foo (x) return 2*x end  
2. --实际上为：  
3. foo = function (x) return 2*x end  

从上面可以看出，function的定义实际上是创建一个'function'类型的值，并赋值给一个变量。我们可以将function (x) body end 看成是function的构造函数，就像{}是table的构造函数一样。

table库有一个函数table.sort ，接受一个table，然后对table中的元素排序。排序可能有各种规则，升序，降序，数字或字母表顺序，根据table中的key排序等。该函数没有提供各种各样所有的排序选项，而是提供了一个单独的选项，即函数的第二个参数，order函数，order函数，接受两个元素，返回一个布尔值，来指示是否第一个元素排在第二个元素之前。看下面的例子：

[plain]  view plain copy

1. network = {  
2.            {name = "grauna", IP = "210.26.30.34"},  
3.            {name = "arraial", IP = "210.26.30.23"},  
4.            {name = "lua", IP = "210.26.23.12"},  
5.            {name = "derain", IP = "210.26.23.20"},  
6.           }  
7. table.sort(network, function (a,b) return (a.name > b.name) end)  

从上面看，匿名函数使用起来很方便吧。

这里先讲一个概念，higher-order function。它可以把其他函数当作参数。下面给个示例，求导函数（哎，好多年前的东西，一点都不记得了，还跟同事讨论了半天）

[plain]  view plain copy

1. function derivative (f, delta)  
2.     delta = delta or 1e-4  
3.     return function (x)  
4.                return (f(x + delta) - f(x))/delta  
5.            end  
6. end  
7.   
8. c = derivative(math.sin)  
9. print(math.cos(10), c(10))  
10. --> -0.83907152907645 -0.83904432662041  

文章开头也说了，Lua中的function可以像普通的值一样使用，可以存储到全局变量，局部变量，table中。往下看，function存储到table中，这是个牛B的特性，可以实现很多高级的功能，例如模块，面向对象等。

1. 闭合函数

先看一个示例，有两个table，一个table中是student names，另一个table里面有每个student的grade；现在要根据student的grade来对前一个table进行排序。根据之前所学，可以使用如下code：

[plain]  view plain copy

1. names = {"Peter", "Paul", "Mary"}  
2. grades = {Mary = 10, Paul = 7, Peter = 8}  
3. table.sort(names, function (n1, n2)  
4.     return grades[n1] > grades[n2] -- compare the grades  
5. end)  

现在写一个function来实现这一个功能：

[plain]  view plain copy

1. function sortbygrade (names, grades)  
2.     table.sort(names, function (n1, n2)  
3.         return grades[n1] > grades[n2] -- compare the grades  
4.     end)  
5. end  

上面这段code的有趣之处在于，sort中的匿名函数可以访问参数中的grades，grades是sortbygrade的局部变量。在该匿名函数中，grades既不是局部变量，也不是全局变量，而是非局部变量（智商有点捉鸡了）。

现在来看看这个非局部变量的妙用。看下面示例：

[plain]  view plain copy

1. function newCounter ()  
2.     local i = 0  
3.     return function () -- anonymous function  
4.           i = i + 1  
5.           return i  
6.     end  
7. end  
8.   
9. c1 = newCounter()  
10. print(c1()) --> 1  
11. print(c1()) --> 2  
12.   
13. c2 = newCounter()  
14. print(c2()) --> 1  
15. print(c1()) --> 3  
16. print(c2()) --> 2  

在上面的代码中，匿名函数引用了非局部变量i ，来记数。但是，调用这个匿名函数的时候，i已经不再在有效作用域了，因为创建i 的函数（newCounter ）已经返回了。但是Lua可以使用闭合函数正确处理这种情况。简单地说，闭合函数就是一个函数加上要访问一个非局部变量所需要的所有元素。如果再调用一个newCounter ，它会重新创建一个新的非局部变量i， 得到一个新的闭合函数。如上面示例，c1和c2是两个基于用一个函数的闭合函数，二者有两个独立的非局部变量i 的实例。

闭合函数在很多场合都很好用。例如，在higer-order函数（如sort ）中，可以作为参数；在newCounter这样的在自己函数体中创建其他的函数；作为回调函数。一个典型的例子就是，在传统的GUI工具箱中，创建按钮，每个按钮需要一个回调函数来响应按键动作。例如一个计算器，需要10个类似的按钮，每个数字一个。可以用下面的function来创建：

[plain]  view plain copy

1. function digitButton (digit)  
2.     return Button{ label = tostring(digit),  
3.                    action = function ()  
4.                                add_to_display(digit)  
5.                             end  
6.                  }  
7. end  

在上面的示例中，我们假设digitButton是一个工具箱函数，用来创建一个按钮，lable是按钮的label， action是回调函数，响应按键操作。这个回调函数可以在digitButton完成工作以后很久，局部变量digit超出作用域后再调用，但是它仍然能够访问变量digit。

由于函数是存储在普通的变量中，Lua可以方便的重新定义一些函数，甚至Lua预定义的函数。下面看一个示例，重新定义sin函数，将参数由原来的弧度，改成度数。新的函数一定要转换一下参数的值，然后调用原来的sin函数来实现功能。

[plain]  view plain copy

1. oldSin = math.sin  
2. math.sin = function (x)  
3. return oldSin(x*math.pi/180)  
4. end  
5.   
6. --建议用下面这种  
7. do  
8. local oldSin = math.sin  
9. local k = math.pi/180  
10. math.sin = function (x)  
11.                return oldSin(x*k)  
12.            end  
13. end  

推荐使用第二种实现，我们将原来的函数保存在一个局部变量中中，访问它的唯一途径就是通过新版本的函数。通过这种技巧，可以构建沙箱安全环境。这种安全环境在你需要运行一些不被信任的代码（例如从internet上收到的代码）时是很有必要的。例如，为了严格限制程序可以访问的文件，可以重新定义函数io.open：

[plain]  view plain copy

1. do  
2.     local oldOpen = io.open  
3.     local access_OK = function (filename, mode)  
4.                           --here to add some code to restrict access  
5.                           <check access>  
6.                       end  
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  

如下代码，重定义open函数后，程序没办法访问无限制版本的open函数，只能使用这个限制版本。通过这种方法，Lua可以简便灵活地构建安全的沙箱环境。

2.非全局函数

Lua中的函数可以存储到全局变量中，也可以存储到table和局部变量中。

大多数的Lua库都是将函数存入table中。下面示例集中定义table中函数的方法：

[plain]  view plain copy

1. Lib = {}  
2. Lib.foo = function (x,y) return x + y end  
3. Lib.goo = function (x,y) return x - y end  
4.   
5. --使用构造函数  
6. Lib = {  
7. foo = function (x,y) return x + y end,  
8. goo = function (x,y) return x - y end  
9. }  
10.   
11. --另一种语法  
12. Lib = {}  
13. function Lib.foo (x,y) return x + y end  
14. function Lib.goo (x,y) return x - y end  

当我们将函数存储到一个局部变量中，我们就得到一个局部函数，只在给定的作用域中有效。这个特性在包中经常用到，可以在一个包中定义局部函数，这些函数只在该包中可见，包中的其他函数可以调用这些局部函数：

[plain]  view plain copy

1. local f = function (<params>)  
2.               <body>  
3.           end  
4. local g = function (<params>)  
5.               <some code>  
6.               f() -- 'f' is visible here  
7.               <some code>  
8.            end  

在递归函数中有一点微妙，看下面两份代码。

[plain]  view plain copy

1. local fact = function (n)  
2.     if n == 0 then return 1  
3.     else return n*fact(n-1) -- buggy  
4.     end  
5. end  
6.   
7. --下面这个可以工作  
8. local fact  
9. fact = function (n)  
10.     if n == 0 then return 1  
11.     else return n*fact(n-1)  
12.     end  
13. end  

再看下面这个局部函数定义展开后的形式：

[plain]  view plain copy

1. local function foo (<params>) <body> end  
2.   
3. --expands to  
4.   
5. local foo  
6. foo = function (<params>) <body> end  

因此，上面的递归函数也可以写成，注意3中实现方式的不同。

[plain]  view plain copy

1. local function fact (n)  
2.     if n == 0 then return 1  
3.     else return n*fact(n-1)  
4.     end  
5. end  

但是，上面这个技巧在非直接递归函数中就不好使了啊。看下面的示例：

[plain]  view plain copy

1. local f, g -- 'forward' declarations  
2.   
3. function g ()  
4.     <some code>  
5.     f()   
6.     <some code>  
7. end  
8.   
9. --local f 如果这句放在这，那么上面的g()是引用不到正确的f函数的  
10. function f ()  
11.     <some code>   
12.     g()   
13.     <some code>  
14. end  
15.   
16. --调用一下，要把上面的代码补全哦  
17. g()  

不信，试试把local f这句放到fucntion g ()的定义后面看有什么后果。

3.强大的尾调用

程序员都知道，函数的调用会产生调用堆栈。但是在Lua中，当然也有调用堆栈啦。但是尾调用在Lua中就不同于其他编程语言啦。我们先通过几行代码来看下什么是尾调用tailor call

[plain]  view plain copy

1. function f (x) return g(x) end  
2.   
3. function foo (n)  
4.     if n > 0 then   
5.         return foo(n - 1)   
6.     end  
7. end  
8.   
9. --下面这几个都不是  
10. function f (x)   
11.     g(x)            --after calling g, f still has to discard occasional results from g before returning  
12. end    
13. function f (x)  
14.     return g(x) + 1 -- must do the addition  
15. end  
16.   
17. function f (x)  
18.     return x or g(x) -- must adjust to 1 result  
19. end  
20.   
21. function f (x)  
22.     return (g(x)) -- must adjust to 1 result  
23. end  

在Lua中，只用格式为return func(args)的调用才是尾调用。即使func和args都是复杂的表达式也没关系，因为Lua在调用之前算得到它们的值。所以下面这个也是尾调用

[plain]  view plain copy

1. return x[i].foo(x[j] + a*b, i + j)  

我们再来针对下面这行代码讲讲Lua中对尾调用处理的强大。

[plain]  view plain copy

1. function f (x) return g(x) end  

Lua是怎么处理尾调用的呢。像C语言的话，上面代码中，f对g调用后，g执行完毕后，会返回到g的被调用处。但是在Lua中，这是一个尾调用，g执行完毕之后，会直接返回到f的被调用处。这样的话，可以节省很多堆栈空间。因此像下面这个函数，就不需担心n太大的话会有溢出。

在Lua中，对尾调用的一个很好的应用是状态机。可以用一个函数表示一个状态，改变状态就是跳转到一个指定的函数。下面我们用一个简单的迷宫程序示例：迷宫有几个房间（我们这里是4个），每个房间有4扇门，通向东，南，西，北。每一步，玩家指定一个移动的方向，如果这个方向有门，那么就进入对于的房间；否则，程序给一个警告；目标是从开始的房间走到目标房间。

这个程序是一个典型的状态机，状态就是当前的房间，每个房间写一个函数。用尾调用来从一个房间移动到另一个房间。如果不用尾调用的话，每一次移动都要将堆栈升级一个level，一定数量的移动后，可能就会导致程序溢出了。使用尾调用的话，就不需要担心这个问题了。废话少说，下面是代码，已经验证过了，比较简单。

[plain]  view plain copy

1. function room1 ()  
2.     local move = io.read()  
3.     if move == "south" then return room3()  
4.     elseif move == "east" then return room2()  
5.     else  
6.         print("invalid move")  
7.         return room1() -- stay in the same room  
8.     end  
9. end  
10.   
11. function room2 ()  
12.     local move = io.read()  
13.     if move == "south" then return room4()  
14.     elseif move == "west" then return room1()  
15.     else  
16.         print("invalid move")  
17.         return room2()  
18.     end  
19. end  
20.   
21. function room3 ()  
22.     local move = io.read()  
23.     if move == "north" then return room1()  
24.     elseif move == "east" then return room4()  
25.     else  
26.         print("invalid move")  
27.         return room3()  
28.     end  
29. end  
30.   
31. function room4 ()  
32.     print("congratulations!")  
33. end  
34.   
35. --写完上面的四个room，调用一下就可以了。  
36. room1()