Go Academy · Leçon

Écrivains tamponnés

Écrire par lots

Écrivains tamponnés est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Pourquoi les écritures avec Buffer

Comme pour les lectures, chaque petite écriture peut déclencher un appel système. bufio.Writer rassemble les écritures en mémoire et les vide par grands blocs.

Important : les données mises en tampon sont perdues si vous n'appelez pas Flush().

Créer un bufio.Writer

Enveloppez n'importe quel io.Writer. Ici, nous enveloppons os.Stdout.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.WriteString("Hello buffered\n")
	w.Flush()
}

N'oubliez pas Flush

Sans Flush(), votre sortie pourrait ne jamais apparaître. Une pratique courante consiste à utiliser defer w.Flush().

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	w.WriteString("written via defer\n")
}

Écrire des Bytes et des chaînes

Utilisez Write pour les tranches d'octets, WriteString pour les chaînes, et WriteByte et WriteRune pour les valeurs individuelles.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.Write([]byte("bytes "))
	w.WriteString("string ")
	w.WriteRune('!')
	w.WriteByte('\n')
	w.Flush()
}

Vérifier l'état du Buffer

Buffered() indique combien d'octets sont en attente, et Available() indique combien d'espace libre reste.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.WriteString("abc")
	fmt.Fprintf(os.Stderr, "buffered: %d\n", w.Buffered())
	w.Flush()
}

Vidage automatique lorsque le Buffer est plein

Lorsque le tampon est plein, bufio.Writer le vide automatiquement. Vous devez tout de même appeler Flush() à la fin pour le contenu partiel restant dans le tampon.

Taille personnalisée du Buffer

bufio.NewWriterSize(w, size) définit la capacité. Des tampons plus grands réduisent la fréquence des vidages.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriterSize(os.Stdout, 8192)
	w.WriteString("custom size buffer\n")
	w.Flush()
}

Écritures formatées avec Fprintf

Comme bufio.Writer est un io.Writer, vous pouvez le transmettre à fmt.Fprintf pour obtenir une sortie formatée et mise en tampon.

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	for i := 1; i <= 3; i++ {
		fmt.Fprintf(w, "line %d\n", i)
	}
	w.Flush()
}

Gérer les erreurs d'écriture

Les erreurs peuvent apparaître lors d'une écriture ultérieure ou au moment de Flush(). Vérifiez toujours l'erreur renvoyée par Flush().

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	w.WriteString("data\n")
	if err := w.Flush(); err != nil {
		fmt.Fprintln(os.Stderr, "flush failed:", err)
	}
}

Regrouper de nombreuses écritures

Le véritable avantage est le suivant : une boucle serrée de petites écritures devient un seul appel système, ou quelques-uns, après la mise en tampon.

package main

import (
	"bufio"
	"os"
)

func main() {
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for i := 0; i < 5; i++ {
		w.WriteString("x")
	}
	w.WriteByte('\n')
}

Bonnes pratiques

Appelez toujours Flush() (ou utilisez defer)
Vérifiez l'erreur renvoyée par Flush(), pas seulement celle de chaque écriture
Adaptez la taille du tampon à votre charge de travail

Vérification rapide

Vérifiez vos connaissances sur les écrivains avec tampon.

Récapitulatif

Vous avez appris à regrouper les écritures avec bufio.Writer.

NewWriter / NewWriterSize
Write, WriteString, WriteByte, WriteRune
Fonctionne avec fmt.Fprintf
Appelez toujours Flush() et vérifiez son erreur

Questions Fréquemment Posées

La leçon « Écrivains tamponnés » est-elle gratuite ?

Oui — le texte complet de « Écrivains tamponnés » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Écrivains tamponnés » ?

Écrire par lots Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Écrivains tamponnés » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy