Go 语言入门很简单：Go 函数

函数是一段代码的片段，包含连续的执行语句，它可以将零个或多个输入参数映射到零个或多个参数输出。函数像一个黑盒，对它的使用者隐藏实现细节。还可以在代码中通过函数调用来执行它们。

学到现在，我们使用的 Go 函数只有 main 函数：

func main() {
}

函数声明

每个函数都包含 func 关键字、函数名、输入参数列表、一个可选的返回列表以及函数体

func name(parameter-list) (result-list) {
    function body
}

• func 关键字：Go 语言使用 func 关键字来声明一个函数。类似 Python 的 def 关键字。

• 函数名：紧跟 func 关键字后的事函数名称，函数名必须是一个标识符，即不能跟 Go 语言关键字冲突

• 输入参数列表（形参列表）：输入参数声明列表必须用一对小括号括起来，指定一组变量的参数名和**参数类型，**这些局部变量都由调用者提供的实参传递而来。

• 输出结果列表（返回列表）：指定了函数返回值的类型。当函数返回一个未命名的返回值或者没有返回值的时候，返回列表的圆括号可以省略。在 Go 中，一个函数可以有多个返回值。

• 函数体：函数体必须用一对大括号括起来。一对大括号和它其间的代码形成了一个显式代码块。在一个函数体内， return 关键字可以用来结束此函数的正常执行流程并进入此函数的退出阶段。

函数例子

接下来，看一个简单的 Go 整数计算器的 加、减、乘、除 函数的例子。

package main

import "fmt"

func add(num1 int, num2 int) (num3 int) {
    num3 = num1 + num2
    return
}

func subtract(num1 int, num2 int) int {

    num3 := num1 - num2
    return num3
}

func multiply(num1 int, num2 int) int {
    result := num1 * num2
    return result
}

func divide(num1 int, num2 int) (result int) {
    if num2 != 0 {
        result = num1 / num2
    } else {
        panic("division by zero")
    }
    return result
}

func main() {

    fmt.Printf("2021 + 19 = %d\n", add(2021, 19))
    fmt.Printf("2021 - 19 = %d\n", subtract(2021, 19))
    fmt.Printf("2021 * 19 = %d\n", multiply(2021, 19))
    fmt.Printf("2021 / 19 = %d\n", divide(2021, 19))
    // fmt.Printf("2021 / 0 = %d\n", divide(2021, 0))
}

结果为：

2021 + 19 = 2040
2021 - 19 = 2002
2021 * 19 = 38399
2021 / 19 = 106

如果我们除以 0 的话，调用了一个叫做 panic 的内置函数，该函数会导致一个运行时的错误。还会得到一个异常，异常也会在接下来的博客中学习到。

panic: division by zero

goroutine 1 [running]:
main.divide(...)
...

多返回值

Go 支持一个函数返回多个值：

func f() (int, int){
    return 2014, 2021
}

func main() {
    x, y := f()
}

这里需要做三个改变：

• 返回类型改变：多个返回类型用多个逗号,分隔的类型，

• 改变 return 后的表达式：使其包含多个逗号, 的表达式，

• 最后改变赋值语句，使多个值都在 := 或 = 的左边

多个返回值一般用于返回 error，例如 (x, err := f()) , 或者返回一个布尔值表示成功，如 (x, ok := f()) .

变量函数

对于Go函数中的最后一个参数，有一种特殊的形式可以使用:

func add(args ...int) int {
    total := 0
    for _, v := range args {
        total += v
    }
    return total
}

func main() {
    fmt.Println(add(1,2,3))
}

通过在最后一个参数的类型名称前使用 ... ，你可以表示它需要零个或多个这些 参数。在这种情况下，我们需要零个或多个整数。我们像其他函数一样调用该函数，而且可以传递我们想要的任何数量的变量。

这正是 fmt.Println 函数的实现方式：

func Println(a ...interface{}) (n int, err error)

Println 函数可以接受任何数量的任何类型的值。我们也可以通过在 slice 后面加上 ... 来传递一个 ints的 slice 。

func main() {
    s1 := []int{1,2,3}
    fmt.Println(add(s1...))
}

闭包

可以在函数内部创建函数。

func main() {
    add := func(x, y int) int {
        return x + y
    }
    fmt.Println(add(1,1))
}

add 是一个局部变量，其类型为 func(int, int) int（一个函数接收两个 int 参数，并返回一个 int 参数）。当你创建一个像这样的局部函数时，它还可以访问其他局部变量。

递归

最后，一个函数能够调用自己。下面是一种方法来计算一个数字的阶乘。

package main

import "fmt"

func factorial(x uint) uint {
    if x == 0 {
        return 1
    }

    return x * factorial(x-1)
}

func main() {
    fmt.Println(factorial(4))
}

闭包和递归是强大的编程技术，它构成了被称为函数式编程的范式的基础。大多数人都会发现函数式编程比以下方法更难理解:for 循环、if 语句、变量和简单函数的方法。

总结

• 声明函数需要提供函数名、形参列表和返回值列表

• 名称中首字母大写的函数和类型将被导出并为其他包所用

• 函数声明中的每个形参和返回值都由名字后跟类型组成，如果多个形参或者返回值具有相同的类型，那么类型只需要给出一次即可。

• 函数声明中的返回值也可以省略名字，而只给出类型

• 调用函数时需要根据其接受的形参给予相应的实参，至于函数的执行结果则会通过关键字 return 返回给调用者。