Docs Go exécutables : Lire et écrire des fichiers

Q: Comment lire tout un fichier dans une chaîne en Go ?

data, err := os.ReadFile("notes.txt") renvoie le contenu sous forme de []byte ; convertissez avec string(data). La fonction ouvre, lit et ferme le fichier pour vous. Utilisez-la pour des fichiers qui tiennent confortablement en mémoire ; pour les gros fichiers, lisez ligne par ligne avec bufio.Scanner.

Q: Comment lire un fichier ligne par ligne en Go ?

Ouvrez le fichier avec os.Open, faites defer f.Close(), enveloppez-le dans bufio.NewScanner(f), bouclez avec for sc.Scan() { line := sc.Text() }, et vérifiez sc.Err() après la boucle. Les lignes de plus de 64 Ko font échouer le scanner avec token too long, sauf si vous agrandissez son buffer avec sc.Buffer.

Q: Comment ajouter du contenu à la fin d'un fichier en Go ?

Ouvrez-le avec os.OpenFile(name, os.OAPPEND|os.OCREATE|os.OWRONLY, 0o644), écrivez, et vérifiez l'erreur de Close. OCREATE crée le fichier s'il n'existe pas, et O_APPEND envoie chaque écriture à la fin.

Q: Comment vérifier si un fichier existe en Go ?

Appelez os.Stat(path) et testez l'erreur avec errors.Is(err, fs.ErrNotExist). Une erreur nil signifie qu'il existe. Toute autre erreur (permission refusée, par exemple) signifie que vous ne pouvez pas savoir, donc traitez-la à part au lieu de la considérer comme « n'existe pas ».

Lire et écrire un fichier entier

os.WriteFile et os.ReadFile couvrent la plupart des besoins. Elles ouvrent, écrivent ou lisent, et ferment en un seul appel.

package main

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

func main() {
	dir, err := os.MkdirTemp("", "demo")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir) // clean up everything at the end

	path := filepath.Join(dir, "greeting.txt")

	if err := os.WriteFile(path, []byte("hello, file\nsecond line\n"), 0o644); err != nil {
		fmt.Println("write:", err)
		return
	}

	data, err := os.ReadFile(path)
	if err != nil {
		fmt.Println("read:", err)
		return
	}
	fmt.Print(string(data))
	fmt.Println("bytes:", len(data))
}

Les exemples de cette page travaillent dans un répertoire temporaire créé par os.MkdirTemp et le suppriment avec defer os.RemoveAll(dir), donc ils ne laissent rien derrière eux. Dans votre propre code, un chemin relatif comme "config.json" est résolu par rapport au répertoire de travail du processus, qui n'est pas forcément celui du fichier source ou du binaire.

os.WriteFile crée le fichier si nécessaire et le tronque s'il existe. Le troisième argument est la permission Unix d'un fichier nouvellement créé : 0o644 signifie que le propriétaire peut lire et écrire, tous les autres lire. Il est ignoré pour un fichier qui existe déjà, et l'umask du processus peut retirer des bits.

os.ReadFile lit tout en mémoire. C'est le bon choix pour des fichiers de configuration et de petites entrées, et le mauvais pour un log de plusieurs gigaoctets.

Lire ligne par ligne avec bufio.Scanner

Pour les gros fichiers, ou quand vous voulez de toute façon des lignes, utilisez bufio.Scanner. Il lit par blocs et vous donne une ligne à la fois, sans le retour à la ligne.

package main

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

func main() {
	f, err := os.CreateTemp("", "log-*.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.Remove(f.Name())
	fmt.Fprintln(f, "INFO started")
	fmt.Fprintln(f, "ERROR disk full")
	fmt.Fprintln(f, "INFO retrying")
	fmt.Fprintln(f, "ERROR disk still full")
	f.Close()

	in, err := os.Open(f.Name())
	if err != nil {
		fmt.Println(err)
		return
	}
	defer in.Close()

	sc := bufio.NewScanner(in)
	lineNo, errorsSeen := 0, 0
	for sc.Scan() {
		lineNo++
		line := sc.Text()
		if strings.HasPrefix(line, "ERROR") {
			errorsSeen++
			fmt.Printf("line %d: %s\n", lineNo, line)
		}
	}
	if err := sc.Err(); err != nil { // Scan returns false on errors too
		fmt.Println("scan:", err)
		return
	}
	fmt.Println("errors:", errorsSeen, "of", lineNo, "lines")
}

Trois détails :

Vérifiez sc.Err() après la boucle. Scan renvoie false aussi bien en fin de fichier qu'en cas d'erreur, et seul Err fait la différence.
La limite de 64 Ko par ligne. Par défaut, une ligne de plus de 64 Ko arrête le scanner avec bufio.Scanner: token too long. Pour les fichiers à longues lignes (JSON minifié, certains logs), relevez la limite avant la boucle : sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
Autres unités. sc.Split(bufio.ScanWords) produit des mots ; bufio.ScanRunes produit des caractères.

Pour lire un flux par blocs de taille fixe plutôt que par lignes, utilisez f.Read(buf) dans une boucle ou io.Copy vers un autre writer.

Écrire : os.Create, os.OpenFile et l'ajout en fin de fichier

os.Create(name) ouvre un fichier en écriture, en le créant ou en le tronquant. os.OpenFile donne un contrôle total grâce à des flags :

Flag	Signification
`os.O_RDONLY`, `os.O_WRONLY`, `os.O_RDWR`	ouvrir en lecture, en écriture, ou les deux (choisissez-en un)
`os.O_CREATE`	créer le fichier s'il n'existe pas
`os.O_TRUNC`	vider le fichier à l'ouverture
`os.O_APPEND`	chaque écriture va à la fin
`os.O_EXCL`	avec `O_CREATE` : échouer si le fichier existe déjà

os.Open(name) équivaut à OpenFile(name, O_RDONLY, 0). os.Create(name) équivaut à OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0o666).

package main

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

func appendLine(path, line string) error {
	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
	if err != nil {
		return err
	}
	if _, err := fmt.Fprintln(f, line); err != nil {
		f.Close()
		return err
	}
	return f.Close() // Close can report a failed write: return its error
}

func main() {
	dir, err := os.MkdirTemp("", "append")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir)
	path := filepath.Join(dir, "audit.log")

	for _, msg := range []string{"login alice", "upload report.pdf", "logout alice"} {
		if err := appendLine(path, msg); err != nil {
			fmt.Println("append:", err)
			return
		}
	}

	// Buffered writing: many small writes, one syscall per buffer.
	out, err := os.Create(filepath.Join(dir, "numbers.txt"))
	if err != nil {
		fmt.Println(err)
		return
	}
	w := bufio.NewWriter(out)
	for i := 1; i <= 1000; i++ {
		fmt.Fprintln(w, i)
	}
	if err := w.Flush(); err != nil { // without Flush the tail of the data is lost
		fmt.Println("flush:", err)
	}
	if err := out.Close(); err != nil {
		fmt.Println("close:", err)
	}

	data, _ := os.ReadFile(path)
	fmt.Print(string(data))
	info, _ := os.Stat(filepath.Join(dir, "numbers.txt"))
	fmt.Println("numbers.txt size:", info.Size(), "bytes")
}

En écriture, l'erreur de Close compte. Certains systèmes de fichiers ne signalent les échecs d'écriture qu'à la fermeture, donc defer f.Close() seul peut masquer une perte de données. Pour les fichiers que vous écrivez, vérifiez Close explicitement comme le fait appendLine. Pour les fichiers que vous lisez seulement, defer f.Close() suffit.

fmt.Fprintln et les autres fonctions d'affichage de fmt acceptent n'importe quel io.Writer, y compris un fichier. Un bufio.Writer regroupe les petites écritures en mémoire. Oublier w.Flush() est un bug classique : le programme se termine normalement et les derniers kilo-octets n'atteignent jamais le fichier.

Le fichier existe-t-il ?

Go n'a pas de os.Exists. Appelez os.Stat et examinez l'erreur :

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
)

func exists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	}
	if errors.Is(err, fs.ErrNotExist) {
		return false, nil
	}
	return false, err // permission denied, broken mount, ...: unknown
}

func main() {
	dir, err := os.MkdirTemp("", "exists")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir)

	fmt.Println(exists(dir))
	fmt.Println(exists(filepath.Join(dir, "nope.txt")))

	_, err = os.ReadFile(filepath.Join(dir, "nope.txt"))
	fmt.Println("not exist:", errors.Is(err, fs.ErrNotExist))
	fmt.Println(err)
}

errors.Is(err, fs.ErrNotExist) est l'idiome actuel. Il remplace l'ancien os.IsNotExist(err), qui ne voit pas à travers les erreurs enveloppées.

Vérifier avant d'ouvrir est souvent inutile et sujet aux races : le fichier peut apparaître ou disparaître entre la vérification et l'ouverture. En général, vous l'ouvrez simplement et gérez le fs.ErrNotExist renvoyé par l'ouverture. Pour créer un fichier seulement s'il n'existe pas encore, utilisez O_CREATE|O_EXCL, qui fait de la vérification et de la création une seule étape atomique.

Répertoires

package main

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

func main() {
	root, err := os.MkdirTemp("", "tree")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(root)

	// MkdirAll creates every missing parent, like mkdir -p.
	if err := os.MkdirAll(filepath.Join(root, "src", "util"), 0o755); err != nil {
		fmt.Println(err)
		return
	}
	for _, name := range []string{"main.go", "src/app.go", "src/util/strings.go", "README.md"} {
		if err := os.WriteFile(filepath.Join(root, name), []byte("x"), 0o644); err != nil {
			fmt.Println(err)
			return
		}
	}

	// One level: ReadDir returns entries sorted by name.
	entries, err := os.ReadDir(root)
	if err != nil {
		fmt.Println(err)
		return
	}
	for _, e := range entries {
		fmt.Printf("%-10s dir=%v\n", e.Name(), e.IsDir())
	}

	// Recursive: WalkDir visits every file and directory in lexical order.
	fmt.Println("Go files:")
	err = filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !d.IsDir() && filepath.Ext(path) == ".go" {
			rel, _ := filepath.Rel(root, path)
			fmt.Println(" ", filepath.ToSlash(rel))
		}
		return nil
	})
	if err != nil {
		fmt.Println(err)
	}

	// Glob matches one directory level against a pattern.
	matches, _ := filepath.Glob(filepath.Join(root, "*.md"))
	fmt.Println("markdown files:", len(matches))
}

Tâche	Fonction
créer un répertoire	`os.Mkdir(path, 0o755)`
créer un chemin avec ses parents	`os.MkdirAll(path, 0o755)`
lister un répertoire	`os.ReadDir(path)`
parcourir une arborescence	`filepath.WalkDir(root, fn)`
supprimer un fichier ou un répertoire vide	`os.Remove(path)`
supprimer une arborescence	`os.RemoveAll(path)`
renommer ou déplacer	`os.Rename(old, new)`
fichier ou répertoire temporaire	`os.CreateTemp("", "prefix-*")`, `os.MkdirTemp("", "prefix")`
assembler des morceaux de chemin	`filepath.Join(a, b, c)`

Utilisez path/filepath pour les chemins du système de fichiers : il emploie le bon séparateur pour le système d'exploitation (\ sous Windows). Le package path sert aux chemins séparés par des barres obliques, comme les URL.

Go 1.24 a aussi ajouté os.Root (os.OpenRoot(dir)), qui n'ouvre des fichiers qu'à l'intérieur d'un répertoire et refuse les chemins qui en sortent via .. ou des liens symboliques. Utilisez-le quand les noms de fichiers viennent des utilisateurs.

Erreurs courantes

Ne pas vérifier les erreurs. Chacun de ces appels peut échouer. Un fichier dont l'ouverture a échoué vaut nil, et chaque Read, Write ou Close ultérieur renvoie invalid argument, ce qui masque la vraie cause (le fichier manquait, ou la permission a été refusée).
Oublier sc.Err() après une boucle de lecture. Une erreur de lecture ressemble à une fin de fichier.
Oublier Flush sur un bufio.Writer. La fin du fichier manque.
Ignorer l'erreur de Close après une écriture. Les erreurs d'écriture peuvent n'apparaître qu'à ce moment-là.
defer f.Close() dans une boucle sur de nombreux fichiers. Les fichiers restent ouverts jusqu'au retour de la fonction et vous pouvez manquer de descripteurs de fichiers. Déplacez le corps dans une fonction pour que chaque fichier soit fermé à chaque itération.
Des permissions écrites en décimal. 644 n'est pas 0o644. Go lit 644 comme le nombre décimal, soit 0o1204, ce qui positionne des bits étranges.

Questions fréquentes

Comment lire tout un fichier dans une chaîne en Go ?

data, err := os.ReadFile("notes.txt") renvoie le contenu sous forme de []byte ; convertissez avec string(data). La fonction ouvre, lit et ferme le fichier pour vous. Utilisez-la pour des fichiers qui tiennent confortablement en mémoire ; pour les gros fichiers, lisez ligne par ligne avec bufio.Scanner.

Comment lire un fichier ligne par ligne en Go ?

Ouvrez le fichier avec os.Open, faites defer f.Close(), enveloppez-le dans bufio.NewScanner(f), bouclez avec for sc.Scan() { line := sc.Text() }, et vérifiez sc.Err() après la boucle. Les lignes de plus de 64 Ko font échouer le scanner avec token too long, sauf si vous agrandissez son buffer avec sc.Buffer.

Comment ajouter du contenu à la fin d'un fichier en Go ?

Ouvrez-le avec os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644), écrivez, et vérifiez l'erreur de Close. O_CREATE crée le fichier s'il n'existe pas, et O_APPEND envoie chaque écriture à la fin.

Comment vérifier si un fichier existe en Go ?

Appelez os.Stat(path) et testez l'erreur avec errors.Is(err, fs.ErrNotExist). Une erreur nil signifie qu'il existe. Toute autre erreur (permission refusée, par exemple) signifie que vous ne pouvez pas savoir, donc traitez-la à part au lieu de la considérer comme « n'existe pas ».

Concepts liés