函数

按值传递（call by value） 按引用传递（call by reference）

Go 默认使用按值传递来传递参数，也就是传递参数的副本。函数接收参数副本之后，在使用变量的过程中可能对副本的值进行更改，但不会影响到原来的变量。如果你希望函数可以直接修改参数的值，而不是对参数的副本进行操作，你需要将参数的地址（变量名前面添加 & 符号，比如 &variable）传递给函数，这就是按引用传递，如果传递给函数的是一个指针，指针的值（一个地址）会被复制，但指针的值所指向的地址上的值不会被复制；我们可以通过这个指针的值来修改这个值所指向的地址上的值。（译者注：指针也是变量类型，有自己的地址和值，通常指针的值指向一个变量的地址。所以，按引用传递也是按值传递。）

命名的返回值（named return variables）

命名返回值作为结果形参（result parameters）被初始化为相应类型的零值，当需要返回的时候，我们只需要一条简单的不带参数的 return 语句。需要注意的是，即使只有一个命名返回值，也需要使用 () 括起来

package main
​
import "fmt"
​
var num int = 10
var numx2, numx3 int
​
func main() {numx2, numx3 = getX2AndX3(num)PrintValues()numx2, numx3 = getX2AndX3_2(num)PrintValues()
}
​
func PrintValues() {fmt.Printf("num = %d, 2x num = %d, 3x num = %d\n", num, numx2, numx3)
}
​
func getX2AndX3(input int) (int, int) {return 2 * input, 3 * input
}
​
func getX2AndX3_2(input int) (x2 int, x3 int) {x2 = 2 * inputx3 = 3 * input// return x2, x3return
}

改变外部变量（outside variable）

传递指针给函数不但可以节省内存（因为没有复制变量的值），而且赋予了函数直接修改外部变量的能力，所以被修改的变量不再需要使用 return 返回

package main
​
import ("fmt"
)
​
// this function changes reply:
func Multiply(a, b int, reply *int) {*reply = a * b
}
​
func main() {n := 0reply := &nMultiply(10, 5, reply)fmt.Println("Multiply:", *reply) // Multiply: 50
}

传递变长参数

如果函数的最后一个参数是采用 ...type 的形式，那么这个函数就可以处理一个变长的参数，这个长度可以为 0，这样的函数称为变长函数。

func myFunc(a, b, arg ...int) {}

defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

关键字 defer 允许我们推迟到函数返回之前（或任意位置执行 return 语句之后）一刻才执行某个语句或函数（为什么要在返回之后才执行这些语句？因为 return 语句同样可以包含一些操作，而不是单纯地返回某个值）。 (译者注：return 是非原子性的，需要两步，执行前首先要得到返回值 (为返回值赋值)，return 将返回值返回调用处。 defer 和 return 的执行顺序是先为返回值赋值，然后执行 defer，然后 return 到函数调用处。)

package main
​
import "fmt"
​
func main() {defer fmt.Println("world")
​fmt.Println("hello")
}

defer 栈

当有多个 defer 行为被注册时，它们会以逆序执行。推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

package main
​
import "fmt"
​
func main() {fmt.Println("counting")
​for i := 0; i < 10; i++ {defer fmt.Println(i)}
​fmt.Println("done")
}

关键字 defer 的用法类似于面向对象编程语言 Java 和 C# 的 finally 语句块，它一般用于释放某些已分配的资源。

使用 defer 语句实现代码追踪

一个基础但十分实用的实现代码执行追踪的方案就是在进入和离开某个函数打印相关的消息，如下：

package main
​
import "fmt"
​
func trace(s string)   { fmt.Println("entering:", s) }
func untrace(s string) { fmt.Println("leaving:", s) }
​
func a() {trace("a")defer untrace("a")fmt.Println("in a")
}
​
func b() {trace("b")defer untrace("b")fmt.Println("in b")a()
}
​
func main() {b()
}

内置函数

Go 语言拥有一些不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作，例如：len、cap 和 append，或必须用于系统级的操作，例如：panic。因此，它们需要直接获得编译器的支持。

递归函数

将函数作为参数

函数可以作为其它函数的参数进行传递，然后在其它函数内调用执行，一般称之为回调。

例如：

package main
​
import ("fmt"
)
​
func main() {callback(1, Add)
}
​
func Add(a, b int) {fmt.Printf("The sum of %d and %d is: %d\n", a, b, a+b)
}
​
func callback(y int, f func(int, int)) {f(y, 2) // this becomes Add(1, 2)
}

闭包

当我们不希望给函数起名字的时候，可以使用匿名函数，例如：func(x, y int) int { return x + y }。

这样的一个函数不能够独立存在，但可以被赋值于某个变量，即保存函数的地址到变量中：

fplus := func(x, y int) int { return x + y }

，然后通过变量名对函数进行调用：fplus(3,4)。当然，您也可以直接对匿名函数进行调用：

func(x, y int) int { return x + y } (3, 4)

注意：

package main
​
import "fmt"
​
func f() (ret int) {defer func() {ret++}()return 1
}
func main() {fmt.Println(f())
}

这段代码返回2，因为return先取值然后指向defer，最后返回。

学习参考资料：

《Go 入门指南》 | Go 技术论坛 (learnku.com)

Go 语言之旅