函数

    函数声明和调用已经在前面的文章中解释过了。 当前这篇文章将介绍更多关于函数的概念和细节。

    事实上，在Go中，函数是一种一等公民类型。换句话说，我们可以把函数当作值来使用。 尽管Go是一门静态语言，但是Go函数的灵活性宛如甚至超越了很多动态语言。

    Go中有一些内置函数，这些函数展示在和unsafe标准包中。 内置函数和自定义函数有很多差别。其中一个差别是很多内置函数支持泛型参数，但自定义函数不支持（至少到Go 1.17为止）。 更多这两者之间的差异将在下面逐一提及。

    刚已经提到了，在Go中，函数是一种一等公民类型。 一个函数类型的字面表示形式由一个关键字和一个函数签名字面表示表示形式组成。 一个函数签名由一个输入参数类型列表和一个输出结果类型列表组成。 参数名称和结果名称可以出现函数签名的字面表示形式中，但是它们并不重要。

    func关键字可以出现在函数签名的字面形式中，也可以不出现。 鉴于此，我们常常混淆使用函数类型（见下）和函数签名这两个概念。

    下面是一个函数类型的字面形式:

    从前面的函数声明和调用一文中，我们了解到连续的同类型参数和结果可以声明在一块儿。 所以上面的字面形式等价于：

    1. func (a int, b, c string) (x, y int, z bool)

    参数名称和结果名称并不重要，只要它们不重名即可。上面两个字面形式等价于下面这个：

    1. func (x int, y, z string) (a, b int, c bool)

    参数名和结果名可以是空标识符_。上面的字面形式等价于：

    1. func (_ int, _, _ string) (_, _ int, _ bool)

    函数参数列表中的参数名或者结果列表中的结果名可以同时省略（即匿名）。上面的字面形式等价于：

    1. func (int, string, string) (int, int, bool) // 标准函数字面形式
    2. func (a int, b string, c string) (int, int, bool)
    3. func (x int, _ string, z string) (int, int, bool)
    4. func (int, string, string) (x int, y int, z bool)
    5. func (int, string, string) (a int, b int, _ bool)

    所有上面列出的函数类型字面形式表示同一个（非定义）函数类型。

    参数列表必须用一对小括号()括起来，即使此列表为空。 如果一个函数类型一个结果列表为空，则它可以在函数类型的字面形式中被省略掉。 当一个结果列表含有最多一个结果，则此结果列表的字面形式在它不包含结果名称的时候可以不用括号()括起来。

    变长参数和变长参数函数类型

    一个函数的最后一个参数可以是一个变长参数。一个函数可以最多有一个变长参数。一个变长参数的类型总为一个切片类型。 变长参数在声明的时候必须在它的（切片）类型的元素类型前面前置三个点...，以示这是一个变长参数。 两个变长函数类型的例子：

    1. func (values ...int64) (sum int64)
    2. func (sep string, tokens ...string) string

    一个变长函数类型和一个非变长函数类型绝对不可能是同一个类型。

    后面的一节将展示几个变长函数声明和使用的例子。

    所有的函数类型都属于不可比较类型

    因为函数类型属于不可比较类型，所以函数类型不可用做映射类型的键值类型。

    一个函数原型由一个函数名称和一个函数类型（或者说一个函数签名）组成。 它的字面形式由一个func关键字、一个函数名和一个函数签名字面形式组成。

    一个函数原型的例子：

    1. func Double(n int) (result int)

    换句话说，一个函数原型可以看作是一个不带函数体的函数声明； 或者说一个函数声明由一个函数原型和一个函数体组成。

    普通非变长函数的声明和调用已经在一文中介绍过了。 本节将介绍变长函数的声明和调用。

    变长函数声明

    变长函数声明和普通函数声明类似，只不过最后一个参数必须为变长参数。 一个变长参数在函数体内将被视为一个切片。

    1. // Sum返回所有输入实参的和。
    2. func Sum(values ...int64) (sum int64) {
    3.     // values的类型为[]int64。
    4.     sum = 0
    5.     for _, v := range values {
    6.         sum += v
    7.     }
    8.     return
    9. }
    11. // Concat是一个低效的字符串拼接函数。
    12. func Concat(sep string, tokens ...string) string {
    13.     // tokens的类型为[]string。
    14.     r := ""
    15.     for i, t := range tokens {
    16.         if i != 0 {
    17.             r += sep
    18.         }
    19.         r += t
    20.     }
    21.     return r
    22. }

    从上面的两个变长参数函数声明可以看出，如果一个变长参数的类型部分为...T，则此变长参数的类型实际为[]T。

    事实上，在前面的文章中多次使用过的fmt标准库包中的Print、Println和Printf函数均为变长参数函数。 它们的声明大致如下：

    1. func Printf(format string, a ...interface{}) (n int, err error)
    2. func Println(a ...interface{}) (n int, err error)

    这三个函数中的变长参数的类型均为[]interface{}。此类型的元素类型为interface{}，这是一个接口类型。 接口类型和接口值将在后面的一文中详述。

    变长参数函数调用

    在变长参数函数调用中，可以使用两种风格的方式将实参传递给类型为[]T的变长形参：

    1. 传递一个切片做为实参。此切片必须可以被赋值给类型为[]T的值（或者说此切片可以被隐式转换为类型[]T）。 此实参切片后必须跟随三个点。
    2. 传递零个或者多个可以被隐式转换为T的实参（或者说这些实参可以赋值给类型为T的值）。 这些实参将被添加入一个匿名的在运行时刻创建的类型为[]T的切片中，然后此切片将被传递给此函数调用。

    注意，这两种风格的方式不可在同一个变长参数函数调用中混用。

    下面这个例子展示了一些变长参数函数调用：

    另一个展示了一些变长参数函数调用的例子：

    1. package main
    3. import "fmt"
    5. func Concat(sep string, tokens ...string) (r string) {
    6.     for i, t := range tokens {
    7.         if i != 0 {
    8.             r += sep
    9.         }
    10.         r += t
    11.     }
    12.     return
    13. }
    15. func main() {
    16.     tokens := []string{"Go", "C", "Rust"}
    17.     langsA := Concat(",", tokens...)        // 风格1
    18.     langsB := Concat(",", "Go", "C","Rust") // 风格2
    19.     fmt.Println(langsA == langsB)           // true
    20. }

    下面这个例子编译不通过，因为两种调用风格混用了。

    1. package main
    3. // 这两个函数的声明见前面几例。
    4. func Sum(values ...int64) (sum int64) {......}
    5. func Concat(sep string, tokens ...string) string {......}
    7. func main() {
    8.     // 下面两行报同样的错：实参数目太多了。
    9.     _ = Sum(2, []int64{3, 5}...)
    10.     _ = Concat(",", "Go", []string{"C", "Rust"}...)
    11. }

    同一个包中可以同名的函数

    一般来说，同一个包中声明的函数的名称不能重复，但有两个例外：

    1. 同一个包内可以声明若干个原型为func ()的。
    2. 多个函数的名称可以被声明为空标识符_。这样声明的函数不可被调用。

    某些函数调用是在编译时刻被估值的

    所有的函数调用的传参均属于值复制

    在重申一次，和赋值一样，传参也属于值（浅）复制。当一个值被复制时，只有它的直接部分被复制了。

    不含函数体的函数声明

    我们可以使用Go汇编（Go assembly）来实现一个Go函数。 Go汇编代码放在后缀为.a的文件中。 一个使用Go汇编实现的函数依旧必须在一个*.go文件中声明，但是它的声明必须不能含有函数体。 换句话说，一个使用Go汇编实现的函数的声明中只含有它的原型。

    某些有返回值的函数可以不必返回

    如果一个函数有返回值，则它的函数体内的最后一条语句必须为一条终止语句。 Go中有多种终止语句，return语句只是其中一种。所以一个有返回值的函数的体内不一定需要一个return语句。 比如下面两个函数（它们均可编译通过）：

    1. func fa() int {
    2.     a:
    3.     goto a
    4. }
    6. func fb() bool {
    7.     for{}
    8. }

    自定义函数的调用返回结果可以被舍弃，但是某些内置函数的调用返回结果不可被舍弃

    自定义函数的调用结果都是可以被舍弃掉的。 但是大多数内置函数（除了recover和copy）的调用结果都是不可被舍弃的。 调用结果不可被舍弃的函数是不可以被用做延迟调用函数和协程起始函数的，比如append函数。

    有返回值的函数的调用是一种表达式

    一个有且只有一个返回值的函数的每个调用总可以被当成一个单值表达式使用。 比如，它可以被内嵌在其它函数调用中当作实参使用，或者可以被当作其它表达式中的操作数使用。

    如果一个有多个返回结果的函数的一个调用的返回结果没有被舍弃，则此调用可以当作一个多值表达式使用在两种场合：

    1. 此调用可以在一个赋值语句中当作源值来使用，但是它不能和其它源值掺和到一块。
    2. 此调用可以内嵌在另一个函数调用中当作实参来使用，但是它不能和其它实参掺和到一块。

    一个例子：

    3.     return n/2, -n
    4. }
    6. func AddSub(a, b int) (int, int) {
    7.     return a+b, a-b
    8. }
    10. func Dummy(values ...int) {}
    12. func main() {
    13.     // 这几行编译没问题。
    14.     AddSub(HalfAndNegative(6))
    15.     AddSub(AddSub(AddSub(7, 5)))
    16.     AddSub(AddSub(HalfAndNegative(6)))
    17.     Dummy(HalfAndNegative(6))
    18.     _, _ = AddSub(7, 5)
    20.     // 下面这几行编译不通过。
    21.     /*
    22.     _, _, _ = 6, AddSub(7, 5)
    23.     Dummy(AddSub(7, 5), 9)
    24.     Dummy(AddSub(7, 5), HalfAndNegative(6))
    25.     */
    26. }

    注意，在目前的标准编译器的实现中，。

    本文开头已经介绍了函数类型是Go中天然支持的一种类型。函数类型的值称为函数值。 在字面上，函数类型的零值也使用预定义的nil来表示。

    当我们声明了一个函数的时候，我们实际上同时声明了一个不可修改的函数值。 此函数值用此函数的名称来标识。此函数值的类型的字面表示形式为此函数的原型刨去函数名部分。

    注意：内置函数和init函数不可被用做函数值。

    任何函数值都可以被当作普通声明函数来调用。 调用一个nil函数来开启一个协程将产生一个致命的不可恢复的错误，此错误将使整个程序崩溃。 在其它情况下调用一个nil函数将产生一个可恢复的恐慌。

    从一文，我们得知，当一个函数值被赋给另一个函数值后，这两个函数值将共享底层部分（内部的函数结构）。 换句话说，这两个函数值表示的函数可以看作是同一个函数。调用它们的效果是相同的。

    一个例子：

    在上例中，g(6, Double)和Apply(6, f)是等价的。

    1. package main
    3. import "fmt"
    5. func main() {
    6.     // 此函数返回一个函数类型的结果，亦即闭包（closure）。
    7.     isMultipleOfX := func (x int) func(int) bool {
    8.         return func(n int) bool {
    9.             return n%x == 0
    10.         }
    11.     }
    13.     var isMultipleOf3 = isMultipleOfX(3)
    14.     var isMultipleOf5 = isMultipleOfX(5)
    15.     fmt.Println(isMultipleOf3(6))  // true
    16.     fmt.Println(isMultipleOf3(8))  // false
    17.     fmt.Println(isMultipleOf5(10)) // true
    18.     fmt.Println(isMultipleOf5(12)) // false
    20.     isMultipleOf15 := func(n int) bool {
    21.         return isMultipleOf3(n) && isMultipleOf5(n)
    22.     }
    23.     fmt.Println(isMultipleOf15(32)) // false
    24.     fmt.Println(isMultipleOf15(60)) // true

    Go中所有的函数都可以看作是闭包，这是Go函数如此灵活及使用体验如此统一的原因。