一、错误处理机制

Go 语言以结果多值返回方式处理错误,函数或者方法最后一个返回值作为错误类型。

func ReadFile(filename string) ([]byte, error)

调用时根据错误值判断是否正常

data, err := ReadFile("abc.txt")
if err != nil {
    // 处理错误
} else {
   // 处理data
}

1. error 类型及其意义

Go 语言通过内置的 error 类型实现错误处理,它是一个接口

type error interface {
    Error() string
}

实现 error 的类型都可以作为错误类型返回,框架会使用 Error()方法打印错误信息。

任意类型只要实现该接口就表示一个错误

type ParseError struct {
    Filename string // 文件名
    Line     int    // 错误行号
}


func (e *ParseError) Error() string {
    return fmt.Sprintf("%s:%d", e.Filename, e.Line)  
}

2. if err != nil 检查错误

if 语句常用于判断函数调用是否发生错误

file, err := os.Open("/tmp/abc.txt")
if err != nil {
    log.Fatal(err)
}

3. 自定义错误类型

可自定义错误类型保存更多信息，自定义错误能更好表达错误场景,修正错误也更方便。

type NotFoundError struct {
    FileName string
}


func (e *NotFoundError) Error() string {
    return fmt.Sprintf("%s not found", e.FileName)
}


func find(filename string) error {
    _, err := os.Stat(filename)
    if err != nil {
        // 创建自定义错误类型并返回
        return &NotFoundError{filename} 
    }
    return nil
}

调用时可以转换回来

err := find("hello.txt")


if e, ok := err.(*NotFoundError); ok {
    fmt.Println(e.FileName) 
}

二、defer 处理资源释放问题

Go 语言中的 defer 语句会将函数执行推迟到外层函数返回之前。

1. defer 的执行规则与特点

defer 延迟调用遵循 FILO 规则。

func main() {
  defer fmt.Println(1) 
  defer fmt.Println(2)
  fmt.Println(3) 
  // 输出顺序是 3,2,1。
}

defer 语句中的变量在定义时求值（输出是 1,不是 2。）

func main() {
  x := 1
  defer fmt.Println(x)  
  x++      
}

2. defer 释放资源

defer 经常用于释放资源，不管 process 返回与否,都能保证文件关闭。

func main() {
  file := openFile("abc.txt")
  defer file.Close()
  
  process(file) // 使用文件
}

3. defer 经典案例

读取文件内容的示例，输出完内容后,defer 确保文件正确关闭。

func cat(f string) error {
    file, err := os.Open(f) 
    if err != nil {
        return err
    }
    defer file.Close() 
    
    stat, err := file.Stat()
    if err != nil {
        return err
    }
    
    bs := make([]byte, stat.Size())
    _, err = file.Read(bs)
    if err != nil {
       return err 
    }
    
    fmt.Println(string(bs))
    return nil
}

 三、panic 和 recover

panic 用于程序未能处理的错误,recover 可以让 panic 跳出的 goroutine 恢复,防止整个程序崩溃。

1. panic、defer 和 recover 的关系

• panic 会导致当前 goroutine 立即中止执行,但 defer 保证执行
• recover 可以捕获 panic,从而影响应用恢复

2. recover 捕获 panic

recover 只在 defer 内调用时有效

func ProtectRun(entry func()) {
   defer func() {
       // 捕获函数异常
       if r := recover(); r != nil {
           log.Printf("run time panic: %v", r)
       }
   }()
   entry() // 可能引发panic的函数
}

3. panic 应用场景

不希望看到 panic,但它也有合理应用场景

// 非法状态,不可能恢复
panic("invalid state") 


// 参数校验未过,不应继续
// 等于“抛出异常”,让程序停下。
if x <= 0 {
  panic("x must > 0") 
}

 四、日志的最佳实践

log 包实现日志收集,支持输出到文件,网络等地方。

1. log 包的基本使用

导入 log 包并设置输出位置

func main() {
    log.SetOutput(os.Stdout)
    
    log.Println("logging example")
}

2. 设置日志级别,控制日志输出

log 级别包含 Debug、Info、Warning、Error、Fatal 等。

log.SetPrefix("[Debug] ")


log.SetFlags(log.Llongfile | log.LUTC) 


log.Println("debug message") 


log.Fatalln("fatal message")

Fatal 会在写入日志后调用 os.Exit(1)。

3. 将日志写入文件,按文件大小切分

默认日志只输出到 stderr，可以写入文件，超过文件限制后,将日志保存到 xx.log.1。

f, _ := os.OpenFile("/tmp/xx.log",
 os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
 
log.SetOutput(f)