go 函数

函数是一块执行特定任务的代码。一个函数是在输入源基础上，通过执行一系列的算法，生成预期的输出。

在go语言中，函数是第一等公民，这点同python一样，都可以把函数当做变量值使用

函数中的参数列表和返回值并非是必须的

函数基础

定义函数的基础语法如下:

func 关键字 函数名(形参1 形参1的类型, 形参2 形参2的类型)(返回值类型){
    函数体的内容(跟缩进无关,只要是大括号内,都是函数体内容)
}
// 在python中，函数需要先定义再使用，而在go中，只要函数定义过即可使用

func main()  {
	fmt.Println("hello world")
	test()  // 调用函数test
}

func test()  {
	fmt.Println("hello test")
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当函数需要参数时,应定义好参数的类型，并且只能按位置传参，没有python的关键字参数

func main()  {
	test1(1,2)
}

func test1(a int, b int){
	sum := a + b
	fmt.Println(sum)
}
1
2
3
4
5
6
7
8

当函数有放回值时，应提前定义好返回值的类型，并且支持多返回值，并且调用函数必须接收改返回值

func main()  {
    sum := test2(1,2)   // 推荐写法， 也可以用其他定义变量方式如:  var sum int = test2(1,2)
	sum1, b := test3(3,4)
	sum2, b2 := test4(5,6)
	fmt.Println(sum,sum1,b)
	fmt.Println(sum2, b2)
}

func test2(a int, b int)(int){  // 只有一个返回值，可以不加 ()，但是多个返回值必须加
	sum := a + b
	return sum
}

func test3(a int, b int)(int, int){  // 一个返回值定义一个类型
	sum := a + b
	return sum, b
}

func test4(a int, b int)(sum int,b2 int){  // 相当于已经定义了 sum 和 b2 两个变量
	sum = a + b
	b2 = b
	return		// 不需要明确指定返回值，默认返回 sum, b2 的值
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

空白符
_ 在 Go 中被用作空白符，可以用作表示任何类型的任何值，作用同python中一样。使用频率很高

func main()  {
	a,_,_ := test5()
	_,b,_ := test5()
	fmt.Println(a,b)
}

func test5()(int,int,int){
	return 5,6,7
}
1
2
3
4
5
6
7
8
9

函数高级

1 可变长参数

跟python不一样，python有可变长位置参数和可变长关键字参数，go只有可变长位置参数 (…)

func main()  {
	test6(1,2,3,4,5)
}

func test6(a ...int) {
	fmt.Println(a)  // [1 2 3 4 5]
}
1
2
3
4
5
6
7

2 匿名函数

定义在函数内部的函数, 在go中必须是匿名函数

// 基本的匿名函数
func test7(){
	func (){fmt.Println("基本匿名函数")}()
}
// 有参数的匿名函数
func test7(){
	func(a,b int) {
		fmt.Println("有参数的匿名函数")
	}(4,5)
}
// 有参数,有返回值的匿名函数
func test7(){
	a :=func(a,b int)int{
		return a+b
	}(3,4)
	fmt.Println(a)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3 函数参数

在go语言中，函数是第一等公民，这点同python一样，都可以把函数当做变量值，赋值给一个变量，并且传给函数,当作返回值使用

func test7(){
    f := func(){                   // 推荐写法  也可 var f func() = 
		fmt.Println("函数赋值")
	}
    fmt.Printf("f的类型是：%T",f)   // 是这个类型 func()
	f()  // 调用函数
}
// 闭包函数定义, go语言也可以同python一样制作装饰器，但是没有语法糖，所以基本不用
    1. 定义在函数内部的函数
    2. 对外部函数有引用

func test8()  {
	a := 10
	func(){
		fmt.Println(a)
	}()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4 给类型重命名

因为go中函数是一等公民，可以传给变量，因此go中函数传参类型可以写的非常复杂，案例如下

func main()  {
	a := test9()
	a1, f := a(1,test8)   // 我是内层函数  10
	fmt.Println(a1)       // 1
	f()  				// 头晕了
}

func test8()  {
	a := 10
	func(){
		fmt.Println(a)
	}()

}

func test9() func(a int,b func()) (int,func()){ 
	a:=func(a int,b func()) (int,func()){
		fmt.Println("我是内层函数")
		b()
		return a, func() {
			fmt.Println("头晕了")
		}
	}
	return a
}

test9() func(a int,b func()) (int,func())  解析
	test9()  函数名
	func(a int,b func()) test9 的函数参数
	(int,func())   test9 的放回值类型
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

这时候就可以来给函数重命名

// 把func(a int,b func()) (int,func()) 类型，重命名为MyFunc
type MyFunc func(a int,b func()) (int,func())

func test9() MyFunc{
	a:=func(a int,b func()) (int,func()){
		fmt.Println("我是内层函数")
		b()
		return a, func() {
		}
	}
	return a
}

byte 和 rune 就是这样实现的
type byte uint8
type rune int32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

补充:

1. go是以包为最小单位，因此同一个包下不能出现同样的变量名和函数名