入门教程 go语言

go语言学习笔记之四---函数的使用

用一生去回望，那些经年的岁月，是记忆里不灭的伤

Posted by yishuifengxiao on 2020-09-16

一 格式定义

函数构成代码执行的逻辑结构。在Go语言中，函数的基本组成为：关键字func、函数名、参数列表、返回值、函数体和返回语句。

Go 语言函数定义格式如下：

1
2
3
4
5
func FuncName(/*参数列表*/) (o1 type1, o2 type2/*返回类型*/) {
    //函数体

    return v1, v2 //返回多个值
}

函数定义说明：

  • func：函数由关键字 func 开始声明

  • FuncName：函数名称，根据约定，函数名首字母小写即为private，大写即为public

  • 参数列表：函数可以有0个或多个参数，参数格式为：变量名 类型，如果有多个参数通过逗号分隔，不支持默认参数

  • 返回类型：

    ①　上面返回值声明了两个变量名o1和o2(命名返回参数)，这个不是必须，可以只有类型没有变量名

    ②　如果只有一个返回值且不声明返回值变量，那么你可以省略，包括返回值的括号

    ③　如果没有返回值，那么就直接省略最后的返回信息

    ④　如果有返回值， 那么必须在函数的内部添加return语句

二 自定义函数

2.1 无参无返回值

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

import "fmt"

func main() {

	Test() //无参无返回值函数调用

}

func Test() { //无参无返回值函数定义

	fmt.Println("this is a test func")

}

2.2 有参无返回值

2.2.1 普通参数列表
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import "fmt"

func main() {

	Test01(10, 20) //函数调用

	Test02(11, 22) //函数调用

}

func Test01(v1 int, v2 int) { //方式1

	fmt.Printf("v1 = %d, v2 = %d\n", v1, v2)

}

func Test02(v1, v2 int) { //方式2, v1, v2都是int类型

	fmt.Printf("v1 = %d, v2 = %d\n", v1, v2)

}
2.2.2 不定参数列表

1) 不定参数类型

不定参数是指函数传入的参数个数为不定数量。为了做到这点，首先需要将函数定义为接受不定参数类型：

//形如...type格式的类型只能作为函数的参数类型存在，并且必须是最后一个参数

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
package main

import "fmt"

func main() {

	//函数调用，可传0到多个参数

	Test()

	Test(1)

	Test(1, 2, 3, 4)

}

func Test(args ...int) {

	for _, n := range args { //遍历参数列表

		fmt.Println(n)

	}

}

2) 不定参数的传递

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
package main

import "fmt"

func main() {
	Test(1, 2, 3) //函数调用

}
func MyFunc01(args ...int) {

	fmt.Println("MyFunc01")

	for _, n := range args { //遍历参数列表
		fmt.Println(n)

	}

}

func MyFunc02(args ...int) {

	fmt.Println("MyFunc02")

	for _, n := range args { //遍历参数列表
		fmt.Println(n)
	}

}

func Test(args ...int) {

	MyFunc01(args...)     //按原样传递, Test()的参数原封不动传递给MyFunc01
	MyFunc02(args[1:]...) //Test()参数列表中，第1个参数及以后的参数传递给MyFunc02

}

2.3 无参有返回值

有返回值的函数，必须有明确的终止语句，否则会引发编译错误。

2.3.1 一个返回值
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
package main

import "fmt"

func main() {

	v1 := Test01() //函数调用

	v2 := Test02() //函数调用

	v3 := Test03() //函数调用

	fmt.Printf("v1 = %d, v2 = %d, v3 = %d\n", v1, v2, v3)

}

func Test01() int { //方式1

	return 250

}

//官方建议：最好命名返回值，因为不命名返回值，虽然使得代码更加简洁了，但是会造成生成的文档可读性差
func Test02() (value int) { //方式2, 给返回值命名

	value = 250

	return value

}

func Test03() (value int) { //方式3, 给返回值命名

	value = 250

	return

}
2.3.2 多个返回值
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
package main

import "fmt"

func main() {

	v1, v2 := Test01() //函数调用

	_, v3 := Test02() //函数调用， 第一个返回值丢弃

	v4, _ := Test02() //函数调用， 第二个返回值丢弃

	fmt.Printf("v1 = %d, v2 = %s, v3 = %s, v4 = %d\n", v1, v2, v3, v4)

}

func Test01() (int, string) { //方式1

	return 250, "sb"

}

func Test02() (a int, str string) { //方式2, 给返回值命名

	a = 250

	str = "sb"

	return

}

2.4 有参有返回值

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

import "fmt"

func main() {

	min, max := MinAndMax(33, 22)

	fmt.Printf("min = %d, max = %d\n", min, max) //min = 22, max = 33

}

//求2个数的最小值和最大值
func MinAndMax(num1 int, num2 int) (min int, max int) {
	if num1 > num2 { //如果num1 大于 num2
		min = num2
		max = num1
	} else {
		max = num2
		min = num1
	}
	return
}

三 递归函数

递归指函数可以直接或间接的调用自身。

递归函数通常有相同的结构：一个跳出条件和一个递归体。所谓跳出条件就是根据传入的参数判断是否需要停止递归，而递归体则是函数自身所做的一些处理。

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
package main

import "fmt"

func main() {
	fmt.Println(Test01())    //5050
	fmt.Println(Test02(100)) //5050
	fmt.Println(Test03(1))   //5050
}

//通过循环实现1+2+3……+100
func Test01() int {
	i := 1

	sum := 0
	for i = 1; i <= 100; i++ {
		sum += i
	}
	return sum

}

//通过递归实现1+2+3……+100

func Test02(num int) int {
	if num == 1 {
		return 1
	}
	return num + Test02(num-1) //函数调用本身

}

//通过递归实现1+2+3……+100
func Test03(num int) int {
	if num == 100 {
		return 100
	}
	return num + Test03(num+1) //函数调用本身
}

四 函数类型 (回调函数)

在Go语言中，函数也是一种数据类型，我们可以通过type来定义它，它的类型就是所有拥有相同的参数，相同的返回值的一种类型。

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
package main

import "fmt"

func main() {

	//函数调用，第三个参数为函数名字，此函数的参数，返回值必须和FuncType类型一致
	result := Calc(1, 1, Add)
	fmt.Println(result) //2

	var f FuncType = Minus
	fmt.Println("result = ", f(10, 2)) //result = 8

}

type FuncType func(int, int) int //声明一个函数类型, func后面没有函数名

//函数中有一个参数类型为函数类型：f FuncType

func Calc(a, b int, f FuncType) (result int) {

	result = f(a, b) //通过调用f()实现任务

	return

}

func Add(a, b int) int {

	return a + b

}

func Minus(a, b int) int {

	return a - b

}

第二个示例 函数作为实参

函数作为参数传递，实现回调。

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
package main

import (
	"fmt"
)

// 声明一个函数类型
type cb func(int) int

func main() {
	testCallBack(1, callBack)
	testCallBack(2, func(x int) int {
		fmt.Printf("我是回调2，x：%d\n", x)
		return x
	})
}

func testCallBack(x int, f cb) {
	f(x)
}

func callBack(x int) int {
	fmt.Printf("我是回调1，x：%d\n", x)
	return x
}

运行结果为

1
2
3
4
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
我是回调1，x：1
我是回调2，x：2
成功: 进程退出代码 0.

五 匿名函数与闭包

所谓闭包就是一个函数“捕获”了和它在同一作用域的其它常量和变量。这就意味着当闭包被调用的时候，不管在程序什么地方调用，闭包能够使用这些常量或者变量。它不关心这些捕获了的变量和常量是否已经超出了作用域，所以只有闭包还在使用它，这些变量就还会存在。

在Go语言里，所有的匿名函数(Go语言规范中称之为函数字面量)都是闭包。匿名函数是指不需要定义函数名的一种函数实现方式，它并不是一个新概念，最早可以回溯到1958年的Lisp语言。

5.1 基本使用

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
package main

import "fmt"

func main() {

	i := 0

	str := "mike"

	//方式1

	f1 := func() { //匿名函数，无参无返回值

		//引用到函数外的变量

		fmt.Printf("方式1：i = %d, str = %s\n", i, str)

	}

	f1() //函数调用

	//方式1的另一种方式

	type FuncType func() //声明函数类型, 无参无返回值

	var f2 FuncType = f1

	f2() //函数调用

	//方式2

	var f3 FuncType = func() {

		fmt.Printf("方式2：i = %d, str = %s\n", i, str)

	}

	f3() //函数调用

	//方式3

	func() { //匿名函数，无参无返回值

		fmt.Printf("方式3：i = %d, str = %s\n", i, str)

	}() //别忘了后面的(), ()的作用是，此处直接调用此匿名函数

	//方式4, 匿名函数，有参有返回值

	v := func(a, b int) (result int) {

		result = a + b

		return

	}(1, 1) //别忘了后面的(1, 1), (1, 1)的作用是，此处直接调用此匿名函数， 并传参

	fmt.Println("v = ", v)

}

5.2 闭包捕获外部变量

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
package main

import "fmt"

func main() {

	i := 10

	str := "mike"

	func() {

		i = 100

		str = "go"

		//内部：i = 100, str = go

		fmt.Printf("内部：i = %d, str = %s\n", i, str)

	}() //别忘了后面的(), ()的作用是，此处直接调用此匿名函数

	//外部：i = 100, str = go

	fmt.Printf("外部：i = %d, str = %s\n", i, str)

}

5.3 函数返回值为匿名函数

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
package main

import "fmt"

// squares返回一个匿名函数，func() int
// 该匿名函数每次被调用时都会返回下一个数的平方。
func squares() func() int {

	var x int

	return func() int { //匿名函数

		x++ //捕获外部变量
		return x * x

	}

}

func main() {

	f := squares()

	fmt.Println(f()) // "1"

	fmt.Println(f()) // "4"
	fmt.Println(f()) // "9"

	fmt.Println(f()) // "16"

}

函数squares返回另一个类型为 func() int 的函数。对squares的一次调用会生成一个局部变量x并返回一个匿名函数。每次调用时匿名函数时，该函数都会先使x的值加1，再返回x的平方。第二次调用squares时，会生成第二个x变量，并返回一个新的匿名函数。新匿名函数操作的是第二个x变量。

通过这个例子，我们看到变量的生命周期不由它的作用域决定：squares返回后，变量x仍然隐式的存在于f中。

六 延迟调用defer

6.1 defer作用

关键字 defer ⽤于延迟一个函数或者方法（或者当前所创建的匿名函数）的执行。注意，defer语句只能出现在函数或方法的内部。

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {

	fmt.Println("this is a test")

	defer fmt.Println("this is a defer") //main结束前调用

}

运行结果为

1
2
this is a test
this is a defer

defer语句经常被用于处理成对的操作，如打开、关闭、连接、断开连接、加锁、释放锁。通过defer机制，不论函数逻辑多复杂，都能保证在任何执行路径下，资源被释放。释放资源的defer应该直接跟在请求资源的语句后。

6.2 多个defer执行顺序

如果一个函数中有多个defer语句，它们会以LIFO（后进先出）的顺序执行。哪怕函数或某个延迟调用发生错误，这些调用依旧会被执⾏。

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

import "fmt"

func main() {

	defer fmt.Println("aaaaaaaa")

	defer fmt.Println("bbbbbbbb")

	defer test(0)

	defer fmt.Println("cccccccc")

}

func test(x int) {

	fmt.Println(100 / x) //x为0时，产生异常

}

运行结果为

1
2
3
4
5
6
7
8
9
10
11
12
13
14
C:/Go/bin/go.exe build [C:/Users/qingteng/Desktop/aa/src]
成功: 进程退出代码 0.
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
cccccccc
bbbbbbbb
aaaaaaaa
panic: runtime error: integer divide by zero

goroutine 1 [running]:
main.test(0x0)
	C:/Users/qingteng/Desktop/aa/src/main.go:19 +0xc5
main.main()
	C:/Users/qingteng/Desktop/aa/src/main.go:15 +0x198
错误: 进程退出代码 2.

6.3 defer和匿名函数结合使用

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

import "fmt"

func main() {

	a, b := 10, 20

	defer func(x int) { // a以值传递方式传给x

		fmt.Println("defer:", x, b) // b 闭包引用

	}(a)

	a += 10

	b += 100

	fmt.Printf("a = %d, b = %d\n", a, b)

}

运行结果为

1
2
3
4
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
a = 20, b = 120
defer: 10 120
成功: 进程退出代码 0.

七 获取命令行参数

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
package main

import (
	"fmt"

	"os" //os.Args所需的包
)

func main() {

	args := os.Args //获取用户输入的所有参数

	//如果用户没有输入,或参数个数不够,则调用该函数提示用户

	if args == nil || len(args) < 2 {

		fmt.Println("err: xxx ip port")

		return

	}

	ip := args[1] //获取输入的第一个参数

	port := args[2] //获取输入的第二个参数

	fmt.Printf("ip = %s, port = %s\n", ip, port)

}

运行结果为

1
2
3
4
5
6
7
C:\Users\qingteng\Desktop\aa\src
λ ls
main.go  src.exe*  sub/

C:\Users\qingteng\Desktop\aa\src
λ src 127.0.0.1 8080
ip = 127.0.0.1, port = 8080

八 作用域

作用域为已声明标识符所表示的常量、类型、变量、函数或包在源代码中的作用范围。

8.1 局部变量

在函数体内声明的变量、参数和返回值变量就是局部变量，它们的作用域只在函数体内：

可通过花括号来控制变量的作用域，花括号中的变量是单独的作用域，同名变量会覆盖外层

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
package main

import (
	"fmt"
)

func test(a, b int) {

	var c int

	a, b, c = 1, 2, 3

	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

}

func main() {

	//a, b, c = 1, 2, 3 //err, a, b, c不属于此作用域

	{

		var i int

		i = 10

		fmt.Printf("i = %d\n", i)

	}

	//i = 20 //err, i不属于此作用域

	if a := 3; a == 3 {
		fmt.Println("a = ", a)

	}

	//a = 4 //err，a只能if内部使用

}

8.2 全局变量

在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

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

import (
	"fmt"
)

var a int //全局变量的声明

func test() {

	fmt.Printf("test a = %d\n", a)

}

func main() {

	a = 10

	fmt.Printf("main a = %d\n", a) //main a = 10

	test() //test a = 10

}

运行结果为

1
2
3
4
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
main a = 10
test a = 10
成功: 进程退出代码 0.

8.3 不同作用域同名变量

在不同作用域可以声明同名的变量，其访问原则为：在同一个作用域内，就近原则访问最近的变量，如果此作用域没有此变量声明，则访问全局变量，如果全局变量也没有，则报错。

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
package main

import (
	"fmt"
)

var a int //全局变量的声明

func test01(a float32) {

	fmt.Printf("a type = %T\n", a) //a type = float32

}

func main() {

	fmt.Printf("a type = %T\n", a) //a type = int, 说明使用全局变量的a

	var a uint8 //局部变量声明

	{

		var a float64 //局部变量声明

		fmt.Printf("a type = %T\n", a) //a type = float64

	}

	fmt.Printf("a type = %T\n", a) //a type = uint8

	test01(3.14)

	test02()

}

func test02() {

	fmt.Printf("a type = %T\n", a) //a type = int

}

运行结果为

1
2
3
4
5
6
7
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
a type = int
a type = float64
a type = uint8
a type = float32
a type = int
成功: 进程退出代码 0.

九 函数参数传递

函数如果使用参数，该变量可称为函数的形参。

形参就像定义在函数体内的局部变量。

调用函数，可以通过两种方式来传递参数：

传递类型 描述
值传递 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

9.1 值传递

传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

以下定义了 swap() 函数：

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
package main

import (
	"fmt"
)

/* 定义相互交换值的函数 */
func swap(x, y int) int {
	var temp int

	temp = x /* 保存 x 的值 */
	x = y    /* 将 y 值赋给 x */
	y = temp /* 将 temp 值赋给 y*/

	return temp
}

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200

	fmt.Printf("交换前 a 的值为 : %d\n", a)
	fmt.Printf("交换前 b 的值为 : %d\n", b)

	/* 通过调用函数来交换值 */
	swap(a, b)

	fmt.Printf("交换后 a 的值 : %d\n", a)
	fmt.Printf("交换后 b 的值 : %d\n", b)
}

运行结果为

1
2
3
4
5
6
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
交换前 a 的值为 : 100
交换前 b 的值为 : 200
交换后 a 的值 : 100
交换后 b 的值 : 200
成功: 进程退出代码 0.

9.2 引用传递

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

引用传递指针参数传递到函数内，以下是交换函数 swap()使用了引用传递：

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
package main

import (
	"fmt"
)

/* 定义交换值函数*/
func swap(x *int, y *int) {
	var temp int
	temp = *x /* 保持 x 地址上的值 */
	*x = *y   /* 将 y 值赋给 x */
	*y = temp /* 将 temp 值赋给 y */
}

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200

	fmt.Printf("交换前，a 的值 : %d\n", a)
	fmt.Printf("交换前，b 的值 : %d\n", b)

	/* 调用 swap() 函数
	 * &a 指向 a 指针，a 变量的地址
	 * &b 指向 b 指针，b 变量的地址
	 */
	swap(&a, &b)

	fmt.Printf("交换后，a 的值 : %d\n", a)
	fmt.Printf("交换后，b 的值 : %d\n", b)
}

运行结果为

1
2
3
4
5
6
C:/Users/qingteng/Desktop/aa/src/src.exe  [C:/Users/qingteng/Desktop/aa/src]
交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100
成功: 进程退出代码 0.
FEATURED TAGS
入门教程 go语言
FRIENDS