Utilisez le mécanisme d'emballage et de déroulement des erreurs de Golang pour la gestion des erreurs

La gestion des erreurs dans Go inclut les erreurs d’encapsulage et les erreurs de déroulement. L'encapsulation des erreurs permet d'encapsuler un type d'erreur avec un autre, fournissant ainsi un contexte plus riche pour l'erreur. Développez les erreurs et parcourez la chaîne d'erreurs imbriquée pour trouver l'erreur de niveau le plus bas pour un débogage facile. En combinant ces deux techniques, les conditions d'erreur peuvent être gérées efficacement, offrant un contexte d'erreur plus riche et de meilleures capacités de débogage.

Utilisez le mécanisme d'emballage et de déballage des erreurs de Go pour la gestion des erreurs

Dans Go, la gestion des erreurs est cruciale et nous permet de gérer les conditions d'erreur qui se produisent lors de l'exécution du programme. Les erreurs d’emballage et de déballage sont deux techniques courantes de gestion des erreurs dans Go qui offrent un contrôle plus précis sur la gestion des erreurs.

Encapsulage des erreurs

L'encapsulation des erreurs nous permet d'encapsuler un type d'erreur avec un autre, créant ainsi des erreurs avec un contexte plus riche. Ce faisant, nous pouvons fournir des informations supplémentaires sur la source et la cause de l’erreur, ce qui facilite une gestion plus robuste des erreurs.

import (
    "errors"
    "fmt"
)

type DBError struct {
    error
}

func (e *DBError) Unwrap() error {
    return e.error
}

func main() {
    // 原始数据库错误
    origErr := errors.New("database connection failed")

    // 包装数据库错误
    wrappedErr := &DBError{
        error: fmt.Errorf("failed to connect to database: %w", origErr),
    }

    // 处理包装后的错误
    switch {
    case errors.Is(wrappedErr, errors.New("database connection failed")):
        fmt.Println("Database connection failed.")
    }
}

Dans l'exemple ci-dessus, le type DBError encapsule l'erreur brute de la base de données (origErr) et fournit des informations contextuelles supplémentaires. Nous utilisons fmt.Errorf pour créer l'erreur encapsulée, et la fonction errors.Is est utilisée pour comparer si l'erreur encapsulée correspond à l'erreur de base de données d'origine. DBError 类型包装了原始的数据库错误 (origErr)，并提供了额外的上下文信息。我们使用 fmt.Errorf 来创建包装后的错误，errors.Is 函数用于比较包装后的错误是否与原始的数据库错误匹配。

展开错误

展开错误是一种遍历嵌套错误链的机制，直到找到最底层的错误。这对于理解错误的根本原因以及调试目的非常有用。

import (
    "fmt"
)

func f1(s string) error {
    if s == "" {
        return errors.New("empty string")
    }
    return nil
}

func f2(s string) error {
    if err := f1(s); err != nil {
        return fmt.Errorf("f1() failed: %w", err)
    }
    return nil
}

func main() {
    // 嵌套错误
    err := f2("")

    for {
        // 检查错误是否为 nil
        if err == nil {
            break
        }

        // 展开错误
        fmt.Println(err)
        err = errors.Unwrap(err)
    }
}

在上面的例子中，f2 函数包装了 f1 函数的错误。errors.Unwrap

Développer les erreurs

🎜🎜Développer les erreurs est un mécanisme qui parcourt une chaîne d'erreurs imbriquées jusqu'à ce que l'erreur de niveau le plus bas soit trouvée. Ceci est utile pour comprendre la cause première des erreurs ainsi qu’à des fins de débogage. 🎜rrreee🎜Dans l'exemple ci-dessus, la fonction f2 encapsule l'erreur de la fonction f1. La fonction errors.Unwrap déballe les erreurs imbriquées, nous permettant de parcourir la chaîne d'erreurs et d'imprimer chaque erreur. 🎜🎜En combinant les erreurs d'encapsulage et les erreurs de déballage, nous pouvons gérer efficacement les conditions d'erreur dans les programmes Go et fournir un contexte d'erreur plus riche et de meilleures capacités de débogage. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!