defer, la promesse différée defer, the deferred promise

defer planifie du code pour la sortie de fonction, quelle que soit la sortie — en pile LIFO. On libère une ressource juste à côté de son acquisition. Reste un piège : l'erreur de defer f.Close() qu'on laisse filer sans la regarder. defer schedules code for the function's exit, whatever the exit — LIFO order. You free a resource right next to where you acquired it. One trap remains: the error from defer f.Close() that slips away unlooked-at.

Audience
Dev qui ferme ses ressources à la main sur chaque return, ou ignore l'erreur de Close en écriture Dev who closes resources by hand on every return, or ignores Close's error on a write
ChapitresChapters
5
LectureReading
≈ 15 min
NiveauLevel
●○○○
Date
Déc 2027 Dec 2027

deferRessources

SommaireContents ·
№ 01CadrageFraming3 min

defer planifie du code pour la sortie de la fonction — quelle que soit la façon dont elle sort.defer schedules code for the function's exit — whatever way it exits.

On ouvre un volume nouveau. Jusqu'ici, on a parlé d'espace — où vit une valeur, qui la possède, qui peut la changer. defer parle de temps : il déplace un bout de code dans le futur, à l'instant précis où la fonction se terminera. Sa promesse est simple et puissante : tu écris defer suivi d'un appel, et cet appel ne s'exécute pas tout de suite — il est mis de côté, et Go garantit de le lancer juste avant que la fonction ne rende la main, quel que soit le chemin emprunté pour sortir. Un return en début de fonction, un return après une erreur, un return tout au fond, et même un panic qui déroule la pile : dans tous les cas, le code différé s'exécute. C'est exactement ce qu'il faut pour gérer les ressources. Une ressource qu'on acquiert — un fichier ouvert, un verrou pris, une connexion établie — doit toujours être libérée, et le drame habituel est d'oublier cette libération sur l'un des nombreux chemins de sortie d'une fonction. defer supprime le problème à la racine : on écrit la libération juste après l'acquisition, sur la ligne d'à côté, et on n'y pense plus. Acquérir puis defer libérer, collés l'un à l'autre, est l'un des motifs les plus reconnaissables du Go idiomatique. Le code différé est lisible là où il compte — près de ce qu'il nettoie — et il s'exécute là où il faut — à la toute fin, sans exception.We open a new volume. So far, we've spoken of space — where a value lives, who owns it, who can change it. defer speaks of time: it moves a piece of code into the future, to the precise instant the function ends. Its promise is simple and powerful: you write defer followed by a call, and that call doesn't run right away — it's set aside, and Go guarantees to launch it just before the function returns, whatever path was taken to exit. A return early in the function, a return after an error, a return deep at the bottom, and even a panic unwinding the stack: in every case, the deferred code runs. That's exactly what's needed to manage resources. A resource you acquire — an open file, a held lock, an established connection — must always be released, and the usual tragedy is forgetting that release on one of a function's many exit paths. defer removes the problem at the root: you write the release right after the acquisition, on the next line, and you stop thinking about it. Acquire then defer release, glued together, is one of the most recognizable patterns of idiomatic Go. The deferred code is readable where it matters — near what it cleans up — and it runs where it must — at the very end, no exception.

Sans defer : fermer sur chaque chemin, et en oublier unWithout defer: close on every path, and miss one
func process(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }

    data, err := parse(f)
    if err != nil {
        f.Close()              // … qu'il faut penser à fermer ici …
        return err
    }
    if data.empty() {
        f.Close()              // … et ici …
        return ErrEmpty
    }
    f.Close()                  // … et ici. Un seul oubli, et le fichier fuit.
    return nil
}
Avec defer : une libération, collée à l'acquisitionWith defer: one release, glued to the acquisition
func process(path string) error {
    f, err := os.Open(path)
    if err != nil {
        return err
    }
    defer f.Close()            // planifié MAINTENANT, exécuté à la SORTIE

    data, err := parse(f)
    if err != nil {
        return err             // f.Close() aura lieu, automatiquement
    }
    if data.empty() {
        return ErrEmpty        // … ici aussi …
    }
    return nil                 // … et ici. Un seul Close, pour tous les chemins.
}
Tous les chemins de sortie passent par le deferEvery exit path goes through the defer
return tôt
return sur erreur
return final
panic qui déroule
→
defer f.Close()
s'exécute, toujours

Peu importe par où la fonction s'en va : le code différé est sur le passage. Une seule ligne couvre tous les retours, présents et ceux qu'un collègue ajoutera demain — y compris la sortie par panic.No matter where the function leaves: the deferred code is on the way out. A single line covers every return, present ones and those a colleague adds tomorrow — including the exit by panic.

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

« J'acquiers une ressource ? la ligne suivante est son defer de libération. » Le geste se fait en deux temps qu'on n'écrit qu'une fois : f, _ := os.Open(...) puis defer f.Close(), l'un sous l'autre. La proximité est le bénéfice principal : le lecteur voit, au même endroit, ce qui est pris et ce qui sera rendu. Plus de fermeture éparpillée sur dix return, plus de fuite quand un chemin de sortie est ajouté plus tard."Do I acquire a resource? the next line is its defer release." The gesture happens in two beats you write only once: f, _ := os.Open(...) then defer f.Close(), one under the other. The proximity is the main benefit: the reader sees, in one place, what's taken and what will be returned. No more close scattered across ten returns, no more leak when an exit path is added later.

defer n'est pas « à la fin du bloc »defer isn't 'at the end of the block'

Un piège de débutant venu d'autres langages : croire que defer s'exécute à la fin du bloc courant — la fin du if, la fin du for. Faux. defer est attaché à la fonction, pas au bloc. Un defer écrit à l'intérieur d'un if ne se déclenchera pas en sortant du if, mais en sortant de la fonction tout entière. Cette distinction est sans conséquence dans une fonction courte, mais elle devient un vrai problème dans une boucle : un defer dans un for s'accumule et n'est honoré qu'au retour de la fonction, pas à chaque tour. On y reviendra — c'est l'un des pièges du numéro 2 — mais retiens dès maintenant la portée exacte : defer vise la sortie de la fonction, et rien d'autre.A beginner trap coming from other languages: believing defer runs at the end of the current block — the end of the if, the end of the for. Wrong. defer is attached to the function, not the block. A defer written inside an if won't fire when leaving the if, but when leaving the whole function. This distinction is harmless in a short function, but it becomes a real problem in a loop: a defer in a for accumulates and is only honored on the function's return, not each iteration. We'll come back to it — it's one of issue 2's traps — but remember right now the exact scope: defer targets the function's exit, and nothing else.

№ 02La surpriseThe surprise4 min

Plusieurs defer ne s'exécutent pas dans l'ordre où tu les écris. Ils s'exécutent à l'envers — et c'est exactement ce qu'il faut.Multiple defers don't run in the order you write them. They run backwards — and that's exactly right.

Quand une fonction contient plusieurs defer, ils ne se déclenchent pas dans l'ordre de lecture, mais dans l'ordre inverse : le dernier defer écrit est le premier exécuté. On dit qu'ils forment une pile — Last In, First Out. À la première rencontre, ça surprend ; on s'attend à ce que les choses arrivent dans l'ordre où on les a posées. Mais cet ordre inversé n'est pas un caprice d'implémentation : c'est précisément le bon ordre pour défaire ce qu'on a fait. Pense à des couches qu'on empile pour acquérir des ressources dépendantes les unes des autres : on prend un verrou, puis on ouvre un fichier, puis on enveloppe ce fichier dans un tampon d'écriture. Ces couches se montent dans un ordre, et elles doivent se démonter dans l'ordre exactement inverse — on vide d'abord le tampon dans le fichier, ensuite on ferme le fichier, et seulement après on relâche le verrou. Faire l'inverse — fermer le fichier avant d'avoir vidé le tampon — perdrait des données. Le LIFO de defer encode cette logique de démontage sans que tu aies à y penser : il suffit d'écrire chaque libération juste après son acquisition, et l'ordre de nettoyage se met en place tout seul, à l'envers, comme on dépile des assiettes. C'est l'une des raisons pour lesquelles defer rend le code de gestion de ressources si naturel : la structure du nettoyage suit, en miroir, la structure de la mise en place.When a function contains several defers, they don't fire in reading order, but in reverse: the last defer written is the first executed. We say they form a stack — Last In, First Out. On first encounter, it surprises; you expect things to happen in the order you laid them down. But this reversed order isn't an implementation whim: it's precisely the right order to undo what you did. Think of layers you stack to acquire resources that depend on one another: you take a lock, then open a file, then wrap that file in a write buffer. These layers build up in one order, and they must tear down in the exact reverse — you first flush the buffer into the file, then close the file, and only after release the lock. Doing the opposite — closing the file before flushing the buffer — would lose data. defer's LIFO encodes this teardown logic without you having to think about it: just write each release right after its acquisition, and the cleanup order falls into place by itself, backwards, like unstacking plates. It's one of the reasons defer makes resource code so natural: the cleanup's structure mirrors, in reverse, the setup's structure.

Le dernier empilé est le premier dépiléLast pushed is first popped
func demo() {
    fmt.Println("début")
    defer fmt.Println("defer 1")   // empilé en 1er
    defer fmt.Println("defer 2")   // empilé en 2e
    defer fmt.Println("defer 3")   // empilé en 3e
    fmt.Println("fin du corps")
}
// sortie :
//   début
//   fin du corps
//   defer 3      ← dernier empilé, PREMIER exécuté
//   defer 2
//   defer 1      ← premier empilé, dernier exécuté

Trois defer, exécutés dans l'ordre 3, 2, 1. Chaque defer pose son appel au sommet d'une pile ; à la sortie, Go dépile du sommet vers le bas. Le modèle mental est exactement celui d'une pile d'assiettes : la dernière posée est la première reprise. Tant qu'on garde ce schéma en tête, l'ordre d'exécution n'a plus rien de surprenant — il est mécanique, prévisible, et on apprend vite à le lire à l'envers du code.Three defers, executed in order 3, 2, 1. Each defer places its call atop a stack; at exit, Go pops from the top down. The mental model is exactly that of a stack of plates: the last laid down is the first taken back. As long as you keep this picture in mind, the execution order is no longer surprising — it's mechanical, predictable, and you quickly learn to read it backwards from the code.

L'ordre inverse n'est pas une bizarrerie. C'est l'ordre exact pour défaire des couches — la dernière prise, la première rendue.The reverse order isn't a quirk. It's the exact order to undo layers — last taken, first returned.
№ 03La mécaniqueThe mechanics5 min

defer survit à tout — au return comme au panic. C'est le seul code dont l'exécution est garantie.defer survives everything — the return as the panic. It's the only code whose execution is guaranteed.

La garantie de defer va plus loin qu'un simple « à la fin de la fonction ». Elle couvre les deux façons de quitter une fonction, et c'est ce qui fait toute sa valeur. La première façon, ordinaire, est le return : qu'il soit explicite ou implicite, précoce ou final, chaque return déclenche les defer en attente avant de rendre la main à l'appelant. La seconde façon, exceptionnelle, est le panic : quand une fonction panique, ou qu'une fonction qu'elle a appelée panique sans être récupérée, la pile se déroule frame par frame — et à chaque frame, Go exécute les defer en attente avant de remonter d'un cran. Autrement dit, même un programme en train de s'effondrer honore ses defer en chemin. C'est précisément cette propriété qui fait de defer le bon outil — en réalité le seul outil correct — pour libérer une ressource. Un simple appel de nettoyage placé en fin de fonction serait sauté par un return précoce et par un panic ; un defer, non. C'est aussi le lien direct avec ce qu'on a vu au volume 4 : un panic déroule la pile en exécutant les defer, et c'est dans un defer, et seulement là, que recover peut intercepter ce panic. La position de defer dans le cycle de vie de la fonction — juste après que la valeur de retour est fixée, juste avant le retour effectif à l'appelant, et systématiquement pendant un déroulement — n'est pas un détail. C'est l'emplacement unique d'où l'on peut à la fois nettoyer ce qui doit l'être et, le cas échéant, reprendre la main sur une panique. On y reviendra au numéro 3 de ce volume.defer's guarantee goes further than a mere 'at the end of the function.' It covers both ways of leaving a function, and that's what makes all its value. The first way, ordinary, is the return: explicit or implicit, early or final, each return triggers the pending defers before handing back to the caller. The second way, exceptional, is the panic: when a function panics, or a function it called panics without being recovered, the stack unwinds frame by frame — and at each frame, Go executes the pending defers before climbing one notch. In other words, even a collapsing program honors its defers on the way. It's precisely this property that makes defer the right tool — really the only correct tool — to release a resource. A plain cleanup call placed at the function's end would be skipped by an early return and by a panic; a defer, not. It's also the direct link with what we saw in volume 4: a panic unwinds the stack executing the defers, and it's in a defer, and only there, that recover can intercept that panic. defer's position in the function's lifecycle — just after the return value is set, just before the actual return to the caller, and systematically during an unwind — isn't a detail. It's the unique vantage from which you can both clean up what must be and, if needed, take back control of a panic. We'll return to it in this volume's issue 3.

Chaque return, précoce ou final, déclenche le deferEvery return, early or final, triggers the defer
func read(path string) (err error) {
    f, e := os.Open(path)
    if e != nil {
        return e
    }
    defer f.Close()           // s'exécute à CHAQUE return

    if bad {
        return ErrBad         // … Close a lieu, puis read renvoie ErrBad
    }
    return nil                // … Close a lieu, puis read renvoie nil
}

Quel que soit le return emprunté, f.Close() s'exécute avant que l'appelant ne reprenne la main. C'est ce qui rend la gestion de ressources robuste aux modifications : ajoute un nouveau return dans six mois, au milieu de la fonction, et le fichier sera quand même fermé — tu n'as rien à penser. Le defer couvre les chemins de sortie que tu n'as pas encore écrits.Whatever return is taken, f.Close() runs before the caller resumes. That's what makes resource handling robust to changes: add a new return in six months, in the middle of the function, and the file will still be closed — you have nothing to think about. The defer covers the exit paths you haven't written yet.

Un nettoyage en fin de fonction est sauté par un retour précoce ou un panic. Un defer est le seul code dont l'exécution est promise, quoi qu'il arrive.A cleanup at the function's end is skipped by an early return or a panic. A defer is the only code whose execution is promised, no matter what.
№ 04Le piègeThe trap4 min

defer f.Close() jette l'erreur que Close renvoie. Sur un fichier qu'on écrit, c'est une perte de données muette.defer f.Close() throws away the error Close returns. On a file you write, that's silent data loss.

Le defer f.Close() qu'on écrit machinalement cache un défaut qu'on n'imagine pas tant qu'on ne s'est pas fait mordre : il ignore la valeur de retour de Close. Or Close, sur un fichier ouvert en écriture, n'est pas une formalité — c'est souvent le moment où les données encore en tampon sont réellement écrites sur le disque, et c'est donc un moment où ça peut échouer : disque plein, quota dépassé, erreur réseau sur un système de fichiers distant. Si Write a réussi mais que Close échoue, et que tu as écrit defer f.Close() sans regarder son erreur, ta fonction renvoie « tout va bien » alors que les octets ne sont jamais arrivés à destination. C'est l'un des bugs les plus sournois qui soient, parce qu'il ne se manifeste qu'en conditions limites — précisément celles où l'on aurait le plus besoin de savoir que l'écriture a raté. Pour un fichier ouvert en lecture seule, ignorer l'erreur de Close est acceptable, et tout le monde le fait ; mais dès qu'on écrit, il faut la capturer. La technique standard combine deux ingrédients qu'on a déjà croisés : un retour nommé, et un defer sous forme de fermeture plutôt que d'appel direct. La fermeture, exécutée à la sortie, appelle Close, regarde son erreur, et l'assigne au retour nommé si aucune erreur plus grave ne s'est produite avant. C'est un petit motif, un peu verbeux, mais c'est la différence entre une sauvegarde fiable et une sauvegarde qui ment.The defer f.Close() you write mechanically hides a flaw you don't imagine until it bites you: it ignores Close's return value. Yet Close, on a file opened for writing, isn't a formality — it's often the moment the still-buffered data is actually written to disk, and thus a moment where it can fail: disk full, quota exceeded, network error on a remote filesystem. If Write succeeded but Close fails, and you wrote defer f.Close() without looking at its error, your function returns 'all good' while the bytes never reached their destination. It's one of the sneakiest bugs there is, because it only shows up in edge conditions — precisely the ones where you'd most need to know the write failed. For a file opened read-only, ignoring Close's error is acceptable, and everyone does it; but the moment you write, you must capture it. The standard technique combines two ingredients we've already met: a named return, and a defer as a closure rather than a direct call. The closure, run at exit, calls Close, looks at its error, and assigns it to the named return if no graver error occurred before. It's a small pattern, a bit verbose, but it's the difference between a reliable save and a save that lies.

L'erreur de Close part à la poubelleClose's error goes to the trash
func save(path string, data []byte) error {
    f, err := os.Create(path)
    if err != nil {
        return err
    }
    defer f.Close()           // ← l'erreur que Close renvoie est JETÉE

    _, err = f.Write(data)
    return err
}
// si Write réussit mais que Close échoue (flush disque, quota dépassé),
// save renvoie nil — alors que les données ne sont PAS sur le disque.

Le code paraît complet : on crée, on écrit, on renvoie l'erreur de Write, on ferme. Mais la seule erreur qui dit « tes données sont vraiment sur le disque » est celle de Close, et on l'a jetée. En lecture, aucune importance — Close ne fait que libérer un descripteur. En écriture, c'est le contrôle final, celui qui valide le flush. L'ignorer transforme save en fonction qui réussit toujours sur le papier, même quand le disque a refusé les octets.The code looks complete: you create, write, return Write's error, close. But the only error that says "your data really is on disk" is Close's, and you threw it away. On a read, no matter — Close only frees a descriptor. On a write, it's the final check, the one validating the flush. Ignoring it turns save into a function that always succeeds on paper, even when the disk refused the bytes.

La règle simpleThe simple rule

Lecture : defer f.Close() suffit. Le Close d'un fichier qu'on n'a fait que lire ne peut rien perdre d'important, et ignorer son erreur est la convention. Écriture : capture l'erreur. Tout ce qui a un tampon — un fichier en écriture, un gzip.Writer, un bufio.Writer — peut échouer à la fermeture, et c'est précisément là que se joue la persistance. La distinction lecture/écriture est le bon discriminant ; quand tu écris, le Close mérite le même soin que le Write.Read: defer f.Close() is enough. The Close of a file you only read can't lose anything important, and ignoring its error is the convention. Write: capture the error. Anything with a buffer — a file open for writing, a gzip.Writer, a bufio.Writer — can fail on close, and that's precisely where persistence is decided. The read/write distinction is the right discriminator; when you write, the Close deserves the same care as the Write.

Cette closure soulève une question : que capture-t-elle ?This closure raises a question: what does it capture?

Le motif de réparation qu'on vient d'écrire repose sur une fermeture qui lit err à la sortie de la fonction — donc sa valeur finale, pas celle qu'elle avait au moment du defer. Mais juste avant, defer f.Close() figeait f tout de suite. Pourquoi l'un est-il évalué maintenant et l'autre à la sortie ? Parce que defer obéit à une règle de capture précise et contre-intuitive : les arguments de l'appel différé sont évalués à l'instant du defer, tandis que le corps d'une fermeture différée s'exécute, lui, à la sortie. Tout l'écart entre les deux comportements qu'on vient de voir tient dans cette distinction — et c'est exactement le sujet du prochain numéro, avec son lot de pièges, à commencer par la fameuse variable de boucle. Vol. 7 №02 — La capture du defer.The repair pattern we just wrote rests on a closure that reads err at the function's exit — so its final value, not the one it had at the moment of defer. But just before, defer f.Close() froze f right away. Why is one evaluated now and the other at exit? Because defer obeys a precise, counterintuitive capture rule: the deferred call's arguments are evaluated at the moment of defer, while a deferred closure's body runs at exit. The whole gap between the two behaviors we just saw lives in this distinction — and it's exactly the next issue's subject, with its share of traps, starting with the famous loop variable. Vol. 7 №02 — What defer captures.

Sur un fichier qu'on lit, oublie l'erreur de Close. Sur un fichier qu'on écrit, la jeter, c'est mentir sur la persistance.On a file you read, forget Close's error. On a file you write, throwing it away is lying about persistence.
№ 05Bilan & éditoWrap-up & editorial2 min

defer écrit la libération à côté de l'acquisition, et garantit qu'elle aura lieu — par quelque porte que sorte la fonction.defer writes the release next to the acquisition, and guarantees it happens — through whatever door the function exits.

Ce numéro a ouvert le volume sur l'outil qui relie une acquisition à sa libération. defer planifie un appel pour la sortie de la fonction — la fonction, pas le bloc — et l'on écrit ainsi la libération juste après l'acquisition, collée à elle, lisible d'un coup d'œil. Plusieurs defer forment une pile LIFO, exécutée à l'envers, ce qui est précisément le bon ordre pour démonter des couches imbriquées : la dernière prise, la première rendue. La garantie couvre les deux sorties possibles : un return, précoce ou final, et un panic qui déroule la pile — dans les deux cas, le code différé s'exécute, ce qui fait de defer le seul outil de nettoyage robuste, et le point d'ancrage où recover pourra plus tard reprendre la main. Reste le piège : defer f.Close() jette l'erreur de Close, anodin en lecture, mais en écriture c'est une perte de données muette, qu'on répare avec un retour nommé et une fermeture différée. Et cette fermeture ouvre la question du prochain numéro — qu'est-ce, au juste, qu'un defer capture, et quand ?This issue opened the volume on the tool that ties an acquisition to its release. defer schedules a call for the function's exit — the function, not the block — and you thus write the release right after the acquisition, glued to it, readable at a glance. Several defers form a LIFO stack, executed in reverse, which is precisely the right order to dismantle nested layers: last taken, first returned. The guarantee covers both possible exits: a return, early or final, and a panic unwinding the stack — in both cases the deferred code runs, which makes defer the only robust cleanup tool, and the anchor point where recover will later be able to take back control. The trap remains: defer f.Close() throws away Close's error, harmless on a read, but on a write it's silent data loss, repaired with a named return and a deferred closure. And that closure opens the next issue's question — what, exactly, does a defer capture, and when?

L'idéeThe ideaLa règleThe ruleSi tu la ratesIf you miss it
Planifié pour la sortieScheduled for exitdefer met l'appel de côté ; il s'exécute à la sortie de la fonction.defer sets the call aside; it runs at the function's exit.Tu le crois lié au bloc ; dans une boucle, il s'accumule.You think it's tied to the block; in a loop, it piles up.
Pile LIFOLIFO stackPlusieurs defer s'exécutent à l'envers — la dernière prise, la première rendue.Several defers run in reverse — last taken, first returned.Démontage dans le mauvais ordre : tampon perdu, verrou mal rendu.Teardown in the wrong order: lost buffer, mis-released lock.
Survit au panicSurvives the panicLe code différé s'exécute aussi pendant un déroulement de pile.The deferred code also runs during a stack unwind.Un crash localisé laisse fuir fichiers ouverts et verrous.A localized crash leaks open files and locks.
L'erreur de CloseClose's errorEn écriture, capture-la : retour nommé + defer en fermeture.On a write, capture it: named return + defer as a closure.Une écriture qui réussit « sur le papier », des octets jamais sauvés.A write that succeeds 'on paper,' bytes never saved.
Le volume 6 demandait : à qui est cette valeur ? Le volume 7 demande : quand ce code s'exécutera-t-il — et defer répond « à la sortie, sans faute ».Volume 6 asked: whose value is this? Volume 7 asks: when will this code run — and defer answers "at exit, without fail."
Mot de l'éditeurFrom the editor

defer n'est pas un raccourci de nettoyage. C'est une façon d'écrire le programme pour qu'on ne puisse pas oublier de défaire ce qu'on a fait.defer isn't a cleanup shortcut. It's a way of writing the program so you can't forget to undo what you did.

La vraie idée de defer n'est pas technique, elle est ergonomique. Dans la plupart des langages, l'acquisition et la libération d'une ressource sont séparées par tout le corps de la fonction : on ouvre en haut, on ferme en bas, et entre les deux s'accumulent les return, les erreurs, les chemins qui sautent la fermeture. La distance physique entre les deux gestes est la source du bug — on lit l'ouverture sans voir la fermeture, on ajoute un return sans penser à nettoyer. defer abolit cette distance. Il permet d'écrire la libération sur la ligne qui suit l'acquisition, tout en la faisant s'exécuter à la sortie. Le code dit ce qu'il fait là où il le fait, et l'exécution se charge du quand. C'est une forme d'honnêteté structurelle : la responsabilité de rendre une ressource est inscrite à l'endroit où on la prend, pas reléguée à une fin de fonction qu'on espère atteindre. Et comme la garantie tient même sous un panic, cette honnêteté ne flanche pas dans les moments où elle compte le plus.defer's real idea isn't technical, it's ergonomic. In most languages, a resource's acquisition and release are separated by the whole body of the function: you open at the top, close at the bottom, and between them pile up the returns, the errors, the paths that skip the close. The physical distance between the two gestures is the bug's source — you read the open without seeing the close, you add a return without thinking to clean up. defer abolishes that distance. It lets you write the release on the line following the acquisition, while making it run at exit. The code says what it does where it does it, and execution handles the when. It's a form of structural honesty: the responsibility to return a resource is inscribed where you take it, not relegated to a function's end you hope to reach. And since the guarantee holds even under a panic, this honesty doesn't falter in the moments it matters most.

Le prochain numéro va regarder defer de plus près, là où sa simplicité apparente cache une mécanique précise. On a vu deux formes : defer f.Close(), un appel direct, et defer suivi d'une fermeture. Elles ne capturent pas la même chose au même moment, et cet écart est la source de la moitié des surprises liées à defer. Les arguments d'un appel différé sont figés à l'instant où le defer est rencontré — une photographie prise sur-le-champ. Le corps d'une fermeture différée, lui, ne s'exécute qu'à la sortie, et lit alors les variables dans leur état final. Confondre les deux, c'est s'exposer au bug le plus célèbre du langage — celui de la variable de boucle capturée — et à son cousin, le defer qui s'empile silencieusement dans une boucle au lieu de se déclencher à chaque tour. Comprendre exactement ce qui est gelé et ce qui est différé, c'est passer de « defer marche » à « je sais ce que defer va faire ». Vol. 7 №02 — La capture du defer.The next issue will look at defer more closely, where its apparent simplicity hides a precise mechanic. We saw two forms: defer f.Close(), a direct call, and defer followed by a closure. They don't capture the same thing at the same moment, and that gap is the source of half the surprises tied to defer. A deferred call's arguments are frozen at the instant the defer is met — a photograph taken on the spot. A deferred closure's body, by contrast, only runs at exit, and then reads the variables in their final state. Confusing the two exposes you to the language's most famous bug — the captured loop variable — and its cousin, the defer that silently piles up in a loop instead of firing each iteration. Understanding exactly what's frozen and what's deferred is moving from 'defer works' to 'I know what defer will do.' Vol. 7 №02 — What defer captures.