《快学 Go 语言》第 10 课 —— 错误与异常

Go 语言的异常处理语法绝对是独树一帜，在我见过的诸多高级语言中，Go 语言的错误处理形式就是一朵奇葩。一方面它鼓励你使用 C 语言的形式将错误通过返回值来进行传递，另一方面它还提供了高级语言一般都有的异常抛出和捕获的形式，但是又不鼓励你使用这个形式。后面我们统一将返回值形式的称为「错误」，将抛出捕获形式的称为「异常」。

Go 语言的错误处理在业界饱受批评，不过既然我们已经入了这个坑，那还是好好蹲着吧。

错误接口

Go 语言规定凡是实现了错误接口的对象都是错误对象，这个错误接口只定义了一个方法。

type error interface {
  Error() string
}

编写一个错误对象很简单，写一个结构体，然后挂在 Error() 方法就可以了。

package main

import "fmt"

type SomeError struct {
    Reason string
}

func (s SomeError) Error() string {
    return s.Reason
}

func main() {
    var err error = SomeError{"something happened"}
    fmt.Println(err)
}

---------------
something happened

package errors

func New(text string) error {
    return &errorString{text}
}

type errorString struct {
    s string
}

func (e *errorString) Error() string {
    return e.s
}

var err = errors.New("something happened")

var thing = "something"
var err = fmt.Errorf("%s happened", thing)

错误处理首体验

在 Java 语言里，如果遇到 IO 问题通常会抛出 IOException 类型的异常，在 Go 语言里面它不会抛异常，而是以返回值的形式来通知上层逻辑来处理错误。下面我们通过读文件来尝试一下 Go 语言的错误处理，读文件需要使用内置的 os 包。

package main

import "os"
import "fmt"

func main() {
    // 打开文件
    var f, err = os.Open("main.go")
    if err != nil {
        // 文件不存在、权限等原因
        fmt.Println("open file failed reason:" + err.Error())
        return
    }
    // 推迟到函数尾部调用，确保文件会关闭
    defer f.Close()
    // 存储文件内容
    var content = []byte{}
    // 临时的缓冲，按块读取，一次最多读取 100 字节
    var buf = make([]byte, 100)
    for {
        // 读文件，将读到的内容填充到缓冲
        n, err := f.Read(buf)
        if n > 0 {
            // 将读到的内容聚合起来
            content = append(content, buf[:n]...)
        }
        if err != nil {
            // 遇到流结束或者其它错误
            break
        }
    }
    // 输出文件内容
    fmt.Println(string(content))
}

-------
package main

import "os"
import "fmt"
.....

var score, ok := scores["apple"]

第三个需要注意的地方是 append 函数参数中出现了 … 符号。在切片章节，我们知道 append 函数可以将单个元素追加到切片中，其实 append 函数可以一次性追加多个元素，它的参数数量是可变的。

var s = []int{1,2,3,4,5}
s = append(s,6,7,8,9)

第四个需要注意的地方是读文件操作 f.Read() ，它会将文件的内容往切片里填充，填充的量不会超过切片的长度(注意不是容量)。如果将缓冲改成下面这种形式，就会死循环！

var buf = make([]byte, 0, 100)

体验 Redis 的错误处理

上面读文件的例子并没有让读者感受到错误处理的不爽，下面我们要引入 Go 语言 Redis 的客户端包，来真实体验一下 Go 语言的错误处理有多让人不快。

使用第三方包，需要使用 go get 指令下载这个包，该指令会将第三方包放到 GOPATH 目录下。

go get github.com/go-redis/redis

package main

import "fmt"
import "strconv"
import "github.com/go-redis/redis"

func main() {
 // 定义客户端对象，内部包含一个连接池
    var client = redis.NewClient(&redis.Options {
        Addr: "localhost:6379",
    })

    // 定义三个重要的整数变量值，默认都是零
    var val1, val2, val3 int

    // 获取第一个值
    valstr1, err := client.Get("value1").Result()
    if err == nil {
        val1, err = strconv.Atoi(valstr1)
        if err != nil {
            fmt.Println("value1 not a valid integer")
            return
        }
    } else if err != redis.Nil {
        fmt.Println("redis access error reason:" + err.Error())
        return
    }

    // 获取第二个值
    valstr2, err := client.Get("value2").Result()
    if err == nil {
        val2, err = strconv.Atoi(valstr2)
        if err != nil {
            fmt.Println("value1 not a valid integer")
            return
        }
    } else if err != redis.Nil {
        fmt.Println("redis access error reason:" + err.Error())
        return
    }

    // 保存第三个值
    val3 = val1 * val2
    ok, err := client.Set("value3",val3, 0).Result()
    if err != nil {
        fmt.Println("set value error reason:" + err.Error())
        return
    }
    fmt.Println(ok)
}

------
OK

另外还有一个需要特别注意的是因为字符串的零值是空串而不是 nil，你不好从字符串内容本身判断出 Redis 是否存在这个 key 还是对应 key 的 value 为空串，需要通过返回值的错误信息来判断。代码中的 redis.Nil 就是客户端专门为 key 不存在这种情况而定义的错误对象。

相比于写习惯了 Python 和 Java 程序的朋友们来说，这样繁琐的错误判断简直太地狱了。不过还是那句话，习惯了就好。

异常与捕捉

Go 语言提供了 panic 和 recover 全局函数让我们可以抛出异常、捕获异常。它类似于其它高级语言里常见的 throw try catch 语句，但是又很不一样，比如 panic 函数可以抛出来任意对象。下面我们看一个使用 panic 的例子

package main

import "fmt"

var negErr = fmt.Errorf("non positive number")

func main() {
    fmt.Println(fact(10))
    fmt.Println(fact(5))
    fmt.Println(fact(-5))
    fmt.Println(fact(15))
}

// 让阶乘函数返回错误太不雅观了
// 使用 panic 会合适一些
func fact(a int) int{
    if a <= 0 {
        panic(negErr)
    }
    var r = 1
    for i :=1;i<=a;i++ {
        r *= i
    }
    return r
}

-------
3628800
120
panic: non positive number

goroutine 1 [running]:
main.fact(0xfffffffffffffffb, 0x1)
    /Users/qianwp/go/src/github.com/pyloque/practice/main.go:16 +0x75
main.main()
    /Users/qianwp/go/src/github.com/pyloque/practice/main.go:10 +0x122
exit status 2

package main

import "fmt"

var negErr = fmt.Errorf("non positive number")

func main() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("error catched"， err)
        }
    }()
    fmt.Println(fact(10))
    fmt.Println(fact(5))
    fmt.Println(fact(-5))
    fmt.Println(fact(15))
}

func fact(a int) int{
    if a <= 0 {
        panic(negErr)
    }
    var r = 1
    for i :=1;i<=a;i++ {
        r *= i
    }
    return r
}

-------
3628800
120
error catched non positive number

defer func() {
  if err := recover(); err != nil {
   fmt.Println("error catched"， err)
  }
}()

defer f.Close()

func panic(v interface{})
func recover() interface{}

defer func() {
    if err := recover(); err != nil {
        if err == negErr {
            fmt.Println("error catched", err)
        } else {
            panic(err)  // rethrow
        }
    }
}()

异常的真实应用

Go 语言官方表态不要轻易使用 panic recover，除非你真的无法预料中间可能会发生的错误，或者它能非常显著地简化你的代码。简单一点说除非逼不得已，否则不要使用它。

在一个常见的 Web 应用中，不能因为个别 URL 处理器抛出异常而导致整个程序崩溃，就需要在每个 URL 处理器外面包括一层 recover() 来恢复异常。

图片

在 json 序列化过程中，逻辑上需要递归处理 json 内部的各种类型，每一种容器类型内部都可能会遇到不能序列化的类型。如果对每个函数都使用返回错误的方式来编写代码，会显得非常繁琐。所以在内置的 json 包里也使用了 panic，然后在调用的最外层包裹了 recover 函数来进行恢复，最终统一返回一个 error 类型。

图片

你可以想象一下，内置 json 包的开发者在设计开发这个包的时候应该也是纠结的焦头烂额，最终还是使用了 panic 和 recover 来让自己的代码变的好看一些。

多个 defer 语句

有时候我们需要在一个函数里使用多次 defer 语句。比如拷贝文件，需要同时打开源文件和目标文件，那就需要调用两次 defer f.Close()。

package main

import "fmt"
import "os"

func main() {
    fsrc, err := os.Open("source.txt")
    if err != nil {
        fmt.Println("open source file failed")
        return
    }
    defer fsrc.Close()
    fdes, err := os.Open("target.txt")
    if err != nil {
        fmt.Println("open target file failed")
        return
    }
    defer fdes.Close()
    fmt.Println("do something here")
}

package main

import "fmt"
import "os"

func main() {
    fsrc, err := os.Open("source.txt")
    if err != nil {
        fmt.Println("open source file failed")
        return
    }
    defer func() {
        fmt.Println("close source file")
        fsrc.Close()
    }()

    fdes, err := os.Open("target.txt")
    if err != nil {
        fmt.Println("open target file failed")
        return
    }
    defer func() {
        fmt.Println("close target file")
        fdes.Close()
    }()
    fmt.Println("do something here")
}

--------
do something here
close target file
close source file

阅读《快学 Go 语言》更多章节，扫一扫关注公众号「码洞」