GO 函数闭包与自执行函数学习

函数学习

1、自执行函数和闭包 在js中也有这个概念，通过对比我们就能更好的理解go语言的语法特性

• 自执行函数
  1、1 通过学习javascript我们再来深入学习go的语法，在javascript的意思就是自己调用自己

(function ( a,  b) {
	console.log("a=" + a +"b="+b)
})(1,2);
// result =  a =1 b =2

1、2 在GO中语法是怎么样的呢

func main()  {

	/*fmt.Println(intSum(1,2))
    var f = adder()
	fmt.Println(f(10))
	fmt.Println(f(20))
	fmt.Println(f(30))*/

	func(x, y int) {
		fmt.Println(x + y)
	}(10, 20)
}

总结： 通过两种语言的对比我们知道，他们先定义执行，之后立马调用自己, 然后执行函数体里面的内容。

---

• 闭包
  1、3 在js中的闭包

function init() {
    var name = "Mozilla"; // name 是一个被 init 创建的局部变量
    function displayName() { // displayName() 是内部函数，一个闭包
        alert(name); // 使用了父函数中声明的变量
    }
    displayName();
}
init();

1、4 在go中我们应该如何写闭包，他有什么特性

func adder() func(int) int{
	var x int  // 10
	return func(y int) int {
		x+=y
		return x
	}
}
fmt.Println(f(10))  //1O
fmt.Println(f(20))  //30
fmt.Println(f(30))  //60

总结： 这个理解属于个人理解, 为什么调用f(10)的时候是10呢。调用f(20)的时候等于30呢。这时候我们需要思考，如果他没有保存局部变量的值那么f(10)=10，f(20)=20，这个理解应该没有问题， 当我们运行的时候发现结果并不是我们理解的这样。那么我认为，程序在运行的时候并没有销毁局部变量的值，而是保存最新的局部变量值，这样他就可以得到我们上面执行的结果。

闭包场景二学习

func main()  {
	jpgFunc := suffix(".jpg")
	txtFunc := suffix(".txt")
	fmt.Println(jpgFunc("test")) //test.jpg
	fmt.Println(txtFunc("test")) //test.txt
}
// 判断前缀
func suffix(suffix string) func(string) string {
	return func(name string) string {
		if !strings.HasSuffix(name, suffix) {
			return name + suffix
		}
		return name
	}
}

场景三学习

func calc(base int) (func(int) int, func(int) int) {
	add := func(i int) int {
		base += i
		return base
	}

	sub := func(i int) int {
		base -= i
		return base
	}
	return add, sub
}

func main() {
	f1, f2 := calc(10)
	fmt.Println(f1(1), f2(2)) //11 9
	fmt.Println(f1(3), f2(4)) //12 8
	fmt.Println(f1(5), f2(6)) //13 7
}

总结: 通过上面三个例子我们不难知道，闭包其实不难理解，他会保存引用变量的值。