《Lua程序设计》之 闭包

九、闭包

9.1 函数是第一类值

第一类值(first-class value)意味着Lua语言中的函数与其他常见类型的值(如数值和字符串)有同等权限,即函数既可以保存在变量中、表中,又可以作为参数、返回值等,如:

a = {p = print}
a.p("Hello World")
print = math.sin
a.p(print(1))
math.sin = a.p
math.sin(10,20)

--打印
Hello World
0.8414709848079
10  20

函数作为值的一种,定义方式如下:

function foo(x) return 2*x end
--等价于
foo = function(x) return 2*x end --右边就是函数构造器,与表构造器{}相似

看匿名函数作为参数的使用场景

network = {
    {name = 'grauna'},
    {name = 'arraial'},
    {name = 'lua'},
    {name = 'derain'}
}
table.sort( network, function(a,b) return(a.name > b.name) end)

for i,t in pairs(network) do
    for k,v in pairs(t) do
        print(k,v)
    end
end

--print
name    lua
name    grauna
name    derain
name    arraial

像函数sort这样以另一个函数为参数的函数,我们称之为高阶函数(higher-order function)

9.2 非全局函数

我们先来模拟一下io.read和math.sin这种存储在表中的函数的实现

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

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

以上两种写法都可以

当把一个函数存储到局部变量时,就得到一个局部函数,局部函数对于包(package)而言尤其有用。

local function f(param)
    body
end

但是对于迭代函数,我们看下下面的局部函数使用是否有问题:

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

fact(10)

运行的时候会发现报test.lua:3: attempt to call global 'fact' (a nil value)的错,也就是在使用fact函数的时候,fact都还没赋值,调用全局的fact,而全局fact并未定义,所以会报该错,我们改一下代码

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

print(fact(10))

这样就没问题了,所以局部函数涉及到迭代的时候应该按上面的方法定义

local f
f = function (param)
    body
end

对于间接递归函数,必须要使用与明确的前向声明等价的形式

local f --“前向” 声明

local function g ( )
    some code f() some code
end

function f()   --这里的f是上面声明的f,不需要再用local修饰
    some code g() some code
end
9.2 词法定界

当编写一个被其他函数B包含的函数A时,被包含的函数A可以访问包含其的函数B的所有局部变量,我们将这种特性称为词法定界(lexical scoping)。看例子

function sortbygrade(names,grades)
    table.sort(names,function (name1,name2) return grades[name1] > grades[name2] end )
    for i,v in ipairs(names) do
        print(i,v)
    end
end

names = {"Peter","Paul","Mary"}
grades = {Mary = 10,Paul = 7,Peter = 8}
sortbygrade(names,grades)

我们看到table.sort的第二个参数匿名函数,可以访问grades,而grades是sortbygrade的形参,在该匿名函数中,这个grades就是我们所说的非局部变量。
实际上匿名函数就是一个闭包,一个闭包就是一个函数外加能够使用该函数正确访问非局部变量所需的其他机制,看以下代码

function newCounter()
    local count = 0
    return function ()
            count = count + 1
            return count
           end
end

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

调用newCounter都会生成一个新的闭包,每个闭包都有自己的非局部变量count,保存着count的值,是不是很神奇。从技术上讲,Lua语言是没有函数的,只有闭包,函数本身只是闭包的一种原型。

接下来我们来创建安全的运行时环境,即所谓的沙盒,当执行一些诸如从远程服务器上下载到的未受信任代码时,安全的运行时环境非常重要。例如,我们可以通过使用闭包重定义函数io.open来限制一个程序能够访问的文件

do              -- do 限制局部变量oldOpen的作用范围
    local oldOpen = io.open 
    local access_OK = function (filename,mode)
        check access
    end
    io.open = function (filename,mode)
        if access_OK(filename,mode) then
            return oldOpen(filename,mode)
        else
            return nil,"access denied"
        end
    end
end

这个跟iOS魔法盒功能一样(method swizzing),但是iOS写起来很麻烦,这个轻便很舒服,通过这一技巧,就可以在保证简洁性和灵活性的前提下在Lua语言本身构建Lua沙盒。相对于提供一套大而全的解决方案,Lua语言提供的是一套“元机制”。很棒!Lua的魅力越来越显示出来了。

9.3 小试函数式编程

好多代码,关于几何的看的脑壳疼,不写了。

推荐阅读更多精彩内容