Comment puis-je réaliser un emballage d'erreur récursif avec Is() et As() dans Go ?

Erreurs Go : Is() et As() prennent en charge le wrapping récursif des erreurs

Dans Go, la gestion des erreurs est cruciale pour gérer et analyser les erreurs tout au long de la demande. L'interface d'erreur fournit un moyen courant de représenter les erreurs et inclut des méthodes telles que Is() et As() pour l'introspection des erreurs.

Cependant, il est important de noter que l'interface d'erreur standard ne prend pas en charge le renvoi récursif des erreurs. . Cela signifie que si vous utilisez fmt.Errorf pour envelopper les erreurs, vous ne pourrez pas utiliser Is() et As() pour vérifier les erreurs sous-jacentes de manière récursive.

Type d'erreur personnalisé pour les erreurs récursives Wrapping

Pour réaliser un emballage d'erreur récursif, vous pouvez créer un type d'erreur personnalisé qui implémente l'interface d'erreur. Ce type doit inclure une référence à l'erreur encapsulée et définir des méthodes Is() et As() personnalisées pour permettre des comparaisons récursives.

Voici un exemple d'implémentation d'un type d'erreur récursif :

type errorChain struct {
    err  error
    next *errorChain
}

func (c errorChain) Is(err error) bool {
    // Check the current error against the given error
    if c.err == err {
        return true
    }
    // Check if there is a wrapped error and recursively call Is()
    if c.next != nil {
        return c.next.Is(err)
    }
    return false
}

func (c errorChain) As(target interface{}) bool {
    // Check if the current error As() to the target interface
    if errors.As(c.err, target) {
        return true
    }
    // Check if there is a wrapped error and recursively call As()
    if c.next != nil {
        return c.next.As(target)
    }
    return false
}

Encapsuler les erreurs de manière récursive

Une fois que vous avez défini un type d'erreur personnalisé, vous pouvez envelopper les erreurs de manière récursive en utilisant une fonction comme la suivante :

func Wrap(errs ...error) error {
    if len(errs) == 0 {
        return nil
    }
    // Create the first error in the chain
    out := &errorChain{err: errs[0]}
    // Iterate over the remaining errors
    for _, err := range errs[1:] {
        // Link the errors together
        out.next = &errorChain{err: err}
        out = out.next
    }
    return out
}

Utilisation

Vous pouvez désormais utiliser ce type d'erreur personnalisé pour envelopper les erreurs et vérifier les erreurs sous-jacentes de manière récursive à l'aide de Is() et Comme(). Par exemple :

var Err1 = errors.New("error 1")
var Err2 = errors.New("error 2")
var Err3 = errors.New("error 3")

err := Wrap(Err1, Err2, Err3)

fmt.Println(errors.Is(err, Err2)) // true
fmt.Println(errors.Is(err, Err3)) // true
fmt.Println(errors.Is(err, Err0)) // false

Conclusion

En créant un type d'erreur personnalisé avec les méthodes récursives Is() et As(), vous pouvez obtenir un emballage d'erreur récursif et effectuer Gestion des erreurs plus précise dans vos applications Go.

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!