共计 4028 个字符,预计需要花费 11 分钟才能阅读完成。
函数是一组语句,能够在程序中重复使用。函数不会在页面加载时主动执行。函数将通过调用函数来执行。
创立函数
要创立(通常称为申明)一个函数,请执行以下操作:
- 应用
func
关键字。 - 指定函数的名称,后跟括号
()
。 - 最初,在花括号
{}
内增加定义函数应执行的代码。
语法
func 函数名() {// 要执行的代码}
调用函数
函数不会立刻执行。它们被“保留以供当前应用”,并在调用时执行。
在上面的示例中,咱们创立了一个名为 “myMessage()” 的函数。开括号 {
示意函数代码的开始,闭括号 }
示意函数的完结。该函数输入 “I just got executed!”。要调用函数,只需写下函数的名称,前面跟着两个括号 ()
:
示例
package main
import ("fmt")
func myMessage() {fmt.Println("I just got executed!")
}
func main() {myMessage() // 调用函数
}
后果:
I just got executed!
一个函数能够被屡次调用。
示例
package main
import ("fmt")
func myMessage() {fmt.Println("I just got executed!")
}
func main() {myMessage()
myMessage()
myMessage()}
后果:
I just got executed!
I just got executed!
I just got executed!
Go 函数命名规定
- 函数名必须以字母结尾。
- 函数名只能蕴含字母数字字符和下划线(A-z,0-9 和 _)。
- 函数名辨别大小写。
- 函数名不能蕴含空格。
- 如果函数名由多个单词组成,能够应用多词变量命名的技巧。
参数和参数值
信息能够作为参数传递给函数。参数在函数外部充当变量。
在函数名前面,括号内指定参数及其类型。您能够增加任意数量的参数,只需用逗号分隔即可:
语法
func 函数名(参数 1 类型, 参数 2 类型, 参数 3 类型) {// 要执行的代码}
带参数的函数示例
上面的示例有一个带有一个参数 fname
(类型为字符串)的函数。当调用 familyName()
函数时,咱们还传递了一个名字(例如,Liam),并且这个名字在函数外部应用,输入多个不同的名字,但雷同的姓氏:
示例
package main
import ("fmt")
func familyName(fname string) {fmt.Println("Hello", fname, "Refsnes")
}
func main() {familyName("Liam")
familyName("Jenny")
familyName("Anja")
}
后果:
Hello Liam Refsnes
Hello Jenny Refsnes
Hello Anja Refsnes
留神:当将参数传递给函数时,它被称为参数。因而,从下面的示例中能够看出:fname
是参数,而 Liam、Jenny 和 Anja 是参数值。
多个参数
在函数外部,您能够增加任意数量的参数:
示例
package main
import ("fmt")
func familyName(fname string, age int) {fmt.Println("Hello", age, "岁的", fname, "Refsnes")
}
func main() {familyName("Liam", 3)
familyName("Jenny", 14)
familyName("Anja", 30)
}
后果:
Hello 3 岁的 Liam Refsnes
Hello 14 岁的 Jenny Refsnes
Hello 30 岁的 Anja Refsnes
心愿这些信息能帮忙您了解 Go 语言中的函数、参数和参数值的应用形式。如果您有任何其余问题,请随时提出。
返回值
如果您想让函数返回一个值,您须要定义返回值的数据类型(如 int、string 等),并在函数外部应用 return 关键字:
语法
func 函数名(参数 1 类型, 参数 2 类型) 类型 {
// 要执行的代码
return 输入
}
函数返回示例
在上面的示例中,myFunction()
接管两个整数(x 和 y),并返回它们的加法(x + y)作为整数(int):
示例
package main
import ("fmt")
func myFunction(x int, y int) int {return x + y}
func main() {fmt.Println(myFunction(1, 2))
}
后果:
3
命名返回值
在 Go 中,您能够为函数的返回值命名。
在这里,咱们将返回值命名为 result
(类型为 int),并应用“袒露”的返回(即,咱们应用 return 语句而不指定变量名)返回值:
示例
package main
import ("fmt")
func myFunction(x int, y int) (result int) {
result = x + y
return
}
func main() {fmt.Println(myFunction(1, 2))
}
后果:
3
下面的示例也能够像这样写。在这里,return 语句指定了变量名:
示例
package main
import ("fmt")
func myFunction(x int, y int) (result int) {
result = x + y
return result
}
func main() {fmt.Println(myFunction(1, 2))
}
将返回值存储在变量中
您也能够将返回值存储在变量中,像这样:
示例
package main
import ("fmt")
func myFunction(x int, y int) (result int) {
result = x + y
return
}
func main() {total := myFunction(1, 2)
fmt.Println(total)
}
多个返回值
Go 函数也能够返回多个值。
在这里,myFunction()
返回一个整数(result)和一个字符串(txt1):
示例
package main
import ("fmt")
func myFunction(x int, y string) (result int, txt1 string) {
result = x + x
txt1 = y + "World!"
return
}
func main() {fmt.Println(myFunction(5, "Hello"))
}
后果:
10 Hello World!
在这里,咱们将两个返回值存储在两个变量(a 和 b)中:
示例
package main
import ("fmt")
func myFunction(x int, y string) (result int, txt1 string) {
result = x + x
txt1 = y + "World!"
return
}
func main() {a, b := myFunction(5, "Hello")
fmt.Println(a, b)
}
后果:
10 Hello World!
如果因为某种原因不想应用其中一些返回的值,能够增加下划线(_)来省略这个值。
在这里,咱们要省略第一个返回的值(result – 存储在变量 a 中):
示例
package main
import ("fmt")
func myFunction(x int, y string) (result int, txt1 string) {
result = x + x
txt1 = y + "World!"
return
}
func main() {_, b := myFunction(5, "Hello")
fmt.Println(b)
}
后果:
Hello World!
在这里,咱们要省略第二个返回的值(txt1 – 存储在变量 b 中):
示例
package main
import ("fmt")
func myFunction(x int, y string) (result int, txt1 string) {
result = x + x
txt1 = y + "World!"
return
}
func main() {a, _ := myFunction(5, "Hello")
fmt.Println(a)
}
递归函数
Go 承受递归函数。如果一个函数调用本人并达到一个进行条件,那么这个函数就是递归的。
在以下示例中,testcount()
是一个调用本人的函数。咱们应用 x 变量作为数据,每次递归时都会减少 1(x + 1)。当 x 变量等于 11(x == 11)时,递归完结。
示例
package main
import ("fmt")
func testcount(x int) int {
if x == 11 {return 0}
fmt.Println(x)
return testcount(x + 1)
}
func main() {testcount(1)
}
后果:
1
2
3
4
5
6
7
8
9
10
递归是一个常见的数学和编程概念。这有利于意味着您能够循环遍历数据以达到一个后果。
开发人员应审慎应用递归函数,因为很容易陷入编写永远不会终止的函数,或者应用过多的内存或处理器资源的函数。然而,当正确编写时,递归能够是一种十分无效和数学上优雅的编程办法。
在以下示例中,factorial_recursion()
是一个调用本人的函数。咱们应用 x 变量作为数据,每次递归时都会减小 1(x – 1)。当条件不大于 0 时(即当它等于 0 时),递归完结。
示例
package main
import ("fmt")
func factorial_recursion(x float64) (y float64) {
if x > 0 {y = x * factorial_recursion(x - 1)
}
else {y = 1}
return
}
func main() {fmt.Println(factorial_recursion(4))
}
后果:
24
心愿这些信息对您有所帮忙,帮忙您了解 Go 语言中的返回值和递归函数的应用形式。如果您有任何其余问题,请随时提出。
最初
为了不便其余设施和平台的小伙伴观看往期文章,链接奉上:
公众号搜寻 Let us Coding
, 知乎 , 开源中国 ,CSDN, 思否 , 掘金 ,InfoQ, 简书 , 博客园 , 慕课 ,51CTO,helloworld, 腾讯开发者社区 , 阿里开发者社区
看完如果感觉有帮忙,欢送 点赞、珍藏 和关注