初识闭包

闭包是一种能访问当前作用域外变量的函数。

简单来说就是：使用某个函数时，依赖于该函数作用域外的环境，该函数称之为闭包。

判断一下情况是否是闭包？

  • A

    1
    2
    3
    4
    5
    6
    func f() {
    	name := "Jane"
    	func() {
    		fmt.Println("My name is ", name)
    	}()
    }

  • B

    1
    2
    3
    4
    5
    6
    func B() {
    	name := "Jane"
    	func(name string) {
    		fmt.Println("My name is ", name)
    	}(name)
    }

  • C

    1
    2
    3
    4
    5
    6
    7
    8
    func C() {
    	name := "Jane"
    	func() {
    		fmt.Println("My name is Maria")
    	}()

    	fmt.Println("this is ", name)
    }

**A ** 是标准的闭包，闭包是用了当前函数作用域外的变量name

B 不是闭包，函数内的name是自己作用域的变量，是通过参数传递进来的

C 不是闭包，没有是用作用域外的环境，外部环境对其没用影响

闭包的使用

判断一下程序运行的结果

  • A

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17

    package main

    import "fmt"

    func main() {
    	fac := fA(10)
    	fac()
    	fac()
    }

    func fA(i int) func() {
        return func(){
            i++
            fmt.Println("i:", i)
        }
    }

  • B

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    package main

    import "fmt"

    func main() {
    	fbc := fB(10)
    	fbc()
    	fbc()
    }

    func fB(i int) func() {
        i++
        return func(){
            fmt.Println("i:", i)
        }
    }

A的结果：
11
12

B的结果：

11
11

A：闭包引用了外部环境的变量，也就是说共享了一个栈上面的变量，致使该变量不会立刻被销毁，延长了改变变量的生命周期。闭包对变量追加了操作，所以会累加。

闭包的作用

  • 访问其他函数内的变量
  • 延长变量的生命周期，保护其不备回收机制回收
  • 避免全局变量被污染 方便调用上下文的局部变量 加强封装性。更为了高内聚、低耦合的设计思想，使用闭包可以提升开发效率，更便于维护。