1.什么是闭包

闭包就是能够读取其他函数内部变量的函数，所以闭包可以理解成“定义在一个​ ​函数​​内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。

​2.实例1


          

           package 
           main
           

           import (
           
    
           "fmt"
           
)
           

           

           //函数片段
           

           func 
           add(
           base 
           int) 
           func(
           int) 
           int {
           

           
    
           fmt
           .
           Printf(
           "%p\n", 
           &
           base)  
           //打印变量地址，可以看出来 内部函数时对外部传入参数的引用
           

           
    
           f :
           = 
           func(
           i 
           int) 
           int {
           
        
           fmt
           .
           Printf(
           "%p\n", 
           &
           base)
           
        
           base 
           += 
           i
           
        
           return 
           base
           
    }
           

           
    
           return 
           f
           
}
           

           

           func 
           main(){
           
    
           res :
           = 
           add(
           10)
           
    
           fmt
           .
           Println(
           res(
           1))
           
    
           fmt
           .
           Println(
           res(
           2))
           
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.

golang闭包_后进先出

根据程序运行结果可以看出来，13这个答案是接着11运行的结果，内部函数是对外部函数的引用

3.实例2


          

           package 
           main
           

           

           import (
           
    
           "fmt"
           
)
           

           

           func 
           main() {
           
      
           a :
           = []
           int{
           1, 
           2, 
           3}
           
     
           for 
           _, 
           i :
           = 
           range 
           a {
           
           
           fmt
           .
           Println(
           i)
           
           
           defer 
           p(
           i)
           
          }
           
}
           

           

           func 
           p(
           i 
           int) {
           
     
           fmt
           .
           Println(
           i)
           
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.

golang闭包_后进先出_02

这里就是普通的函数调用，每次调用func p时，完成 i 的值复制，然后打印，此时 i 值复制了3次，分别是1，2，3。由于defer是后进先出，所以执行变成3，2，1


          

           package 
           main
           

           

           import (
           
    
           "fmt"
           
)
           

           

           func 
           main() {
           
      
           a :
           = []
           int{
           1, 
           2, 
           3}
           
     
           for 
           _, 
           i :
           = 
           range 
           a {
           
           
           fmt
           .
           Println(
           i)
           
           
           defer 
           func() {
           
             
           fmt
           .
           Println(
           i)
           
         }()
           
     }
           
}
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.

golang闭包_后进先出_03

这个就是闭包的“神奇”之处。闭包里的非传递参数外部变量值是传引用的，在闭包函数里那个i就是外部非闭包函数自己的参数，所以是相当于引用了外部的变量， i 的值执行到第三次是3 ，闭包是地址引用所以打印了3次i地址指向的值，所以是3，3，3