Go语言-函数

函数定义

函数是结构化编程的最小模块单元，使用关键字‘func’定义函数。Go语言定义函数的一些特点总结如下：
- 无需前置声明
- 不支持命名嵌套定义
- 不支持同名函数重载
- 不支持默认参数
- 支持不定长变参
- 支持多返回值
- 支持命名返回值
- 支持匿名函数和闭包
函数属于第一类对象，具备相同签名(参数及返回值类型)的视为同一类型。
定义一个函数：
func test(x int,s string)int{} //其中func为关键字，test为函数名，(x int,s string)为参数列表，int为返回值类型

package main
import(
    "fmt"
)
func hello(){                 //定义一个名为hello的函数，参数列表为空返回值为空
    fmt.Println("hello word!")
}
func main(){                 //main函数程序的入口
    hello()
}

函数只能判断其是否为nil，不支持其它比较操作，从函数返回局部变量指针是安全的。

package main
import(
    "fmt"
)
func test()*int{
    a := 10
    return &a
}
func main(){
    var a *int = test()
    fmt.Println(a,*a)
}

输出：
0xc04203e1d0 10

参数

Go语言不支持有默认值得可选参数，不支持命名实参。调用时，必须按签名顺序传递指定类型和数量的实参，就算以“_”忽略的也不能省略掉。
不管是指针、引用类型，还是其他类型参数，都是值拷贝传递。如果函数参数过多，建议将其定义为一个复合结构类型。

变参

变参本质上就是一个切片。只能接受一个到多个同类型参数，并且放在列表尾部。

package main
import(
    "fmt"
)
func test(s string,a ...int){      //定义一个不定参数的函数，注意'...'不可省略
    fmt.Printf("%s,%T,%v\n",s,a,a) //输出类型及值
}
func main(){
    test("adb",1,2,3,4)
}

输出：
adb,[]int,[1 2 3 4]
既然变参是切片，那么参数复制的仅是切片自身，并不包含底层数组，因此可修改原数据。如果需要可使用内置函数copy复制底层数据。

package main
import(
    "fmt"
)
func test(a ...int){
    for i := range a{
        a[i] += 10
    }
}
func main(){
    a := []int{1,2,3,4}
    test(a...)
    fmt.Println(a)
}

输出:
[11 12 13 14]

返回值

有返回值得函数必须有明确的return语句，除非有panic或者无break的死循环则无需return语句。

package main
import(
    "fmt"
    "errors"
)
func test(x,y int)(int,error){    //函数多返回值
    if 0 == y{
        return 0,errors.New("Can not be zero")
    }
    return x/y ,nil
}
func main(){
    a,ret := test(2,4)
    if nil != ret{
        fmt.Println(ret)
    }else{
        fmt.Println(a)
    }
}

输出：
0

命名返回值

使用命名返回值，可直接使用return隐式返回，如果返回值类型能明确表明其含义，就尽量不要对其命名

package main
import(
    "fmt"
    "errors"
)
func test(x,y int)(a int,err error){   //显示的定义了函数返回值
    if 0 == y{
        err = errors.New("Can not be zero")
        return
    }
    a = x/y
    return 
}
func main(){
    a,ret := test(4,0)
    if nil != ret{
        fmt.Println(ret)
    }else{
        fmt.Println(a)
    }
}

输出：
Can not be zero

匿名函数

匿名函数是指没有定义名字的函数。除没有名字外，匿名函数和普通函数完全相同。最大的区别是我们可在函数内部定义匿名函数，形成类似嵌套效果。匿名函数可直接调用，保存到变量，作为参数或返回值。
直接执行：

package main
import(
    "fmt"
)
func main(){
    func(s string){      //匿名函数，无函数名
        fmt.Println(s)
    }("hello word")
}

输出：
hello word
赋值给变量：

package main
import(
    "fmt"
)
func main(){
    add := func(x,y int)int{
        return x+y
    }
    fmt.Println(add(1,2))
}

输出:
3
作为参数:

package main
import(
    "fmt"
)
func test(f func()){
    f()
}
func main(){
    test(func(){
        fmt.Println("hello")
    })
}

输出：
hello
作为返回值

package main
import(
    "fmt"
)
func test() func(int,int)int{
    return func(x,y int)int{
        return x+y
    }
}
func main(){
    add := test()
    fmt.Println(add(1,2))
}

输出：
3
普通函数和匿名函数都可以作为结构体字段，或经通道传递。不曾使用的匿名函数会被编译器当做错误。
闭包
闭包(closure)是在其词法上下问引用了自由变量的函数，或者说是函数和其引用的环境组合体。

package main
import(
    "fmt"
)
func test(x int) func(){
    return func(){
        fmt.Println(x)
    }
}
func main(){
    f := test(123)
    f()
}

输出：123
就以上代码而言，test返回的匿名函数会引用上下文环境变量x。当该函数在main中执行时，它依然可正确读取x的值，这种现象就称作闭包。闭包直接引用了原环境变量。
正因为闭包通过指针引用环境变量，那么可能会导致其生命周期延长，甚至被分配到堆内。解决的办法就是每次用不同的环境变量或传参复制，让各自闭包环境各不相同。

延迟调用

语句defer向当前函数注册稍后执行的函数调用。这些函数被称作延迟调用，因为它们直到当前函数函数执行结束前才被执行，常用语资源释放、解除锁定、以及错误处理等操作。

func main(){
    f,err := os.Open("./test.go")
    if err != nil{
        log.Fatalln(err)
    }
    defer f.Close()    //仅注册，直到mian函数退出之前才执行
    ...do something...
}

注意：延迟调用注册的是调用，必须提供执行所需参数(哪怕为空)。参数值在注册时被复制并缓存起来。如对状态敏感，可改用指针或闭包。

package main
import(
    "fmt"
)
func main(){
    x,y := 1,2
    defer func(a int){
        fmt.Println("defer x,y = ",a,y)
    }(x)
    x += 10
    y += 20
    fmt.Println(x,y)
}

输出:
11 22
defer x,y = 1 22
延迟调用可修改当前函数命名返回值，但其自身返回值被抛弃，多个延迟注册按FILO次序（先进后出）执行。

错误处理

error
官方推荐的标准做法是返回error状态
func test(a …interface{})(n int,err error)
标准库将error定义为接口类型，以便实现自定义错误类型。按照惯例，error总是最后一个返回参数。标准库提供了相关创建函数，可方便的创建包含简单错误文本的error对象。

package main
import(
    "fmt"
    "errors"
)
func test(x,y int)(a int,err error){   
    if 0 == y{
        err = errors.New("Can not be zero")//设置了返回错误
        return
    }
    a = x/y
    return 
}
func main(){
    a,ret := test(4,0)
    if nil != ret{
        fmt.Println(ret)
    }else{
        fmt.Println(a)
    }
}

某些时候我们需要自定义错误类型，以容纳更多上下文状态信息。这样做还可以基于类型做出判断

package main
import(
    "fmt"
)
type DivError struct{    //自定义错误类型
    x,y int
}
func (DivError) Error() string{  //实现Error接口方法
    return "division by zero"
}
func div(x,y int)(int,error){
    if y == 0{
        return -1,DivError{x,y}    //返回自定义错误类型
    }
    return x/y,nil
}
func main(){
    z,err := div(5,0)
    if err != nil{
        switch e := err.(type){     //根据错误类型匹配
            case DivError:
                fmt.Println(e,e.x,e.y)
            default:
                fmt.Println(e)
        }
    }
    fmt.Println(z)
}

输出：
division by zero 5 0
-1
panic，recover
与error相比，panic/recover在使用方法更接近try/catch结构化异常。但是它们是内置函数而非语句。panic会立即中断当前函数流程，执行延迟调用。而在延迟调用函数中recover可捕获并返回panic提交的错误对象。

func main(){
    defer func(){
        if err := recover(); err != nil{ //捕获错误
            fmt.Println("erro")
        }
    }()
    panic("dead")                        //引发错误
    fmt.Println("exit")                  //永不会执行
}

因为panic参数是空接口类型，因此可使用任何对象作为错误状态。而recover返回结果同样要做转型才能获得具体信息。
无论是否执行recover，所有延迟调用都会被执行。但中断性错误会沿用堆栈向外传递，要么被外层捕获，要么进程崩溃。连续的调用panic，仅最后一个会被recover捕获。
在延迟函数中panic，不会影响后续延迟调用执行。而recover之后panic，可被再次捕获。另外，recover必须在延迟调用 函数中执行才能正常工作。
建议：除非是不可恢复性、导致系统无法正常工作的错误，否则不建议使用panic