Go Academy · Leçon

Lecteurs tamponnés

Lire efficacement avec bufio

Lecteurs tamponnés est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 lectures avec Buffer

Lire un octet à la fois depuis un fichier ou le réseau déclenche un appel système à chaque fois. C'est lent.

Le package bufio enveloppe un lecteur et lit de grands blocs dans un tampon en mémoire, puis fournit vos petites lectures à partir de ce tampon.

Moins d'appels système
Beaucoup plus rapide pour de nombreuses petites lectures

Créer un bufio.Reader

Enveloppez n'importe quel io.Reader avec bufio.NewReader. Ici, nous enveloppons un strings.Reader.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("Hello, Go!"))
	fmt.Printf("buffered reader ready: %T\n", r)
}

Lire des Bytes

ReadByte renvoie l'octet suivant. Il provient du tampon et non d'un nouvel appel système.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("Go"))
	b1, _ := r.ReadByte()
	b2, _ := r.ReadByte()
	fmt.Printf("%c%c\n", b1, b2)
}

ReadString jusqu'à un délimiteur

ReadString(delim) lit jusqu'à la première occurrence de l'octet délimiteur et renvoie tout le contenu y compris le délimiteur.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("first,second,third"))
	part, _ := r.ReadString(',')
	fmt.Printf("%q\n", part)
}

Examiner la suite

Peek(n) renvoie les n octets suivants sans les consommer. C'est très pratique pour décider comment analyser les données avant de s'engager.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("HTTP/1.1"))
	head, _ := r.Peek(4)
	fmt.Printf("starts with: %s\n", head)
}

Taille du Buffer

bufio.NewReaderSize(r, size) définit la capacité du tampon. Un tampon plus grand signifie moins de lectures sous-jacentes, mais davantage de mémoire utilisée.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReaderSize(strings.NewReader("data"), 4096)
	fmt.Println("buffer size:", r.Size())
}

ReadLine ou ReadString

ReadString('\n') conserve le saut de ligne ; de nombreux analyseurs préfèrent le supprimer. Le Scanner (dans la prochaine leçon) s'en charge automatiquement.

Utilisez ReadString lorsque vous avez besoin d'un contrôle total sur les délimiteurs.

Gérer io.EOF

Lorsque le flux sous-jacent est épuisé, les méthodes de lecture renvoient io.EOF. Vérifiez-le toujours pour savoir quand vous arrêter.

package main

import (
	"bufio"
	"fmt"
	"io"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("ab"))
	for {
		c, err := r.ReadByte()
		if err == io.EOF {
			break
		}
		fmt.Printf("%c", c)
	}
	fmt.Println()
}

ReadRune pour Unicode

ReadRune décode un rune UTF-8 complet, qui peut s'étendre sur plusieurs octets. Utilisez-le pour du texte contenant des caractères non ASCII.

package main

import (
	"bufio"
	"fmt"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("héllo"))
	for {
		ru, _, err := r.ReadRune()
		if err != nil {
			break
		}
		fmt.Printf("%c ", ru)
	}
	fmt.Println()
}

Lire jusqu'à la fin

Un schéma courant consiste à boucler avec ReadString jusqu'à EOF afin de traiter un flux ligne par ligne tout en gardant un contrôle précis.

package main

import (
	"bufio"
	"fmt"
	"io"
	"strings"
)

func main() {
	r := bufio.NewReader(strings.NewReader("a\nb\nc\n"))
	for {
		line, err := r.ReadString('\n')
		fmt.Print("got: " + line)
		if err == io.EOF {
			break
		}
	}
}

Quand utiliser bufio.Reader

Pour envelopper des sources lentes (fichiers, sockets)
Pour de nombreuses petites lectures
Lorsque vous devez examiner la suite ou lire par délimiteur ou par rune

Pour un simple parcours ligne par ligne, préférez bufio.Scanner (dans la prochaine leçon).

Vérification rapide

Vérifiez votre compréhension des lecteurs avec tampon.

Récapitulatif

Vous avez appris comment bufio.Reader réduit le nombre d'appels système grâce à la mise en tampon.

NewReader / NewReaderSize enveloppent un io.Reader
ReadByte, ReadRune et ReadString fournissent les données depuis le tampon
Peek examine la suite sans la consommer
Arrêtez-vous sur io.EOF

Questions Fréquemment Posées

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

Oui — le texte complet de « Lecteurs 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 « Lecteurs tamponnés » ?

Lire efficacement avec bufio 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 1 sur 4.

Combien de temps prend la leçon « Lecteurs 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