Lua闭包与作用域 - 元素码农

发布时间: 2025-03-24 12:04

↑

# Lua闭包与作用域

本文将深入介绍Lua中的闭包概念和作用域规则，帮助你理解这些强大的编程特性。

## 作用域基础

### 1. 局部作用域

```lua
-- 局部变量的作用域
do
    local x = 10
    print(x)  -- 可以访问x
end
-- print(x)  -- 错误：x在这里不可见

-- 函数作用域
local function outer()
    local count = 0
    return function()
        count = count + 1
        return count
    end
end
```

### 2. 全局作用域

```lua
-- 全局变量
globalVar = 100  -- 不使用local的变量是全局的

function globalFunc()
    print(globalVar)  -- 可以访问全局变量
end

-- 显式声明全局变量
_G.explicitGlobal = 200
```

### 3. 块作用域

```lua
do
    local blockVar = "仅在块内可见"
    print(blockVar)
end

for i = 1, 3 do
    local loopVar = i * 2
    print(loopVar)
end
```

## 闭包概念

闭包是一个函数和其相关的引用环境的组合。

### 1. 基本闭包

```lua
local function createCounter()
    local count = 0
    return function()
        count = count + 1
        return count
    end
end

local counter1 = createCounter()
local counter2 = createCounter()

print(counter1())  -- 1
print(counter1())  -- 2
print(counter2())  -- 1（独立的计数器）
```

### 2. 闭包特性

```lua
-- 访问外部变量
local function makeAdder(x)
    return function(y)
        return x + y  -- 闭包记住了x的值
    end
end

local add5 = makeAdder(5)
print(add5(3))  -- 8

-- 修改外部变量
local function createAccumulator()
    local sum = 0
    return {
        add = function(x) sum = sum + x end,
        get = function() return sum end
    }
end

local acc = createAccumulator()
acc.add(5)
acc.add(3)
print(acc.get())  -- 8
```

## 闭包应用

### 1. 数据封装

```lua
-- 创建私有状态
local function createPerson(name)
    local age = 0
    
    return {
        setAge = function(newAge)
            if newAge >= 0 then
                age = newAge
            end
        end,
        
        getAge = function()
            return age
        end,
        
        getName = function()
            return name
        end
    }
end

local person = createPerson("张三")
person.setAge(25)
print(person.getName(), person.getAge())  -- 张三 25
```

### 2. 回调函数

```lua
-- 事件处理
local function createEventHandler(eventName)
    local handlers = {}
    
    return {
        addHandler = function(handler)
            table.insert(handlers, handler)
        end,
        
        trigger = function(...)
            for _, handler in ipairs(handlers) do
                handler(...)
            end
        end
    }
end

local clickEvent = createEventHandler("click")
clickEvent.addHandler(function(x, y)
    print("点击位置:", x, y)
end)
```

### 3. 函数工厂

```lua
-- 创建特定功能的函数
local function makeFormatter(format)
    return function(...)
        return string.format(format, ...)
    end
end

local numberFormat = makeFormatter("数字是: %d")
local dateFormat = makeFormatter("%d-%02d-%02d")

print(numberFormat(42))          -- 数字是: 42
print(dateFormat(2023, 12, 25))  -- 2023-12-25
```

## 作用域链

### 1. 作用域查找规则

```lua
-- 作用域链示例
local x = 10

local function outer()
    local y = 20
    
    local function inner()
        local z = 30
        print(x, y, z)  -- 可以访问所有外部变量
    end
    
    return inner
end

local func = outer()
func()  -- 10 20 30
```

### 2. 遮蔽（Shadowing）

```lua
-- 变量遮蔽
local x = "全局x"

local function test()
    local x = "局部x"  -- 遮蔽外部的x
    print(x)          -- 局部x
    
    do
        local x = "块级x"  -- 遮蔽函数级的x
        print(x)          -- 块级x
    end
    
    print(x)  -- 局部x
end

test()
print(x)  -- 全局x
```

## 常见问题解答

### Q1: 闭包会导致内存泄漏吗？

闭包会保持对其外部变量的引用，但这通常不会导致内存泄漏。当闭包不再被引用时，Lua的垃圾收集器会自动清理相关的内存。

```lua
-- 正确的资源管理
local function createResource()
    local data = "大量数据"
    return function()
        return data
    end
end

do
    local resource = createResource()
    print(resource())
end
-- resource及其闭包在这里会被垃圾收集
```

### Q2: 如何在闭包中共享状态？

```lua
-- 共享状态示例
local function createSharedState()
    local state = {count = 0}
    
    return {
        increment = function()
            state.count = state.count + 1
        end,
        
        decrement = function()
            state.count = state.count - 1
        end,
        
        getCount = function()
            return state.count
        end
    }
end

local counter = createSharedState()
counter.increment()
counter.increment()
print(counter.getCount())  -- 2
```

### Q3: 闭包和普通函数的区别是什么？

主要区别在于闭包可以访问和保持其创建时的作用域中的变量，而普通函数只能访问其参数和内部声明的局部变量。

```lua
-- 普通函数
local function regularFunc(x)
    return x + 1
end

-- 闭包
local function createClosure(x)
    return function(y)
        return x + y  -- 可以访问外部的x
    end
end
```

## 下一步

现在你已经掌握了Lua的闭包和作用域概念，可以继续学习[高阶函数应用](/article/lua/advanced/higher-order-functions)来了解如何更好地运用这些特性。

## 参考资源

- [Lua 5.4 参考手册](http://www.lua.org/manual/5.4/manual.html#3.5)
- [Programming in Lua - 闭包](http://www.lua.org/pil/6.1.html)
- [Lua闭包教程](http://lua-users.org/wiki/ClosuresTutorial)