Comment puis-je gérer élégamment plusieurs erreurs dans le marshaling JSON de Go ?

La gestion des erreurs rendue élégante dans Go

Dans Go, il peut être difficile de gérer efficacement plusieurs erreurs. Considérez le code suivant :

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 propose une vérification approfondie des erreurs, mais son approche de gestion est lourde. Existe-t-il une manière plus élégante de gérer ces erreurs ?

Heureusement, il existe. En tirant parti de la puissance des fermetures et d'une variable d'erreur partagée, nous pouvons obtenir une gestion concise des erreurs :

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

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

Dans ce code mis à jour, nous définissons une fermeture f qui gère le marshalling JSON et la vérification des erreurs pour une source donnée. et destination. En utilisant l'opérateur && pour enchaîner ces appels, nous pouvons les exécuter consécutivement, et la première erreur rencontrée sera capturée dans la variable err partagée. Cela nous permet de gérer toutes les erreurs en même temps, améliorant considérablement la lisibilité et la maintenabilité du code.

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!