Golang基础笔记八之函数

本文首发于公众号：Hunter后端

原文链接：Golang基础笔记八之函数

本篇笔记介绍 Golang 里函数相关的内容，以下是本篇笔记目录：

1. 函数的定义语法
2. 函数返回值
3. 可变参数函数
4. 匿名函数
5. 闭包

1、函数的定义语法

函数的定义格式如下：

func 函数名(参数列表) (返回值列表) { 函数体 }

比如下面是一个两数相加返回其和的函数：

func add(a, b int) int {
    return a + b
}

调用的话，直接传参调用即可：

sum := add(1, 4)
fmt.Println(sum)

传入的参数可以传值，也可以传指针，如果传指针的话，在函数内部修改后，会影响原值。

以下是一个传指针修改的示例：

func test(a *int, b int) {
    *a += 2
    b += 2
}
func main() {
    a := 1
    b := 1
    fmt.Printf("调用前 a:%d, b:%d\n", a, b)
    test(&a, b)
    fmt.Printf("调用后 a:%d, b:%d\n", a, b)
}

输出结果为：

调用前 a:1, b:1
调用后 a:3, b:1

2、函数返回值

函数返回值可以返回单个或多个，在函数定义的时候指定返回类型即可：

func add(a, b int) int {
    return a + b
}
func swap(a, b int) (int, int) {
    return b, a
}

还可以对返回值命名，就是在定义函数的时候，将返回值提前声明定义，然后在函数内部对其赋值，函数末尾可以省去 return 具体变量的操作。

比如下面：

func calc(a, b int) (sum, sub int) {
    sum = a + b
    sub = a - b
    return
}

3、可变参数函数

可变参数函数可以接受任意数量的参数，在函数定义的时候，类型前面加上 ... 即表示该参数是可变参数，而在函数内部，可将其作为切片使用。

下面是一个示例，可以接受任意多个元素，作为求和函数的参数：

func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

调用的时候，可以直接传入任意数量参数：

sum(1, 2, 3, 4)

也可以传入一个切片：

slice := []int{1, 2, 3}
s2 := sum(slice...)

4、匿名函数

匿名函数通常用于临时需要处理某个功能，或需要将其作为参数传递给其他变量的场景。

比如下面定义并立即调用了匿名函数：

total := func(a, b int) int {
    return a + b
}(2, 4)

也可以将其赋值给某个变量，再由该变量来调用：

sumFunc := func(a, b int) int {
    return a + b
}
sumFunc(1, 2)

5、闭包

闭包是指能够读取其他函数内部变量的函数，即使该函数已经执行完毕，其作用域内的变量也不会被销毁。

我们可以使用闭包来捕获外部函数的局部变量，并将其生命周期延长至闭包本身，比如实现一个计数器：

func counter() func() int {
    count := 0
    return func() int {
        count += 1
        return count
    }
}

counterFunc := counter()
fmt.Println(counterFunc())
fmt.Println(counterFunc())
fmt.Println(counterFunc())
fmt.Println(counterFunc())

也可以根据外部传入的参数生成不同的闭包实例，比如实现一个计算器：

func calculate(calculate_type string) func(a, b int) int {
    if calculate_type == "add" {
        return func(a, b int) int {
            return a + b
        }
    } else if calculate_type == "sub" {
        return func(a, b int) int {
            return a - b
        }
    } else {
        return func(a, b int) int { return a + b }
    }
}

addFunc := calculate("add")
fmt.Println(addFunc(10, 5))

subFunc := calculate("sub")
fmt.Println(subFunc(3, 1))

而闭包也可以维护迭代的状态，因此可以实现迭代器的功能，比如实现一个斐波那契数列生成器：

func fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        f_count := a
        a, b = b, a+b
        return f_count
    }
}

f := fibonacci()
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())
fmt.Println(f())