Go 函数

函数是一组语句，可以在程序中重复使用。函数不会在页面加载时自动执行。函数将通过调用函数来执行。
创建函数

要创建（通常称为声明）一个函数，请执行以下操作：

• 使用 func 关键字。
  
• 指定函数的名称，后跟括号 ()。
  
• 最后，在花括号 {} 内添加定义函数应执行的代码。
  

语法

1. func 函数名() {
2.    // 要执行的代码
3. }

复制代码

调用函数

函数不会立即执行。它们被“保存以供以后使用”，并在调用时执行。
在下面的示例中，我们创建了一个名为 "myMessage()" 的函数。开括号 { 表示函数代码的开始，闭括号 } 表示函数的结束。该函数输出 "I just got executed!"。要调用函数，只需写下函数的名称，后面跟着两个括号 ()：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myMessage() {
8.    fmt.Println("I just got executed!")
9. }
11. func main() {
12.    myMessage() // 调用函数
13. }

复制代码

结果：

1. I just got executed!

复制代码

一个函数可以被多次调用。
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myMessage() {
8.    fmt.Println("I just got executed!")
9. }
11. func main() {
12.    myMessage()
13.    myMessage()
14.    myMessage()
15. }

复制代码

结果：

1. I just got executed!
2. I just got executed!
3. I just got executed!

复制代码

Go函数命名规则

• 函数名必须以字母开头。
  
• 函数名只能包含字母数字字符和下划线（A-z，0-9 和 _）。
  
• 函数名区分大小写。
  
• 函数名不能包含空格。
  
• 如果函数名由多个单词组成，可以使用多词变量命名的技巧。
  

参数和参数值

信息可以作为参数传递给函数。参数在函数内部充当变量。
在函数名后面，括号内指定参数及其类型。您可以添加任意数量的参数，只需用逗号分隔即可：
语法

1. func 函数名(参数1 类型, 参数2 类型, 参数3 类型) {
2.   // 要执行的代码
3. }

复制代码

带参数的函数示例

下面的示例有一个带有一个参数 fname（类型为字符串）的函数。当调用 familyName() 函数时，我们还传递了一个名字（例如，Liam），并且这个名字在函数内部使用，输出多个不同的名字，但相同的姓氏：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func familyName(fname string) {
8.    fmt.Println("Hello", fname, "Refsnes")
9. }
11. func main() {
12.    familyName("Liam")
13.    familyName("Jenny")
14.    familyName("Anja")
15. }

复制代码

结果：

1. Hello Liam Refsnes
2. Hello Jenny Refsnes
3. Hello Anja Refsnes

复制代码

注意：当将参数传递给函数时，它被称为参数。因此，从上面的示例中可以看出：fname 是参数，而Liam、Jenny 和 Anja 是参数值。
多个参数

在函数内部，您可以添加任意数量的参数：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func familyName(fname string, age int) {
8.    fmt.Println("Hello", age, "岁的", fname, "Refsnes")
9. }
11. func main() {
12.    familyName("Liam", 3)
13.    familyName("Jenny", 14)
14.    familyName("Anja", 30)
15. }

复制代码

结果：

1. Hello 3 岁的 Liam Refsnes
2. Hello 14 岁的 Jenny Refsnes
3. Hello 30 岁的 Anja Refsnes

复制代码

希望这些信息能帮助您理解Go语言中的函数、参数和参数值的使用方式。如果您有任何其他问题，请随时提出。
返回值

如果您想让函数返回一个值，您需要定义返回值的数据类型（如int、string等），并在函数内部使用return关键字：
语法

1. func 函数名(参数1 类型, 参数2 类型) 类型 {
2.    // 要执行的代码
3.    return 输出
4. }

复制代码

函数返回示例

在下面的示例中，myFunction() 接收两个整数（x 和 y），并返回它们的加法（x + y）作为整数（int）：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y int) int {
8.    return x + y
9. }
11. func main() {
12.    fmt.Println(myFunction(1, 2))
13. }

复制代码

结果：

1. 3

复制代码

命名返回值

在Go中，您可以为函数的返回值命名。
在这里，我们将返回值命名为 result（类型为int），并使用“裸露”的返回（即，我们使用return语句而不指定变量名）返回值：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y int) (result int) {
8.    result = x + y
9.    return
10. }
12. func main() {
13.    fmt.Println(myFunction(1, 2))
14. }

复制代码

结果：

1. 3

复制代码

上面的示例也可以像这样写。在这里，return语句指定了变量名：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y int) (result int) {
8.    result = x + y
9.    return result
10. }
12. func main() {
13.    fmt.Println(myFunction(1, 2))
14. }

复制代码

将返回值存储在变量中

您也可以将返回值存储在变量中，像这样：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y int) (result int) {
8.    result = x + y
9.    return
10. }
12. func main() {
13.    total := myFunction(1, 2)
14.    fmt.Println(total)
15. }

复制代码

多个返回值

Go函数也可以返回多个值。
在这里，myFunction() 返回一个整数（result）和一个字符串（txt1）：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y string) (result int, txt1 string) {
8.    result = x + x
9.    txt1 = y + " World!"
10.    return
11. }
13. func main() {
14.    fmt.Println(myFunction(5, "Hello"))
15. }

复制代码

结果：

1. 10 Hello World!

复制代码

在这里，我们将两个返回值存储在两个变量（a 和 b）中：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y string) (result int, txt1 string) {
8.    result = x + x
9.    txt1 = y + " World!"
10.    return
11. }
13. func main() {
14.    a, b := myFunction(5, "Hello")
15.    fmt.Println(a, b)
16. }

复制代码

结果：

1. 10 Hello World!

复制代码

如果由于某种原因不想使用其中一些返回的值，可以添加下划线（_）来省略这个值。
在这里，我们要省略第一个返回的值（result - 存储在变量a中）：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y string) (result int, txt1 string) {
8.    result = x + x
9.    txt1 = y + " World!"
10.    return
11. }
13. func main() {
14.    _, b := myFunction(5, "Hello")
15.    fmt.Println(b)
16. }

复制代码

结果：

1. Hello World!

复制代码

在这里，我们要省略第二个返回的值（txt1 - 存储在变量b中）：
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func myFunction(x int, y string) (result int, txt1 string) {
8.    result = x + x
9.    txt1 = y + " World!"
10.    return
11. }
13. func main() {
14.    a, _ := myFunction(5, "Hello")
15.    fmt.Println(a)
16. }

复制代码

递归函数

Go接受递归函数。如果一个函数调用自己并达到一个停止条件，那么这个函数就是递归的。
在以下示例中，testcount() 是一个调用自己的函数。我们使用x变量作为数据，每次递归时都会增加1（x + 1）。当x变量等于11（x == 11）时，递归结束。
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func testcount(x int) int {
8.    if x == 11 {
9.       return 0
10.    }
11.    fmt.Println(x)
12.    return testcount(x + 1)
13. }
15. func main() {
16.    testcount(1)
17. }

复制代码

结果：

1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10

复制代码

递归是一个常见的数学和编程概念。这有利于意味着您可以循环遍历数据以达到一个结果。
开发人员应谨慎使用递归函数，因为很容易陷入编写永远不会终止的函数，或者使用过多的内存或处理器资源的函数。但是，当正确编写时，递归可以是一种非常有效和数学上优雅的编程方法。
在以下示例中，factorial_recursion() 是一个调用自己的函数。我们使用x变量作为数据，每次递归时都会减小1（x - 1）。当条件不大于0时（即当它等于0时），递归结束。
示例

1. package main
3. import (
4.    "fmt"
5. )
7. func factorial_recursion(x float64) (y float64) {
8.    if x > 0 {
9.       y = x * factorial_recursion(x - 1)
10.    }
12. else {
13.       y = 1
14.    }
15.    return
16. }
18. func main() {
19.    fmt.Println(factorial_recursion(4))
20. }

复制代码

结果：

1. 24

复制代码

希望这些信息对您有所帮助，帮助您理解Go语言中的返回值和递归函数的使用方式。如果您有任何其他问题，请随时提出。
最后

为了方便其他设备和平台的小伙伴观看往期文章，链接奉上：
公众号搜索Let us Coding，知乎，开源中国，CSDN，思否，掘金，InfoQ，简书，博客园，慕课，51CTO，helloworld，腾讯开发者社区，阿里开发者社区
看完如果觉得有帮助，欢迎点赞、收藏和关注

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！