1 函数定义

在go语言中函数定义格式如下：

func functionName([parameter list]) [returnTypes]{
    //body
}

• 函数由func关键字进行声明。
• functionName：代表函数名。
• parameter list：代表参数列表，函数的参数是可选的，可以包含参数也可以不包含参数。
• returnTypes：返回值类型，返回值是可选的，可以有返回值，也可以没有返回值。
• body：用于写函数的具体逻辑
  例1：
  下面的函数是用于求两个数的和

package main

import "fmt"

func main() {
    result := GetSum(1, 2)

    fmt.Println("求和结果1：", result)

    result1 := GetSum1(1, 2)

    fmt.Println("求和结果2：", result1)
}

/**
* 求两个数的和
* 参数：num1，num2
 */
func GetSum(num1 int, num2 int) int {
    result := num1 + num2
    return result
}

/**
* 求两个数的和
* 参数：num1，num2(参数类型相同的时候，可以省略掉前面的类型)
 */
func GetSum1(num1, num2 int) int {
    result := num1 + num2
    return result
}

执行结果

求和结果1： 3
求和结果2： 3

2 值传递与引用传递

因为在go语言中存在值类型与引用类型，所以在函数参数进行传递时也要注意这个问题。

• 值传递是指在函数调用过程中将实参拷贝一份到函数中，这样在函数中如果对参数进行修改，将不会影响到实参。
• 引用传递是指在函数调用过程中将实参的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实参。

如果想要函数可以直接修改参数的值，那么我们可以用指针传递，将变量的地址作为参数传递到函数中。
注意：定义函数参数时--星号+参数变量类型（如：a *int ）
使用函数参数时--和字号+变量（如：&a）
例2：

package main

import "fmt"

func paramFunc(a int, b *int, c []int) {
    a = 100
    *b = 100
    c[1] = 100

    fmt.Println("paramFunc:")
    fmt.Println(a, " 变化前的值为1")
    fmt.Println(*b, " 变化前的值为1")
    fmt.Println(c, " c[1]变化前的值为2")
}

func main() {
    a := 1
    b := 1
    c := []int{1, 2, 3}
    paramFunc(a, &b, c)

    fmt.Println("main:")
    fmt.Println(a, " 变化前的值为1")
    fmt.Println(b, " 变化前的值为1")
    fmt.Println(c, " c[1]变化前的值为2")
}

执行结果

paramFunc:
100  变化前的值为1
100  变化前的值为1
[1 100 3]  c[1]变化前的值为2
main:
1  变化前的值为1
100  变化前的值为1
[1 100 3]  c[1]变化前的值为2

根据上面输出结果，可以看出a：值传递，b引用传递，c引用传递

3 变长参数

在go语言中也支持变长参数，但需要注意的是变长参数必须放在函数参数的最后一个，否则会报错。
下面这段代码演示了如何使用变长参数
例3：

package main

import "fmt"

func main() {
    slice := []int{7, 9, 3, 5, 1}
    x := min(slice...) //多个参数
    fmt.Printf("The minimum is: %d", x)

    y := min(4, 5, 3, 2, 8) //多个参数
    fmt.Printf("The minimum is: %d", y)
}

func min(s ...int) int { //...int
    if len(s) == 0 {
        return 0
    }
    fmt.Println()
    min := s[0]
    for i, v := range s { //i不使用时可以用_代替
        fmt.Println("loop ", i, v)
        if v < min {
            min = v
        }
    }
    return min
}

执行结果

loop  0 7
loop  1 9
loop  2 3
loop  3 5
loop  4 1
The minimum is: 1
loop  0 4
loop  1 5
loop  2 3
loop  3 2
loop  4 8
The minimum is: 2

4 多返回值

go语言中函数还支持一个特性那就是：多返回值。通过返回结果与一个错误值，这样可以使函数的调用者很方便的知道函数是否执行成功，这样的模式也被称为command，ok模式，在我们未来的程序设计中也推荐大家使用这种方式。下面这段代码显示了如何操作多返回值。
例4：

package main

import (
    "errors"
    "fmt"
)

func div(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("The divisor cannot be zero.")
    }
    return a / b, nil
}
func main() {
    result, err := div(1, 2)
    if err != nil {
        fmt.Printf("error: %v", err)
        return
    }
    fmt.Println("result:", result)

    //另外一种写法如下：
    if result, err := div(1, 0); err != nil {
        fmt.Printf("error: %v", err)
        return
    } else {
        fmt.Println("result:", result)
    }
}

执行结果

result: 0.5
error: The divisor cannot be zero.

注意：多返回值需要使用()进行标记。

5 命名返回值

除了上面支持的多返回值，在go语言中还可以给返回值命名，当需要返回的时候，我们只需要一条简单的不带参数的return语句。我们将上面那个除法的函数修改一下
例5：

package main

import (
    "errors"
    "fmt"
)

func div(a, b float64) (result float64, err error) { //原先样子：func div(a, b float64) (float64, error)
    if b == 0 {
        return 0, errors.New("The divisor cannot be zero.")
    }
    result = a / b
    return
}
func main() {

    //另外一种写法如下：
    if result, err := div(1, 0); err != nil {
        fmt.Printf("error: %v", err)
        return
    } else {
        fmt.Println("result:", result)
    }
}

执行结果

error: The divisor cannot be zero.

注：即使只有一个命名返回值，也需要使用()括起来。

6 匿名函数

匿名函数如其名字一样，是一个没有名字的函数，除了没有名字外其他地方与正常函数相同。匿名函数可以直接调用，保存到变量，作为参数或者返回值。
例6：

package main

import (
    "fmt"
)

func main() {
    f := func() string {
        return "hello world"
    }
    fmt.Println(f())
}

执行结果

hello world

7 闭包

闭包可以解释为一个函数与这个函数外部变量的一个封装。粗略地可以理解为一个类，类里面有变量和方法，其中闭包所包含的外部变量对应着类中的静态变量。为什么这么理解，首先让我们来看一个例子。
例7：

package main

import (
    "fmt"
    "strconv"
)

func add() func(int) int {
    n := 10
    str := "string"
    return func(x int) int {
        n = n + x
        str += strconv.Itoa(x)
        fmt.Print(str, " ")
        return n
    }
}
func main() {
    f := add()
    fmt.Println(f(1))
    fmt.Println(f(2))
    fmt.Println(f(3))

    f = add()
    fmt.Println(f(1))
    fmt.Println(f(2))
    fmt.Println(f(3))
}

执行结果

string1 11
string12 13
string123 16
string1 11
string12 13
string123 16

这就要用到我最开始的解释。闭包就是一个函数和一个函数外的变量的封装，而且这个变量就对应着类中的静态变量。 这样就可以将这个程序的输出结果解释的通了。

最开始我们先声明一个函数add，在函数体内返回一个匿名函数
其中的n,str与下面的匿名函数构成了整个的闭包，n与str就像类中的静态变量只会初始化一次，所以说尽管后面多次调用这个整体函数，里面都不会再重新初始化了
而且对于外部变量的操作是累加的，这与类中的静态变量也是一致的
在go语言学习笔记中，雨痕提到在汇编代码中，闭包返回的不仅仅是匿名函数，还包括所引用的环境变量指针，这与我们之前的解释也是类似的，闭包通过操作指针来调用对应的变量。

小问题：
尝试一下如何通过闭包来实现斐波那契数列。

package main

import (
    "fmt"
)

func fib() func(int) int {
    return func(x int) int {
        if x < 0 {
            return -1
        } else if x == 0 {
            return 0
        } else if x == 1 || x == 2 {
            return 1
        } else {
            f := fib()
            return f(x-1) + f(x-2)
        }

    }
}

func main() {
    f := fib()
    fmt.Print(f(0), " ")
    fmt.Print(f(1), " ")
    fmt.Print(f(2), " ")
    fmt.Print(f(3), " ")
    fmt.Print(f(4), " ")
    fmt.Print(f(5), " ")
    fmt.Print(f(6), " ")
    fmt.Print(f(7), " ")
    fmt.Print(f(8), " ")
    fmt.Print(f(9), " ")
    fmt.Print(f(10))

}

执行结果

0 1 1 2 3 5 8 13 21 34 55