golang 函数

go语言中的函数特性

• go语言中有3种函数：普通函数、匿名函数（没有名称的函数）、方法(定义在struct上 的函数)。
• go语言中不允许函数重载(overload),也就是说不允许函数同名。
• go语言中的函数不能嵌套函数，但可以嵌套匿名函数。
• 函数是一个值，可以将函数赋值给变量，使得这个变量也成为函数。
• 函数可以作为参数传递给另一个函数。
• 函数的返回值可以是一个函数。
• 函数调用的时候，如果有参数传递给函数，则先拷贝参数的副本，再将副本传递给函数。
• 函数参数可以没有名称。
• 基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。

函数的基本语法

func 函数名（形参列表)（返回值类型列表）{
执行语句..
return + 返回值列表
}

• 函数名：
  遵循标识符命名规范，驼峰命名，见名知意，首字母不能是数字。
  当首字母大写时，该函数可以被本包文件和其它包文件使用。
  当首学母小写只能被本包文件使用，其它包文件不能使用。
• 形参列表：
  形参个数可以是一个参数，可以是n个参数，可以是0个参数。形参的作用为接收外来的数据。
• 返回值类型列表：
  返回值个数为0：不用写返回值类型列表。
  返回值个数为1：括号内写一个返回类型，如（int），括号也可以不写直接写返回类型，如 int。
  返回值个数为多个：括号内写每个返回值的类型，以逗号隔开，如（int32,int8）,接收也必须接收多个返回值，如果不需要接收可以_忽略。

package main

import "fmt"

func test(n1 int, n2 int) int { //定义自定义函数test，指定需要传入2个参数n1,n2（形参），参数类型为int，返回的值类型也为int
	var n3 int
	n3 = n1 + n2
	return n3 //定义返回n3
}

func main() {
	n4 := test(4, 5) //调用自定义函数test，传入第一个参数为4，第二个参数为5，（4,5为实参）,定义n4接收函数test的返回值
	fmt.Printf("n4的值为:%v\n", n4)
	n5 := 11
	n6 := 50
	n7 := test(n5, n6)
	fmt.Printf("n7的值为:%v\n", n7) //将两个已经赋值的变量传入自定义函数test
}

执行结果

n4的值为:9
n7的值为:61

可变参数

使用...表示参数个数是可变数量的，函数内部处理可变参数的时候，将可变参数当做切片来处理。

package main

import "fmt"

func test2(num ...int) {
	for key, val := range num { //遍历可变参数
		fmt.Printf("num[%v]的值为：%v\n", key, val)
	}
}

func main() {
	fmt.Println("不传参数调用test2函数")
	test2()
	fmt.Println("传一个参数调用test2函数")
	test2(1)
	fmt.Println("传多个参数调用test2函数")
	test2(2, 3, 4, 5, 6)
}

执行结果

不传参数调用test2函数
传一个参数调用test2函数
num[0]的值为：1        
传多个参数调用test2函数
num[0]的值为：2        
num[1]的值为：3        
num[2]的值为：4        
num[3]的值为：5        
num[4]的值为：6 

函数的内存

当main函数中的n1，n2执行test1函数重新赋值时，只是在test1函数的内存空间中改变了n1，n2的值，跟main函数中的n1，n2的值无关，所以执行完test1函数时，n1，n2的值没有发生改变。

package main

import "fmt"

func test1(n1 int, n2 int) {
	n1 = 10 //重新给n1赋值
	n2 = 20 //重新给n2赋值
	fmt.Printf("test1函数中，n1的内存地址为：%p,n2的内存地址为%p\n", &n1, &n2)
}

func main() {
	var n1 int = 5
	var n2 int = 10
	fmt.Printf("n1的值为%v，n2的值为%v\n", n1, n2)
	fmt.Printf("n1的内存地址为：%p,n2的内存地址为%p\n", &n1, &n2)
	test1(n1, n2)
	fmt.Printf("执行test函数后，n1的值为%v，n2的值为%v\n", n1, n2)
}

执行结果

n1的值为5，n2的值为10
n1的内存地址为：0xc00001c0b8,n2的内存地址为0xc00001c0d0
test1函数中，n1的内存地址为：0xc00001c0d8,n2的内存地址为0xc00001c100
执行test函数后，n1的值为5，n2的值为10 

通过指针修改函数中变量的值。

main函数调用test1函数时，直接将变量的内存地址传入到test1函数，test1函数中，直接按照传入的地址指向的值进行修改，此时main函数中的n1,n2的地址还是之前的内存地址，在test1函数执行时已将内存地址指向的值修改了，所有重新输出的n1，n2的值为test1函数中的值。

package main

import "fmt"

func test1(n1 *int, n2 *int) {
	*n1 = 10 //将n1地址对应的值进行赋值
	*n2 = 20 //将n2地址对应的值进行赋值
	fmt.Printf("test1函数中，n1的值为：%p,n2的值为%p\n", n1, n2)
}

func main() {
	var n1 int = 5
	var n2 int = 10
	fmt.Printf("n1的值为%v，n2的值为%v\n", n1, n2)
	fmt.Printf("n1的内存地址为：%p,n2的内存地址为%p\n", &n1, &n2)
	test1(&n1, &n2) //将n1,n2的内存地址传入test1函数
	fmt.Printf("执行test函数后，n1的值为%v，n2的值为%v\n", n1, n2)
}

执行结果

n1的值为5，n2的值为10
n1的内存地址为：0xc00001c0b8,n2的内存地址为0xc00001c0d0
test1函数中，n1的值为：0xc00001c0b8,n2的值为0xc00001c0d0
执行test函数后，n1的值为10，n2的值为20  

函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用。

package main

import "fmt"

func test(num1 int) {
	fmt.Println(num1)
}

func main() {
	f := test //将test函数赋值给f
	fmt.Printf("f的数据类型为:%T,test的数据类型为%T\n", f, test)
	f(8) //通过f调用test函数
}

执行结果

f的数据类型为:func(int),test的数据类型为func(int)
8

函数可以作为形参，并且调用

package main

import "fmt"

func test(num1 int) {
	fmt.Println(num1)
}

func test2(num2 int, fun func(int)) { //传入两个参数为，第一个为int类型，第二个为函数类型
	fmt.Printf("num2的值为%v，fun的值为%v\n", num2, fun)
}

func main() {
	f := test //将test函数赋值给f
	fmt.Printf("f的数据类型为:%T,test的数据类型为%T\n", f, test)
	test2(10, test) //直接传入函数名称
	test2(11, f)    //传入函数类型的变量
}

执行结果

f的数据类型为:func(int),test的数据类型为func(int)
num2的值为10，fun的值为0x60b120
num2的值为11，fun的值为0x60b120

type定义函数类型

type自定义数据类型

基本语法: type 自定义数据类型名（别名） 数据类型
例如：type aint int，则aint类型等价于int类型。
var num1 aint 等于 var num1 int

package main

import "fmt"

func main() {
	type aint int //将int类型取别名为aint
	var num1 aint = 10
	var num2 int = 20
	fmt.Printf("num1的值为：%v,num1的类型为：%T\n", num1, num1) //虽然是别名，但是在编译的时候还是认为不是一种数据类型
	sum := num2 + int(num1)                            //需要将num1类型aint转成int才能操作
	fmt.Printf("num1+num2的值为:%v", sum)
}

执行结果

num1的值为：10,num1的类型为：main.aint
num1+num2的值为:30

type自定义函数类型

基本语法: type 自定义函数名（别名） 函数类型
例如：type afunc func(int)，则afunc类型等价于func(int)类型。

package main

import "fmt"

func test(num1 int) {
	fmt.Println(num1)
}

type afunc func(int) //定义函数别名

func test2(num2 int, fun afunc) { //传入两个参数为，第一个为int类型，第二个为函数类型
	fmt.Printf("num2的值为%v，fun的值为%v\n", num2, fun)
}

func main() {
	f := test //将test函数赋值给f
	fmt.Printf("f的数据类型为:%T,test的数据类型为%T,test2的数据类型为%T\n", f, test, test2)
	test2(10, test) //直接传入函数名称
	test2(11, f)    //传入函数类型的变量
}

执行结果

f的数据类型为:func(int),test的数据类型为func(int),test2的数据类型为func(int, mai
n.afunc)
num2的值为10，fun的值为0xb6b120
num2的值为11，fun的值为0xb6b120

对函数返回值命名

return返回值的类型和函数定义的返回值类型对应，顺序不能变

package main

import "fmt"

func test1(num1 int, str1 string) (int, string) { //返回的第一个值为int类型，第二个值的类型为string类型
	n1 := num1
	s1 := str1
	return n1, s1 //返回的第一个值必须也是int类型，第二个值也得是string类型
}

func main() {
	a, b := test1(10, "hello")
	fmt.Printf("a的值为:%v,b的值为:%v\n", a, b)
}

执行结果

a的值为:10,b的值为:hello

对函数返回值命名，return顺序随意，顺序不用对应函数返回值

package main

import "fmt"

func test1(num1 int, str1 string) (a int, b string) { //对函数的返回值命名了，所以return无需指定
	a = num1
	b = str1
	return 
}

func main() {
	a, b := test1(10, "hello")
	fmt.Printf("a的值为:%v,b的值为:%v\n", a, b)
}

执行结果

a的值为:10,b的值为:hello

init函数

每一个源文件都可以包含一个 init 函数，该函数会在 main 函数执行前，被 Go 运行框架调用，也就是说 init 会在 main 函数前被调用。

注意事项与细节：
如果一个文件同时包含全局变量定义，init 函数和 main 函数，则执行的流程全局变量定义->init 函数->main 函数

package main

import "fmt"

var n int = test10()

func test10() int {
	fmt.Println("执行test10函数")
	return 100
}

func main() {
	fmt.Println("执行main函数")
	fmt.Println(n)
}

func init() {
	fmt.Println("执行init函数")
}

执行结果

执行test10函数
执行init函数
执行main函数
100

注意：如果两个文件中都含有 变量定义，init 函数时，从引入的import开始，按照之前的顺序：变量定义 -> init函数 -> （进入main包）变量定义 -> init函数 -> main函数...

匿名函数

golang支持匿名函数，如果某些函数仅想在特定位置使用一次，那么可以考虑使用匿名函数，匿名函数也可以实现多次调用。

• 可以在函数内部定义匿名函数,但是不能定义命名函数。
• 匿名函数可以直接调用,保存到变量,作为参数,作为返回值。
• 除了没有名字之外,匿名函数和命名函数没有什么不同。
• 将局部变量赋值匿名函数，匿名函数可以在函数内部多次调用。
• 将全局变量赋值匿名函数，匿名函数可以在程序中多次调用。

package main

import "fmt"

var res03 = func(n1 int, n2 int) int { //定义匿名函数，赋值给全局变量，调用这个全局变量等价于调用这个匿名函数
	return n1 + n2
}

func main() {
	res01 := func(n1 int, n2 int) int { //定义匿名函数，同时调用
		return n1 + n2
	}(10, 20) //将n1=10，n2=20传入匿名函数
	fmt.Printf("res01的值为：%v\n", res01)

	res02 := func(n1 int, n2 int) int { //定义匿名函数赋值给res02，res02等价于这个匿名函数
		return n1 + n2
	}
	sum1 := res02(30, 40) //调用匿名函数
	num1 := 100
	num2 := 140
	sum2 := res02(num1, num2) //调用匿名函数
	fmt.Printf("sum1的值为：%v\n", sum1)
	fmt.Printf("sum2的值为：%v\n", sum2)

	sum3 := res03(200, 210) //调用匿名函数
	fmt.Printf("sum3的值为：%v\n", sum3)
}

执行结果

res01的值为：30
sum1的值为：70 
sum2的值为：240
sum3的值为：410

闭包

闭包可以理解成定义在一个函数内部的函数，闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境。
闭包的特点：

• 返回的是一个匿名函数，但是这个匿名函数引用到函数外的变量/参数 ,因此这个匿名函数就和变量/参数形成一个整体，构成闭包。
• 闭包中使用的变量/参数会一直保存在内存中，所以会一直使用---》意味着闭包不可滥用（对内存消耗大）

package main

import "fmt"

func get() func(int) int { //get函数返回一个函数类型，返回的函数类型的形参为int，返回的函数返回一个int类型
	var n1 int = 0
	a := func(n2 int) int {
		n1 += n2  //在匿名函数中调用get函数中的局部变量n1
		return n1 //匿名返回的返回，int类型
	}
	return a //get函数的返回，get函数里边嵌套一个匿名函数，返回里边的函数就形成了闭包。
}

func main() {
	f := get()         //将get函数赋值给f
	fmt.Println(f(10)) //f(n1)等于调用了get函数中的匿名函数，并给匿名函数传了n1，n1=10
	fmt.Println(f(20)) //因为变量n1常驻内存，每一次调用都会修改n1的值，使其加n2。n1=10+20=30
	fmt.Println(f(30)) //n1=30+30=60
}

执行结果
n1只在第一次调用初始化了（var n1 int = 0），后面的调用中n1都是上一次n1+n2的值。

10
30
60