错误处理与测试

错误处理与测试

Go没有try/catch异常机制：不能执行抛异常操作。但是有一套defer-panic-and-recover机制。

通过在函数和方法中返回错误对象作为它们的唯一或最后一个返回值，如果返回nil，则没有错误发生，并且主调(calling)函数总是应该检查收到的错误。

处理错误并且在函数发生错误的地方给用户返回错误信息：照这样处理就算真的出了问题，程序也能继续运行并且通知给用户。panic and recover是用来处理真正的异常(无法预测的错误)而不是普通的错误。

Go检查和报告错误条件的惯有方式：

• 产生错误的函数会返回两个变量，一个值和一个错误码；如果后者是 nil 就是成功，非 nil 就是发生了错误。
• 为了防止发生错误时正在执行的函数（如果有必要的话甚至会是整个程序）被中止，在调用函数后必须检查错误。

错误处理

Go有一个预先定义的error接口类型

type error interface {
    Error() string
}

定义错误

任何时候当需要一个新的错误类型，都可以用errors包的errors.New函数接收合适的错误信息来创建，如：err := errors.New("xxx")

一个简单示例，errors.go:

package main
import (
    "errors"
    "fmt"
)
var errNotFound error = errors.New("Not found error")
func main() {
    fmt.Printf("error: %v\n", errNotFound)
}

可以把它用于计算平方根函数的参数测试：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math - square root of negative number")
    }
}

然后像下边这样调用Sqrt函数：

if f, err := Sqrt(-1), err != nil {
    fmt.Printf("Error: %s\n", err)
}

在大部分情况下自定义错误结构类型很有意义的，可以包含除了（低层级的）错误信息以外的其它有用信息，例如，正在进行的操作（打开文件等），全路径或名字。看下面例子中 os.Open 操作触发的 PathError 错误：

type PathError struct {
    Op   string
    Path string
    Err  error
}
func (e *PathError) Error() string {
    return e.Op + " " + e.Path + " " + e.Err.Error()
}

如果不通错误条件可能发生，那么对实际的错误使用类型断言或类型判断(type-switch)是很有用的，并且可以根据错误场景做一些补救和恢复操作

switch err := err.(type){
case ParseError:
    PrintParseError(err)
case PathError:
    PrintPathError(err)
...
default:
    fmt.Printf("Not a special error, just %s\n", err)
}

考虑用json包的情况，当json.Decode在解析JSON文档发生语法错误时，指定返回一个SyntaxError类型的错误：

type SyntaxError struct {
    msg string
    Offset int64
}
func (e *SyntaxError) Error() string { return e.msg }

在调用代码中可以像这样用类型断言测试错误是不是上面的类型：

if serr, ok := err.(*json.SyntaxError); ok {
    line, col := findLine(f, serr.Offset)
    return fmt.Errorf("%s:%d:%d: %v", f.Name(), line, col, err)
}

用fmt创建错误对象

通常想要返回包含错误参数的更有信息量的字符串，可以用fmt.Errorf()来实现，它和fmt.Printf()完全一样，和打印信息不同的是它用信息生成错误对象。

比如前面的平方根例子：

if f < 0 {
    return 0, fmt.Errorf("math: square root of negative number %g", f)
}

另一个例子，从命令行读取输入时，如果加了help标志，可以用有用的信息产生一个错误：

if len(os.Args) > 1 && (os.Args[1] == "-h" || os.Args[1] == "--help") {
    err = fmt.Errorf("usage: %s infile.txt outfile.txt", filepath.Base(os.Args[0]))
    return
}

运行时异常和panic

panic可以直接从代码初始化：当错误条件(所测试的代码)很严苛且不可恢复，程序不能继续运行时，可以使用panic函数产生一个终止程序的运行时错误。panic接收一个做任意类型的参数，通常是字符串，在程序死亡时被打印出来。

func main() {
    fmt.Println("Staring")
    panic("A server error occurred")
    fmt.Println("Ending")
}

在多层嵌套的函数调用中调用 panic，可以马上中止当前函数的执行，所有的 defer 语句都会保证执行并把控制权交还给接收到 panic 的函数调用者。这样向上冒泡直到最顶层，并执行（每层的） defer，在栈顶处程序崩溃，并在命令行中用传给 panic 的值报告错误情况：这个终止过程就是 panicking。

Recover(从panic恢复)

recover可以让程序从panicking重新获得控制权，停止终止过程进而恢复正常执行。

recover只能在defer修饰的函数中使用：用于取得panic调用中传递过来的错误值，如果是正常执行，调用recover会返回nil，且没有其他效果。

panic会导致栈被展开直到defer修饰的recover()被调用或者程序中止。

panic_recover.go:

package main
import "fmt"
func badCall() {
    panic("bad end")
}
func test() {
    defer func() {
        if e := recover(); e != nil {
            fmt.Printf("Panicing %s\n", e)
        }
    }()
    badCall()
    fmt.Printf("After bad call\n")
}
func main() {
    fmt.Printf("Calling test\n")
    test()
    fmt.Printf("Test completed\n")
}

结果：

Calling test
Panicing bad end
Test completed

自定义包中的错误处理和panicking

所有自定义包实现者应该遵守的最佳实践：

• 在包内部，总是应该从panic中recover: 不允许显式的超出包范围的panic()
• 向包的调用者返回错误值(而不是panic)

// parse.go
package parse
import (
    "fmt"
    "strconv"
    "strings"
)
type ParseError struct {
    Index int
    Word  string
    Err   error
}
func (e *ParseError) String() string {
    return fmt.Sprintf("pkg parse: error parsing %q as int", e.Word)
}
func Parse(input string) (numbers []int, err error) {
    defer func() {
        if r := recover(); r != nil {
            var ok bool
            err, ok = r.(error)
            if !ok {
                err = fmt.Errorf("pkg: %v", r)
            }
        }
    }()
    fields := strings.Fields(input)
    numbers = fields2numbers(fields)
    return
}
func fields2numbers(fields []string) (numbers []int) {
    if len(fields) == 0 {
        panic("no words to parse")
    }
    for idx, field := range fields {
        num, err := strconv.Atoi(field)
        if err != nil {
            panic(&ParseError{idx, field, err})
        }
        numbers = append(numbers, num)
    }
    return
}

// panic_parse.go
package main
import (
    "fmt"
    "parse_panic/parse"
)
func main() {
    var examples = []string{
        "1 2 3 4 5",
        "100 50 25 12.5",
        "2 + 2 =4",
        "1st class",
        "",
    }
    for _, ex := range examples {
        fmt.Printf("Parsing %q:\n", ex)
        nums, err := parse.Parse(ex)
        if err != nil {
            fmt.Println(err)
            continue
        }
        fmt.Println(nums)
    }
}

一种用闭包处理错误的模式

每当函数返回时，我们应该检查是否有错误发生：但是这会导致重复乏味的代码。结合 defer/panic/recover 机制和闭包可以得到一个我们马上要讨论的更加优雅的模式。不过这个模式只有当所有的函数都是同一种签名时可用，这样就有相当大的限制。一个很好的使用它的例子是 web 应用，所有的处理函数都是下面这样：

func handler1(w http.ResponseWriter, r *http.Request) { ... }

假设所有的函数都有这样的签名：

func f(a type1, b type2)

参数的数量和类型是不相关的。

给这个类型一个名字：

fType1 = func f(a type1, b type2)

在模式中使用了两个帮助函数：

1. check: 用来检查是否有错误和panic发生的函数：

func check(err error) {if err != nil { panic(err) } }

1. errorhandler: 一个包装函数，接收一个fType2类型的函数fn并返回一个调用fn的函数。里面就包含有defer/recover机制：

func errorhandler(fn fType1) fType1 {
    return func(a type1, b type2) {
        defer func() {
            if err, ok := recover().(error); ok {
                log.Printf("run time panic: %v", err)
            }
        }()
        fn(a, b)
    }
}

当错误发生时会recover并打印在日志中；除了简单的打印，应用也可以用template包为用户生成自定义的输出。check()函数会在所有的被调函数中调用：

func f1(a type1, b type2) {
    ...
    f, _, err := // call function/method
    check(err)
    t, err1 := // call function/method
    check(err1)
    _, err2 := // call function/method
    check(err2)
}

panci_defer.go:

package main
import "fmt"
func main() {
    f()
    fmt.Println("Returned normally from f.")
}
func f() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered in f", r)
        }
    }()
    fmt.Println("Calling g.")
    g(0)
    fmt.Println("Retruned normally from g.")
}
func g(i int) {
    if i > 3 {
        fmt.Println("Panicking!")
        panic(fmt.Sprintf("%v", i))
    }
    defer fmt.Println("Defer in g", i)
    fmt.Println("Printing in g", i)
    g(i + 1)
}

启动外部命令和程序

os包有一个StartProcess函数可以调用或启动外部系统命令和二进制可执行文件；它的第一个参数是要运行的进程，第二个参数用来传递选项或参数，第三个参数是含有系统环境基本信息的结构体。这个函数返回被启动进程的id(pid)，或启动失败返回错误。

exec包中也有同样功能的更简单的结构体和函数；主要是exec.Command(name string, arg …string) 和 Run()。首先需要系统命令或可执行文件的名字创建一个Command对象，然后用这个对象作为接收者调用Run()。

exec.go:

package main
import (
    "bytes"
    "fmt"
    "log"
    "os"
    "os/exec"
)
func main() {
    // osStart()
    execRun()
}
func osStart() {
    env := os.Environ()
    procAttr := &os.ProcAttr{
        Env: env,
        Files: []*os.File{
            os.Stdin,
            os.Stdout,
            os.Stderr,
        },
    }
    pid, err := os.StartProcess("/bin/ls", []string{"ls", "-l"}, procAttr)
    if err != nil {
        fmt.Printf("Error %v staring process!", err)
        os.Exit(1)
    }
    fmt.Printf("The process id is %v", pid)
    // show all processes
    pid, err = os.StartProcess("/bin/ps", []string{"ps", "-e", "-opid,ppid,comm"}, procAttr)
    if err != nil {
        fmt.Printf("Error %v starting process!", err)
        os.Exit(1)
    }
    fmt.Printf("The process id is %v", pid)
}
func execRun() {
    // 只执行命令，不获取结果
    cmd := exec.Command("pwd")
    err := cmd.Run()
    if err != nil {
        fmt.Printf("Error %v executing command!", err)
        os.Exit(1)
    }
    fmt.Printf("The command is %v", cmd)
    // 执行命令，并获取结果
    cmd = exec.Command("ls", "-l", "/var/log")
    out, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Printf("combined out: \n %s\n", string(out))
        log.Fatalf("cmd.Run() failed with %s\n", err)
    }
    fmt.Printf("combined out: \n%s\n", string(out))
    // 执行命令，并区分stdout和stderr
    cmd = exec.Command("ls", "-l", "/var/log/*.log")
    var stdout, stderr bytes.Buffer
    cmd.Stdout = &stdout
    cmd.Stderr = &stderr
    err = cmd.Run()
    outStr, errStr := string(stdout.Bytes()), string(stderr.Bytes())
    fmt.Printf("out: \n%s \nerr:\n%s\n", outStr, errStr)
    if err != nil {
        log.Fatalf("cmd.Run() failed with %s\n", err)
    }
    // 多条命令组合
    c1 := exec.Command("grep", "failed", "/var/log/system.log")
    c2 := exec.Command("wc", "-l")
    c2.Stdin, _ = c1.StdoutPipe()
    c2.Stdout = os.Stdout
    _ = c2.Start()
    _ = c1.Run()
    _ = c2.Wait()
        // 设置命令级别的环境变量
    os.Setenv("NAME", "test")
    cmd := exec.Command("echo", os.ExpandEnv("$NAME"))
    out, err := cmd.CombinedOutput()
    if err != nil {
        log.Fatalf("cmd.Run() failed with %s\n", err)
    }
    fmt.Printf("%s", out)
}

单元测试和基准测试

名为testing的包被专门用来进行自动化测试，日志和错误报告。并且还包含一些基准测试函数的功能。

对一个包做(单元)测试，需要写一些可以频繁(每次更新后)执行的小块测试单元来检查代码的正确性。于是必须写一些Go源文件来测试代码，测试程序必须属于被测试的包，并且文件名满足这种形式*_test.go，所以测试代码和包中的业务代码是分开的。

_test程序不会被普通的Go编译器编译，所以当放应用部署到生产环境时它们不会被部署；只有gotest会编译所有的程序：普通程序和测试程序。

测试文件中必须导入“testing”包，并写一些名字以TestXXX打头的全局函数，如TestFmtInterface,TestPayEmployees等。

备注：gotest 是 Unix bash 脚本，所以在 Windows 下你需要配置 MINGW 环境（参见 2.5 节）；在 Windows 环境下把所有的 pkg/linux_amd64 替换成 pkg/windows。

测试函数必须有这种形式的头部：

func TestAbcde(t *testing.T)

T是传给测试函数的结构类型，用来管理测试状态，支持格式化测试日志，如t.Log, t.Error, t.ErrorF等。在函数的结尾把输出跟想要的结果对比，如果不等就打印一个错误，成功的测试则直接返回。

1. func (t *T) Fail() 标记测试函数为失败，然后继续执行；
2. func (t *T) FailNow() 标记测试函数为失败并中止执行，文件中别的测试也被略过，继续执行下一个文件；
3. func (t *T) Log(args ...interface{}) args被用默认的格式格式化并打印到错误日志中；
4. func (t *T) Fatal(args ...interface{}) 先执行3，在执行2的效果；

运行go test来编译测试程序，并执行程序中所有的TestXXX函数，如果所有的测试都通过会打印出PASS；

even.go:

package even
func Even(i int) bool {
    return i%2 == 0
}
func Odd(i int) bool {
    return i%2 != 0
}

oddeven_test.go:

package even
import "testing"
func TestEven(t *testing.T) {
    // if !Even(10) {
    //     t.Log("10 must be even")
    //     t.Fail()
    // }
    // if Even(7) {
    //     t.Log("7 is not even")
    //     t.Fail()
    // }
    if Even(10) {
        t.Log("just a test")
        t.Fail()
    }
}
func TestOdd(t *testing.T) {
    if !Odd(11) {
        t.Log("11 must be odd!")
        t.Fail()
    }
    if Odd(10) {
        t.Log("10 is not odd")
        t.Fail()
    }
}

even_main.go:

package main
import (
    "fmt"
    "testing/even"
)
func main() {
    for i := 0; i < 100; i++ {
        fmt.Printf("Is the interger %d even? %v\n", i, even.Even(i))
    }
}

性能调试：分析并优化Go程序

用 go test 调试

如果代码使用了 Go 中 testing 包的基准测试功能，我们可以用 gotest 标准的 -cpuprofile 和 -memprofile 标志向指定文件写入 CPU 或 内存使用情况报告。

使用方式：go test -x -v -cpuprofile=prof.out -file x_test.go

用pprof调试

可以在单机程序progexec中引入runtime/pprof包；这个包以pprof可视化工具需要的格式写入运行时报告数据。对于CPU性能分析来说需要添加一些代码：

var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
func main() {
    flag.Parse()
    if *cpuprofile != "" {
        f, err := os.Create(*cpuprofile)
        if err != nil {
            log.Fatal(err)
        }
        pprof.StartCPUProfile(f)
        defer pprof.StopCPUProfile()
    }
}
  ...

代码定义了一个名为 cpuprofile 的 flag，调用 Go flag 库来解析命令行 flag，如果命令行设置了 cpuprofile flag，则开始 CPU 性能分析并把结果重定向到那个文件（os.Create 用拿到的名字创建了用来写入分析数据的文件）。这个分析程序最后需要在程序退出之前调用 StopCPUProfile 来刷新挂起的写操作到文件中；我们用 defer 来保证这一切会在 main 返回时触发。

现在用这个 flag 运行程序：progexec -cpuprofile=progexec.prof

然后可以像这样用 gopprof 工具：gopprof progexec progexec.prof