Comment puis-je empêcher les boucles infinies lors de la gestion des erreurs personnalisées dans Go ?

Gestion des erreurs non récursives : prévenir les boucles infinies

Dans Go, les situations exceptionnelles sont généralement gérées à l'aide de valeurs d'erreur, qui implémentent l'interface d'erreur. La méthode Error() de l'interface renvoie une chaîne décrivant l'erreur.

Cependant, lorsque vous travaillez avec des types d'erreur personnalisés, il est essentiel d'éviter la récursion dans la méthode Error().

L'Infini Problème de boucle

Considérez un type d'erreur personnalisé où la méthode Error() appelle fmt.Sprint(e) pour convertir la valeur d'erreur en chaîne. Cette approche pose un problème potentiel :

type MyError struct {
    message string
}

func (e MyError) Error() string {
    return fmt.Sprint(e)
}

Si vous essayez maintenant d'imprimer l'erreur, une boucle infinie se produit :

func main() {
    err := MyError{"Error!"}
    fmt.Println(err)
}

Cela se produit car fmt.Sprint(e) appelle e .Error(), qui à son tour appelle à nouveau fmt.Sprint(e), et ainsi de suite.

Rupture du Récursion

Pour rompre la récursion, convertissez e en une valeur qui n'a pas de méthode String ou Error avant de la transmettre à fmt.Sprint :

func main() {
    err := MyError{"Error!"}
    fmt.Println(fmt.Sprint(float64(err)))
}

Dans cet exemple, convertir e à un float64 supprime ses méthodes String et Error, empêchant la boucle infinie.

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!