golang 闭包

package main

import "fmt"

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}

此段代码，我一开始困惑在于main 调用adder赋给pos为什么可以传参，因为adder并没有接受参数，只有返回参数fun(int) int

但后面细一看，闭包返回值是一个函数，所以当返回一个匿名函数，func(x int) int

pos便可以接受传参

所以闭包在我理解就是函数代理，当client调用函数A(x)，函数A会返回一个函数B，函数B(x)接受client调用A(x)，并最终返回。

闭包的特性

下图显示是函数调用和返回函数的关系

package main

import "fmt"

// 返回一个“返回int的函数”
func fibonacci() func() int {
   start,end := 0,1
   return func() int{
     current := start
     start,end = end,(start+end)
	 
	  return current
   }
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

https://tour.go-zh.org/moretypes/26

闭包的生命周期与闭包存在的关键点

https://juejin.cn/post/6872982744733843463

简而言之，闭包和生命周期就是把函数当返回值赋给变量对象来维持的？

使用一个变量接受嵌套的内部函数，让它在执行完之后不会成为垃圾对象，闭包从而得以存在

递归和闭包

https://www.cnblogs.com/mlw1814011067/p/11648290.html

闭包函数调用的内部函数需要引用外部函数的变量、参数；递归函数是自己调用自己，不需要引用

package main

import "fmt"

func adder() func(int) int {
   sum :=0
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-2*i),
		)
	}
}
执行输出值为
===============
0 0
1 -2
3 -6
6 -12
10 -20
15 -30
21 -42
28 -56
36 -72
==============

当 sum :=0定义是是初始化给内部func(x int) int函数使用，如果把sum :=0定义在函数内部，则每次闭包函数都会
初始sum值，那样就无法寄存sum的执行值了。比如改成如下
func adder() func(int) int {
   
	return func(x int) int {
	    sum :=0
		sum += x
		return sum
	}
}

执行输出值为
====================
0 0
1 -2
2 -4
3 -6
4 -8
5 -10
6 -12
7 -14
8 -16
9 -18
=====================