chapter6 深入了解函数

　　Lua函数是具有特定词法域的第一类值，与其他传统类型的值(string and number)具有相同的权利。

它可以保存在变量和table中，也可以把它当参数传递，也可以作为返回值。

　　在Lua中有个容易混淆的概念，函数与所有其它值一样都是匿名的，即他们没有名称。

当讨论一个函数名(print)，实际上是讨论一个持有某函数的变量。

这与其他变量持有各种值一个道理，可以用多种方式来操作这些变量：

a  =  {p = print}
a.p("Hello World")        -->Hello World
print = math.sin          -->"print" 现在引用了sin函数
a.p(print())             -->0.841470
sin = a.p                 -->"sin" 现在引用了print函数
sin(,)                -->10   20

通常我们这样定义一个函数：

function foo (x) return *x end

这种写法仅仅是下面方式的一种简写：

foo = function(x) return *x end

实际上，函数定义就是创建了一个function类型的值，并把它赋值给一个变量。

可以将上面的function(x) body end表达式叫做函数构造式，就像{}是一个table构造式一样。

将这种函数构造式的结果叫作匿名函数。一些场合会用到匿名函数：

table.sort可以接收不同的排序方式,升序、降序、数字顺序、字符排序......

table.sort没有这些方式的函数实现，需要通过传入order function参数。

order function接收两个l列表内元素为参数，当第一个元素需要排在第二个元素之前，返回真并有序返回这两个参数。比如有一个table：

network = {
        {name = "grauna",    IP = "210.26.20.30"},
        {name = "arraial",   IP = "210.26.45.33"},
        {name = "lua",       IP = "210.45.34.56"},
        {name = "derain",    IP = "210.26.23.76"},
}

如果想以name字段按照反向的字符顺序进行排序，则：

table.sort(network,function (a,b) return (a.name > b.name) end)
--有点不好理解，a.name > b.name是ture 然后function是要排序还是不进行排序。
--但是从测试结果去了解，是要让table.name按照d,c,b,a进行排序
--索性就把（a.name > b.name ）当成想要实现的结果，这样好理解一点

把这样的sort函数称作高阶函数，然后用匿名函数来创建高阶函数需要的实参。

另一个用高阶函数的例子，一个函数f在点x的导数（f(x+d)-f(x)）/d ,其中d趋向无穷小:

function derivative (f,delta)
    delta = delta  or  1e-4
    return function(x)
               return (f(x +delta) -f(x))/delta
           end
    end

对于特定函数f调用derivative(f)将（近似地）返回其导数：

c = derivative(math.sin)
print(math.cos(5.2),c(5.2))
--> 0.46851667130038      0.46856084325086
print(math.cos(),c())
--> -0.83907152907645    -0.83904432662041

6.1 闭合函数

　　把一个函数嵌入到另一个函数内，并且它具有访问闭合函数里的局部变量。

有以下代码：

names  = {"Peter", "Paul" , "Mary"}
grades = {Mary=,Paul=, Peter=}
table.sort(name,function(n1,n2) return grades[n1] > grades [n2] end

现在，用一个函数去实现这个功能：

function sortbygrade (names,grades)
    table.sort(names,function (n1,n2) return grades[n1] > grades[n2] end
end

匿名函数function可以访问grades变量，grades变量是闭合函数sortbygrade的局部变量。

对于匿名函数，grades既不是全局变量，也不是局部变量，我们称它为upvalue——上值。

Why is this point so interesting? Because functions are first-class values,
and therefore they can escape the original scope of their variables.

这是原文，没有理解透彻。待以后再细细品尝。

要对upvalue的深入了解，参考云风博客里的一篇译文：the_implementation_of_lua_50.pdf

参考以下代码：的

function newCounter()
    local i =
    return function()
            i = i +
            return i
    end
end

c1 = newCounter()
print(c1())        -->1
print(c1())        -->2

在这个代码中，匿名函数引用了一个非局部变量i去计数。

当在调用匿名函数时，newCounter函数已经返回，i变量超出作用范围。

对此，Lua用了一个叫做closure的概念去处理这种情况。

closure是一个函数加上所有它需要访问的非局部变量。

当再重新调用newCounter,它会创建一个新的局部变量i，从而得到一个新的closure。

c2 = newCounter()
print(c2())            --> 1
print(c1())            --> 3
print(c1())            --> 2

此时，c1和c2是两个不同的closure函数，各自有独立的局部变量i。

从技术层面讲，Lua中只存在closure，不存在function。

function本身仅仅是closure的原形。

closure是一个很有用的工具，比如在高阶函数sort中作为参数传参。

对创建其他函数的函数也很有用（比如沙盒函数）。

这种机制使Lua程序可以融合那些在函数式编程世界中久经考验的编程技术。

closure对于回调函数也很有用。

一个典型的例子：当你调用传统的GUI 工具创建按钮时。每当用户按下按钮，就会触发一个

回调函数。你希望的是不同的按钮按下时，只做一点轻微不同的操作。

比如一个 十进制的计算器，需要10个相似的按钮，每个数字对应一个。

function digiButton (digit)
    return Button { label   = tostring(digit),
                     action = function()
                            add_to_display(digit)
                        　　end
                   }
end

该例子中，Button是一个创建按钮的函数，label是按钮标签，action是一个closur函数，每

次有按钮按下就会触发。即使在digitButton函数返回，digit变量超出范围。action任然可以

去访问这个digit变量。

函数可以保存在一个变量里，使得它在很多不同环境使用起来很方便。

像以下代码重定义sin函数：

oldSin = math.sin
math.sin = function (x)
            　　return oldSin(x * math.pi/)
           end

一个更测底的方法：

do
    local oldsin = math.sin
    local k = math.pi/
    math.sin = function(x)
                    return oldSin(x * k)
                end
end

把原始的sin保存为一个私有变量，只有通过新版本的sin才可以访问到它。

可以使用该技术创建一个安全的运行环境，即所谓的sandbox——”沙盒”。

当运行一些不受信任的代码时会用到该功能。比如限制一个程序访问文件：

do
    local oldOpen = io.open
        local access_OK = function (filename ,mode)
        --check access authority
        end
    io.open = function(filename,mode)
                    if access_OK(filename,mode)
                        return oldOpen(filename,mode)
                    else
                        return nil,"access denied"
                    end
            end
end

这样，只能通过新授权的版本才能访问原来的不受限的open函数。

对此Lua提供了一套元机制，可以根据特定的安全需要来创建一个安全的运行环境。

6.2 非全局函数

　　大多数的Lua库（io.read,math.sin）使用了这样的机制，把函数放在table字段里。

在Lua中创建这样的函数，只需要将函数语法与table语法结合起来即可。

Lib = {}
Lib.foo = function (x,y) return x+y end
Lib.goo = function (x,y) return x-y end
print(Lib.foo(,),Lib.goo(,))    -->5    -1

也可以这样写：

Lib = {
    goo = function (x,y) return x+y end,
    foo = function (x,y) return x-y end
}

还可以这样写：

Lib = {}
function Lib.foo (x,y) return x+y end
function Lib.goo (x,y) return x-y end

在程序块中：

local f = function()
        <body>
end

local g = function()
    f()      --f在这里可见
end

对于这种局部函数的定义，Lua支持的一种特殊的语法糖：

local  function f()
        <body>
end

当Lua在展开局部函数定义的语法糖时：并不是使用基本函数定义的语法。

local function foo()   <body> end

---->展开后

local foo;foo = function() <body> end

在定义递归函数时，下面的代码是不能运行的：

local fact = function(n)
                if n ==  then return
                else return n*fact(n-)
              end
end

原因是，当Lua编译fact (n-1)时，local fact 还没有定义。此时该表达式将会去调用全局的fact，而不是local fact。

解决办法：

local fact
fact = function(n)
        if n ==  then return
        else return n*fact(n-)
        end
end

------------------或者----------------------

local function fact(n)
        if n ==  then return
        else return n*fact(n-)
        end
end

当函数运行时，fact已经有了确切的值，所以不会产生错误。

当间接使用递归时，你必须明确地使用前向声明。

local f , g
function g()
    f()
end

function f()
    g()
end

注意，别把第二个函数定义为local function f，否则 g 中调用的 f 处于未定义状态。

6.3 正确的尾调用

Lua函数的另一个特性，Lua支持尾调用消除。

当一个函数调用是另一个函数的最后一个动作，该调用就是一个尾调用。

有点类似于goto语句。

比如：

function f(x) return g(x) end

当g返回时，控制权直接返回到调用f的那个点上。

尾调用消除这个特点，使得在进行 “尾调用” 时不消耗任何栈空间。

所以一个程序可以有无数嵌套的“尾调用”

function foo(n)
    if n> then
        return foo(n-)
    end
end

该函数支持任意的数字，都不会出现栈溢出。

想要用尾调用的好处，就必须要保证是尾调用。

以下代码都不是尾调用。

function f(x)  g(x)  end        --在调用g后，f还要丢弃g的返回值
return g(x) +                  --g返回后，还要再加
return x or g(x)                --g返回后，还要再或
return (g(x))                   --g返回后，还要调整为一个返回值

在Lua中，只有“return func()” 才是尾调用，Lua会在调用前对func和它的参数求值。

比如下面的代码就是尾调用：

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