重学Golang-函数总结

匿名函数

        匿名函数是指没有名字的函数，使用场景如下：

        1）不带参数的匿名函数

package main
import (
    "fmt"
)

func main(){
    f := func(){
        fmt.Println("不带参数")
    }
    f()
    fmt.Printf("% T\n",f)    
}
输出：
不带参数
func()

        2）带参数的匿名函数

package main
import (
    "fmt"
)

func main(){
    f := func(args string){
        fmt.Println(args)
    }
    f("带参数")
    fmt.Printf("% T\n",f)

    //写法2
    (func(args string){
        fmt.Println(args)
    })("带参数2")

    //写法3
    func(args string){
            fmt.Println(args)
    }("带参数3")
}
输出：
带参数
func(string)
带参数2
带参数3

        3)带返回值的匿名函数

package main
import (
    "fmt"
)

func main(){
    f := func()string{
        return "带返回值"
    }
    fmt.Println(f())

}
输出：
带返回值

        4）返回多个匿名匿名函数的函数

package main
import (
    "fmt"
)


func MultiFunc(a,b int)(func(int)int, func()int){
        f1 := func(c int)int{
                return (a+b)*c
        }

        f2 := func()int{
                return a*b;
        }
        return f1,f2
}
func main(){
    f1,f2 := MultiFunc(2,3)
    fmt.Println(f1(4),f2())

}
输出：
20 6

闭包

        闭包是有函数和与其相关的引用环境组合而成的实体。闭包是从其主体外部引用变量的函数值。函数可以访问并分配给引用的变量，即函数是被“绑定”到了变量上。闭包的实质是函数的嵌套，内层的函数可以使用外层函数的所有变量。

package main

import "fmt"

func Func()func(string)string{
        a := "hello"
        return func(b string)string{
                a += b
                return a
        }
}

func main(){
        a := Func();
        fmt.Println(a("world"))
        fmt.Println(a("shuge"))

}
输出：
helloworld
helloworldshuge

函数可变参数

        Go语言支持可变参数，定义可变参的函数形式如下：

func myFunc(arg ...string){
    for _,v := range arg{
        fmt.Println(v)
    }
}

注意事项

        recover()函数必须要在defer函数中运行

func main(){
    defer func(){
        recover()
    }()
}
多层嵌套、直接调用都无效

        不要在循环中调用defer，但是可以在循环中增加一个局部函数来调用defer