Comment Go peut-il gérer efficacement plusieurs erreurs dans un seul bloc ?

Gérer plusieurs erreurs avec élégance dans Go

Dans Go, il est souvent nécessaire de gérer plusieurs erreurs à la fois, en particulier lorsqu'il s'agit d'E/S. opérations ou transformations de données. Alors que l'approche traditionnelle consistant à vérifier chaque erreur individuellement peut être fastidieuse et répétitive, Go fournit un mécanisme pour gérer toutes les erreurs dans un seul bloc concis.

Problème : gestion de plusieurs erreurs

Considérez le code suivant qui tente de rassembler plusieurs valeurs en JSON :

aJson, err1 := json.Marshal(a)
bJson, err2 := json.Marshal(b)
cJson, err3 := json.Marshal(c)
dJson, err4 := json.Marshal(d)
eJson, err5 := json.Marshal(e)
fJson, err6 := json.Marshal(f)
gJson, err4 := json.Marshal(g)
if err1 != nil {
    return err1
} else if err2 != nil {
    return err2
} else if err3 != nil {
    return err3
} else if err4 != nil {
    return err4
} else if err5 != nil {
    return err5
} else if err5 != nil {
    return err5
} else if err6 != nil {
    return err6
}

Ce code est sujet aux erreurs et nécessite contrôles répétitifs de gestion des erreurs pour chaque opération de marshaling. Cela rend également difficile la gestion des erreurs pour tous les objets JSON.

Solution : Utiliser une variable non locale pour la détection des erreurs

Go fournit un moyen simple de gérer plusieurs erreurs dans un seul bloc utilisant une variable non locale. Voici une version améliorée du code :

var err error
f := func(dest *D, src S) bool {
    *dest, err = json.Marshal(src)
    return err == nil
}

f(&aJson, a) &&
    f(&bJson, b) &&
    f(&cJson, c) &&
    f(&dJson, d) &&
    f(&eJson, e) &&
    f(&fJson, f) &&
    f(&gJson, g)
return err

Dans cette solution, nous définissons une fonction f qui effectue le marshaling et définit la variable err. La variable err est déclarée en dehors de la fonction, ce qui lui permet d'être partagée entre tous les appels à la fonction f.

La fonction f prend des pointeurs vers les objets JSON de destination et les données source. Il renvoie un bool indiquant si le marshaling a réussi (aucune erreur ne s'est produite).

Ensuite, nous appelons la fonction f pour chaque objet et connectons les résultats avec && (et logique). Si l'un des appels renvoie false (une erreur s'est produite), la chaîne est interrompue et la variable err contient la première erreur rencontrée. Sinon, si tous les appels renvoient vrai, aucune erreur ne s'est produite et l'erreur finale est nulle.

Dans la dernière ligne, nous renvoyons la variable err, qui contient la première erreur rencontrée, ou nil si toutes les opérations ont réussi .

Cette approche nous permet de gérer toutes les erreurs dans une seule instruction, ce qui rend la gestion des erreurs plus concise et efficace.

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!