Go Academy · Leçon

Flux de fichiers volumineux

Traiter les fichiers sans tout charger

Flux de fichiers volumineux est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 4 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.

Le problème du chargement complet

Lire un fichier de plusieurs gigaoctets en mémoire avec os.ReadFile peut épuiser la RAM. À la place, traitez-le en flux : traitez les blocs au fur et à mesure de leur arrivée.

Le concept de flux

Le traitement en flux signifie que vous ne gardez en mémoire qu'une petite fenêtre de données à la fois. Associé à la mise en tampon, il vous permet de traiter des entrées de taille arbitraire avec une quantité de mémoire constante.

Ligne par ligne avec Scanner

Pour le texte, un bufio.Scanner parcourant un lecteur traite une ligne à la fois, quelle que soit la taille du fichier. Ici, nous simulons un fichier avec un strings.Reader.

package main

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

func main() {
	src := strings.NewReader("alpha\nbeta\ngamma")
	s := bufio.NewScanner(src)
	for s.Scan() {
		fmt.Println("processed:", s.Text())
	}
}

Compter sans tout charger

Vous pouvez calculer des statistiques sur un flux volumineux en ne conservant presque rien en mémoire.

package main

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

func main() {
	s := bufio.NewScanner(strings.NewReader("a\nbb\nccc"))
	total := 0
	for s.Scan() {
		total += len(s.Text())
	}
	fmt.Println("total chars:", total)
}

Blocs de taille fixe

Pour les données binaires, lisez dans un tampon de taille fixe avec Read. n indique combien d'octets ont été remplis.

package main

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

func main() {
	src := strings.NewReader("0123456789")
	buf := make([]byte, 4)
	for {
		n, err := src.Read(buf)
		if n > 0 {
			fmt.Printf("chunk: %s\n", buf[:n])
		}
		if err == io.EOF {
			break
		}
	}
}

io.Copy pour le traitement en flux

io.Copy(dst, src) transfère tout le contenu d'un lecteur vers un écrivain en utilisant un petit tampon interne, sans tout charger en mémoire.

package main

import (
	"io"
	"os"
	"strings"
)

func main() {
	src := strings.NewReader("streamed straight through\n")
	io.Copy(os.Stdout, src)
}

Combiner les tampons du Reader et du Writer

Enveloppez les deux extrémités dans bufio pour réaliser efficacement des transformations en flux : lecture avec tampon, traitement, écriture avec tampon, puis vidage.

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	r := bufio.NewScanner(strings.NewReader("one\ntwo"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for r.Scan() {
		w.WriteString(r.Text() + "!\n")
	}
}

Garantie de mémoire constante

Comme la taille du tampon est fixe, l'utilisation de la mémoire reste stable, que l'entrée fasse 1 Ko ou 1 To. C'est le principal avantage du traitement en flux.

Éviter les erreurs courantes

N'appelez pas os.ReadFile sur des fichiers volumineux
Traitez toujours les n octets avant de vérifier l'erreur
N'oubliez pas d'appeler Flush() pour les écrivains avec tampon

Transformer un flux

Ici, nous convertissons chaque ligne en majuscules au fur et à mesure de son parcours, en ne conservant qu'une seule ligne en mémoire à la fois.

package main

import (
	"bufio"
	"os"
	"strings"
)

func main() {
	s := bufio.NewScanner(strings.NewReader("hi\nthere"))
	w := bufio.NewWriter(os.Stdout)
	defer w.Flush()
	for s.Scan() {
		w.WriteString(strings.ToUpper(s.Text()) + "\n")
	}
}

Quand utiliser le traitement en flux

Utilisez le traitement en flux lorsque la taille de l'entrée est importante ou inconnue, ou lorsque vous pouvez la traiter progressivement. Ne chargez entièrement les données que si elles sont petites, de taille limitée et nécessaires en une seule fois.

Vérification rapide

Vérifiez vos connaissances sur le traitement en flux.

Récapitulatif

Vous avez appris à traiter de grandes quantités de données sans tout charger en mémoire.

Scanner pour le texte ligne par ligne
Read de taille fixe pour les blocs binaires
io.Copy pour les transferts de flux à flux
Mettre les deux extrémités en tampon, vider les écrivains et conserver une mémoire constante

Questions Fréquemment Posées

La leçon « Flux de fichiers volumineux » est-elle gratuite ?

Oui — le texte complet de « Flux de fichiers volumineux » 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 « Flux de fichiers volumineux » ?

Traiter les fichiers sans tout charger 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 4 sur 4.

Combien de temps prend la leçon « Flux de fichiers volumineux » ?

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