Travail avec le système de fichiers en Go : pour les débutants

Travail avec le système de fichiers en Go : pour les débutants

Go (Golang) est un langage compilé moderne, réputé pour sa simplicité, ses performances et ses outils intégrés. L'une des tâches clés de tout développeur backend est l'interaction avec le système de fichiers : lecture de configurations, écriture de logs, création de fichiers et répertoires temporaires. Dans cet article, nous allons détailler les opérations de base avec les fichiers et dossiers en Go, en commençant par les fondamentaux. Ce contenu est destiné aux débutants, chaque étape sera donc accompagnée d'exemples de code clairs.

Packages principaux pour travailler avec les fichiers

Dans la bibliothèque standard de Go, il existe deux packages principaux pour travailler avec le système de fichiers :

• os — travail de bas niveau avec les fichiers, dossiers, droits d'accès et processus.
• io/ioutil (obsolète depuis Go 1.16, mais encore rencontré) — fonctions pratiques pour lire/écrire des fichiers entiers.
• io — interfaces pour les entrées/sorties en flux.
• bufio — lecture/écriture tamponnée (utile pour les gros fichiers).

Depuis Go 1.16, il est recommandé d'utiliser les fonctions du package os (os.ReadFile, os.WriteFile) au lieu de ioutil. Nous nous appuierons sur l'approche moderne.

Lecture de fichiers

La façon la plus simple de lire un petit fichier en entier est d'utiliser os.ReadFile. Il retourne une tranche d'octets et une erreur.

package main

import (    "fmt"    "os")

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

Si le fichier est volumineux (par exemple, un fichier log de plusieurs centaines de mégaoctets), il est préférable de le lire ligne par ligne ou par blocs avec bufio.Scanner :

package main

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

func main() {    file, err := os.Open("bigfile.log")    if err != nil {        fmt.Println("Erreur d'ouverture du fichier :", err)        return    }    defer file.Close() // fermer le fichier impérativement

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

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

Notez l'utilisation de defer file.Close() — cela garantit que le fichier sera fermé après la fin de la fonction, même en cas d'erreur.

Écriture dans les fichiers

Pour écrire des données dans un fichier, utilisez os.WriteFile (crée/réécrit le fichier) ou os.Create + Write (pour une écriture plus flexible).

package main

import (    "fmt"    "os")

func main() {    // Écriture simple d'une chaîne dans un fichier    text := "Bonjour le monde !Deuxième ligne."    err := os.WriteFile("output.txt", []byte(text), 0644)    if err != nil {        fmt.Println("Erreur d'écriture :", err)        return    }    fmt.Println("Fichier écrit avec succès")}

Le paramètre 0644 correspond aux droits d'accès de style Unix (le propriétaire peut lire/écrire, les autres peuvent seulement lire).

Si vous devez ajouter des données à la fin d'un fichier (append), utilisez os.OpenFile avec le drapeau os.O_APPEND :

package main

import (    "fmt"    "os")

func main() {    file, err := os.OpenFile("log.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)    if err != nil {        fmt.Println("Erreur d'ouverture du fichier :", err)        return    }    defer file.Close()

    _, err = file.WriteString("Nouvelle entrée dans le log")    if err != nil {        fmt.Println("Erreur d'écriture :", err)    }}

Travail avec les répertoires