go语言函数

函数定义

一个函数的定义包括如下几个部分:

函数声明关键字func,函数名，参数列表，返回列表，函数体。函数的参数和返回值需要使用“()“包裹,如果只有一个返回值,而且使用的是非命名的参数,则返回参数的”()“可以省略。函数体使用”{}“包裹,并且”{"必须位于函数返回值同行的行尾。多个相邻的相同类型的参数可以使用简写模式.

func sum(a, b int) int { //相当于 sum(a int , b int ) int
   return a+b
}

函数可以没有输入参数,也可以没有返回值

func tmpFunc() {

}

支持有名的返回值,参数名就相当于函数体内最外层的局部变量,命名返回值变量会被初始化为类型零值,最后的return可以不带参数名直接返回。

func sum(a int, b int) (sum int) {
	sum = a + b
	return
}
fmt.Println(sum(1, 2)) //输出3

也可以return 一个别的值，相当于给命名返回值赋值并返回

func sum(a int, b int) (sum int) {
	sum = a + b
	fmt.Println("adding sum=", sum)
	defer func() {
		fmt.Println("after add sum=", sum)
	}()
	return a
}
fmt.Println(sum(1, 2))
/* 输出
adding sum= 3
after add sum= 1
1
 */

go语言函数

1. 不支持默认值参数。
2. 不支持函数重载。
3. 不支持函数嵌套,严格地说是不支持命名函数的嵌套定义,但可以支持嵌套匿名函数

func sum(a, b int) (sum int) {
	tmpAddFunc := func(a, b int) int {
		return a + b
	}
	return tmpAddFunc(a, b)
}

多值返回

定义多值返回的返回参数列表时要使用"()"包裹

func swap(a, b int) (int, int) {
	return b, a
}
	
a, b := 1, 2
b, a = swap(a, b)

实参到形参的传递

Go函数实参到形参的传递永远是值拷贝,有时函数调用后实参指向的值发生了变化,那是因为参数传递的是指针值的拷贝,实参是一个指针变量,传递给形参的是这个指针变量的副本,二者指向同一地址,本质上参数传递仍然是值拷贝。

func chValue(a int) int {
	a = a + 1
	return a
}
func chPointer(a *int) *int {
	*a = *a + 1
	return a
}
a := 1
chValue(a)
fmt.Println(a)
b := 1
chPointer(&b)
fmt.Println(b)
/*
输出
1
2
 */

不定参数

所有的不定参数类型必须是相同的。

不定参数必须是函数的最后一个参数。

不定参数名在函数体内相当于切片,对切片的操作同样适合对不定参数的操作。

func sum(arr ...int) (sum int) {
	for _, v := range arr { //此时arr就相当于切片,可以使用range访问
		sum += v
	}
	return
}
//切片可以作为参数传递给不定参数
	slice := []int{1, 2, 3, 4}

	fmt.Println(sum(slice...))

形参为不定参数的函数和形参为切片的函数类型不相同

func sum(arr ...int) (sum int) {
	for _, v := range arr { //此时arr就相当于切片,可以使用range访问
		sum += v
	}
	return
}
func sum2(arr []int) (sum int) {
	for _, v := range arr {
		sum += v
	}
	return
}
func main() {
	fmt.Printf("%T\n", sum)  //func(...int) int
	fmt.Printf("%T\n", sum2) //func([]int) int
}

函数类型

函数类型又叫函数签名,一个函数的类型就是函数定义首行去掉函数名、参数名和{,可以用fmt.Printf的%T格式化参数打印

func sum(arr ...int) (sum int) {
	for _, v := range arr { //此时arr就相当于切片,可以使用range访问
		sum += v
	}
	return
}
func sum2(arr []int) (sum int) {
	for _, v := range arr {
		sum += v
	}
	return
}
func main() {
	fmt.Printf("%T\n", sum)  //func(...int) int
	fmt.Printf("%T\n", sum2) //func([]int) int
}

可以使用type定义函数类型,函数类型变量可以作为函数的参数或返回值

type tmpType func(int, int) int

func sum(a, b int) (sum int) {
	sum = a + b
	return
}

func doFun(fun tmpType, a, b int) int {
	return fun(a, b)
}
func main() {
	fmt.Println(doFun(sum, 1, 2))
}

匿名函数

匿名函数可以看作函数字面量,所有直接使用函,数类型变量的地方都可以由匿名函数代替。匿名函数可以直接赋值给函数变量,可以当作实参,也可以作为返回值,还可以直接被调用。

func getFunc(str string) func(int, int) int {
	switch str {
	case "add":
		return func(a, b int) int { return a + b }
	case "sub":
		return func(a, b int) int { return a - b }
	default:
		return nil

	}
}
func main() {
	tmpFunc := getFunc("add")
	fmt.Println(tmpFunc(1, 2))//4
}