go 函数注意及细节

1、函数形参和返回值可以有多个
2、形参列表和返回值的数据类型可以是值类型也可以是引用类型（map,切片）
3、函数的命名遵循标识符命名规范，首字母不能是数字，首字母大写该函数可以被本包或其它包使用，类似public。首字母小写，只能被本包使用，其它包不能使用，类似private
4、函数的变量是局部的。函数外不生效
5、基本数据类型和数组默认都是值传递(拷贝)的，在函数内部修改不会影响原来的值

func test(n1 int) {
    n1 = n1 + 10
    fmt.Println("test() n1=", n1)
}
func main() {
    //调用
    var n1 = 10
    test(n1)
    fmt.Println("main() n1=", n1)
}

6、如果希望函数内的变量能修改函数外的变量，可以传入变量的地址&，函数内以指针的方式操作变量，类似引用。

* 是指针 &是取地址符

//n1 就是 *int类型
func test(n1 *int) {
    fmt.Printf("test空间内，n1的地址：%v \n", &n1)
    *n1 = *n1 + 10
    fmt.Println("test() n1=", *n1)
}
func main() {
    //调用
    var n1 = 10
    fmt.Printf("main空间内，n1的地址：%v \n", &n1)
    test(&n1)
    fmt.Println("main() n1=", n1)
}

上图解

7、go不支持传统的函数重载
8、在go中函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了。通过该变量可以对函数调用。

func getSum(n1 int, n2 int) int {
    return n1 + n2
}
func main() {
    a := getSum
    fmt.Printf("a的类型是%T，getSum的类型是%T \n", a, getSum)
    res1 := a(10, 40)
    res2 := getSum(67, 3)
    fmt.Printf("res1=%v，res2=%v \n", res1, res2)
}

9、函数做为一种数据类型，可以做为一种形参，并且调用

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)
    res1 := a(10, 40)
    res2 := getSum(67, 3)
    res3 := myFun(getSum, 50, 60)
    fmt.Printf("res1=%v，res2=%v，res3=%v \n", res1, res2, res3)
}

10、为了简化数据类型定义，Go支持自定义数据

基本语法： type 自定义数据类型名 数据类型 // 相当于一个别名

type myInt int //myInt 等价int来使用
type mySum func(int,int) int //mySum等价于一个函数类型func (int,int) int

案例1：

    //给int取了名，在go中 myInt和int都是int型，go认为是两种数据类型
    type myInt int
    var num1 myInt
    var num2 int
    num1 = 40
    num2 = int(num1) //这里依然需要显示转换，因为go认为myInt和int是不同的类型
    fmt.Println("num1=", num1, "num2=", num2)

案例2：

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

//自定义数据类型 myFunType
type myFunType func(int, int) int

//函数做形参
func myFun(funvar myFunType, num1 int, num2 int) int {
    return funvar(num1, num2)
}
func main() {
    res := myFun(getSum, 33, 44)
    fmt.Println("res=", res)
}

11、支持对返回值命名

//支持对函数返回值命名 sub int ,sum int
func getSumAndSub(n1 int, n2 int) (sub int, sum int) {
    sum = n1 + n2
    sub = n1 - n2
    return
}
func main() {
    a, b := getSumAndSub(30, 13)
    fmt.Printf("a=%v,b=%v\n", a, b)
}

12、使用_ 忽略返回值

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、可变参数必须放在形参列表的最后一项

//参数从1到多个int
func sum(n1 int, args ...int) int {
    sum := n1
    for i := 0; i < len(args); i++ {
        sum += args[i]
    }
    return sum
}
func main() {
    res := sum(1, 23, 34, 56)
    fmt.Println("res=", res)
}

• 编写一个函数 swap(n1 *int , n2 *int)可以交换n1和n2的值

func swap(n1 *int, n2 *int) {
    //定义一个临时变量
    t := *n1
    *n1 = *n2
    *n2 = t
}
func main() {
    a := 10
    b := 20
    swap(&a, &b) //传入地址
    fmt.Printf("a=%v,b=%v\n", a, b)
}