Go 语言基础之基本语法（2）https://developer.aliyun.com/article/1534246
2.2.4、引用传递
Go 语言中引用类型的数据：slice、map、chan ...
func main() { // 切片是一个可扩容的数组 s1 := []int{1,2,3,4} update(s1) fmt.Println(s1) // [-1 2 3 4] } func update(arr []int) { arr[0] = -1 }
可以看到，如果参数是值类型（包括数组和结构体！），就像在 Java 中的形参为值类型一样，进入函数的参数会开辟自己的栈空间，所以我们事实上操作的是形参而不是实参！
这里我们的参数类型是应用类型 slice，它虽然看起来像数组，但是它是一个引用类型，对于 Go 语言中的引用类型，它就像我们 Java 中的对象，所以当我们修改它的属性值的时候，修改的就是实参的值。
总之，值传递时传递的是数据的拷贝，而引用传递时传递的是引用地址。
2.2.5、递归
递归就简单了，这里玩一个斐波那契数列：
func main() { for i:=1;i<10;i++ { fmt.Print(feb(i)," ") } } func feb(num int)(res int) { if num==1 || num==2 { return 1 }else { return feb(num-1)+feb(num-2) } }
运行结果：
2.2.6、defer 延迟
被 defer 修饰的代码总是放到最后执行，它采用的是后进先出（栈）模式：
func main() { f("1") f("2") defer f("3") f("4") } func f(s string) { fmt.Println(s) }
运行结果：
因为 defer 的这个特性，我们可以用它去关闭资源。
2.3、函数高级
2.3.1、函数的本质
函数的本质就是一个引用类型，只不过它的类型为 func()：
func main() { fmt.Printf("%T",f) } func f(s string) { fmt.Println(s) }
运行结果：
所以，我们可以想到，当函数不加括号的时候函数就是一个类型，所以我们是否可以定义一个函数类型的变量？
func main() { fmt.Printf("%T\n",f) var f2 func(s string) = f f2("hello") // 打印函数的地址 fmt.Println(f) fmt.Println(f2) } func f(s string) { fmt.Println(s) }
运行结果：
可以看到，函数 f 被赋值给了一个为函数类型的变量 f2，而且这个 f2 已经具备了 f 的功能。而且我们可以看到，f 和 f2 的地址是相同的，这更加说明函数就是一个引用类型，我们给 f2 赋值的过程其实就是将 f 的地址传递给 f2。
2.3.2、匿名函数
Go 语言是支持函数式编程的：
- 将匿名函数作为另一个函数的参数，回调函数
- 将匿名函数作为另外一个函数的返回值，形成闭包
package main import ( "fmt" ) func main() { f1() f2:=f1 f2() // 匿名函数 f3:=func(){ fmt.Println("函数 f3") } f3() // 进一步简化 func(){ fmt.Println("函数 f4") }() // 带参数的匿名函数 func(name string){ fmt.Println("hello " + name) }("tom") // 带返回值的匿名函数 sum:=func(a,b int) int{ return a+b }(1,1) fmt.Println(sum) } func f1() { fmt.Println("函数 f1") }
2.3.3、回调函数
把一个函数作为另一个函数的参数：
比如：f2(f1())
其中，f2 就叫做高阶函数，f1 就叫做回调函数
func main(){ res2 := f2(1,1,f1) fmt.Println(res2) // 2 } // 高阶函数 func f2(a,b int,f1 func(int,int) int) int { return f1(a,b) } // 回调函数 func f1(a,b int) int { return a+b }
这是一个非常高级的特性， 之后我们可以对同一个对象（高阶函数的参数）进行不同的业务操作，就可以通过给高阶函数传递不同的回调函数来执行不同的业务。
2.3.4、闭包
如果一个函数包含层函数，内层函数可以操作外层函数的局部变量（当外层函数销毁，但是内存函数没有销毁，那么这个局部变量依旧存在），并且外层函数的返回值就是这个内层函数。而内层函数和外层函数的局部变量就称为闭包结构。
在闭包结构中，局部变量的生命周期会发生改变，正常的局部变量的生命周期会随着函数创建而创建，随着函数的销毁而销毁。但是闭包结构中的外层函数的局部变量并不会随着外层函数的结束而销毁，因为内层函数还在继续使用。
package main import "fmt" func main() { r1 := increament() v1 := r1() fmt.Println("r1 => ",v1) v2 := r1() fmt.Println("r1 => ",v2) r2 := increament() fmt.Println("r2 => ",r2()) fmt.Println("r2 => ",r2()) fmt.Println("r1 => ",r1()) } func increament() func() int { // 局部变量 i := 0 // 内层函数 num := func() int{ // num 是 func() int 类型 i++ return i } return num }
运行结果：
在上面，当我们把 increament 函数赋值给 r1 的时候，相当于给了 r1 它的引用地址，所以 r1 可以直接执行。但是当我们把 increament 函数赋值给 r2 的时候，按道理给的是同一个引用地址（普通函数赋值给一个函数类型变量的时候一定是同一个地址），但事实上，它会给 r1 一个新的地址值:
package main import "fmt" func main() { r:=f fmt.Printf("r地址=%p,f地址=%p\n",r,f) r1 := increament() fmt.Printf("r1地址=%p,increament地址=%p\n",r1,increament) v1 := r1() fmt.Println("r1 => ",v1) v2 := r1() fmt.Println("r1 => ",v2) r2 := increament() fmt.Printf("r2地址=%p,increament地址=%p\n",r2,increament) fmt.Println("r2 => ",r2()) fmt.Println("r2 => ",r2()) fmt.Println("r1 => ",r1()) } func increament() func() int { // 局部变量 i := 0 // 内层函数 num := func() int{ // num 是 func() int 类型 fmt.Printf("i 的地址=%p ",&i) i++ return i } return num } func f(){ fmt.Println("f") }
运行结果：
可以看到，首先，变量 r 和普通函数 f 的引用地址是完全一样的。
而 r1 和 r2 同样都是直接通过 increament 直接赋值的，但是它们和 increament 的引用地址并不相同。此外，尽管 r1 和 r2 引用地址相同，但是它俩的局部变量 i 的地址并不相同！尽管 r1 和 r2 的引用地址相同，按道理它俩操作的是一个对象（内存地址），但是事实上这个对象的局部变量地址并不相同。
总结
可以感觉到，Go 语言确实是一门简洁但是又严格的语言，它不像 Python 那种弱语言类型说来就来一个变量，什么类型都不知道。而且 Go 语言中的变量不使用就会报错、可以把不需要的值传给匿名变量抛弃掉，而且不占内存，所以也很高效。
此外，Go 同样支持函数式编程，虽然不如 Scala 的支持度高，但是性能比 Scala 是要更加高效的。
