Go

比如，有人写代码就会在每一层都判断错误并记录日志，从代码层面看，貌似很严谨，但是如果看日志会发现一堆重复的信息，等到排查问题时反而会造成干扰。

Go
这些最佳实践也是网上一些前辈分享的，我自己实践后在这里用自己的语言描述出来，希望能对大家有所帮助。

认识error

Goerror
errorError
type error interface {
    Error() string
}

Goerrorerrornil
i, err := strconv.Atoi("42")
if err != nil {
    fmt.Printf("couldn't convert number: %v\n", err)
    return
}
fmt.Println("Converted integer:", i)

errornilnilerror

自定义错误记得要实现error接口

error
myErrorerrormyErrorrunerror
package myerror
​
import (
 "fmt"
 "time"
)
​
type myError struct {
 Code int
 When time.Time
 What string
}
​
func (e *myError) Error() string {
 return fmt.Sprintf("at %v, %s, code %d",
  e.When, e.What, e.Code)
}
​
func run() error {
 return &MyError{
    1002,
    time.Now(),
    "it didn't work",
 }
}
​
func TryIt() {
 if err := run(); err != nil {
  fmt.Println(err)
 }
}

myErrorerrormyErrormyError.Code == xxxmyErrorMyError
errormyError
myerror.IsXXXError(err) 
...

errorio.EOF
gorm.ErrRecordNotFound
if err != io.EOF {
    return err
}

错误处理常犯的错误

先看一段简单的程序，看大家能不能发现一些细微的问题

func WriteAll(w io.Writer, buf []byte) error {
    _, err := w.Write(buf)
    if err != nil {
        log.Println("unable to write:", err) // annotated error goes to log file
        return err                           // unannotated error returned to caller
    }
    return nil
}
​
func WriteConfig(w io.Writer, conf *Config) error {
    buf, err := json.Marshal(conf)
    if err != nil {
        log.Printf("could not marshal config: %v", err)
        return err
    }
    if err := WriteAll(w, buf); err != nil {
        log.Println("could not write config: %v", err)
        return err
    }
    return nil
}
​
func main() {
    err := WriteConfig(f, &conf)
    fmt.Println(err) // io.EOF
}

错误处理常犯的两个问题

上面程序的错误处理暴露了两个问题：

WriteAll
unable to write: io.EOF
could not write config: io.EOF
...
WriteAllWriteConfig
WriteAllWriteConfig
fmt.Errorf
func WriteConfig(w io.Writer, conf *Config) error {
    buf, err := json.Marshal(conf)
    if err != nil {
        return fmt.Errorf("could not marshal config: %v", err)
    }
    if err := WriteAll(w, buf); err != nil {
        return fmt.Errorf("could not write config: %v", err)
    }
    return nil
}
func WriteAll(w io.Writer, buf []byte) error {
    _, err := w.Write(buf)
    if err != nil {
        return fmt.Errorf("write failed: %v", err)
    }
    return nil
}

给错误附加上下文信息

fmt.Errorfgithub.com/pkg/errors
//只附加新的信息
func WithMessage(err error, message string) error
​
//只附加调用堆栈信息
func WithStack(err error) error
​
//同时附加堆栈和信息
func Wrap(err error, message string) error

Cause
func Cause(err error) error
github.com/pkg/errors
func ReadFile(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil {
        return nil, errors.Wrap(err, "open failed")
    }
    defer f.Close()
    buf, err := ioutil.ReadAll(f)
    if err != nil {
        return nil, errors.Wrap(err, "read failed")
    }
    return buf, nil
}
func ReadConfig() ([]byte, error) {
    home := os.Getenv("HOME")
    config, err := ReadFile(filepath.Join(home, ".settings.xml"))
    return config, errors.WithMessage(err, "could not read config")
}
​
​
func main() {
    _, err := ReadConfig()
    if err != nil {
        fmt.Printf("original error: %T %v\n", errors.Cause(err), errors.Cause(err))
        fmt.Printf("stack trace:\n%+v\n", err)
        os.Exit(1)
    }
}
上面格式化字符串时用的 %+v 是在 % v 基础上，对值进行展开，即展开复合类型值，比如结构体的字段值等明细。
Cause

总结

总结一下，错误处理的原则就是：

  1. 错误只在逻辑的最外层处理一次，底层只返回错误。
  2. 底层除了返回错误外，要对原始错误进行包装，增加错误信息、调用栈等这些有利于排查的上下文信息。
喜欢网管的文章内容和写作风格，记得把我安利给更多人哦（微信搜：网管叨bi叨）