Golang基础笔记八之函数

本文首发于公众号：Hunter后端
原文链接：Golang基础笔记八之函数

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

• 函数的定义语法
  
• 函数返回值
  
• 可变参数函数
  
• 匿名函数
  
• 闭包
  

1、函数的定义语法

函数的定义格式如下：

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

复制代码

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

1. func add(a, b int) int {
2.     return a + b
3. }

复制代码

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

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

复制代码

传入的参数可以传值，也可以传指针，如果传指针的话，在函数内部修改后，会影响原值。
以下是一个传指针修改的示例：

1. func test(a *int, b int) {
2.     *a += 2
3.     b += 2
4. }
5. func main() {
6.     a := 1
7.     b := 1
8.     fmt.Printf("调用前 a:%d, b:%d\n", a, b)
9.     test(&a, b)
10.     fmt.Printf("调用后 a:%d, b:%d\n", a, b)
11. }

复制代码

输出结果为：

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

复制代码

2、函数返回值

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

1. func add(a, b int) int {
2.     return a + b
3. }func swap(a, b int) (int, int) {    return b, a}

复制代码

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

1. func calc(a, b int) (sum, sub int) {
2.     sum = a + b
3.     sub = a - b
4.     return
5. }

复制代码

3、可变参数函数

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

1. func sum(nums ...int) int {
2.     total := 0
3.     for _, num := range nums {
4.         total += num
5.     }
6.     return total
7. }

复制代码

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

1. sum(1, 2, 3, 4)

复制代码

也可以传入一个切片：

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

复制代码

4、匿名函数

匿名函数通常用于临时需要处理某个功能，或需要将其作为参数传递给其他变量的场景。
比如下面定义并立即调用了匿名函数：

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

复制代码

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

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

复制代码

5、闭包

闭包是指能够读取其他函数内部变量的函数，即使该函数已经执行完毕，其作用域内的变量也不会被销毁。
我们可以使用闭包来捕获外部函数的局部变量，并将其生命周期延长至闭包本身，比如实现一个计数器：

1. func counter() func() int {
2.     count := 0
3.     return func() int {
4.         count += 1
5.         return count
6.     }
7. }
9. counterFunc := counter()
10. fmt.Println(counterFunc())
11. fmt.Println(counterFunc())
12. fmt.Println(counterFunc())
13. fmt.Println(counterFunc())

复制代码

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

1. func calculate(calculate_type string) func(a, b int) int {
2.     if calculate_type == "add" {
3.         return func(a, b int) int {
4.             return a + b
5.         }
6.     } else if calculate_type == "sub" {
7.         return func(a, b int) int {
8.             return a - b
9.         }
10.     } else {
11.         return func(a, b int) int { return a + b }
12.     }
13. }
16. addFunc := calculate("add")
17. fmt.Println(addFunc(10, 5))
19. subFunc := calculate("sub")
20. fmt.Println(subFunc(3, 1))

复制代码

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

1. func fibonacci() func() int {
2.     a, b := 0, 1
3.     return func() int {
4.         f_count := a
5.         a, b = b, a+b
6.         return f_count
7.     }
8. }
10. f := fibonacci()
11. fmt.Println(f())
12. fmt.Println(f())
13. fmt.Println(f())
14. fmt.Println(f())
15. fmt.Println(f())
16. fmt.Println(f())

复制代码

来源：豆瓜网用户自行投稿发布，如果侵权，请联系站长删除