Travailler avec CSV en Go (Golang) : guide complet du package encoding/csv

Package encoding/csv en Go : guide complet pour travailler avec les fichiers CSV

Le format CSV (Comma-Separated Values) reste l'un des moyens les plus populaires d'échanger des données tabulaires. En Go (Golang), le package standard encoding/csv est disponible pour travailler avec ce format, offrant une interface pratique et performante pour lire et écrire des fichiers CSV. Dans cet article, nous allons détailler toutes les fonctionnalités du package, des opérations de base aux techniques avancées.

Fonctionnalités principales du package encoding/csv

Le package encoding/csv fait partie de la bibliothèque standard de Go et ne nécessite pas l'installation de dépendances supplémentaires. Il prend en charge :

• La lecture de fichiers CSV avec des séparateurs personnalisables
• L'écriture de données au format CSV
• La gestion des guillemets et l'échappement des caractères spéciaux
• Le travail avec les en-têtes de colonnes
• La lecture paresseuse (traitement en flux des gros fichiers)

Lecture de fichiers CSV en Go

Pour lire un fichier CSV, on utilise la structure csv.Reader. Voici un exemple de base :

package main

import (    "encoding/csv"    "fmt"    "log"    "os")

func main() {    // Ouvrir le fichier CSV    file, err := os.Open("data.csv")    if err != nil {        log.Fatal("Erreur d'ouverture du fichier :", err)    }    defer file.Close()

    // Créer un nouveau lecteur CSV    reader := csv.NewReader(file)

    // Lire tous les enregistrements d'un coup    records, err := reader.ReadAll()    if err != nil {        log.Fatal("Erreur de lecture CSV :", err)    }

    // Afficher les données    for i, record := range records {        fmt.Printf("Ligne %d : %v", i+1, record)    }}

Lecture en flux des gros fichiers

Pour traiter de gros fichiers CSV (centaines de mégaoctets ou plus), il est recommandé d'utiliser une lecture ligne par ligne :

func readLargeCSV(filename string) error {    file, err := os.Open(filename)    if err != nil {        return err    }    defer file.Close()

    reader := csv.NewReader(file)        // Ignorer l'en-tête    header, err := reader.Read()    if err != nil {        return err    }    fmt.Println("En-têtes :", header)

    // Lire ligne par ligne    lineCount := 0    for {        record, err := reader.Read()        if err != nil {            break // Fin du fichier        }        // Traiter l'enregistrement        fmt.Printf("Ligne %d : %s | %s", lineCount+1, record[0], record[1])        lineCount++    }    return nil}

Configuration de l'analyseur CSV

Le package encoding/csv permet de configurer flexiblement les paramètres de lecture :

• Comma — caractère séparateur (par défaut la virgule)
• Comment — caractère de commentaire (les lignes commençant par celui-ci sont ignorées)
• FieldsPerRecord — nombre attendu de champs par enregistrement
• LazyQuotes — autoriser les guillemets non échappés
• TrimLeadingSpace — supprimer les espaces en début de champs

func customCSVParser() {    file, _ := os.Open("custom.csv")    defer file.Close()

    reader := csv.NewReader(file)    reader.Comma = ';'           // Utiliser le point-virgule    reader.Comment = '#'         // Les lignes avec # sont ignorées    reader.TrimLeadingSpace = true    reader.LazyQuotes = true

    records, _ := reader.ReadAll()    for _, record := range records {        fmt.Println(record)    }}

Écriture de données au format CSV

Pour l'écriture, on utilise la structure csv.Writer. Exemple de création d'un fichier CSV :

func writeCSV(filename string) error {    file, err := os.Create(filename)    if err != nil {        return err    }    defer file.Close()

    writer := csv.NewWriter(file)    defer writer.Flush() // Important ! Vider le tampon dans le fichier

    // Écrire l'en-tête