Travailler avec le système de fichiers en Go : guide pratique

Travailler avec le système de fichiers en Go : guide pratique

Go (Golang) est un langage compilé moderne, parfait pour créer des applications serveur, des utilitaires et des outils en ligne de commande. L'une des tâches clés dans ces projets est le travail avec le système de fichiers. Dans cet article, nous allons explorer des exemples pratiques : de l'ouverture et la lecture de fichiers au parcours récursif de répertoires. Tous les exemples sont écrits en Go pur, sans bibliothèques tierces.

Les bases : ouvrir, lire et écrire des fichiers

Le package os fournit des fonctions pour le travail bas niveau avec les fichiers. Pour lire tout le contenu d'un fichier en mémoire, utilisez os.ReadFile (disponible depuis Go 1.16).

package main

import (    "fmt"    "os")

func main() {    data, err := os.ReadFile("example.txt")    if err != nil {        fmt.Println("Erreur de lecture du fichier :", err)        return    }    fmt.Println(string(data))}

Pour écrire des données dans un fichier, il existe la fonction os.WriteFile. Elle crée le fichier s'il n'existe pas, ou écrase le fichier existant.

package main

import (    "fmt"    "os")

func main() {    content := []byte("Bonjour, Go !Deuxième ligne")    err := os.WriteFile("output.txt", content, 0644)    if err != nil {        fmt.Println("Erreur d'écriture :", err)        return    }    fmt.Println("Fichier écrit avec succès")}

Le troisième argument 0644 représente les permissions de style Unix (le propriétaire peut lire et écrire, les autres peuvent seulement lire). Sous Windows, ce paramètre est partiellement ignoré.

Lecture et écriture en flux : travailler avec de gros fichiers

Pour travailler avec de gros fichiers (plus de quelques mégaoctets), il ne faut pas les charger entièrement en mémoire. Utilisez la lecture tamponnée avec bufio ou le package io.

package main

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

func main() {    file, err := os.Open("large_file.log")    if err != nil {        fmt.Println("Erreur d'ouverture :", err)        return    }    defer file.Close()

    scanner := bufio.NewScanner(file)    for scanner.Scan() {        line := scanner.Text()        // Traiter la ligne        fmt.Println(line)    }

    if err := scanner.Err(); err != nil {        fmt.Println("Erreur de scan :", err)    }}

Pour l'écriture en flux, utilisez bufio.NewWriter :

package main

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

func main() {    file, err := os.Create("output_stream.txt")    if err != nil {        fmt.Println("Erreur de création :", err)        return    }    defer file.Close()

    writer := bufio.NewWriter(file)    for i := 0; i < 10; i++ {        _, err := writer.WriteString(fmt.Sprintf("Ligne %d", i+1))        if err != nil {            fmt.Println("Erreur d'écriture :", err)            return        }    }    writer.Flush() // Important : vider le tampon    fmt.Println("Écriture terminée")}

La méthode Flush() est obligatoire — sans elle, les données peuvent rester dans le tampon et ne pas être écrites dans le fichier.

Travailler avec les répertoires : création, suppression et parcours

Vous pouvez créer un nouveau répertoire avec os.Mkdir (un dossier) ou os.MkdirAll (récursivement, comme mkdir -p).

package main

import (    "fmt"    "os")

func main() {    // Créer un dossier    err := os.Mkdir("new_folder", 0755)    if err != nil {        fmt.Println("Erreur de création du dossier :", err)    }

    // Créer une structure imbriquée    err = os.MkdirAll("a/b/c/d", 0755)    if err != nil {        fmt.Println("Erreur de création des dossiers imbriqués :", err)    } else {        fmt.Println("Dossiers créés")    }}

La suppression d'un répertoire se fait avec os.Remove (seulement s'il est vide) ou os.RemoveAll (récursivement).

package main

import (    "fmt"    "os")

func main() {    // Supprimer un dossier vide    err := os.Remove("new_folder")    if err != nil {        fmt.Println("Erreur de suppression :", err)    }

    // Supprimer récursivement    err = os.RemoveAll("a")    if err != nil {        fmt.Println("Erreur de suppression récursive :", err)    } else {        fmt.Println("Dossiers supprimés")    }}

Pour parcourir le contenu d'un répertoire, utilisez os.ReadDir (disponible depuis Go 1.16).

package main

import (    "fmt"    "os")

func main() {    entries, err := os.ReadDir(".")    if err != nil {        fmt.Println("Erreur de lecture du répertoire :", err)        return    }

    for _, entry := range entries {        info, _ := entry.Info()        if entry.IsDir() {            fmt.Printf("[RÉP] %s", entry.Name())        } else {            fmt.Printf("[FIC] %s (taille : %d octets)", entry.Name(), info.Size())        }    }}

Pour un parcours récursif de tous les fichiers et sous-dossiers, utilisez filepath.Walk du package path/filepath.

package main

import (    "fmt"    "os"    "path/filepath")

func main() {    err := filepath.Walk(".", func(path string, info os.FileInfo, err error) error {        if err != nil {            return err        }        if info.IsDir() {            fmt.Printf("Dossier : %s", path)        } else {            fmt.Printf("Fichier : %s (taille : %d)", path, info.Size())        }        return nil    })

    if err != nil {        fmt.Println("Erreur de parcours :", err)    }}

Gestion des erreurs et bonnes pratiques

Lors du travail avec le système de fichiers, il est important de gérer correctement les erreurs. Utilisez toujours defer file.Close() pour fermer les fichiers après utilisation. Vérifiez les erreurs après chaque opération sur le système de fichiers.

N'oubliez pas que les chemins de fichiers peuvent différer selon le système d'exploitation. Utilisez filepath.Join pour créer des chemins de manière portable.

package main

import (    "fmt"    "path/filepath")

func main() {    // Créer un chemin portable    path := filepath.Join("dossier", "sous-dossier", "fichier.txt")    fmt.Println("Chemin :", path)}

Conclusion

Nous avons couvert les opérations de base avec le système de fichiers en Go : lecture et écriture de fichiers, travail avec les répertoires et parcours récursif. Le package standard de Go fournit tous les outils nécessaires pour ces tâches sans avoir besoin de bibliothèques tierces. Utilisez les exemples de cet article comme base pour vos projets.

Pour approfondir, consultez la documentation officielle des packages os, io, bufio et path/filepath.