函数

Go不是一门纯函数式的编程语言，但是函数在Go中是“第一公民”，表现在：

1. 函数是一种类型，函数类型变量可以像其他类型变量一样使用，可以作为其他函数的参数或返回值，也可以直接调用执行。
2. 函数支持多值返回。
3. 支持闭包。
4. 函数支持可变参数。

Go是通过编译成本地代码且基于“堆栈”式执行的，Go的错误处理和函数也有千丝万缕的联系。

函数定义

函数是Go程序源代码的基本构造单位，一个函数的定义包括如下几个部分：
1.函数声明关键字func
2.函数名
3.参数列表
4.返回列表
5.函数体。
函数名遵循标识符的命名规则，首字母的大小写决定该函数在其他包的可见性：大写时其他包可见，小写时只有相同的包可以访问；
函数的参数和返回值需要使用“()”包裹，如果只有一个返回值，而且使用的是非命名的参数，则返回参数的“()”可以省略。
函数体使用“{}”包裹，并且“{”必须位于函数返回值同行的行尾。

func funcName(param-list) (result-list) {
    function-body
}

函数的特点

• 函数可以没有输入参数，也可以没有返回值（默认返回0）。

func A() {
    //do something 
    //...
}

func A() int {
    //do something 
    //...
    return 1
）

• 多个相邻的相同类型的参数可以使用简写模式。

func add(a, b int) int {    //a int, b int简写为a, b int 
    return a+b
}

• 支持有名的返回值，参数名就相当于函数体内最外层的局部变量，命名返回值变量会被初始化为类型零值，最后的return可以不带参数名直接返回。

//sum 相当于函数内的局部变量，被初始化为0
func add(a, b int) (sum int) {  //sum 是命名返回值变量
    sum = a + b
    return  //return sum 简写
    //sum := a + b  //如果是sum := a + b,则相当于新声明一个sum变量命名返回变量sum覆盖
    //return sum    //需要显式的调用return sum
}

• 不支持默认值参数。
• 不支持函数重载。
• 不支持命名函数的嵌套定义，但支持嵌套匿名函数。

func add(a, b int) (sum int) {
    anonymous := fumc(x, y int) int {
        return x + y
    }
    return anonymous(a, b)
}

多值返回

Go函数支持多值返回，定义多值返回的返回参数列表时要使用“()”包裹，支持命名参数的返回。

fune swap(a，b int) (int, int){
    return b, a
}

注意：
如果多值返回值有错误类型，则一般将错误类型作为最后一个返回值。

实参➳形参

Go函数实参到形参的传递永远是值拷贝，有时函数调用后实参指向的值发生了变化，那是因为参数传递的是指针值的拷贝，实参是一个指针变量，传递给形参的是这个指针变量的副本，二者指向同一地址，本质上参数传递仍然是值拷贝。

func chvalue(a int) int {
    a = a + 1
    return a
}

func chpointer(a *int) {
    *a = *a + 1
}

func main() {
    a := 10
    chvalue(a)
    fmt.Println(a) //10 ，实参传递给形参是值拷贝
    chpointer(&a)
    fmt.Println(a) //11，仍然是值拷贝，但是复制的是地址值
}

不定参数

Go函数支持不定数目的形式参数，不定参数声明使用param ...type的语法格式。
函数的不定参数有如下几个特点：

• 所有的不定参数类型必须是相同的。
• 不定参数必须是函数的最后一个参数。
• 不定参数名在函数体内相当于切片，对切片的操作同样适合对不定参数的操作。

func sum(arr ...int) (sum int) {
    for _, v := range arr { //此时 arr 就相当于切片，可以使用 range 访问
        sum += v
    }
    return
}

• 切片可以作为参数传递给不定参数，切片名后要加上“...”。

func sum(arr ...int) (sum int) {
    for _, v := range arr { //此时 arr 就相当于切片，可以使用 range 访问
        sum += v
    }
    return
}

func main() {
    slice := []int{1, 2, 3, 4}    //切片
    array := [...]int{1, 2, 3, 4} //数组
    //数组不可以作为实参传递给不定参数的函数
    sum(slice...)
}

• 形参为不定参数的函数和形参为切片的函数类型不相同。

func suma(arr ...int) (sum int) {
    for _, v := range arr { //此时 arr 就相当于切片，可以使用 range 访问
        sum += v
    }
    return
}

func sumb(arr []int) (sum int) {
    for v := range arr {
        sum += v
    }
    return
}

func main() {
    fmt.Printf("%T", suma) //func(...int) int
    fmt.Printf("%T", sumb) //func([]int) int
}

函数签名

函数类型又叫函数签名，一个函数的类型就是函数定义首行去掉函数名、参数名和"{"，可以使用fimt.Printf的“%T“格式化参数打印函数的类型。如上程序。
两个函数类型相同的条件是：拥有相同的形参列表和返回值列表（列表元素的次序、个数和类型都相同），形参名可以不同。以下2个函数的函数类型完全一样。

func add(a，b int) int { return a+b }
func sub(x int, y int)(c int) { c = x-y; return c }

可以使用type定义函数类型，函数类型变量可以作为函数的参数或返回值

package main

import "fmt"

func add(a, b int) int {
    return a + b
}

func sub(a, b int) int {
    return a - b
}

type Op func(int, int) int //定义一个函数类型，输入的是两个int类型，返回值是一个int类型

func do(f Op, a, b int) int {
    return f(a, b) //函数类型变量可以直接用来进行函数调用
}

func main() {

    a := do(add, 1, 2) //函数名add可以当作相同函数类型形参
    fmt.Println(a)     //3
    s := do(sub, 1, 2)
    fmt.Println(s) //-1
}

函数类型和map、slice、chan一样，实际函数类型变量和函数名都可以当作指针变量，该指针指向函数代码的开始位置。
通常说函数类型变量是一种引用类型，未初始化的函数类型的变量的默认值是nil。
Go中有名函数的函数名可以看作函数类型的常量，可以直接使用函数名调用函数，也可以直接赋值给函数类型变量，后续通过该变量来调用该函数。

package main

func sum(a, b int) int {
    return a + b
}

func main() {
    sum(3, 4)   //1.直接调用
    f := sum    //2.有名函数可以直接赋值给变量
    f(1, 2)
}

匿名函数

匿名函数可以看作函数字面量，所有直接使用函数类型变量的地方都可以由匿名函数代替。匿名函数可以直接赋值给函数变量，可以当作实参，也可以作为返回值，还可以直接被调用。

package main

import "fmt"

//匿名函数被直接赋值函数变量
var sum = func(a, b int) int {
    return a + b
}

func doinput(f func(int, int) int, a, b int) int {
    return f(a, b)
}

func wrap(op string) func(int, int) int {
    switch op {
    case "add":
        return func(a, b int) int {
            return a + b
        }
    case "sub":
        return func(a, b int) int {
            return a - b
        }
    default:
        return nil
    }

}

func main() {
    //匿名函数直接被调用
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()
    sum(1, 2)

    //匿名函数作为实参
    doinput(func(x, y int) int {
        return x + y
    }, 1, 2)

    opFunc := wrap("add")
    re := opFunc(2, 3) //5
    fmt.Printf("%d\n", re)
}

defer

• Go函数里提供了defer关键字，可以注册多个延迟调用，这些调用以先进后出（FILO）的顺序在函数返回前被执行。这有点类似于Java语言中异常处理中的finally子句。defer常用于保证一些资源最终一定能够得到回收和释放。

package main

func main() {
    //先进后出
    defer func() {
        println("first")
    }()
    defer func() {
        println("second")
    }()
    println("function bldy")
}

//结果(先注册，后执行)
//function bldy
//second
//first

• defer 后面必须是函数或方法的调用，不能是语句，否则会报expression in defer must be function call错误。
• defer 函数的实参在注册时通过值拷贝传递进去。下面示例代码中，实参a的值在defer注册时通过值拷贝传递进去，后续语句a++并不会影响defer语句最后的输出结果。

func f() int {
    a := 0
    defer func(i int) {
        println("defer i=", i) //defer i= 0
    }(a)    //a注册时是以值拷贝传递，所以先执行a++也不会影响注册时的a值
    a++
    return a
}

func main() {
    a := f()
    fmt.Println(a) //1
}

• defer语句必须先注册后才能执行，如果defer位于return之后，则defer因为没有注册，不会执行。
• 主动调用os.Exit(int)退出进程时，defer将不再被执行（即使defer已经提前注册）。

func main() {
    defer func() {
        println("defer")
    }()
    println("func body")
    os.Exit(1)
}
//运行结果
//func body

defer的好处是可以在一定程度上避免资源泄漏，特别是在有很多return语句，有多个资源需要关闭的场景中，很容易漏掉资源的关闭操作。例如：

func CopyFile(dst, src string) (w int64, err error) {
    src, err := os.Open(src)
    if err != nil {
        return
    }
    dst, err := os.Create(dst)
    if err != nil {
        src.Close() //src 很容易忘记关闭
        return
    }
    w, err = io.Copy(dst, src)
    dst.Close()
    src.Close()
    return
}

使用defer改写后，在打开资源无报错后直接调用defer关闭资源，一旦养成这样的编程习惯，则很难会忘记资源的释放。

func CopyFile(dst, src string) (w int64, err error) {
    src, err := os.Open(src)
    if err != nil {
        return
    }
    defer src.Close
    dst, err := os.Create(dst)
    if err != nil {
        return
    }
    defer dst.Close()
    w, err = io.Copy(dst, src)
    return
}

defer语句的位置不当，有可能导致panic，一般 defer 语句放在错误检查语句之后。
defer也有明显的副作用：defer会推迟资源的释放，defer尽量不要放到循环语句里面，将大函数内部的defer语句单独拆分成一个小函数是一种很好的实践方式。
defer相对于普通的函数调用需要间接的数据结构的支持，相对于普通函数调用有一定的性能损耗。
defer中最好不要对有名返回值参数进行操作，否则会引发匪夷所思的结果。

闭包

闭包是由函数及其相关引用环境组合而成的实体，一般通过在匿名函数中引用外部函数的局部变量或包全局变量构成。
闭包=函数+引用环境
闭包对闭包外的环境引入是直接引用，编译器检测到闭包，会将闭包引用的外部变量分配到堆上。
如果函数返回的闭包引用了该函数的局部变量（参数或函数内部变量）：
（1）多次调用该函数，返回的多个闭包所引用的外部变量是多个副本，原因是每次调用函数都会为局部变量分配内存。
（2）用一个闭包函数多次，如果该闭包修改了其引用的外部变量，则每一次调用该闭包对该外部变量都有影响，因为闭包函数共享外部引用。
示例如下：

func fa(a int) func(i int) int {
    return func(i int) int {
        println(&a, a)
        a = a + i
        return a
    }
}

func main() {
    f := fa(1) //f引用的外部的闭包环境包括本次函数调用的形参a的值1
    g := fa(1) //g引用的外部的闭包环境包括本次函数调用的形参a的值1

    println(f(1))
    println(f(1))

    println(g(1))
    println(g(1))
}
/*
运行结果：
0xc00004a000 1
2
0xc00004a000 2
3
0xc00004a008 1
2
0xc00004a008 2
3
*/

f和g引用的是不同的a。
如果一个函数调用返回的闭包引用修改了全局变量，则每次调用都会影响全局变量。
如果函数返回的闭包引用的是全局变量a，则多次调用该函数返回的多个闭包引用的都是同一个a。同理，调用一个闭包多次引用的也是同一个a。此时如果闭包中修改了a值的逻辑，则每次闭包调用都会影响全局变量a的值。使用闭包是为了减少全局变量，所以闭包引用全局变量不是好的编程方式。

var (
    a = 0
)

func fa() func(i int) int {
    return func(i int) int {
        println(&a, a)
        a = a + 1
        return a
    }
}

func main() {
    f := fa()     //f引用外部的闭包环境包括全局变量a
    g := fa()     //g引用的外部环境闭包环境包括全局变量a
    println(f(1)) //1
    println(g(1)) //2
    println(f(1)) //3
    println(g(1)) //4
}

/*
运行结果：
0x4e49f8 0
1
0x4e49f8 1
2
0x4e49f8 2
3
0x4e49f8 3
4
*/

用一个函数返回的多个闭包共享该函数的局部变量。

func fa(base int) (func(int) int, func(int) int) {
    println(&base, base)

    add := func(i int) int {
        base += i
        println(&base, base)
        return base
    }

    sub := func(i int) int {
        base -= i
        println(&base, base)
        return base
    }

    return add, sub
}

func main() {
    f, g := fa(0)   //f、g 闭包引用的 base 是同一个，是 fa 函数调用传递过来的实参值
    s, k := fa(0)   //s、k 闭包引用的 base 是同一个，是 fa 函数调用传递过来的实参值
    println(f(1), g(2))
    println(s(1), k(2))
}

闭包最初的目的是减少全局变量，在函数调用的过程中隐式地传递共享变量，有其有用的一面；但是这种隐秘的共享变量的方式带来的坏处是不够直接，不够清晰，除非是非常有价值的地方，一般不建议使用闭包。
对象是附有行为的数据，而闭包是附有数据的行为，类在定义时已经显式地集中定义了行为，但是闭包中的数据没有显式地集中声明的地方，这种数据和行为耦合的模型不是一种推荐的编程模型，闭包仅仅是锦上添花的东西，不是不可缺少的。

panic & recover

但在有些情况，当程序发生异常时，无法继续运行。在这种情况下，我们会使用 panic 来终止程序。当函数发生 panic 时，它会终止运行，在执行完所有的延迟函数后，程序控制返回到该函数的调用方。这样的过程会一直持续下去，直到当前协程的所有函数都返回退出，然后程序会打印出 panic 信息，接着打印出堆栈跟踪（Stack Trace），最后程序终止。当程序发生 panic 时，使用 recover 可以重新获得对该程序的控制。

可以认为 panic 和 recover 与其他语言中的 try-catch-finally 语句类似，只不过一般我们很少使用 panic 和 recover。而当我们使用了 panic 和 recover 时，也会比 try-catch-finally 更加优雅，代码更加整洁。

什么时候应该使用 panic?
(需要注意的是：你应该尽可能地使用错误，而不是使用 panic 和 recover。只有当程序不能继续运行的时候，才应该使用 panic 和 recover 机制)

panic 有两个使用情况：

1. 发生了一个不能恢复的错误，此时程序不能继续运行。 主动调用panic函数结束程序运行。
   例如： web 服务器无法绑定所要求的端口。在这种情况下，就应该使用 panic，因为如果不能绑定端口，啥也做不了。

2. 发生了一个编程上的错误。 在调试程序中，通过主动调用panic来实现快速推出，painc打印出的堆栈能更快的定位错误。
   例如：我们有一个接收指针参数的方法，而其他人使用 nil 作为参数调用了它。在这种情况下，我们可以使用 panic，因为这是一个编程错误：用 nil 参数调用了一个只能接收合法指针的方法。

为了保证程序的健壮性，需要主动在程序的分支流程上使用recover()拦截运行时错误。

panic和recover的函数签名如下：

panic(i interface{})
recover()interface{}

panic用法挺简单的, 其实就是throw exception。panic是golang的内建函数，panic会中断函数F的正常执行流程, 从F函数中跳出来, 跳回到F函数的调用者。 对于调用者来说, F看起来就是一个panic, 所以调用者会继续向上跳出, 直到当前goroutine返回。在跳出的过程中, 进程会保持这个函数栈。 当goroutine退出时, 程序会crash。

要注意的是, F函数中的defer定义的函数会正常执行, 按照defer的规则。

同时引起panic除了我们主动调用panic之外, 其他的任何运行时错误, 例如数组越界都会造成panic
调用panic的方法非常简单:panic(xxx)。

package main

import (
    "fmt"
)

func main() {
    test()
}

func test() {
    defer func() { fmt.Println("打印前") }()
    defer func() { fmt.Println("打印中") }()
    defer func() { fmt.Println("打印后") }()
    panic("触发异常")
    fmt.Println("test")
}
/* 
运行结果：
打印后
打印中
打印前
panic: 触发异常

goroutine 1 [running]:
main.test()
    C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:15 +0xd1
main.main()
    C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:8 +0x27

Process finished with exit code 2
 */

panic与defer
panic 其实是一个终止函数栈执行的过程,但是在函数退出前都会执行defer里面的函数，直到所有的函数都退出后,才会执行panic。发生panic后，程序会从调用panic的函数位置或发生panic的地方立即返回，逐层向上执行函数的defer 语句，然后逐层打印函数调用堆栈，直到被recover 捕获或运行到最外层函数而退出。

func fullName(firstName *string, lastName *string) {
    defer fmt.Println("deferred call in fullName")

    if firstName == nil {
        panic("runtime error: first name cannot be nil")
    }
    if lastName == nil {
        panic("runtime error: last name cannot be nil")
    }
    fmt.Printf("%s %s\n", *firstName, *lastName)
    fmt.Println("returned normally from fullName")
}

func main() {
    defer fmt.Println("deferred call in main")
    firstName := "Elon"
    fullName(&firstName, nil)
    fmt.Println("returned normally from main")
}
/*
运行结果：
deferred call in fullName
deferred call in main
panic: runtime error: last name cannot be nil

goroutine 1 [running]:
main.fullName(0xc00007df20, 0x0)
    C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:14 +0x255
main.main()
    C:/Users/WINDSUN/Desktop/Golang/CloseFunc.go:23 +0xe0

Process finished with exit code 2
*/

panic不但可以在函数正常流程中抛出，在defer逻辑里也可以再次调用panic或抛出panic。如果defer中也有panic 那么会依次按照发生panic的顺序执行。

recover也是golang的一个内建函数， 其实就是try catch。
不过需要注意的是：
　　1. recover如果想起作用的话， 必须在defer函数中使用。
　　2. 在正常函数执行过程中，调用recover没有任何作用, 他会返回nil。如这样：fmt.Println(recover()) 。
　　3. 如果当前的goroutine panic了，那么recover将会捕获这个panic的值，并且让程序正常执行下去。不会让程序crash。

package main

import "fmt"

func main() {
    fmt.Println("c")
    defer func() { // 必须要先声明defer，否则不能捕获到panic异常
        fmt.Println("d")
        if err := recover(); err != nil {
            fmt.Println(err) // 这里的err其实就是panic传入的内容
        }
        fmt.Println("e")
    }()
    f()              //开始调用f
    fmt.Println("f") //这里开始下面代码不会再执行
}

func f() {
    fmt.Println("a")
    panic("异常信息")
    fmt.Println("b") //这里开始下面代码不会再执行
}

/*
运行结果：
c
a
d
异常信息
e

Process finished with exit code 0
 */

可以有连续多个panic被抛出，连续多个panic的场景只能出现在延迟调用里面，否则不会出现多个panic被抛出的场景。但只有最后一次panic能被捕获。

package main

import "fmt"

func main() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }()

    //只有最后一次panic调用能够被捕获
    defer func() {
        panic("first defer panic")
    }()

    defer func() {
        panic("second defer panic")
    }()

    panic("main body panic")
}

/*
运行结果：
first defer panic
*/

错误处理

Go的错误处理涉及接口的相关知识。
error
Go 语言内置错误接口类型error。任何类型只要实现Error() string方法，都可以传递error接口类型变量。Go语言典型的错误处理方式是将error作为函数最后一个返回值。在调用函数时，通过检测其返回的error值是否为nil来进行错误处理。

type error interface {
    Error() string
}

Go语言标准库提供的两个函数返回实现了error接口的具体类型实例，一般的错误可以使用这两个函数进行封装。遇到复杂的错误，用户也可以自定义错误类型，只要其实现error接口即可。例如：

//http://golang. org/src/pkg/fmt/print. go
//ErrOFf formats according to a format specifier and returns the string
//as a value that satisfies error.
func Errorf(format string, a... interface{}) errort {
    return errors.New(Sprintf(format,a...))
}
//http://golang. org/src/pkg/errors/errors. go
//New returns an error that formats as the given text.
func New(text string) error {
return &errorString{ text }
}

错误处理的最佳实践:

• 在多个返回值的函数中，error通常作为函数最后一个返回值。
• 如果一个函数返回error类型变量，则先用if语句处理error!=nil的异常场景，正常逻辑放到if语句块的后面，保持代码平坦。
• defer 语句应该放到err判断的后面，不然有可能产生panic。
• 在错误逐级向上传递的过程中，错误信息应该不断地丰富和完善，而不是简单地抛出下层调用的错误。这在错误日志分析时非常有用和友好。

错误和异常
广义上的错误：发生非期望的行为
狭义的错误：发生非期望的已知行为，这里的已知是指错误的类型是预料并定义好的。
异常：发生非期望的未知行为，未知是指错误的类型不在预先定义的错误。异常又被称为未捕获的错误。未捕获由操作系统进行异常处理，如C语言中的段错误。
错误关系如图：

Go是一门类型安全的语言，其运行时不会出现这种编译器和运行时都无法捕获的错误，也就是说，不会出现untrapped error，所以从这个角度来说，Go语言不存在所谓的异常，出现的“异常”全是错误。
Go程序需要处理的这些错误可以分为两类：

• 一类是运行时错误（runtime errors），此类错误语言的运行时能够捕获，并采取措施---隐式或显式地抛出panic。
• 一类是程序逻辑错误：程序执行结果不符合预期，但不会引发运行时错误。
  对于运行时错误，程序员无法完全避免其发生，只能尽量减少其发生的概率，并在不影响程序主功能的分支流程上“recover”这些panic，避免其因为一个panic引发整个程序的崩溃。

Go对于错误提供了两种处理机制：
（1）通过函数返回错误类型的值来处理错误。
（2）通过panic打印程序调用栈，终止程序执行来处理错误。

error和panic使用遵循如下规则：
（1）程序发生的错误导致程序不能容错继续执行，此时程序应该主动调用panic或由运行时抛出panic。
（2）程序虽然发生错误，但是程序能够容错继续执行，此时应该使用错误返回值的方式处理错误，或者在可能发生运行时错误的非关键分支上使用recover 捕获panic。

go的整个错误处理过程如图：

Go程序的有些错误是在运行时进行检测的，运行期的错误检测包括空指针、数组越界等。
如果运行时发生错误，则程序出于安全设计会自动产生panic。另外，程序在编码阶段通过主动调用panic来进行快速报错，这也是一种有效的调试手段。