Techniques de traitement des erreurs de Golang

Question

Je commence juste avec Go. Mon code commence a avoir beaucoup de ceci:

    if err != nil {
      //handle err
   }
 

ou ca

   if err := rows.Scan(&some_column); err != nil {
      //handle err
  }
 

Existe-t-il de bons idiomes / stratégies / meilleures pratiques pour vérifier et traiter les erreurs en golang?

EDIT pour clarifier: je ne suis pas en train de me faire mal ou de suggérer que l’équipe de golang propose quelque chose de mieux. Je demande si je le fais bien ou si j'ai manqué une technique que la communauté a mise au point. Merci a tous.

Answer 1

Votre code est idiomatique et, à notre connaissance, c'est la meilleure pratique disponible. Certains seraient en désaccord avec certitude, mais je dirais que c'est le style que l'on retrouve partout dans le monde. IOW, Go auteurs écrivent de cette manière la gestion des erreurs.

Answer 2

Je suis d'accord avec jnml la réponse qu'ils sont à la fois idiomatiques code, et ajoutez la ligne suivante:

Votre premier exemple:

if err != nil {
      //handle err
}

est plus idiomatique lorsque l'on traite avec plus d'une valeur de retour. par exemple:

val, err := someFunc()
if err != nil {
      //handle err
}
//do stuff with val

Votre deuxième exemple est agréable d'abréviation quand ne traite que de l' err de la valeur. Cela s'applique si la fonction renvoie uniquement un error, ou si vous avez délibérément ignorer le retour à des valeurs autres que l' error. Comme un exemple, il est parfois utilisé avec l' Reader et Writer fonctions qui renvoient un int le nombre d'octets écrits (parfois inutiles de l'information) et un error:

if _, err := f.Read(file); err != nil {
      //handle err
}
//do stuff with f

La deuxième forme est appelée à l'aide d'un si l'instruction d'initialisation.

Donc, en ce qui concerne les meilleures pratiques, autant que je sache (sauf pour l'utilisation de la "erreurs" package pour créer de nouvelles erreurs lorsque vous en avez besoin) vous avez couvert pratiquement tout ce que vous devez savoir buter les erreurs dans le jeu de Go!

EDIT: Si vous trouvez que vous avez vraiment ne pouvez pas vivre sans exceptions, vous pouvez imiter avec defer,panic & recover.

Answer 3

J'ai fait une bibliothèque pour optimiser la gestion des erreurs et de la tuyauterie grâce à une file d'attente de go fonctions.

Vous pouvez le trouver ici: https://github.com/go-on/queue

Il dispose d'un compact et d'un verbose variante syntaxique. Voici un exemple de la syntaxe courte:

import "github.com/go-on/queue/q"

func SaveUser(w http.ResponseWriter, rq *http.Request) {
    u := &User{}
    err := q.Q(                      
        ioutil.ReadAll, rq.Body,  // read json (returns json and error)
    )(
        // q.V pipes the json from the previous function call
        json.Unmarshal, q.V, u,   // unmarshal json from above  (returns error)
    )(
        u.Validate,               // validate the user (returns error)
    )(
        u.Save,                   // save the user (returns error)
    )(
        ok, w,                    // send the "ok" message (returns no error)
    ).Run()

    if err != nil {
       switch err {
         case *json.SyntaxError:
           ...
       }
    }
}

S'il vous plaît être conscient que c'est un peu les performances, car il fait usage de la réflexion.

Aussi ce n'est pas idiomatique aller de code, de sorte que vous voulez l'utiliser dans vos propres projets, ou si votre équipe s'engage sur de l'utiliser.