---

一、函数

1.什么是函数

函数是将具有独立功能的代码块组织成一个整体，使其具有特殊功能的代码集。这段代码集可以直接被另一段程序或代码引用的、可重复使用的、用来实现单一或相关联功能的代码段。目的是为了提高应用的模块性和代码的重复利用率。

2.函数的定义和使用

在 Go 语言中，定义一个函数需要声明参数和函数名等。

func 函数名(参数列表) (返回参数列表) {
  函数体
}
1
2
3

相关案例：

package main

import "fmt"

func PlayGame(){
	fmt.Println("超级玛丽，走呀走，跳呀跳")
	fmt.Println("超级玛丽，走呀走，跳呀跳")
}
func Play(){
	fmt.Println("屏幕闪烁")
	fmt.Println("播放音乐")
}
func main()  {
	PlayGame()
	Play()
	PlayGame()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.函数参数

package main

import "fmt"

// 1--100之间所有数字之和
func SumAdd(num int) {  //形参
	var sum int
	for i := 1; i <= num; i++ {
		sum += i
	}
	fmt.Println(sum)
}
func Add(num1 int,num2 int)  { //定义两个形参
	fmt.Println(num1+num2)
}
func main() {
	SumAdd(200) //实参
	Add(3,6) //传递两个实参, 实参与形参的个数要保持一致，类型也要保持一致。
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.函数不定参数

package main

import "fmt"

func TestSum(args...int){
	// args参数可以认为就是一个集合，在该集合中存储了传递过来的数据，
	// 会对每个数据加上一个编号，该编号是从0开始计算的。所以可以通过该编号获取集合中存储的具体的数据。
	/*
	fmt.Println(args[0])
	fmt.Println(args[1])
	fmt.Println(args[2])
	fmt.Println(args[3])
	*/
	/*
	for i:=0;i
	// 集合。 数组，切片
	// 如果只写一个变量，该变量中存储的是集合的编号
	// _:匿名变量。匿名变量不会保存具体的数据
	for _,v:= range args{
		//fmt.Println("a=",a) // 存储的是集合的编号
		fmt.Println("v=",v) // 存储的是具体的值。
	}

}
// 固定参数放在前面，不定参数放在后面
func TestA(num int,args...int){
	fmt.Println(num)
	fmt.Println("argsp[0]=",args[0])
	fmt.Println("argsp[1]=",args[1])
}
func main() {
  //TestSum(3,6,7,10)
  TestA(10,8,9)
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

5.函数返回值

package main

import "fmt"

/*
func AddResult(num1 int,num2 int) int { // 表示指定函数返回的数据的类型。
	var sum int
	sum = num1+num2
	return sum //将变量sum中存储的值返回。
}
*/
// 表明：最终会返回整型变量sum中的值。
// 在函数体中没有必要在重新创建sum变量。
/*
func AddResult(num1 int,num2 int) (sum int) {
	// var sum int
	sum = num1+num2
	return sum //将变量sum中存储的值返回。
}
*/
func AddResult(num1 int,num2 int) (sum int) {
	// var sum int
	sum = num1+num2
	return  //如果已经指定了返回的变量的名称，那么return后面可以不用在加上变量的名称。
}
func GetResult()(num1 int,num2 int){
	//var num1 int = 10
	// var num2 int = 20
	num1=10
	num2=20
	//return num1,num2 //表明返回两个变量的值。
	return 
}
func main() {
	var s int
	s = AddResult(3,6) //将函数返回的结果赋值给了变量s.
	fmt.Println(s/3)

	var s1 int
	var s2 int
	s1,s2=GetResult() // 在这里，函数返回两个值，所以定义两个变量来进行接收。
	fmt.Println("s1=",s1)
	fmt.Println("s2=",s2)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

二、函数案例

模拟用户注册，当用户输入完用户名，密码和邮箱后，进行校验。如果发现
用户名，密码和邮箱是空的，则给出“信息不能为空，用户注册失败”的提示，否则，进行邮件发送，并给出“用户注册成功”的提示。

package main

import "fmt"

func main() {
	/*
		模拟用户注册，当用户输入完用户名，密码和邮箱后，进行校验。如果发现
		用户名，密码和邮箱是空的，则给出“信息不能为空，用户注册失败”的提示，否则，进行邮
		件发送，并给出“用户注册成功”的提示。
	*/
	//1:用户注册
	// 2: 校验信息
	// 3: 发送邮件
	Register()
}

//1:用户注册
func Register() {
	// 1: 接收用户输入的信息
	var userName string = "admin"
	var userPwd string = "admin"
	var userEmail string = "yg@126.com"
	// 2: 进行校验
	b := CheckInfo(userName, userPwd, userEmail)
	// 3: 校验结果成了，调用发送邮件的函数
	if b {
		SendEmail()
		fmt.Println("用户注册成功了！！")
	} else {
		fmt.Println("信息不完整，无法完成用户注册！！")
	}
}

// 2: 校验信息
func CheckInfo(name string, pwd string, email string) bool {
	if name != "" && pwd != "" && email != "" {
		return true
	} else {
		return false
	}
}

// 3: 发送邮件
func SendEmail() {
	fmt.Println("邮件发送成功！！")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

三、函数作用域

1.局部变量

局部变量，也称内部变量，是指在一个函数内部或复合语句内部定义的变量 。局部变量的作用域是定义该变量的函数或定义该变量的复合语句。局部变量的生存期是从函数被调用的时刻算起到函数返回调用处的时刻结束。

package main

import "fmt"

func main() {
	a := 10
	TestA()
	fmt.Println(a)
}
func TestA() {
	a := 6
	a++

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.全局变量

所谓的全局变量: 既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量. 也就是定义在函数外部的变量就是全局变量

package main

import "fmt"

var b int

func main() {
	b = 20
	TestB()
	fmt.Println("main:", b)
}
func TestB() {
	b = 30
	fmt.Println("TestB:", b)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

四、延迟调用defer

1.defer基本使用

关键字 defer ⽤于延迟一个函数的执行。

2.defer执行顺序

如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。

3.相关案例

package main

import "fmt"

func main() {
	defer fmt.Println("愚公1号")
	defer fmt.Println("愚公2号")
	defer fmt.Println("愚公3号")
}

1
2
3
4
5
6
7
8
9
10