Golang预定义错误变量全解析

知识点掌握了，还需要不断练习才能熟练运用。下面golang学习网给大家带来一个Golang开发实战，手把手教大家学习《Golang预定义错误变量使用详解》，在实现功能的过程中也带大家重新温习相关知识点，温故而知新，回头看看说不定又有不一样的感悟！

使用errors.Is判断错误是否为预定义错误，如io.EOF或os.ErrNotExist；通过实现Is方法可使自定义错误与预定义错误兼容。

使用Golang标准库中预定义的错误变量，可以方便地进行错误判断和处理，避免重复定义相同的错误，并提高代码的可读性和可维护性。 这些变量通常用于特定的场景，例如文件操作、网络连接等。

解决方案

直接使用这些预定义的错误变量进行错误比较。例如，io.EOF表示文件结束错误，os.ErrNotExist表示文件不存在的错误。在错误处理时，可以使用errors.Is或errors.As来判断错误是否属于这些预定义的错误。

package main

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

func readData(r io.Reader) ([]byte, error) {
    data := make([]byte, 10)
    n, err := r.Read(data)
    if err != nil {
        if errors.Is(err, io.EOF) {
            fmt.Println("Reached end of file")
            return data[:n], nil // 允许返回部分数据
        }
        return nil, fmt.Errorf("read error: %w", err)
    }
    return data, nil
}

func checkFile(filename string) error {
    _, err := os.Stat(filename)
    if err != nil {
        if errors.Is(err, os.ErrNotExist) {
            return fmt.Errorf("file does not exist: %w", err)
        }
        return fmt.Errorf("file stat error: %w", err)
    }
    return nil
}

func main() {
    // 示例1: 使用 io.EOF
    r := io.LimitReader(strings.NewReader("hello"), 3) // 创建一个限制读取的Reader
    data, err := readData(r)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Data:", string(data))
    }

    // 示例2: 使用 os.ErrNotExist
    filename := "nonexistent_file.txt"
    err = checkFile(filename)
    if err != nil {
        fmt.Println("Error:", err)
    }
}

import "strings"

如何判断一个错误是否是预定义错误？

使用 errors.Is 函数来判断一个错误是否是某个预定义错误的包装。如果 errors.Is(err, io.EOF) 返回 true，则表示 err 错误链中包含 io.EOF。

package main

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

func readFile(filename string) error {
    f, err := os.Open(filename)
    if err != nil {
        return fmt.Errorf("failed to open file: %w", err)
    }
    defer f.Close()

    _, err = io.ReadAll(f)
    if err != nil {
        if errors.Is(err, io.EOF) {
            fmt.Println("end of file reached")
            return nil
        }
        return fmt.Errorf("failed to read file: %w", err)
    }
    return nil
}

func main() {
    err := readFile("my_file.txt")
    if err != nil {
        fmt.Println(err)
    }
}

预定义错误变量有哪些，分别在什么场景下使用？

Golang标准库中包含多个预定义的错误变量，它们分别用于不同的场景：

• io.EOF: 表示读取到文件或流的末尾。常用于io.Reader接口的实现中。
• os.ErrNotExist: 表示文件或目录不存在。常用于文件系统操作。
• os.ErrExist: 表示文件或目录已经存在。常用于文件系统操作。
• os.ErrPermission: 表示没有权限执行操作。常用于文件系统操作。
• syscall.EINVAL: 表示无效的参数。常用于系统调用。
• syscall.EACCES: 表示权限不足。常用于系统调用。
• context.Canceled: 表示context被取消。常用于goroutine的控制。
• context.DeadlineExceeded: 表示context超时。常用于goroutine的控制。

package main

import (
    "context"
    "errors"
    "fmt"
    "os"
    "time"
)

func checkPermission(filename string) error {
    _, err := os.Open(filename)
    if err != nil {
        if errors.Is(err, os.ErrPermission) {
            return fmt.Errorf("permission denied: %w", err)
        }
        return fmt.Errorf("failed to open file: %w", err)
    }
    return nil
}

func doSomething(ctx context.Context) error {
    select {
    case <-ctx.Done():
        if errors.Is(ctx.Err(), context.Canceled) {
            return fmt.Errorf("operation cancelled: %w", ctx.Err())
        }
        if errors.Is(ctx.Err(), context.DeadlineExceeded) {
            return fmt.Errorf("deadline exceeded: %w", ctx.Err())
        }
        return ctx.Err()
    case <-time.After(1 * time.Second):
        fmt.Println("Operation completed")
        return nil
    }
}

func main() {
    // 示例1: 使用 os.ErrPermission
    err := checkPermission("protected_file.txt")
    if err != nil {
        fmt.Println(err)
    }

    // 示例2: 使用 context.Canceled 和 context.DeadlineExceeded
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()

    err = doSomething(ctx)
    if err != nil {
        fmt.Println(err)
    }
}

如何自定义错误，并使其与预定义错误兼容？

可以使用errors.Is来判断自定义错误是否属于某个预定义的错误。为了实现这一点，自定义错误需要实现Is方法。

package main

import (
    "errors"
    "fmt"
    "io"
)

type CustomEOFError struct {
    Message string
}

func (e *CustomEOFError) Error() string {
    return fmt.Sprintf("custom EOF error: %s", e.Message)
}

func (e *CustomEOFError) Is(target error) bool {
    return errors.Is(io.EOF, target) // 检查目标是否是 io.EOF 或包装了 io.EOF
}

func readDataCustom(r io.Reader) ([]byte, error) {
    data := make([]byte, 10)
    n, err := r.Read(data)
    if err != nil {
        if errors.Is(err, io.EOF) {
            return nil, &CustomEOFError{Message: "Reached end of file with custom error"}
        }
        return nil, fmt.Errorf("read error: %w", err)
    }
    return data, nil
}

func main() {
    r := io.LimitReader(strings.NewReader("hello"), 3)
    _, err := readDataCustom(r)
    if err != nil {
        if errors.Is(err, io.EOF) {
            fmt.Println("Custom EOF error encountered")
        }
        fmt.Println("Error:", err)
    }
}

import "strings"

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。