函数的注意事项

1）函数的形参列表可以是多个，返回值列表也可以是多个。

2）形参列表和返回值列表的数据类型可以是值类型和引用类型

3）函数的命名遵循标识符命名规范，首字母不能是数字，首字母大写该函数可以被本报文件和其它包文件使用，类似public，首字母小写，只能被本包使用，其它包文件不能使用，类似private

4）函数中的变量是局部的，函数外不生效

func test() {
　　// n1 是 test函数的局部变量，只能在test函数中使用
　　var n1 int = 10
}

func main() {
　　//这里不能使用n1，因为n1是test函数的局部变量
　　//fmt.Println("n1=", n1)
}

5）基本数据类型和数组默认都是值传递的，即进行值拷贝。在函数内修改，不会影响到原来的值。

func test02(n1 int) {
　　n1 = n1 + 10
　　fmt.Println("test02() n1 = ", n1)
}

func main() {
　　num := 20
　　test02(num)
　　fmt.Println("main() num = ", num)
}

[shell] go run main.go
test02() n1 = 30
main() num = 20

6）如果希望函数内的变量能修改函数外的变量(指的是默认以值传递的方式的数据类型)，可以传入变量的地址&，函数内以指针的方式操作变量。从效果上看类似引用

func test03(n1 *int) {
　　*n1 = *n1 + 10
　　fmt.Println("test03() n1 = ", *n1)
}

func main() {
　　num := 20
　　test03(&num)
　　fmt.Println("main() num = ", num)
}

[shell]go run main.go
test03() n1 = 30
main() num = 30

上面代码的示意图：

7）Go函数不支持函数重载：

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

func getSum(n1 int, n2 int) int {
　　return n1 + n2
}

func main() {
　　a := getSum
　　fmt.Printf("a的类型是%T, getSum的类型是%T", a, getSum)
　　res := a(10, 40) // 等价 res := getSum(10, 40)
　　fmt.Println("res = ", res)
}

9）函数既然是一种数据类型，因此在Go中，函数可以作为形参，并且调用！

func getSum(n1 int, n2 int) int {
　　return n1 + n2
}

func myFun(funvar func (int, int) int, num1 int, num2 int) int {
　　return funvar(num1, num2)
}

func main() {

　　a := getSum
　　fmt.Printf("a的类型是%T, getSum的类型是%T \n", a, getSum)

　　res := a(10, 40) // 等价 res := getSum(10, 40)
　　fmt.Println("res = ", res)

　　res2 := myFun(getSum, 50, 60)
　　fmt.Println("res2 = ", res2)
}

10）为了简化数据类型定义，Go支持自定义数据类型
　　基本语法： type 自定义数据类型名 数据类型 // 理解：相当于一个别名
　　案例：type myInt int // 这时 myInt 就等价 int 来使用了。
　　案例：type mySum func (int, int) int // 这时 mySum 就等价 一个 函数类型 func (int , int) int

例子1：

func main() {

　　type myInt int　　 //给int取了别名，在go中myInt和int虽然都是int类型，但是go认为他们还是两个不同的数据类型。

　　var num3 myInt
　　var num4 int
　　num3 = 49
　　num4 = int(num3)　　 //各位，注意这里依然需要显示转换。
　　fmt.Println("num3 = ", num3, "num4 = ", num4)
}

例子2：

func getSum(n1 int, n2 int) int {
　　return n1 + n2
}

type myFunType func(int, int) int　　 //这时这个myFunType就是func(int,int) int 类型

func myFun2(funvar myFunType, num1 int, num2 int) int {
　　return funvar(num1, num2)
}

func main() {

　　res3 := myFun2(getSum, 500, 600)
　　fmt.Println("res3 = ", res3)
}


11）支持对函数返回值命名

func getSumAndSub(n1 int, n2 int) (sum int, sub int) {
　　sum = n1 + n2
　　sub = n1 - n2
　　return
}

func main() {

　　a1, b1 := getSumAndSub(1, 2)
　　fmt.Printf("a1 = %v b1 = %v \n", a1, b1 )
}

12）使用 _ 标识符，忽略返回值

func cal(n1 int, n2 int) (sum int, sub int) {
　　sum = n1 + n2
　　sub = n1 - n2
　　return
}

func main() {
　　res1, _ := cal(10,20)
　　fmt.Printf("res1=%d", res1)
}

13) Go支持可变参数

//支持0到多个参数
func sum(args... int) sum int {
}
//支持1到多个参数
func sum(n1 int, args... int) sum int {
}

说明：
　　(1) args 是slice(切片)，通过 args[index] 可以访问到各个值。
　　(2) 案例演示：编写一个函数sum，可以求出 1 到多个int的和
　　(3) 如果一个函数的形参列表中有可变参数，则可变参数需要放在形参列表的最后，否则语法是不通过的。

代码演示：

func sum(n1 int,args... int) int { 　　//args... 是可以改变的，写成vars...等其它的也可以的
　　sum := n1
　　//遍历args
　　for i := 0; i < len(args); i++ {
　　　　sum += args[i] //args[0] 表示取出args切片的第一个元素值，其它依次类推
　　}
　　return sum
}

func main() {
　　res4 := sum(10, 0, -1, 90, 10)
　　fmt.Println("res4 = ", res4)
}