Leggere e scrivere file in Golang: os, bufio e directory

Leggere e scrivere un file intero

os.WriteFile e os.ReadFile coprono la maggior parte delle esigenze. Aprono, scrivono o leggono e chiudono con una sola chiamata.

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))
}

Gli esempi di questa pagina lavorano in una directory temporanea creata con os.MkdirTemp e la rimuovono con defer os.RemoveAll(dir), così non lasciano niente dietro di sé. Nel tuo codice, un percorso relativo come "config.json" viene risolto rispetto alla directory di lavoro del processo, che non è necessariamente la directory del file sorgente o del binario.

os.WriteFile crea il file se serve e lo tronca se esiste. Il terzo argomento è il permesso Unix per un file appena creato: 0o644 significa che il proprietario può leggere e scrivere e tutti gli altri possono leggere. Viene ignorato per un file che esiste già, e la umask del processo può togliere dei bit.

os.ReadFile legge tutto in memoria. È la scelta giusta per i file di configurazione e gli input piccoli, e quella sbagliata per un log di diversi gigabyte.

Leggere riga per riga con bufio.Scanner

Per i file grandi, o quando ti servono comunque le righe, usa bufio.Scanner. Legge a blocchi e ti passa una riga alla volta, senza il carattere di a capo.

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")
}

Tre dettagli:

• Controlla sc.Err() dopo il ciclo. Scan restituisce false sia alla fine del file sia in caso di errore, e solo Err distingue i due casi.
• Il limite di 64 KB per riga. Per impostazione predefinita una singola riga più lunga di 64 KB ferma lo scanner con bufio.Scanner: token too long. Per file con righe lunghe (JSON minificato, alcuni log), alza il limite prima del ciclo: sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
• Altre unità. sc.Split(bufio.ScanWords) restituisce parole; bufio.ScanRunes restituisce caratteri.

Per leggere uno stream a blocchi di dimensione fissa invece che a righe, usa f.Read(buf) in un ciclo oppure io.Copy verso un altro writer.

Scrivere: os.Create, os.OpenFile e scrittura in coda

os.Create(name) apre un file in scrittura, creandolo o troncandolo. os.OpenFile dà il controllo completo tramite dei flag:

os.Open(name) equivale a OpenFile(name, O_RDONLY, 0). os.Create(name) equivale a 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")
}

Quando scrivi, l'errore di Close conta. Alcuni file system segnalano gli errori di scrittura solo alla chiusura, quindi un semplice defer f.Close() può nascondere dati persi. Per i file che scrivi, controlla Close esplicitamente come fa appendLine. Per i file che leggi soltanto, defer f.Close() va bene.

fmt.Fprintln e le altre funzioni di stampa di fmt accettano qualsiasi io.Writer, file compresi. Un bufio.Writer raggruppa in memoria le piccole scritture. Dimenticare w.Flush() è un bug classico: il programma termina normalmente e gli ultimi kilobyte non arrivano mai nel file.

Il file esiste?

Go non ha un os.Exists. Chiama os.Stat ed esamina l'errore:

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) è l'idioma attuale. Sostituisce il vecchio os.IsNotExist(err), che non vede attraverso gli errori avvolti.

Controllare prima di aprire spesso non serve e crea una race: il file può comparire o sparire tra il controllo e l'apertura. Di solito lo apri e basta, gestendo il fs.ErrNotExist restituito dall'apertura. Per creare un file solo se non esiste ancora, usa O_CREATE|O_EXCL, che fa del controllo e della creazione un unico passaggio atomico.

Directory

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))
}

Usa path/filepath per i percorsi del file system: usa il separatore giusto per il sistema operativo (\ su Windows). Il package path è per i percorsi separati da slash, come gli URL.

Go 1.24 ha aggiunto anche os.Root (os.OpenRoot(dir)), che apre file solo dentro una directory e rifiuta i percorsi che ne escono con .. o con link simbolici. Usalo quando i nomi dei file arrivano dagli utenti.

Errori comuni

• Non controllare gli errori. Ognuna di queste chiamate può fallire. Un file che non si è riusciti ad aprire è nil, e ogni Read, Write o Close successivo su di esso restituisce invalid argument, il che nasconde la vera causa (il file mancava o il permesso è stato negato).
• Dimenticare sc.Err() dopo un ciclo di scansione. Un errore di lettura sembra la fine del file.
• Dimenticare Flush su un bufio.Writer. Manca la fine del file.
• Ignorare l'errore di Close dopo una scrittura. Gli errori di scrittura possono emergere solo lì.
• defer f.Close() dentro un ciclo su molti file. I file restano aperti finché la funzione non ritorna e puoi finire i descrittori di file. Sposta il corpo in una funzione, così ogni file si chiude a ogni iterazione.
• Permessi scritti in decimale. 644 non è 0o644. Go legge 644 come numero decimale, che corrisponde a 0o1204 e imposta bit strani.