如何在Golang中创建一个实现了error接口的结构体

error

Error()

error

type error interface {
    Error() string
}

Error() string

error

package main

import (
    "fmt"
    "os"
)

// 定义一个自定义错误结构体
type FileOpError struct {
    Filename string
    Op       string // 操作类型，比如 "read", "write"
    Err      error  // 原始的底层错误
}

// 实现 error 接口的 Error() 方法
func (e *FileOpError) Error() string {
    return fmt.Sprintf("文件操作失败: %s %s 失败，原因: %v", e.Op, e.Filename, e.Err)
}

// 一个模拟文件读取的函数
func readFile(filename string) ([]byte, error) {
    // 模拟文件不存在的错误
    if filename == "non_existent.txt" {
        // 返回我们自定义的错误类型，并包装一个标准库错误
        return nil, &FileOpError{
            Filename: filename,
            Op:       "读取",
            Err:      os.ErrNotExist, // 包装一个Go标准库的错误
        }
    }
    // 实际的文件读取逻辑...
    return []byte("文件内容"), nil
}

func main() {
    _, err := readFile("non_existent.txt")
    if err != nil {
        fmt.Println("捕获到错误:", err)

        // 我们可以通过类型断言来检查错误类型
        if fileErr, ok := err.(*FileOpError); ok {
            fmt.Printf("这是一个文件操作错误，文件名: %s，操作: %s，原始错误: %v\n",
                fileErr.Filename, fileErr.Op, fileErr.Err)
        }
    }

    _, err = readFile("existing_file.txt")
    if err != nil {
        fmt.Println("捕获到错误:", err)
    }
}

FileOpError

Error()

error

fmt.Errorf("something went wrong: %s", detail)

error

package main

import (
    "errors"
    "fmt"
    "os"
)

// 定义错误码
type ErrorCode string

const (
    ErrCodeNotFound       ErrorCode = "NOT_FOUND"
    ErrCodeInvalidInput   ErrorCode = "INVALID_INPUT"
    ErrCodeInternalServer ErrorCode = "INTERNAL_SERVER_ERROR"
)

// 自定义错误结构体，包含更多上下文
type MyCustomError struct {
    Code    ErrorCode // 错误码
    Message string    // 用户友好消息
    Op      string    // 发生错误的操作
    Err     error     // 包装的底层错误
}

// 实现 error 接口
func (e *MyCustomError) Error() string {
    if e.Err != nil {
        return fmt.Sprintf("操作[%s]失败，错误码[%s]: %s (底层错误: %v)", e.Op, e.Code, e.Message, e.Err)
    }
    return fmt.Sprintf("操作[%s]失败，错误码[%s]: %s", e.Op, e.Code, e.Message)
}

// 实现 Unwrap 方法，支持错误链
func (e *MyCustomError) Unwrap() error {
    return e.Err
}

// 模拟一个可能出错的业务逻辑
func processData(data string) error {
    if data == "" {
        return &MyCustomError{
            Code:    ErrCodeInvalidInput,
            Message: "输入数据不能为空",
            Op:      "processData",
        }
    }
    if data == "nonexistent_id" {
        // 模拟一个底层文件不存在的错误，并包装它
        return &MyCustomError{
            Code:    ErrCodeNotFound,
            Message: "数据ID不存在",
            Op:      "processData",
            Err:     os.ErrNotExist, // 包装一个标准库错误
        }
    }
    // 假设这里还有其他逻辑
    return nil
}

func main() {
    // 场景1: 无效输入
    err1 := processData("")
    if err1 != nil {
        fmt.Println("--- 场景1 ---")
        fmt.Println("错误:", err1)
        var customErr *MyCustomError
        if errors.As(err1, &customErr) { // 使用 errors.As 检查并提取自定义错误
            fmt.Printf("这是一个自定义错误，错误码: %s, 消息: %s\n", customErr.Code, customErr.Message)
        }
    }

    // 场景2: 数据ID不存在，底层是文件不存在
    err2 := processData("nonexistent_id")
    if err2 != nil {
        fmt.Println("\n--- 场景2 ---")
        fmt.Println("错误:", err2)
        if errors.Is(err2, os.ErrNotExist) { // 使用 errors.Is 检查是否包含特定底层错误
            fmt.Println("错误链中包含 os.ErrNotExist")
        }
        var customErr *MyCustomError
        if errors.As(err2, &customErr) {
            fmt.Printf("这是一个自定义错误，错误码: %s, 消息: %s, 原始错误: %v\n", customErr.Code, customErr.Message, customErr.Err)
        }
    }
}

errors.Is

errors.As

MyCustomError

// 实现 Unwrap 方法，支持错误链
func (e *MyCustomError) Unwrap() error {
    return e.Err
}

Unwrap

errors.Is

errors.As

MyCustomError

e.Err

os.ErrNotExist

errors.Is(topLevelErr, os.ErrNotExist)