【入门】Go语言函数详解
目录
一、函数介绍
1.1 函数介绍
- 函数是基本的代码块，完成某一功能的程序指令(语句)集合，用于执行一个任务。
- 函数声明告诉了编译器函数的名称，返回类型，和参数
- Go提供了很多内置函数，比如len()函数可以接受不同类型参数，并返回该参数的长度
- 不支持重载(函数名称不能重复定义)
1.2 函数语法定义
func 函数名称([形参列表])[返回值类型] {
函数体
return 返回值列表
}
- 形参列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
- 返回值类型，函数返回一列值的数据类型。有些功能不需要返回值，这种情况下不是必须的。
- 函数名称：首字母大写该函数可以被本包文件和其他包文件使用(类似public)
- 函数名称：首字母小写函数只能被本包文件使用(类似private)
1.3 案例一：简单定义及调用函数
package main
import "fmt"
func cal(num1 int, num2 int) {
fmt.Println(num1 + num2)
}
func main() {
cal(10, 30)
}
代码输出内容：
40
1.4 案例二：带函数返回值案例
package main
import (
"fmt"
)
func cal(num1 int, num2 int) int {
sum := num1 + num2
return sum
}
func main() {
sum := cal(10, 30)
fmt.Println(sum)
}
代码输出内容：
40
二、函数的参数
2.1 函数的形参实参
- 形参：定义函数时写的参数
- 实参：调用函数时写的参数
案例：求1-100之间所有数字的和
package main
import (
"fmt"
)
func test(num int) int { // 形参
var sum int = 0
for i := 1; i <= num; i++ {
sum += i
}
return sum
}
func main() {
sum := test(100) // 实参
fmt.Println(sum)
}
2.2 可变参数
可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加...来标识。
函数内部处理可变参数的时候，是将可变参数当做切片来处理的
案例：
package main
import "fmt"
func test(args ...int) {
// 遍历可变参数：
for i := 0; i < len(args); i++ {
fmt.Println(args[i])
}
}
func main() {
test()
test(3)
test(100, 200, 300)
}
代码输出内容：
3
100
200
300
案例：
package main
import (
"fmt"
)
func test(num ...int) {
fmt.Println(num[0])
for i, v := range num {
fmt.Printf("index=%v\tvalue=%v\t", i, v)
}
}
func main() {
test(10, 20, 30, 40)
}
代码输出内容：
10
index=0 value=10 index=1 value=20 index=2 value=30 index=3 value=40
三、返回值
Go语言中通过return关键字向外输出返回值。
3.1 0个返回值
package main
import "fmt"
func cal(num1 int, num2 int) {
fmt.Printf("%v + %v = %v", num1, num2, num1+num2)
}
func main() {
cal(10, 20)
}
代码输出内容：
10 + 20 = 30
3.2 1个返回值
package main
import "fmt"
func cal(num1 int, num2 int) int {
var sum int = 0
sum += num2 + num1
return sum
}
func main() {
sum := cal(60, 100)
sum1 := cal(100, 50)
fmt.Printf("第一次调用：%v\n第二次调用: %v", sum, sum1)
}
代码输出内容：
第一次调用：160
第二次调用: 150
3.3 多个返回值
package main
import "fmt"
func cal(num1 int, num2 int) (int, int) { // 定义多个返回值类型
sum1 := num1 + num2
sum2 := num1 - num2
return sum1, sum2
}
func main() {
sum1, sum2 := cal(10, 20) // 多个变量接受多个返回值
fmt.Println(sum1, sum2)
// sum1, _ := cal(10, 20) //多个返回值,只接受一个 可以使用 '_' 代替不关注的返回值
// fmt.Println(sum1)
}
代码输出内容：
30 -10
3.4 对函数返回值进行命名
常规写法：
package main
import "fmt"
func test(num1 int, num2 int) (int, int) { // 返回参数类型 需要和return 返回列表一一对应上
a := num1 + num2
b := num1 - num2
return a, b
}
func main() {
a, b := test(10, 20)
fmt.Printf("%v\n%v", a, b)
}
对函数返回值进行命名写法：
package main
import "fmt"
func test(num1 int, num2 int) (a int, b int) {
a = num1 + num2 // 注意这里写 = 而不是 := ,因为已经在返回值列表定义变量了
b = num1 - num2
return
}
func main() {
a, b := test(10, 20)
fmt.Printf("%v\n%v", a, b)
}
四、递归函数
在Go语言中，递归函数是指一个函数可以调用自身的函数。递归函数通常用于解决需要重复执行相同操作的问题，例如计算斐波那契数列、二叉树遍历等。
- 递归函数必须有一个终止条件，否则会导致无限递归(递归函数需要一个出口)。
- 递归函数的参数应该尽可能简单，以便于理解和调试。
- 递归函数的性能可能会比循环函数差，因为递归函数需要不断地创建新的函数调用栈。
案例：
package main
import "fmt"
func Test(n int) int {
if n == 1 {
return 1
}
r := Test(n - 1) // 调用自己
fmt.Println("前一排的排数：", r)
return r + 1
}
func main() {
c := Test(3)
fmt.Println("我现在排数:", c)
}
代码输出内容：
前一排的排数： 1
前一排的排数： 2
我现在排数: 3
案例：计算一个数的阶乘
package main
import (
"fmt"
)
var s int = 1
func Test(n int) {
if n == 1 {
return // 终止函数
}
s *= n
Test(n - 1)
}
func main() {
Test(5)
fmt.Printf("阶乘是:%d", s)
}
代码输出内容：
阶乘是:120
五、拓展
5.1 综合案例
需求：模拟用户注册，当用户输入完用户、密码和邮箱后，进行校验，如果发现用户名，密码和邮箱是空的，则输出，"信息不能为空，用户注册失败"的提示，否则，进行邮件发送，并给出"用户注册成功"的提示
package main
import "fmt"
func Register() {
var userName string = "qinzt"
var userPwd string = "666"
var userEmail string = "qinzt@666.com"
temp := ChatInfo(userName, userPwd, userEmail) // 调用校验函数
if temp { // 针对校验做判断
fmt.Println("注册成功")
SendEmail()
} else {
fmt.Println("注册失败,用户信息不完整")
}
}
func ChatInfo(name string, pwd string, email string) bool { // 校验是否为空
if name != "" && pwd != "" && email != "" {
return true
} else {
return false
}
}
func SendEmail() {
fmt.Println("邮件发送成功!")
}
func main() {
Register()
}
代码输出内容：
注册成功
邮件发送成功!
