go语言错误

• error类型是个接口

type error interface{
    Error() string
}

if err!=nil

• 函数调用时判断返回值

errors.New 创建error

package main
import (
    "errors"
    "fmt"
    "strings"
)
func validateArgs(name string) (ok bool, err error) {
    if strings.HasPrefix(name, "mysql") {
        return true, nil
    } else {
        return false, errors.New("name must startwith mysql")
    }
}
func main() {
    s1 := "mysql-abc"
    s2 := "redis-abc"
    _, err := validateArgs(s1)
    if err != nil {
        fmt.Println("[s1 validate 失败]", err)
    }
    _, err = validateArgs(s2)
    if err != nil {
        fmt.Println("[s2 validate 失败]", err)
    }
}

复杂的错误类型

• 以os包举例 提供了 LinkError、PathError、SyscallError
• 上述error都是实现了error接口的错误类型
• 可以用switch err.(type)判断类型

package main
import (
    "fmt"
    "log"
    "os"
)
func main() {
    file, err := os.Stat("test.txt")
    if err != nil {
        switch err.(type) {
        case *os.PathError:
            log.Printf("PathError")
        case *os.LinkError:
            log.Printf("LinkError")
        case *os.SyscallError:
            log.Printf("SyscallError")
        default:
            log.Printf("unknown error")
        }
    } else {
        fmt.Println(file)
    }
}

自定义error

• errors.New 单独的error ，基础的error
• 自定义结构体 ，再原始错误的基础上再封自己的错误信息
• 如下

package main
import (
    "errors"
    "fmt"
)
type MyError struct {
    err error
    msg string // 自定义的error字符串
}
func (e *MyError) Error() string {
    return e.err.Error() + e.msg
}
func main() {
    err := errors.New("原始的错误")
    newErr := MyError{
        err: err,
        msg: "[是研发的锅]",
    }
    fmt.Println(newErr.Error())
}

• 弊端就是要定义很多 error结构体

golang 1.13中的Error Wrapping 错误嵌套

• 目的是很上面的一样 ，扩展error信息
• 使用 fmt.ErrorF(newErrorStr %w,e)
• 好处就是不需要像上面一样定义结构体了，代码如下

package main
import (
    "errors"
    "fmt"
)
func main() {
    e := errors.New("原始错误01")
    w := fmt.Errorf("Wrap了一个新的错误 :%w", e)
    fmt.Println(w)
}