5.4 闭包 (closure)

5.4 闭包 (closure)

Lua 闭包 (Closure) 详解与实践

在 Lua 语言中，函数是一等公民，这意味着函数可以像其他任何值（例如数字、字符串）一样被赋值给变量、作为参数传递给其他函数，以及作为函数的返回值。这种特性为 Lua 带来了强大的灵活性和表达能力。而闭包 (closure) 正是函数作为一等公民这一特性的重要体现，也是 Lua 中一个非常核心且强大的概念。

1. 什么是闭包 (Closure)?

简单来说，闭包是一个函数以及其相关的引用环境 (environment) 的组合体。这个环境包含了函数在定义时所能访问的所有局部变量。更通俗地说，闭包允许函数记住并访问它被创建时所在的作用域中的变量，即使在其创建作用域之外被调用时仍然可以访问这些变量。

理解闭包的关键在于理解 "引用环境"。当一个函数被定义时，Lua 会记录下这个函数能够访问的所有外部局部变量（也称为 upvalues）。即使在函数定义的作用域结束后，这些 upvalues 仍然会被闭包所 "记住"，并在函数被调用时使用。

2. 闭包的核心概念：词法作用域 (Lexical Scoping) 和 Upvalues

要理解闭包，必须先了解 词法作用域 (Lexical Scoping)。Lua 使用词法作用域，这意味着一个变量的作用域是由它在代码中被 词法 定义的位置决定的，而不是运行时调用函数的位置。

考虑以下代码：

function outerFunction(x)
    local localVar = x
    function innerFunction(y)
        print("外部变量 localVar:", localVar) -- innerFunction 可以访问 outerFunction 的局部变量 localVar
        print("内部变量 y:", y)
    end
    return innerFunction -- 返回 innerFunction
end
local closure = outerFunction(10) -- 调用 outerFunction，并传入参数 10，返回 innerFunction，赋值给 closure
closure(5) -- 调用 closure，即 innerFunction，并传入参数 5
​

在这个例子中：

• outerFunction 定义了一个局部变量 localVar 和一个内部函数 innerFunction。

• innerFunction 可以访问 outerFunction 的局部变量 localVar。这就是词法作用域的体现：innerFunction 的作用域嵌套在 outerFunction 的作用域内，因此它可以访问 outerFunction 的局部变量。

• outerFunction 返回了 innerFunction。

• 当我们调用 outerFunction(10) 时，localVar 被赋值为 10，innerFunction 被创建并返回，赋值给 closure。

• 关键在于，即使 outerFunction 函数调用已经结束，localVar 仍然被 innerFunction (也就是 closure) "记住" 了。当我们调用 closure(5) 时，innerFunction 仍然可以访问并打印出之前 outerFunction 中定义的 localVar 的值 10。

Upvalues (上值) 就是 Lua 用来实现闭包中 "记住" 外部局部变量的机制。当一个内部函数访问其外部函数的局部变量时，Lua 实际上并没有复制这个变量的值，而是创建了一个指向外部局部变量的 引用，这个引用就称为 upvalue。

在上面的例子中，localVar 对于 innerFunction 来说就是一个 upvalue。即使 outerFunction 执行完毕，localVar 这个 upvalue 仍然与 innerFunction (即 closure) 关联着，使得 innerFunction 在后续调用时可以访问到 localVar 的值。

3. 闭包的代码实践与详解

下面我们通过一系列代码示例来深入理解闭包的实践应用和内部机制。

3.1 简单的计数器 (Counter)

闭包最经典的应用之一就是创建计数器。我们可以使用闭包来封装一个计数器变量，并提供增加计数和获取计数值的方法。

function createCounter()
    local count = 0 -- 计数器变量，在 createCounter 内部作用域
    return function() -- 返回一个匿名函数，这个匿名函数就是一个闭包
        count = count + 1
        return count
    end
end
local counter1 = createCounter() -- 创建第一个计数器
local counter2 = createCounter() -- 创建第二个计数器
print("counter1 count:", counter1()) -- 输出 1
print("counter1 count:", counter1()) -- 输出 2
print("counter2 count:", counter2()) -- 输出 1
print("counter1 count:", counter1()) -- 输出 3
print("counter2 count:", counter2()) -- 输出 2
​

代码详解:

• createCounter 函数定义了一个局部变量 count，并返回一个匿名函数。

• 返回的匿名函数就是一个闭包。它记住了 createCounter 函数作用域中的 count 变量。

• 每次调用 counter1() 或 counter2()，闭包都会访问并修改其 upvalue count，从而实现计数功能。

• counter1 和 counter2 是两个独立的计数器，因为每次调用 createCounter() 都会创建一个新的 count 变量和新的闭包。它们各自维护自己的计数状态。

关键点:

• 闭包 "记住" 了 createCounter 函数的局部变量 count。

• 即使 createCounter 函数已经执行完毕，返回的闭包仍然可以访问和修改 count 变量。

• 每次调用 createCounter() 都会创建独立的 count 变量和闭包实例，实现多个独立的计数器。

3.2 数据封装与信息隐藏

闭包可以用于实现数据封装和信息隐藏，类似于面向对象编程中的私有成员。我们可以使用闭包将一些数据和操作数据的函数封装在一起，只对外暴露必要的接口，隐藏内部实现细节。

function createAccount(initialBalance)
    local balance = initialBalance -- 账户余额，封装在闭包内
    local deposit = function(amount)
        balance = balance + amount
        print("存款成功，当前余额:", balance)
    end
    local withdraw = function(amount)
        if balance >= amount then
            balance = balance - amount
            print("取款成功，当前余额:", balance)
        else
            print("余额不足")
        end
    end
    local getBalance = function()
        return balance
    end
    return { -- 返回一个包含操作函数的 table，作为账户的接口
        deposit = deposit,
        withdraw = withdraw,
        getBalance = getBalance
    }
end
local myAccount = createAccount(100) -- 创建一个初始余额为 100 的账户
myAccount.deposit(50)    -- 存款
myAccount.withdraw(20)   -- 取款
print("当前余额:", myAccount.getBalance()) -- 获取余额
-- 尝试直接访问 balance (会报错，因为 balance 是 createAccount 的局部变量，外部无法直接访问)
-- print(myAccount.balance) -- 错误!
​

代码详解:

• createAccount 函数创建了一个局部变量 balance 来表示账户余额。

• 它定义了三个内部函数 deposit, withdraw, getBalance，这些函数都是闭包，可以访问和操作 balance 变量。

• createAccount 函数返回一个 table，其中包含了这三个操作函数，作为账户的公共接口。

• 外部代码只能通过 table 中暴露的接口函数来操作账户余额，无法直接访问或修改 balance 变量，实现了数据封装和信息隐藏。

关键点:

• balance 变量被封装在 createAccount 函数的作用域内，外部无法直接访问。

• 闭包 deposit, withdraw, getBalance 提供了操作 balance 的接口，但限制了外部直接访问 balance。

• 这种方式可以有效地保护数据，避免外部代码意外地修改内部状态，提高代码的可靠性和可维护性。

3.3 回调函数 (Callbacks) 与事件处理

闭包常用于实现回调函数和事件处理机制。我们可以将闭包作为回调函数传递给其他函数或模块，当特定事件发生时，闭包会被调用，并可以访问其创建时所在作用域的变量，从而实现灵活的事件处理逻辑。

function eventHandlerFactory(message)
    local eventMessage = message -- 事件消息，封装在闭包内
    return function(eventData) -- 返回一个事件处理闭包
        print("事件发生:", eventMessage)
        print("事件数据:", eventData)
        -- 在这里可以执行具体的事件处理逻辑，例如更新 UI，发送网络请求等
    end
end
local buttonClickHandler = eventHandlerFactory("按钮点击事件") -- 创建按钮点击事件处理器
local networkErrorHandler = eventHandlerFactory("网络错误事件")    -- 创建网络错误事件处理器
-- 模拟事件触发，调用事件处理闭包
buttonClickHandler({x = 10, y = 20})
networkErrorHandler({errorCode = 404, errorMessage = "Not Found"})
​

代码详解:

• eventHandlerFactory 函数接受一个消息参数 message，并返回一个事件处理闭包。

• 返回的闭包记住了 eventHandlerFactory 函数作用域中的 eventMessage 变量。

• buttonClickHandler 和 networkErrorHandler 是通过 eventHandlerFactory 创建的两个不同的事件处理闭包，它们各自记住了不同的事件消息。

• 当事件发生时 (例如按钮点击或网络错误)，我们调用相应的事件处理闭包，并传递事件数据。闭包会被执行，并可以使用其 upvalue eventMessage 和接收到的 eventData 来执行事件处理逻辑。

关键点:

• 闭包可以作为回调函数传递给其他函数或模块。

• 闭包可以 "记住" 创建时所在作用域的变量，并在回调时访问这些变量。

• 这种方式可以实现灵活的事件处理逻辑，不同的事件可以使用不同的闭包来处理，并且闭包可以根据其创建时的上下文信息进行定制化的处理。

3.4 函数工厂 (Function Factories) 与代码生成

闭包可以用于创建函数工厂，即可以生成其他函数的函数。函数工厂可以根据不同的参数或配置，生成具有不同行为的函数。

function createMultiplier(factor)
    return function(number) -- 返回一个闭包，用于乘以 factor
        return number * factor
    end
end
local double = createMultiplier(2) -- 创建一个乘以 2 的函数
local triple = createMultiplier(3) -- 创建一个乘以 3 的函数
print("double of 5:", double(5))   -- 输出 10
print("triple of 5:", triple(5))   -- 输出 15
​

代码详解:

• createMultiplier 函数接受一个参数 factor，并返回一个匿名函数。

• 返回的匿名函数是一个闭包，它记住了 createMultiplier 函数作用域中的 factor 变量.

• double 和 triple 是通过 createMultiplier 创建的两个不同的函数，它们各自记住了不同的 factor 值。

• 当我们调用 double(5) 或 triple(5) 时，闭包会使用其 upvalue factor 和接收到的 number 参数进行乘法运算，并返回结果。

关键点:

• createMultiplier 是一个函数工厂，它可以根据 factor 参数生成不同的乘法函数。

• 闭包使得生成的函数可以 "记住" 创建时的 factor 值，从而实现定制化的行为。

• 函数工厂可以用于动态生成具有特定功能的函数，提高代码的灵活性和可重用性。

3.5 柯里化 (Currying) 和偏函数 (Partial Application)

闭包可以用于实现柯里化 (Currying) 和偏函数 (Partial Application) 等函数式编程技巧。

柯里化 (Currying): 将一个接受多个参数的函数转换为一系列接受单个参数的函数的过程。

function curryAdd(x)
    return function(y)
        return x + y
    end
end
local add5 = curryAdd(5) -- 创建一个 "加 5" 的函数
print("5 + 3 =", add5(3)) -- 输出 8
local add10 = curryAdd(10) -- 创建一个 "加 10" 的函数
print("10 + 7 =", add10(7)) -- 输出 17
​

偏函数 (Partial Application): 固定一个函数的部分参数，生成一个新的函数，这个新函数只需要接受剩余的参数。

function partialMultiply(x, y)
    return x * y
end
function createPartialMultiplier(x)
    return function(y)
        return partialMultiply(x, y) -- 调用原始函数，并固定了第一个参数 x
    end
end
local multiplyBy2 = createPartialMultiplier(2) -- 创建一个 "乘以 2" 的偏函数
print("2 * 4 =", multiplyBy2(4)) -- 输出 8
local multiplyBy10 = createPartialMultiplier(10) -- 创建一个 "乘以 10" 的偏函数
print("10 * 6 =", multiplyBy10(6)) -- 输出 60
​

代码详解:

• 柯里化 (curryAdd): curryAdd(x) 返回一个闭包，这个闭包记住了 x，并在接收到 y 时返回 x + y 的结果。通过柯里化，我们将一个接受两个参数的加法函数转换为一系列接受单个参数的函数。

• 偏函数 (createPartialMultiplier): createPartialMultiplier(x) 返回一个闭包，这个闭包记住了 x，并在接收到 y 时调用 partialMultiply(x, y)， effectively固定了 partialMultiply 的第一个参数为 x。

关键点:

• 闭包可以 "记住" 部分参数，并延迟接收剩余参数，实现柯里化和偏函数。

• 柯里化和偏函数可以提高代码的灵活性和可重用性，可以创建更具特化性的函数。

• 这些技术在函数式编程中非常常见，Lua 的闭包特性使得实现这些技术变得非常容易。

3.6 迭代器 (Iterators)

闭包可以用于创建自定义迭代器。Lua 的 for ... in 循环可以与迭代器函数配合使用，遍历集合或生成序列。

function createIterator(collection)
    local index = 0
    return function() -- 返回一个迭代器闭包
        index = index + 1
        return collection[index] -- 返回集合中的下一个元素
    end
end
local numbers = {1, 2, 3, 4, 5}
local iterator = createIterator(numbers)
for value in iterator do -- 使用迭代器遍历 numbers 集合
    if value == nil then break end -- 当迭代器返回 nil 时，结束循环
    print(value)
end
​

代码详解:

• createIterator 函数接受一个集合 collection，并返回一个迭代器闭包。

• 迭代器闭包维护一个 index 变量，用于跟踪当前迭代的位置。

• 每次调用迭代器闭包，它都会递增 index，并返回 collection 中索引为 index 的元素。如果 index 超出集合范围，则返回 nil。

• for ... in 循环会自动调用迭代器闭包，直到返回 nil 为止，从而实现遍历集合的功能.

关键点:

• 闭包可以用于封装迭代状态 (例如 index 变量)。

• 迭代器闭包可以 "记住" 迭代状态，并在每次调用时更新状态并返回下一个元素。

• 闭包使得创建自定义迭代器变得简单而灵活，可以用于遍历各种数据结构和生成序列。

4. 闭包的注意事项与潜在问题

虽然闭包非常强大，但在使用时也需要注意一些潜在的问题：

• 内存消耗: 闭包会持有其 upvalues 的引用。如果闭包长期存活，并且引用的 upvalues 占用大量内存，可能会导致内存泄漏或增加内存消耗。尤其是在创建大量闭包时，需要注意 upvalues 的生命周期和内存管理。

• 共享 Upvalues: 多个闭包可以共享同一个 upvalue。如果多个闭包同时修改同一个共享 upvalue，可能会导致竞态条件和意外的结果。需要谨慎处理共享 upvalues 的并发访问。

• 性能影响: 创建闭包和访问 upvalues 可能会有一定的性能开销，尤其是在性能敏感的场景下需要考虑。虽然 Lua 的闭包实现已经非常高效，但在极端情况下，过度使用闭包可能会对性能产生影响。

5. 总结

闭包是 Lua 语言中一个非常核心且强大的概念。它基于词法作用域和 upvalues 机制，使得函数可以 "记住" 并访问其创建时所在作用域的变量，即使在其创建作用域之外被调用时仍然可以访问这些变量。

闭包在 Lua 中有广泛的应用，包括：

• 创建计数器和状态管理

• 实现数据封装和信息隐藏

• 作为回调函数和事件处理器

• 构建函数工厂和代码生成

• 实现柯里化和偏函数等函数式编程技巧

• 创建自定义迭代器

理解闭包的本质和应用，可以帮助你编写更灵活、更强大、更具表达力的 Lua 代码。熟练掌握闭包，是成为 Lua 高级开发者的关键一步。在实际开发中，合理地运用闭包，可以有效地提高代码的模块化程度、可重用性和可维护性。