《Go语言四十二章经》第十六章 函数

作者：李骁

16.1 函数分类

Go 里面有三种类型的函数：

  • 普通的带有名字的函数
  • 匿名函数或者lambda函数
  • 方法（Methods）

除了main()、init()函数外，其它所有类型的函数都可以有参数与返回值。

函数参数、返回值以及它们的类型被统称为函数签名。

函数重载（function overloading）指的是可以编写多个同名函数，只要它们拥有不同的形参或者不同的返回值，在 Go 里面函数重载是不被允许的。

如果需要申明一个在外部定义的函数，你只需要给出函数名与函数签名，不需要给出函数体：

  1. func flushICache(begin, end uintptr)

函数也可以以申明的方式被使用，作为一个函数类型，就像：

  1. type binOp func(int, int) int

在这里，不需要函数体 {}。

函数是一等值（first-class value）：它们可以赋值给变量，就像下面一样：

  1. add := binOp

这个变量知道自己指向的函数的签名，所以给它赋一个具有不同签名的函数值是不可能的。

函数值（functions value）之间可以相互比较：如果它们引用的是相同的函数或者都是 nil 的话，则认为它们是相同的函数。函数不能在其它函数里面声明（不能嵌套），不过我们可以通过使用匿名函数来破除这个限制。

没有参数的函数通常被称为 无参数函数（niladic function），就像 main.main()

16.2 函数调用

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

Go 默认使用按值传递来传递参数，也就是传递参数的副本。函数接收参数副本之后，在使用变量的过程中可能对副本的值进行更改，但不会影响到原来的变量，比如 Function(arg1)。

如果你希望函数可以直接修改参数的值，而不是对参数的副本进行操作，你需要将参数的地址（变量名前面添加&符号，比如 &variable）传递给函数，这就是按引用传递，比如 Function(&arg1)，此时传递给函数的是一个指针。如果传递给函数的是一个指针，指针的值（一个地址）会被复制，但指针的值所指向的地址上的值不会被复制；我们可以通过这个指针的值来修改这个值所指向的地址上的值。

在函数调用时，像切片（slice）、字典（map）、接口（interface）、通道（channel）这样的引用类型都是默认使用引用传递（即使没有显式的指出指针）

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

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

这个函数接受一个类似某个类型的 slice 的参数，该参数可以通过 for 循环结构迭代。

  1. func min(s ...int) int {
  2.     if len(s)==0 {
  3.         return 0
  4.     }
  5.     min := s[0]
  6.     for _, v := range s {
  7.         if v < min {
  8.             min = v
  9.         }
  10.     }
  11.     return min
  12. }

16.3 内置函数

Go 语言拥有一些不需要进行导入操作就可以使用的内置函数。它们有时可以针对不同的类型进行操作：

名称 说明
close 用于通道通信
len、cap len 用于返回某个类型的长度或数量（字符串、数组、切片、map 和通道）；cap 是容量的意思，用于返回某个类型的最大容量（只能用于切片和 map）
new、make new 和 make 均是用于分配内存：new 用于值类型和用户定义的类型，如自定义结构，make 用于内置引用类型（切片、map 和通道）。它们的用法就像是函数，但是将类型作为参数：new(type)、make(type)。new(T) 分配类型 T 的零值并返回其地址，也就是指向类型 T 的指针。它也可以被用于基本类型：v := new(int)。make(T) 返回类型 T 的初始化之后的值，因此它比 new 进行更多的工作。 new() 是一个函数，不要忘记它的括号。二者都是内存的分配（堆上），但是make只用于slice、map以及channel的初始化（非零值）；而new用于类型的内存分配，并且内存置为零。
copy、append 用于复制和连接切片
panic、recover 两者均用于错误处理机制

16.4 递归与回调

使用递归函数时经常会遇到的一个重要问题就是栈溢出：一般出现在大量的递归调用导致的程序栈内存分配耗尽。这个问题可以通过一个名为懒惰求值的技术解决，在 Go 语言中，我们可以使用通道（channel）和 goroutine。

Go 语言中也可以使用相互调用的递归函数：多个函数之间相互调用形成闭环。因为 Go 语言编译器的特殊性，这些函数的声明顺序可以是任意的。

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

  1. package main
  2. import (
  3.     "fmt"
  4. )
  5. func main() {
  6.     callback(1, Add)
  7. }
  8. func Add(a, b int) {
  9.     fmt.Printf("The sum of %d and %d is: %d\n", a, b, a+b)
  10. }
  11. func callback(y int, f func(int, int)) {
  12.     f(y, 2) // 实际上是 Add(1, 2)
  13. }

16.5 匿名函数

当我们不希望给函数起名字的时候，可以使用匿名函数，例如：

  1. func(x, y int) int { return x + y }

这样的一个函数不能够独立存在（编译器会返回错误：non-declaration statement outside function body），但可以被赋值于某个变量，即保存函数的地址到变量中：fplus := func(x, y int) int { return x + y }，然后通过变量名对函数进行调用：fplus(3, 4)。

当然，也可以直接对匿名函数进行调用：

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

下面是一个计算从 1 到 1 百万整数的总和的匿名函数：

  1. func() {
  2.     sum := 0
  3.     for i := 1; i <= 1e6; i++ {
  4.         sum += i
  5.     }
  6. }()

表示参数列表的第一对括号必须紧挨着关键字 func，因为匿名函数没有名称。花括号 {} 涵盖着函数体，最后的一对括号表示对该匿名函数的调用。

16.6 闭包函数

匿名函数同样被称之为闭包（函数式语言的术语）：它们被允许调用定义在其它环境下的变量。闭包可使得某个函数捕捉到一些外部状态，例如：函数被创建时的状态。另一种表示方式为：一个闭包继承了函数所声明时的作用域。这种状态（作用域内的变量）都被共享到闭包的环境中，因此这些变量可以在闭包中被操作，直到被销毁。闭包经常被用作包装函数：它们会预先定义好 1 个或多个参数以用于包装。另一个不错的应用就是使用闭包来完成更加简洁的错误检查。

仅仅从形式上将闭包简单理解为匿名函数是不够的，还需要理解闭包实质上的含义。

实质上看，闭包是由函数及其相关引用环境组合而成的实体(即：闭包=函数+引用环境)。闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例。由闭包的实质含义，我们可以推论：闭包获取捕获变量相当于引用传递，而非值传递；对于闭包函数捕获的常量和变量，无论闭包何时何处被调用，闭包都可以使用这些常量和变量，而不用关心它们表面上的作用域。

应用闭包：将函数作为返回值，我们用一个例子来进行验证。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func addNumber(x int) func(int) {
  8.     fmt.Printf("x: %d, addr of x:%p\n", x, &x)
  9.     return func(y int) {
  10.         k := x + y
  11.         x = k
  12.         y = k
  13.         fmt.Printf("x: %d, addr of x:%p\n", x, &x)
  14.         fmt.Printf("y: %d, addr of y:%p\n", y, &y)
  15.     }
  16. }
  18. func main() {
  19.     addNum := addNumber(5)
  20.     addNum(1)
  21.     addNum(1)
  22.     addNum(1)
  24.     fmt.Println("---------------------")
  26.     addNum1 := addNumber(5)
  27.     addNum1(1)
  28.     addNum1(1)
  29.     addNum1(1)
  30. }
  1. 程序输出：
  2. x: 5, addr of x:0xc042054080
  3. x: 6, addr of x:0xc042054080
  4. y: 6, addr of y:0xc042054098
  5. x: 7, addr of x:0xc042054080
  6. y: 7, addr of y:0xc0420540d0
  7. x: 8, addr of x:0xc042054080
  8. y: 8, addr of y:0xc0420540e8
  9. ---------------------
  10. x: 5, addr of x:0xc042054100
  11. x: 6, addr of x:0xc042054100
  12. y: 6, addr of y:0xc042054110
  13. x: 7, addr of x:0xc042054100
  14. y: 7, addr of y:0xc042054128
  15. x: 8, addr of x:0xc042054100
  16. y: 8, addr of y:0xc042054140

首先强调一点，x是闭包中被捕获的变量，y只是闭包内部的局部变量，而非被捕获的变量。因此，对于每一次引用，x的地址都是固定的，是同一个引用变量；y的地址则是变化的。另外，闭包被引用了两次，由此产生了两个闭包实例，即addNum := addNumber(5)和addNum1 :=addNumber(5)是两个不同实例，其中引用的两个x变量也来自两个不同的实例。

16.7 使用闭包调试

当您在分析和调试复杂的程序时，无数个函数在不同的代码文件中相互调用，如果这时候能够准确地知道哪个文件中的具体哪个函数正在执行，对于调试是十分有帮助的。您可以使用 runtime 或 log 包中的特殊函数来实现这样的功能。包 runtime 中的函数 Caller() 提供了相应的信息，因此可以在需要的时候实现一个 where() 闭包函数来打印函数执行的位置：

  1. where := func() {
  2.     _, file, line, _ := runtime.Caller(1)
  3.     log.Printf("%s:%d", file, line)
  4. }
  5. where()
  6. // some code
  7. where()
  8. // some more code
  9. where()

或使用一个更加简短版本的 where 函数：

  1. var where = log.Print
  2. func func1() {
  3. where()
  4. ... some code
  5. where()
  6. ... some code
  7. where()
  8. }

16.8 高阶函数

在定义所需功能时我们可以利用函数可以作为（其它函数的）参数的事实来使用高阶函数

定义一个通用的 Process() 函数，它接收一个作用于每一辆 car 的 f 函数作参数：

  1. // Process all cars with the given function f:
  2. func (cs Cars) Process(f func(car *Car)) {
  3.     for _, c := range cs {
  4.         f(c)
  5.     }
  6. }