一.异常处理
所谓的异常：当GO检测到一个错误时，程序就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。
所以为了保证程序的健壮性，要对异常的信息进行处理。例如,如下程序，定义一个函数实现整除操作，这个程序对大家来说已经很简单了，实现如下：
func Test(a, b int) int {
var result int
result = a / b
return result
}
但是，大家仔细考虑一下，该方法是否有问题？
如果b的值为0，会出现什么情况？
程序会出现以下的异常信息：
panic: runtime error: integer divide by zero
并且整个程序停止运行。
那么出现这种情况，应该怎样进行处理呢？这时就要用到异常处理方法的内容。
1.1 error接口
Go语言引入了一个关于错误处理的标准模式，即error接口，它是Go语言内建的接口类型，该接口的定义如下：
type error interface {
Error() string
}
Go语言的标准库代码包errors为用户提供如下方法：
package errors
// New returns an error that formats as the given text.
func New(text string) error {
return &errorString{text}
}
// errorString is a trivial implementation of error.
type errorString struct {
s string
}
func (e *errorString) Error() string {
return e.s
}
通过以上代码，可以发现error接口的使用是非常简单的（error是一个接口，该接口只声明了一个方法Error()，返回值是string类型，用以描述错误）。下面看一下基本使用,
首先导包：
import "errors"
然后调用其对应的方法：
func main() {
err := errors.New("This is a normal err")
fmt.Println("err:", err.Error())
}
当然fmt包中也封装了一个专门输出错误信息的方法，如下所示：
err := fmt.Errorf("%s", "This is a normal err")
fmt.Println("err:", err)
了解完基本的语法以后，接下来使用error接口解决Test( )函数被0整除的问题，如下所示：
func Test(a, b int) (result int, err error) {
err = nil
if b == 0 {
err = errors.New("除数不能为0")
} else {
result = a / b
}
return result, err
}
func main() {
res, err := Test(10, 0)
if err != nil {
fmt.Println("err:", err)
} else {
fmt.Println(res)
}
}
在Test( )函数中，判断变量b的取值，如果有误，返回错误信息。并且在main( )中接收返回的错误信息，并打印出来。
这种用法是非常常见的，例如，后面讲解到文件操作时，涉及到文件的打开，如下：
func Open(name string) (*File, error)
在打开文件时，如果文件不存在，或者文件在磁盘上存储的路径写错了，都会出现异常，这时可以使用error记录相应的错误信息。
1.2 panic函数
error返回的是一般性的错误，但是panic函数返回的是让程序崩溃的错误。也就是当遇到不可恢复的错误状态的时候，如数组访问越界、空指针引用等，这些运行时错误会引起painc异常，在一般情况下，我们不应通过调用panic函数来报告普通的错误，而应该只把它作为报告致命错误的一种方式。当某些不应该发生的场景发生时，我们就应该调用panic。
一般而言，当panic异常发生时，程序会中断运行。随后，程序崩溃并输出日志信息。日志信息包括panic value和函数调用的堆栈跟踪信息。
当然，如果直接调用内置的panic函数也会引发panic异常；panic函数接受任何值作为参数。
下面给大家演示一下，直接调用panic函数，是否会导致程序的崩溃。
func TestA() {
fmt.Println("func TestA()")
}
func TestB() {
panic("func TestB(): panic")
}
func TestC() {
fmt.Println("func TestcC()")
}
func main() {
TestA()
TestB() //TestB()发生异常，中断程序
TestC()
}
错误信息如下：
panic: func TestB(): panic func TestA() goroutine 1 [running]: main.TestB(...) /Users/guanyuji/go/src/awesomeProject/Go基础班第8天/01.go:45 main.main() /Users/guanyuji/go/src/awesomeProject/Go基础班第8天/01.go:54 +0x98 Process finished with exit code 2
所以，我们在实际的开发过程中并不会直接调用panic( )函数，但是当我们编程的程序遇到致命错误时，系统会自动调用该函数来终止整个程序的运行，也就是系统内置了panic函数。
下面给大家演示一个数组下标越界的问题：
func TestA() {
fmt.Println("func TestA()")
}
func TestB(x int) {
var a [10]int
a[x] = 222
}
func TestC() {
fmt.Println("func TestcC()")
}
func main() {
TestA()
TestB(11)
TestC()
}
错误信息如下：
func TestA() panic: runtime error: index out of range goroutine 1 [running]: main.TestB(...) /Users/guanyuji/go/src/awesomeProject/Go基础班第8天/01.go:46 main.main() /Users/guanyuji/go/src/awesomeProject/Go基础班第8天/01.go:55 +0x7d Process finished with exit code 2
通过观察错误信息，发现确实是panic异常，导致了整个程序崩溃。
1.3 延迟调用defer
(1)defer的基本使用
函数定义完成后，只有调用函数才能够执行，并且一经调用立即执行。例如：
fmt.Println("hello")
fmt.Println("world")
先输出"hello"，再输出"world"。
但是关键字defer ⽤于延迟一个函数（或者当前所创建的匿名函数）的执行(注意，defer语句只能出现在函数的内部)。将一个方法延迟到包裹该方法的方法返回时执行，在实际应用中，defer语句可以充当其他语言中try…catch…的角色，也可以用来处理关闭文件句柄等收尾操作。
基本用法如下：
defer fmt.Println("hello")
fmt.Println("world")
以上两行代码，输出的结果为，先输出"world"，再输出"hello"。
(2)defer触发时机
A "defer" statement invokes a function whose execution is deferred to the moment the surrounding function returns, either because the surrounding function executed a return statement, reached the end of its function body, or because the corresponding goroutine is panicking.
Go官方文档中对defer的执行时机做了阐述，分别是。
- 包裹defer的函数返回时
- 包裹defer的函数执行到末尾时
- 所在的goroutine发生panic时
(3)defer的执行顺序
一个方法中有多个defer时， defer会将要延迟执行的方法“压栈”，当defer被触发时，将所有“压栈”的方法“出栈”并执行。所以defer的执行顺序是LIFO(先进后出)的。
所以下面这段代码的输出不是1 2 3，而是3 2 1。
func main() {
defer func() {
fmt.Println(1)
}()
defer func() {
fmt.Println(2)
}()
defer func() {
fmt.Println(3)
}()
}
(4)defer与return,函数返回值之间的顺序
先说结论：return最先执行->return负责将结果写入返回值中->接着defer开始执行一些收尾工作->最后函数携带当前返回值退出
返回值的表达方式，我们知道根据是否提前声明有两种方式：一种是func test() int 另一种是 func test() (i int)，所以两种情况都来说说：
先看一下：func test() int
func Test() int {
i := 0
defer func() {
i++
fmt.Println("defer2的值:", i)
}()
defer func() {
i++
fmt.Println("defer1的值:", i)
}()
return i
}
func main() {
fmt.Println("main:", Test())
}
结果如下：
defer1的值: 1 defer2的值: 2 main: 0
上面函数Test的返回值属于匿名返回值，返回值在return的时候才确定下来是i的值，具体过程如下：
- 将i赋值给返回值（可以理解成Go自动创建了一个返回值retValue，相当于执行retValue = i）
- 然后检查是否有defer，如果有则执行
- 返回刚才创建的返回值（retValue）
在这种情况下，defer中的修改是对i执行的，而不是retValue，所以defer返回的依然是retValue。
再看一下：func test() (i int)
func Test() (i int) {
defer func() {
i++
fmt.Println("defer2的值:", i)
}()
defer func() {
i++
fmt.Println("defer1的值:", i)
}()
return i
}
func main() {
fmt.Println("main:", Test())
}
结果如下：
defer1的值: 1 defer2的值: 2 main: 2
这里的函数Test的返回值属于命名返回值，在命名返回值方法中，由于返回值在方法定义时已经被定义，所以没有创建retValue的过程，i就是retValue，defer对于i的修改也会被直接返回。
(5)defer的定义和执行是两个步骤
先说结论：会先将defer后函数的参数部分的值(或者地址)给先记下来【你可以理解为()里头参数的值的会先确定】，后面函数执行完，才会执行defer后函数的{}中的逻辑。
func test(i int) int {
return i
}
func main() {
var i int = 1
//defer定义时候test(i)的值就已经确定了，是1，之后就不会变了
defer fmt.Println("i1 = ",test(i))
i++
//defer定义时候test(i)的值就已经确定了，是2，之后就不会变了
defer fmt.Println("i2 = ",test(i))
//defer在定义的时候，i就已经确定了是一个指针类型，地址上的值变了，这里跟着变，是2
defer func(i *int) {
fmt.Println("i3 = ",*i)
}(&i)
//defer在定义的时候，i就已经确定了，是2，之后就不会变了
defer func(i int) {
fmt.Println("i4 = ",i)
}(i)
defer func() {
// 地址，所以后续跟着变
var c = &i
fmt.Println("i5 =" , *c)
}()
// 执行了 i=11 后才调用，此时i值已是11
defer func() {
fmt.Println("i6 =" , i)
}()
i = 11
结果如下：
i6 = 11 i5 = 11 i4 = 2 i3 = 11 i2 = 2 i1 = 1
(6)尽量避免在for循环中使用defer
看下面的代码：
func DeferTest() {
for i := 0;i < 100;i++{
f,_ := os.Open("/etc/hosts")
defer f.Close()
}
}
func main() {
DeferTest()
}
这是一个循环可打开文件的函数(文件操作之后讲到)，defer在紧邻创建资源的语句后声明，看上去逻辑没有什么问题。但是和直接调用相比，defer的执行存在着额外的开销，例如defer会对其后需要的参数进行内存拷贝，还需要对defer结构进行压栈出栈操作。所以在循环中定义defer可能导致大量的资源开销，在本例中，可以将f.Close()语句前的defer去掉，来减少大量defer导致的额外资源消耗。
(7)判断执行没有err之后，再defer释放资源
一些获取资源的操作可能会返回err参数，我们可以选择忽略返回的err参数，但是如果要使用defer进行延迟释放的的话，需要在使用defer之前先判断是否存在err，如果资源没有获取成功，即没有必要也不应该再对资源执行释放操作。如果不判断获取资源是否成功就执行释放操作的话，还有可能导致释放方法执行错误。
正确写法如下。
func main() {
fr,err := os.Open("/etc/hosts")
if err != nil{
fmt.Println("os.Open err",err)
return
}
defer fr.Close()
}
(8)调用os.Exit时defer不会被执行
os.Exit()的作用是种植当前整个程序，当发生panic时，所在goroutine的所有defer会被执行，但是当调用os.Exit()方法退出程序时，defer并不会被执行。unc DeferTest() {
defer func() {
fmt.Println("defer")
}()
os.Exit(0)
}
func main() {
DeferTest()
}
上面的defer并不会输出。
1.4 recover
运行时panic异常一旦被引发就会导致程序崩溃。这当然不是我们愿意看到的，但谁也不能保证程序不会发生任何运行时错误。
Go语言为我们提供了专用于"拦截"运行时panic的内建函数——recover。它可以让当前的程序从运行时panic的状态中恢复并重新获得流程控制权。
语法如下：
func recover() interface{}
注意：recover只有在defer调用的函数中才有效
示例如下：
func TestA() {
fmt.Println("TestA")
}
func TestB(i int) {
//设置recover
defer func() {
recover() //防止程序崩溃
}() //()一定要加上，调用此匿名函数
var a [10]int
a[i] = 222 //当i=11时，会造成数组下标越界，引起panic
}
func TestC() {
fmt.Println("TestC")
}
func main() {
TestA()
TestB(11)
TestC()
}
结果如下：
TestA TestC
通过以上程序，我们发现虽然TestB( )函数会导致整个应用程序崩溃，但是由于在该函数中调用了recover( )函数，所以整个函数并没有崩溃。虽然程序没有崩溃，但是我们也没有看到任何的提示信息，那么怎样才能够看到相应的提示信息呢？
可以直接打印recover( )函数的返回结果，如下所示：
func TestA() {
fmt.Println("TestA")
}
func TestB(i int) {
//设置recover
defer func() {
fmt.Println(recover()) //防止程序崩溃
}() //()一定要加上，调用此匿名函数
var a [10]int
a[i] = 222 //当i=11时，会造成数组下标越界，引起panic
}
func TestC() {
fmt.Println("TestC")
}
func main() {
TestA()
TestB(11)
TestC()
}
结果如下：
TestA runtime error: index out of range TestC
从输出结果发现，确实打印出了相应的错误信息。
但是，如果程序没有出错，也就是数组下标没有越界，会出现什么情况呢？
func TestA() {
fmt.Println("TestA")
}
func TestB(i int) {
//设置recover
defer func() {
fmt.Println(recover()) //防止程序崩溃
}() //()一定要加上，调用此匿名函数
var a [10]int
a[i] = 222 //当i=11时，会造成数组下标越界，引起panic
}
func TestC() {
fmt.Println("TestC")
}
func main() {
TestA()
TestB(1) //没有越界
TestC()
}
结果如下：
TestA <nil> TestC
这时输出的是空，但是我们希望程序没有错误的时候，不输出任何内容。
所以，程序修改如下：
func TestA() {
fmt.Println("TestA")
}
func TestB(i int) {
//设置recover
defer func() {
//判断是否出现错误
if err := recover();err != nil{
fmt.Println(err) //防止程序崩溃
}
}() //()一定要加上，调用此匿名函数
var a [10]int
a[i] = 222 //当i=11时，会造成数组下标越界，引起panic
}
func TestC() {
fmt.Println("TestC")
}
func main() {
TestA()
TestB(11) //没有越界
TestC()
}
通过以上代码，发现其实就是加了一层判断。
最后还要注意：recover一定要放在可能会发生异常的代码段前面。