009. golang 函数 function

╰半橙微兮° 2021-10-06 15:06 321阅读 0赞

## 函数function ##

*  Go 函数 不支持 嵌套、重载和默认参数
 *  但支持以下特性：
    
        无需声明原型、不定长度变参、多返回值、命名返回值参数
        匿名函数、闭包
 *  定义函数使用关键字 func，且左大括号不能另起一行
 *  函数也可以作为一种类型使用

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        fmt.Println(A(1, "a"))
    
        fmt.Println(B(2, "b"))
    
        a, b, c := 1, 2, 3
        C("y", a, b, c)
        fmt.Println(a, b, c)
    
        arr := []int{1, 2, 3, 4, 5, 6}
        D(arr)
        fmt.Println(arr)
    
        e := 2
        E(&e)
        fmt.Println(e)
    
    }
    
    func A(a int, b string) (int, string) {
        return a, b
    }
    
    func B(a int, b string) (A int, B string) {
        A, B = a, b
        return
    }
    
    //不定长变参，只能作为最后一个参数 而且拷贝的都是值拷贝
    func C(x string, a ...int) {
        a[0] = 4
        a[1] = 5
        a[2] = 6
        fmt.Println(x, a)
    }
    
    //数组的话都是地址拷贝
    func D(a []int) {
        a[0] = 10
        a[1] = 11
        a[2] = 12
        fmt.Println(a)
    }
    
    //如果 值拷贝 想更改为 地址拷贝
    //传参数的时候加上 &
    //方法形参加上 *
    func E(e *int) {
        *e = 9
        fmt.Println(*e)
    }

![这里写图片描述][70]

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        //匿名函数
        a := func() {
            fmt.Println("Func A")
        }
        a()
    
        fmt.Println()
    
        //匿名函数+闭包
        f := test(10)
        fmt.Println("------------------------")
        fmt.Println(f(1))
        fmt.Println(f(2))
    
    }
    
    func test(x int) func(int) int {
        fmt.Printf("%p,%d\n", &x, x)
        return func(y int) int {
            fmt.Printf("%p,%d\n", &x, x)
            return x + y
        }
    }

![这里写图片描述][70 1]

--------------------

## defer ##

*  执行方式类似其它语言中的析构函数，在函数体执行结束后
 *  按照调用顺序的相反顺序逐个执行
 *  即使函数发生严重错误也会执行
 *  支持匿名函数的调用
 *  常用于**资源清理**、**文件关闭**、**解锁**以及**记录时间**等操作
 *  通过与匿名函数配合可在return之后修改函数计算结果
 *  如果函数体内某个变量作为defer时匿名函数的参数，则在定义defer
 *  时即已经获得了拷贝，否则则是引用某个变量的地址
 *  Go 没有异常机制，但有 **panic**/**recover** 模式来处理错误
 *  **Panic 可以在任何地方引发**，但**recover只有在defer调用的函数中有效，而且得在panic前面**

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        fmt.Println("a")
        defer fmt.Println("b")
        defer fmt.Println("c")
    
        fmt.Println("------------------")
    
        for i := 0; i < 3; i++ {
            defer func() {
                fmt.Println(i)
            }()
        }
        fmt.Println("---------------")
    }

![这里写图片描述][70 2]

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        A()
        B()
        C()
    }
    
    func A() {
        fmt.Println("func A")
    }
    
    func B() {
        panic("panic in B")
    }
    
    func C() {
        fmt.Println("func C")
    }

![这里写图片描述][70 3]

--------------------

package main
    
    import (
        "fmt"
    )
    
    func main() {
        A()
        B()
        C()
    }
    
    func A() {
        fmt.Println("func A")
    }
    
    func B() {
        defer func() {
            if err := recover(); err != nil {
                fmt.Println("recover in B")
            }
        }()
        panic("panic in B")
    }
    
    func C() {
        fmt.Println("func C")
    }

![这里写图片描述][70 4]

--------------------

package main  
    
    import (  
        "fmt"  
    )  
    
    func main() {  
        var fs = [4]func(){} //声明一个function类型的slice，长度为4 
    
        for i := 0; i < 4; i++ {  
            defer fmt.Println("defer i= ", i)                       //这是一个i作为参数传进去的输出，因为i是int型，所以遵循一个规则值拷贝的传递，还有defer是倒序执行的，所以先后输出3,2,1,0，跟下面的defer交替执行4次 
            defer func() { fmt.Println("defer_closure i = ", i) }() //执行完下面的代码后，到了该defer了，这也是一个匿名函数，同样的也没有参数，也没有定义i，所以这也是个闭包，用的也是外面的i，所以先输出4，接着执行上面的defer，这样反复执行4次 
            fs[i] = func() { fmt.Println("closure i = ", i) }       //把相应的4个匿名函数存到function类型的slice里，因为这是个匿名函数，又没有参数，且也没有定义i，所以i就是外层函数的地址引用，就是for循环的i的地址，执行完for后i的值为4，所以输出4个4 
        }  
    
        for _, f := range fs { //用for循环对slice的调用，f为slice的值，即匿名函数，而f()则是对匿名函数的调用 
            f()  
        }  
    }

![这里写图片描述][70 5]

[70]: /images/20211006/7dd2bf2722f8428888d5d323c7e585c0.png
[70 1]: /images/20211006/23f8dac6f05544959abd0972fdeef9d7.png
[70 2]: /images/20211006/8e670b6b70d347a6afe50409b9e05226.png
[70 3]: /images/20211006/3b5ebabb86814b4ab896aca0b7bf6be7.png
[70 4]: /images/20211006/1b8adc315a724e638ecb31d50fef3f45.png
[70 5]: /images/20211006/c83625e7c35d4950be12bf0c09c450cc.png