0Pricing
Go Academy · Leçon

JSON et CSV en flux

json.Decoder et encoding/csv pour les gros volumes de données

JSON et CSV en flux 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.

Pourquoi utiliser les flux ?

Charger entièrement de grands fichiers JSON ou CSV en mémoire entraîne une forte utilisation du tas. Le traitement en flux traite les enregistrements un par un et maintient une consommation mémoire constante, quelle que soit la taille du fichier.

json.Decoder pour le traitement en flux

json.NewDecoder encapsule n’importe quel io.Reader. Utilisez Token() pour parcourir le flux de jetons JSON ou utilisez Decode dans une boucle pour les tableaux JSON.

dec := json.NewDecoder(file)
// consume opening [
for dec.More() {
    var record Record
    dec.Decode(&record)
    process(record)
}

Détecter le début d’un tableau

Appelez dec.Token() pour consommer le crochet ouvrant avant la boucle de décodage :

t, _ := dec.Token() // consume [
for dec.More() {
    var r Record
    dec.Decode(&r)
}

Traitement en flux depuis HTTP

Décodez directement le JSON depuis le corps d’une réponse HTTP sans mettre toute la réponse en tampon :

resp, _ := http.Get(url)
defer resp.Body.Close()
dec := json.NewDecoder(resp.Body)
for dec.More() {
    var item Item
    dec.Decode(&item)
    process(item)
}

Lecteur encoding/csv

csv.NewReader lit les lignes CSV une par une. Définissez LazyQuotes, TrimLeadingSpace et Comment pour gérer les variantes CSV réelles.

r := csv.NewReader(file)
for {
    record, err := r.Read()
    if err == io.EOF { break }
    if err != nil { return err }
    process(record)
}

Ignorer l’en-tête CSV

Lisez et ignorez le premier enregistrement pour ignorer la ligne d’en-tête :

r.Read() // discard header
for {
    record, err := r.Read()
    if err == io.EOF { break }
}

csv.Writer

Écrivez les lignes CSV une par une avec csv.NewWriter. Appelez toujours w.Flush() et vérifiez w.Error() après l’écriture.

w := csv.NewWriter(file)
w.Write([]string{"name", "age"})
w.Flush()
if err := w.Error(); err != nil { return err }

Séparateur personnalisé

Les fichiers CSV utilisent parfois des points-virgules ou des tabulations. Définissez r.Comma sur le rune souhaité.

r := csv.NewReader(file)
r.Comma = ';' // semicolon-separated

Flux de lignes JSON (NDJSON)

Le JSON délimité par des retours à la ligne (un objet JSON par ligne) est simple à traiter en flux : lisez chaque ligne et désérialisez-la indépendamment.

scanner := bufio.NewScanner(file)
for scanner.Scan() {
    var record Record
    json.Unmarshal(scanner.Bytes(), &record)
}

Profil mémoire du traitement en continu

Avec le traitement en continu, l’allocation sur le tas reste de l’ordre de la taille d’un enregistrement, et non de celle du fichier. Pour un fichier de 1 Go contenant des enregistrements de 1 Ko, le traitement en continu utilise environ 1 Ko, contre environ 1 Go pour un chargement en mémoire.

Annulation du contexte pendant le traitement en continu

Vérifiez ctx.Done() dans la boucle de décodage afin d’interrompre le traitement en continu lorsque le contexte est annulé et d’empêcher les goroutines de continuer à lire jusqu’à EOF.

for dec.More() {
    select {
    case <-ctx.Done():
        return ctx.Err()
    default:
    }
    dec.Decode(&record)
}

Vérification rapide

Quel est l’avantage du traitement en continu de JSON avec json.Decoder par rapport à json.Unmarshal ?

Récapitulatif&nbsp;: JSON et CSV en continu

Points clés :

  • json.Decoder : boucle avec dec.More() pour les tableaux JSON
  • csv.NewReader : lecture ligne par ligne ; définissez Comma pour les séparateurs personnalisés
  • NDJSON : bufio.Scanner + Unmarshal pour chaque ligne
  • Le traitement en continu maintient une utilisation mémoire stable, quelle que soit la taille du fichier

Questions Fréquemment Posées

La leçon « JSON et CSV en flux » est-elle gratuite ?

Oui — le texte complet de « JSON et CSV en flux » 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 « JSON et CSV en flux » ?

json.Decoder et encoding/csv pour les gros volumes de données 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 « JSON et CSV en flux » ?

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

  1. Lire des fichiers avec os et bufio
  2. Écrire des fichiers et des fichiers temporaires
  3. Encoder et décoder du JSON
  4. JSON et CSV en flux
← Retour à Go Academy