别再让 Go 语言的闭包坑害你！了解幕后真相，提升编程功力

2023-09-07 06:49:46

闭包：掌握利器，规避陷阱

理解闭包及其优势

闭包，顾名思义，就是可以访问其他函数内部变量的函数。在 Go 语言中，闭包被广泛应用于各种场景，从函数式编程到并发编程。闭包的优势在于，它允许我们创建拥有私有状态的函数，从而增强了代码的灵活性和可重用性。

闭包中的陷阱：变量作用域混乱

然而，闭包也存在一些潜在陷阱，尤其是当它们与协程结合使用时。最常见的闭包问题之一是变量作用域的混乱。在 Go 语言中，变量的作用域是由其所在的代码块决定的，这意味着如果一个变量在一个函数内部被定义，那么它只能在这个函数内部被访问。

举例来说，以下代码创建了一个闭包函数 add()，用于计算两个数字的和。

func add(a, b int) func() int {
  return func() int {
    return a + b
  }
}

现在，我们创建一个协程，并在协程中调用 add() 函数，并将返回的闭包函数存储在一个变量中。

func main() {
  a := 1
  b := 2
  f := add(a, b)

  go func() {
    // 这里闭包函数访问不到变量 a 和 b
    fmt.Println(f())
  }()
}

当这段代码运行时，闭包函数 f() 不会返回预期的和 3，而是返回 0。这是因为，当在协程中调用 add() 函数时，变量 a 和 b 已经不在作用域内，所以闭包函数无法访问它们。

解决方案：闭包捕获变量

要解决这个问题，我们可以使用闭包捕获变量。闭包捕获变量是指闭包函数在创建时，将外部变量的值复制到自己的内部变量中。这样，即使外部变量的作用域已经结束，闭包函数仍然可以访问这些变量。

修改后的代码如下：

func add(a, b int) func() int {
  return func() int {
    // 捕获变量 a 和 b
    aCopy := a
    bCopy := b

    return func() int {
      return aCopy + bCopy
    }
  }()
}

现在，这段代码就可以正常运行了。当协程调用闭包函数 f() 时，闭包函数可以访问捕获的变量 aCopy 和 bCopy，并正确地返回两个数字的和。

闭包中的陷阱：内存泄漏

除了变量作用域的混乱之外，闭包还可能导致内存泄漏。内存泄漏是指程序在不再需要某些变量或对象时，仍然持有对它们的引用，导致这些变量或对象无法被垃圾回收器回收，从而导致程序的内存占用不断增加。

在 Go 语言中，闭包很容易导致内存泄漏。例如，以下代码创建了一个闭包函数 add()，用于计算两个数字的和。

func add(a, b int) func() int {
  return func() int {
    // 闭包函数持有对变量 a 和 b 的引用
    return a + b
  }
}

现在，我们创建一个协程，并在协程中调用 add() 函数，并将返回的闭包函数存储在一个变量中。

func main() {
  a := 1
  b := 2
  f := add(a, b)

  // 协程启动后，变量 a 和 b 不再被使用
  go func() {
    // 闭包函数仍然持有对变量 a 和 b 的引用
    fmt.Println(f())
  }()
}

当这段代码运行时，即使协程已经结束了，变量 a 和 b 仍然没有被垃圾回收器回收。这是因为，闭包函数 f() 仍然持有对变量 a 和 b 的引用。

解决方案：闭包释放变量引用

要解决这个问题，我们可以使用闭包释放变量的引用。闭包释放变量的引用是指闭包函数在不再需要某些变量或对象时，显式地释放对它们的引用，以便垃圾回收器可以回收这些变量或对象。

修改后的代码如下：

func add(a, b int) func() int {
  return func() int {
    // 捕获变量 a 和 b
    aCopy := a
    bCopy := b

    // 释放变量 a 和 b 的引用
    defer func() {
      aCopy = 0
      bCopy = 0
    }()

    return func() int {
      return aCopy + bCopy
    }
  }()
}