if err != nil, l'erreur qu'on retourne if err != nil, the error you return

Go n'a pas d'exceptions pour le flot normal : une erreur est une valeur, qu'on inspecte et qu'on propage à la main. La verbosité est le prix de l'explicite — et le _ = qui jette l'erreur est le seul vrai danger. Go has no exceptions for the normal path: an error is a value you inspect and propagate by hand. Verbosity is the price of being explicit — and the _ = that throws the error away is the only real danger.

Audience
Dev venant d'un langage à exceptions, déconcerté par les if err != nil partout Dev from an exception-based language, thrown by if err != nil everywhere
ChapitresChapters
5
LectureReading
≈ 15 min
NiveauLevel
●○○○
Date
Mar 2027 Mar 2027

ErreursExplicite

SommaireContents ·
№ 01CadrageFraming3 min

Une erreur, en Go, n'est pas un événement qui surgit. C'est une valeur qu'on rend.An error, in Go, isn't an event that erupts. It's a value you return.

Le volume 3 s'est clos sur une promesse : error n'est qu'une interface à une méthode, et tout ce qu'on a appris s'y applique. La voici tenue. Là où la plupart des langages traitent l'échec comme une rupture — une exception qui saute par-dessus le code normal et atterrit dans un catch lointain — Go refuse ce canal parallèle. Une fonction qui peut échouer renvoie deux choses : son résultat, et une erreur. L'erreur est une valeur ordinaire, du type error, qu'on teste avec un if, qu'on range dans une variable, qu'on remonte d'un return. Pas de magie, pas de pile qui se déroule en douce. Le contrôle reste dans ta main, visible à chaque ligne.Volume 3 closed on a promise: error is just a one-method interface, and everything we learned applies to it. Here it's kept. Where most languages treat failure as a rupture — an exception leaping over normal code to land in a distant catch — Go refuses that parallel channel. A function that can fail returns two things: its result, and an error. The error is an ordinary value, of type error, tested with an if, stored in a variable, propagated with a return. No magic, no stack quietly unwinding. Control stays in your hand, visible on every line.

L'exception : un chemin d'échec invisibleThe exception: an invisible failure path
// ailleurs : l'erreur saute par-dessus le code normal
data := readFile(path)        // peut « lever » — rien ici ne le dit
parse(data)                   // … et on l'apprend ailleurs, dans un catch

// le chemin d'échec est invisible à l'endroit exact où il naît.
La valeur : un chemin d'échec rendu, sous les yeuxThe value: a failure path returned, in plain sight
// en Go : l'erreur est un second résultat, rendu là, sous les yeux
data, err := os.ReadFile(path)   // (.., error) : la signature l'annonce
if err != nil {
    return err                   // on la propage à la main, explicitement
}
parse(data)                      // on n'arrive ici QUE si tout a réussi
error n'est qu'une interface à une méthodeerror is just a one-method interface
error
interface
=
Error() string
une méthode
←
io.EOF
une variable

Tout ce qui possède une méthode Error() string est une error — la satisfaction implicite du volume 3, appliquée à l'échec. Une erreur est donc une valeur comme une autre : io.EOF est une variable de paquet, qu'on peut comparer avec ==, stocker, passer en argument. Rien de spécial, et c'est tout l'intérêt.Anything with an Error() string method is an error — Volume 3's implicit satisfaction, applied to failure. An error is thus a value like any other: io.EOF is a package variable you can compare with ==, store, pass as an argument. Nothing special, and that's the whole point.

Le réflexe du numéroThe issue's reflex

« Une erreur se rend, se teste, se propage — jamais elle ne saute. » Le coût de ce choix est connu : la verbosité, ces trois lignes if err != nil répétées partout. Le numéro défend que ce prix est honnête, et que le seul vrai danger n'est pas d'écrire if err != nil de trop, mais de l'écrire en moins — de jeter l'erreur d'un _ =."An error is returned, tested, propagated — it never leaps." The cost of this choice is well known: verbosity, those three if err != nil lines repeated everywhere. The issue argues that price is honest, and that the only real danger isn't writing one if err != nil too many, but one too few — discarding the error with a _ =.

Pourquoi pas d'exceptions ?Why no exceptions?

Les exceptions promettent un code « heureux » débarrassé de la gestion d'erreur — mais elles la cachent, elles ne l'effacent pas. À la lecture, tu ne sais plus quelle ligne peut échouer ni où l'échec sera rattrapé ; le flot de contrôle file en douce vers un catch que tu ne vois pas. Go fait le pari inverse : rendre l'échec visible coûte des lignes, mais on lit le programme tel qu'il s'exécute. C'est le même principe que partout dans le langage — pas de constructeurs cachés, pas de surcharge, pas de magie. L'explicite contre le concis : Go choisit l'explicite, assumé jusqu'à la verbosité.Exceptions promise a 'happy' code freed of error handling — but they hide it, they don't erase it. Reading, you no longer know which line can fail nor where the failure will be caught; control flow slips quietly toward a catch you can't see. Go makes the opposite bet: making failure visible costs lines, but you read the program as it runs. It's the same principle as everywhere in the language — no hidden constructors, no overloading, no magic. Explicit versus concise: Go chooses explicit, owned all the way to verbosity.

№ 02La surpriseThe surprise4 min

La verbosité n'est pas le danger. Le danger, c'est le _ = qui jette l'erreur.Verbosity isn't the danger. The danger is the _ = that throws the error away.

On reproche à Go ses if err != nil à répétition. Mais ce n'est pas la vérification qui blesse — c'est son absence. Quand une erreur est une valeur, l'ignorer est aussi facile que d'ignorer n'importe quelle autre valeur : un _ à la place du nom, et elle disparaît sans bruit. Le compilateur ne s'en plaint pas. Le programme continue, avec un fichier qui n'a jamais été ouvert ou des données à moitié lues, et le bug n'éclate que plus tard, à des kilomètres de sa cause. L'explicite a un revers : ce qui est explicite peut être explicitement écarté. La discipline du numéro tient en une phrase — vérifie, ou décide consciemment de ne pas, jamais par distraction.Go gets blamed for its repeated if err != nil. But it isn't the checking that hurts — it's its absence. When an error is a value, ignoring it is as easy as ignoring any other value: an _ in place of the name, and it vanishes silently. The compiler doesn't complain. The program continues, with a file that was never opened or half-read data, and the bug only erupts later, miles from its cause. Explicitness has a flip side: what's explicit can be explicitly discarded. The issue's discipline fits in one sentence — check, or consciously decide not to, never out of inattention.

Le bug naît silencieux, éclate ailleursThe bug is born silent, erupts elsewhere
f, _ := os.Open(path)         // _ : on jette l'erreur d'ouverture
defer f.Close()               // si Open a échoué, f est nil → Close renvoie ErrInvalid, ignoré

data, _ := io.ReadAll(f)      // f nil : os.ErrInvalid, data vide — jamais vu
process(data)                 // on traite des données peut-être tronquées
// trois échecs possibles, zéro vérifié. Le bug se révèle loin de sa cause.

Chaque _ est une promesse de bug différé. Si os.Open échoue, f vaut nil et ni le defer f.Close() ni la lecture ne paniquent : sur un *os.File nil, ils renvoient os.ErrInvalid — que le _ avale aussi. process reçoit des données vides, et rien ne mentionne le fichier introuvable qui en est la vraie cause. L'erreur ignorée ne disparaît pas, elle se déguise : elle ressurgit plus tard, sous une forme méconnaissable, à l'endroit le plus coûteux à déboguer — loin de sa source.Each _ is a promise of a deferred bug. If os.Open fails, f is nil and neither the defer f.Close() nor the read panics: on a nil *os.File they return os.ErrInvalid — which the _ swallows too. process gets empty data, and nothing mentions the missing file that's the real cause. An ignored error doesn't vanish, it disguises itself: it resurfaces later, in an unrecognizable form, at the costliest place to debug — far from its source.

errcheck, le garde que le compilateur n'est paserrcheck, the guard the compiler isn't

Le compilateur Go t'oblige à utiliser une variable, mais _ = err compte comme un usage : l'erreur jetée passe. C'est le rôle de errcheck (intégré à golangci-lint) de la rattraper — il signale tout retour d'erreur non vérifié, et même les _ = une fois l'option check-blank activée. Mets-le en CI : il transforme une faute invisible en échec de build. Et quand tu ignores vraiment une erreur à dessein — un fmt.Fprintf vers un bytes.Buffer, qui ne peut pas échouer — écris-le explicitement, avec un commentaire qui dit pourquoi. L'ignorance assumée se documente ; l'ignorance distraite se traque.The Go compiler forces you to use a variable, but _ = err counts as a use: the discarded error gets through. Catching it is errcheck's job (built into golangci-lint) — it flags every unchecked error return, and even _ = once its check-blank option is on. Put it in CI: it turns an invisible fault into a build failure. And when you genuinely ignore an error on purpose — an fmt.Fprintf to a bytes.Buffer, which can't fail — write it explicitly, with a comment saying why. Deliberate ignorance is documented; distracted ignorance is hunted.

Le compilateur t'oblige à voir l'erreur. Il ne t'oblige pas à la traiter — ça, c'est ta discipline, pas la sienne.The compiler forces you to see the error. It doesn't force you to handle it — that's your discipline, not its.
№ 03La mécaniqueThe mechanics5 min

Le message d'une erreur est pour l'humain. Pour le code, on compare la valeur.An error's message is for the human. For code, you compare the value.

Tester qu'une erreur est survenue, c'est if err != nil. Mais souvent il faut savoir laquelle : « pas trouvé » se rattrape, « disque plein » se propage. La tentation du débutant est de lire le texte du message — err.Error() == “...”. C'est un piège : le message est une chaîne destinée aux logs et aux humains, libre de changer à tout moment. Go offre deux façons stables d'identifier une erreur sans toucher à son texte. La sentinelle : une variable d'erreur unique, déclarée avec errors.New, qu'on compare par identité avec ==. Et l'erreur typée : un struct qui implémente Error() et porte des champs structurés. Les deux font de l'erreur ce qu'elle est — une valeur qu'on interroge, pas une phrase qu'on relit.Testing that an error occurred is if err != nil. But often you must know which one: 'not found' is recoverable, 'disk full' propagates. The beginner's temptation is to read the message text — err.Error() == “...”. It's a trap: the message is a string meant for logs and humans, free to change at any time. Go offers two stable ways to identify an error without touching its text. The sentinel: a unique error variable, declared with errors.New, compared by identity with ==. And the typed error: a struct implementing Error() and carrying structured fields. Both make the error what it is — a value you interrogate, not a sentence you reread.

Comparer le message : ça casse au premier reformuléComparing the message: it breaks on the first rephrase
if err.Error() == "record not found" {   // comparer le TEXTE du message
    return defaultUser, nil
}
// fragile : reformule le message, traduis-le, ajoute un préfixe,
// et la comparaison casse en silence. Le texte est pour l'humain,
// pas pour le code.

Comparer err.Error() à une chaîne littérale, c'est coupler ton flot de contrôle à un détail de présentation. Le jour où quelqu'un préfixe le message (« db: record not found »), le traduit, ou ajoute l'identifiant cherché, la branche ne se déclenche plus — sans la moindre erreur de compilation. Le texte d'une erreur n'est pas une API : c'est de la documentation pour l'humain qui lit le log. Le code, lui, ne doit jamais en dépendre.Comparing err.Error() to a literal string couples your control flow to a presentation detail. The day someone prefixes the message ("db: record not found"), translates it, or adds the looked-up id, the branch stops firing — with no compile error at all. An error's text isn't an API: it's documentation for the human reading the log. Code must never depend on it.

L'erreur typée : porter plus qu'un messageThe typed error: carrying more than a message

Quand l'erreur doit transporter des données — un code HTTP, le champ fautif, une valeur limite — on en fait un struct qui implémente Error() string. &ValidationError{Field: "email"} est une error à part entière, et l'appelant peut récupérer le Field après coup. C'est la satisfaction implicite du volume 3 au travail : aucun implements, juste la méthode. Sentinelle pour « quelle erreur », type pour « quelle erreur, avec quels détails » — et errors.As pour l'extraire à travers les emballages.When the error must carry data — an HTTP code, the offending field, a boundary value — you make it a struct implementing Error() string. &ValidationError{Field: "email"} is a full-fledged error, and the caller can recover the Field afterward. It's Volume 3's implicit satisfaction at work: no implements, just the method. Sentinel for "which error," type for "which error, with what details" — and errors.As to extract it through the wrapping.

errors.New, pas un struct à chaque fois.errors.New, not a struct every time.

Pour la majorité des erreurs — celles qu'on crée et qu'on remonte sans jamais les inspecter en détail — errors.New(“...”) ou fmt.Errorf(“...”) suffisent amplement. Ne crée une sentinelle que si un appelant doit pouvoir la reconnaître, et un type d'erreur que s'il doit en extraire des champs. Le sur-typage des erreurs est un travers courant : trois lignes de struct pour une erreur que personne n'inspecte, c'est de la cérémonie. Commence simple ; remonte vers la sentinelle ou le type seulement quand un besoin d'inspection concret apparaît.For most errors — those you create and propagate without ever inspecting in detail — errors.New(“...”) or fmt.Errorf(“...”) amply suffice. Create a sentinel only if a caller must recognize it, and an error type only if it must extract fields. Over-typing errors is a common vice: three lines of struct for an error nobody inspects is ceremony. Start simple; climb to the sentinel or the type only when a concrete inspection need appears.

Lis le message d'une erreur, et tu dépends de sa formulation. Compare sa valeur, et tu dépends de ce qu'elle est.Read an error's message, and you depend on its wording. Compare its value, and you depend on what it is.
№ 04Le piègeThe trap4 min

Logguer et remonter une erreur, c'est la traiter deux fois. Traite-la une fois.Logging and returning an error is handling it twice. Handle it once.

Une fois acquise la discipline de vérifier chaque erreur, un excès de zèle guette : la traiter à chaque étage. On loggue l'erreur, puis on la remonte ; la couche au-dessus loggue à son tour, puis remonte ; et ainsi de suite. Résultat : une seule panne produit une cascade de lignes de log redondantes, et il devient impossible de savoir où l'erreur a vraiment été gérée. Le principe directeur est simple : une erreur se traite exactement une fois. Traiter, c'est soit la résoudre, soit décider de l'afficher et d'arrêter — pas les deux à chaque niveau. Tant qu'on ne fait que la remonter, on ne la traite pas : on l'enrichit de contexte et on la laisse monter, jusqu'à l'unique endroit qui décide quoi en faire.Once you've acquired the discipline of checking every error, an excess of zeal lurks: handling it at every floor. You log the error, then return it; the layer above logs in turn, then returns; and so on. Result: a single failure produces a cascade of redundant log lines, and it becomes impossible to know where the error was actually handled. The guiding principle is simple: an error is handled exactly once. Handling means either resolving it, or deciding to display it and stop — not both at every level. As long as you only propagate it, you aren't handling it: you enrich it with context and let it climb, up to the single place that decides what to do with it.

La même panne, loggée à chaque étageThe same failure, logged at every floor
func loadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        log.Printf("read config failed: %v", err)   // on LOGGE…
        return nil, err                              // … ET on remonte
    }
    ...
}
// chaque couche fait pareil : main logge aussi, le handler logge aussi.
// une seule panne → cinq lignes de log quasi identiques, sans contexte clair.

Logguer puis remonter semble prudent — « au moins ce sera tracé ». En réalité, chaque couche refait le même geste, et une seule panne génère trois, cinq, dix lignes presque identiques, éparpillées, sans hiérarchie. Pire, à la lecture du code, on ne sait plus qui est responsable de l'erreur : tout le monde la touche, personne ne la possède. Logguer est une forme de traitement — le faire en plus de remonter, c'est traiter deux fois la même chose, et brouiller la trace au lieu de l'éclairer.Logging then returning seems prudent — "at least it'll be traced." In reality, each layer repeats the same move, and one failure generates three, five, ten near-identical lines, scattered, without hierarchy. Worse, reading the code, you no longer know who is responsible for the error: everyone touches it, no one owns it. Logging is a form of handling — doing it on top of returning means handling the same thing twice, blurring the trace instead of lighting it up.

Qui décide ? Le sommet, et lui seulWho decides? The top, and it alone

La règle « traite une fois » répond à une question de propriété — la même qui traverse toute la série. Une erreur appartient à la couche capable de décider : un handler HTTP la traduit en code 500, main la transforme en os.Exit(1), une boucle de retry la réessaie. Les couches intermédiaires ne possèdent pas cette décision ; leur seul rôle est d'enrichir et de transmettre. Logguer au milieu, c'est usurper une décision qui revient au sommet. Laisse l'erreur monter jusqu'à son propriétaire légitime.The "handle once" rule answers a question of ownership — the same one running through the whole series. An error belongs to the layer able to decide: an HTTP handler turns it into a 500, main turns it into os.Exit(1), a retry loop retries it. Intermediate layers don't own that decision; their only role is to enrich and pass on. Logging in the middle usurps a decision that belongs to the top. Let the error climb to its legitimate owner.

La chaîne, on la déroule au prochain numéro.The chain, we unroll it next issue.

Tout ce chapitre repose sur un verbe qu'on n'a fait qu'effleurer : envelopper. Le %w de fmt.Errorf n'ajoute pas qu'une chaîne — il chaîne l'erreur d'origine à la nouvelle, formant une pile qu'on pourra dérouler. C'est ce qui permet de logguer un message riche tout en haut et de retrouver, dessous, la sentinelle exacte avec errors.Is, ou le type avec errors.As. Le numéro 2 ouvre cette chaîne : envelopper sans perdre, dérouler sans casser. C'est là que « les erreurs sont des valeurs » devient « les erreurs sont des valeurs qu'on compose ».This whole chapter rests on a verb we only grazed: wrapping. The %w of fmt.Errorf doesn't add just a string — it chains the original error to the new one, forming a stack you can unroll. That's what lets you log a rich message at the top and recover, beneath it, the exact sentinel with errors.Is, or the type with errors.As. Issue 2 opens this chain: wrap without losing, unroll without breaking. That's where 'errors are values' becomes 'errors are values you compose.'

Remonter une erreur, ce n'est pas la traiter. C'est la confier à quelqu'un de mieux placé pour décider.Returning an error isn't handling it. It's entrusting it to someone better placed to decide.
№ 05Bilan & éditoWrap-up & editorial2 min

La verbosité de Go n'est pas un défaut de jeunesse. C'est une position.Go's verbosity isn't a growing pain. It's a stance.

Quatre points ouvrent ce volume. Une erreur est une valeur : rendue en second résultat, testée, propagée — jamais elle ne saute par-dessus le code. Le vrai danger n'est pas le if err != nil de trop, mais le _ = qui jette l'erreur en silence. Pour identifier une erreur, on compare sa valeur — sentinelle ou type — jamais le texte de son message. Et on la traite une seule fois : en chemin on n'ajoute que du contexte, la décision revient au sommet. Une idée les relie : en Go, le contrôle ne se cache pas, il se tient dans la main, ligne après ligne.Four points open this volume. An error is a value: returned as a second result, tested, propagated — it never leaps over the code. The real danger isn't one if err != nil too many, but the _ = that silently throws the error away. To identify an error, you compare its value — sentinel or type — never its message text. And you handle it exactly once: along the way you only add context, the decision belongs to the top. One idea ties them together: in Go, control flow isn't hidden, it's held in the hand, line after line.

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Erreur = valeurError = valueRendue en 2e résultat, testée par if, remontée par return.Returned as 2nd result, tested by if, propagated by return.Tu attends une exception qui ne viendra jamais.You wait for an exception that never comes.
Ne jette pasDon't discardJamais de _ = distrait ; errcheck en CI.Never a careless _ =; errcheck in CI.L'erreur se déguise et ressurgit loin de sa cause.The error disguises itself and resurfaces far from its cause.
Compare la valeurCompare the valueSentinelle == ou erreur typée — pas le texte.Sentinel == or typed error — not the text.Reformule le message, et la branche casse en silence.Rephrase the message, and the branch breaks silently.
Traite une foisHandle onceAjoute du contexte et remonte ; logge au sommet, lui seul.Add context and return; log at the top, it alone.La même panne loggée à chaque étage, sans propriétaire.The same failure logged at every floor, with no owner.
Les autres langages cachent l'échec pour faire joli le succès. Go montre l'échec, parce qu'un programme, c'est aussi tout ce qui peut mal tourner.Other languages hide failure to make success look pretty. Go shows failure, because a program is also everything that can go wrong.
Mot de l'éditeurFrom the editor

« Errors are values » : la phrase la plus sous-estimée de la culture Go."Errors are values": the most underrated sentence in Go culture.

On la cite comme un slogan, on en sous-estime la portée. Dire qu'une erreur est une valeur, ce n'est pas un détail d'implémentation — c'est un refus de toute la mécanique des exceptions, et de la promesse qu'elle porte. Les exceptions vendent un code débarrassé de l'échec : le chemin heureux, propre, et la gestion d'erreur reléguée ailleurs, hors de vue. Go répond que cette propreté est un mensonge. Un programme n'est pas un chemin heureux contrarié par des accidents ; c'est, à parts égales, ce qui réussit et tout ce qui peut échouer. Rendre l'échec visible n'alourdit pas le code — ça le rend honnête. Les trois lignes de if err != nil ne sont pas du bruit autour du vrai programme : elles SONT le programme, autant que le reste.It's quoted as a slogan, its reach underestimated. Saying an error is a value isn't an implementation detail — it's a refusal of the whole machinery of exceptions, and of the promise it carries. Exceptions sell code freed of failure: the happy path, clean, and error handling relegated elsewhere, out of sight. Go answers that this cleanliness is a lie. A program isn't a happy path disrupted by accidents; it's, in equal measure, what succeeds and everything that can fail. Making failure visible doesn't weigh the code down — it makes it honest. The three if err != nil lines aren't noise around the real program: they ARE the program, as much as the rest.

Et parce qu'une erreur est une valeur, on peut en faire tout ce qu'on fait d'une valeur — et c'est là que le volume s'ouvre vraiment. On peut la composer : l'envelopper dans une autre pour ajouter du contexte sans perdre l'originale, former une chaîne qu'on déroule à volonté. fmt.Errorf(“%w”, err) emballe, errors.Is et errors.As retrouvent au fond de la pile la sentinelle ou le type exact — et tu reconnaîtras, sous le capot, les assertions du volume 3. C'est la suite directe : Vol. 4 №02 — Envelopper, dérouler. On passe des erreurs qu'on rend aux erreurs qu'on compose, sans jamais casser la chaîne.And because an error is a value, you can do with it everything you do with a value — and that's where the volume truly opens. You can compose it: wrap it in another to add context without losing the original, forming a chain you unroll at will. fmt.Errorf(“%w”, err) wraps, errors.Is and errors.As find the exact sentinel or type at the bottom of the stack — and you'll recognize, under the hood, Volume 3's assertions. It's the direct sequel: Vol. 4 №02 — Wrap, unwrap. We move from errors you return to errors you compose, without ever breaking the chain.