Dokumentacja Go z przykładami: Odczyt i zapis plików

Q: Jak wczytać cały plik do stringa w Go?

data, err := os.ReadFile("notes.txt") zwraca zawartość jako []byte; skonwertuj ją przez string(data). Funkcja sama otwiera, czyta i zamyka plik. Używaj jej dla plików, które swobodnie mieszczą się w pamięci; duże pliki czytaj linia po linii przez bufio.Scanner.

Q: Jak czytać plik linia po linii w Go?

Otwórz plik przez os.Open, dodaj defer f.Close(), opakuj go w bufio.NewScanner(f), iteruj pętlą for sc.Scan() { line := sc.Text() } i po pętli sprawdź sc.Err(). Linie dłuższe niż 64 KB sprawiają, że scanner kończy się błędem token too long, chyba że powiększysz jego bufor przez sc.Buffer.

Q: Jak dopisać dane do pliku w Go?

Otwórz go przez os.OpenFile(name, os.OAPPEND|os.OCREATE|os.OWRONLY, 0o644), zapisz dane i sprawdź błąd z Close. OCREATE tworzy plik, jeśli nie istnieje, a O_APPEND sprawia, że każdy zapis trafia na koniec.

Q: Jak sprawdzić, czy plik istnieje w Go?

Wywołaj os.Stat(path) i sprawdź błąd przez errors.Is(err, fs.ErrNotExist). Błąd nil oznacza, że plik istnieje. Każdy inny błąd (na przykład brak uprawnień) oznacza, że nie da się tego stwierdzić, więc obsłuż go osobno, zamiast traktować jak "nie istnieje".

Odczyt i zapis całego pliku

os.WriteFile i os.ReadFile pokrywają większość potrzeb. W jednym wywołaniu otwierają plik, zapisują lub czytają i go zamykają.

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

Przykłady na tej stronie działają w katalogu tymczasowym z os.MkdirTemp i usuwają go przez defer os.RemoveAll(dir), więc nic po sobie nie zostawiają. We własnym kodzie ścieżka względna, taka jak "config.json", jest rozwiązywana względem katalogu roboczego procesu, który niekoniecznie jest katalogiem pliku źródłowego ani programu wykonywalnego.

os.WriteFile w razie potrzeby tworzy plik, a jeśli istnieje, obcina go. Trzeci argument to uprawnienia Unix dla nowo tworzonego pliku: 0o644 oznacza, że właściciel może czytać i zapisywać, a wszyscy inni mogą czytać. Dla pliku, który już istnieje, argument jest ignorowany, a umask procesu może usunąć część bitów.

os.ReadFile wczytuje wszystko do pamięci. To dobre rozwiązanie dla plików konfiguracyjnych i małych danych wejściowych, a złe dla wielogigabajtowego logu.

Czytanie linia po linii przez bufio.Scanner

Dla dużych plików, albo gdy i tak chcesz dostać linie, użyj bufio.Scanner. Czyta porcjami i podaje po jednej linii naraz, bez znaku nowej linii.

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

Trzy szczegóły:

Po pętli sprawdź sc.Err(). Scan zwraca false zarówno na końcu pliku, jak i przy błędzie, i tylko Err pozwala je odróżnić.
Limit 64 KB na linię. Domyślnie pojedyncza linia dłuższa niż 64 KB zatrzymuje scanner z błędem bufio.Scanner: token too long. Dla plików z długimi liniami (zminifikowany JSON, niektóre logi) podnieś limit przed pętlą: sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
Inne jednostki. sc.Split(bufio.ScanWords) zwraca słowa; bufio.ScanRunes zwraca znaki.

Do czytania strumienia porcjami o stałym rozmiarze zamiast liniami użyj f.Read(buf) w pętli albo io.Copy do innego writera.

Zapis: os.Create, os.OpenFile i dopisywanie

os.Create(name) otwiera plik do zapisu, tworząc go lub obcinając. os.OpenFile daje pełną kontrolę przez flagi:

Flaga	Znaczenie
`os.O_RDONLY`, `os.O_WRONLY`, `os.O_RDWR`	otwarcie do odczytu, zapisu lub obu (wybierz jedno)
`os.O_CREATE`	utwórz plik, jeśli nie istnieje
`os.O_TRUNC`	wyczyść plik przy otwarciu
`os.O_APPEND`	każdy zapis trafia na koniec
`os.O_EXCL`	z `O_CREATE`: błąd, jeśli plik już istnieje

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

Przy zapisie błąd z Close ma znaczenie. Niektóre systemy plików zgłaszają błędy zapisu dopiero przy zamykaniu, więc samo defer f.Close() może ukryć utracone dane. Dla plików, do których zapisujesz, sprawdzaj Close jawnie, tak jak robi to appendLine. Dla plików, które tylko czytasz, defer f.Close() wystarczy.

fmt.Fprintln i pozostałe funkcje wypisujące z fmt przyjmują dowolny io.Writer, w tym plik. bufio.Writer zbiera małe zapisy w pamięci. Zapomniane w.Flush() to klasyczny błąd: program kończy się normalnie, a ostatnie kilka kilobajtów nigdy nie trafia do pliku.

Czy plik istnieje?

Go nie ma os.Exists. Wywołaj os.Stat i sprawdź błąd:

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) to obecny idiom. Zastępuje starsze os.IsNotExist(err), które nie widzi opakowanych błędów.

Sprawdzanie przed otwarciem często jest zbędne i podatne na wyścigi: plik może pojawić się lub zniknąć między sprawdzeniem a otwarciem. Zwykle po prostu otwierasz plik i obsługujesz fs.ErrNotExist z otwarcia. Żeby utworzyć plik tylko wtedy, gdy jeszcze nie istnieje, użyj O_CREATE|O_EXCL, co łączy sprawdzenie i utworzenie w jeden atomowy krok.

Katalogi

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

Zadanie	Funkcja
utworzenie jednego katalogu	`os.Mkdir(path, 0o755)`
utworzenie ścieżki z katalogami nadrzędnymi	`os.MkdirAll(path, 0o755)`
wylistowanie katalogu	`os.ReadDir(path)`
przejście po drzewie	`filepath.WalkDir(root, fn)`
usunięcie pliku lub pustego katalogu	`os.Remove(path)`
usunięcie drzewa	`os.RemoveAll(path)`
zmiana nazwy lub przeniesienie	`os.Rename(old, new)`
plik lub katalog tymczasowy	`os.CreateTemp("", "prefix-*")`, `os.MkdirTemp("", "prefix")`
łączenie części ścieżki	`filepath.Join(a, b, c)`

Do ścieżek w systemie plików używaj path/filepath: stosuje właściwy separator dla systemu operacyjnego (\ w Windows). Pakiet path jest do ścieżek rozdzielanych ukośnikiem, takich jak URL-e.

Go 1.24 dodało też os.Root (os.OpenRoot(dir)), które otwiera pliki tylko w obrębie jednego katalogu i odrzuca ścieżki, które z niego uciekają przez .. lub dowiązania symboliczne. Używaj go, gdy nazwy plików pochodzą od użytkowników.

Typowe błędy

Brak sprawdzania błędów. Każde z tych wywołań może się nie powieść. Plik, którego nie udało się otworzyć, to nil, a każde późniejsze Read, Write czy Close na nim zwraca invalid argument, co ukrywa prawdziwą przyczynę (pliku nie było albo zabrakło uprawnień).
Zapomniane sc.Err() po pętli skanującej. Błąd odczytu wygląda jak koniec pliku.
Zapomniane Flush na bufio.Writer. Brakuje końca pliku.
Ignorowanie błędu z Close po zapisie. Błędy zapisu mogą ujawnić się tylko tam.
defer f.Close() w pętli po wielu plikach. Pliki pozostają otwarte, dopóki funkcja nie zwróci wyniku, i mogą skończyć się deskryptory plików. Przenieś ciało pętli do funkcji, żeby każdy plik zamykał się w swojej iteracji.
Uprawnienia zapisane dziesiętnie. 644 to nie 0o644. Go czyta 644 jako liczbę dziesiętną, czyli 0o1204, co ustawia dziwne bity.

Najczęściej zadawane pytania

Jak wczytać cały plik do stringa w Go?

data, err := os.ReadFile("notes.txt") zwraca zawartość jako []byte; skonwertuj ją przez string(data). Funkcja sama otwiera, czyta i zamyka plik. Używaj jej dla plików, które swobodnie mieszczą się w pamięci; duże pliki czytaj linia po linii przez bufio.Scanner.

Jak czytać plik linia po linii w Go?

Otwórz plik przez os.Open, dodaj defer f.Close(), opakuj go w bufio.NewScanner(f), iteruj pętlą for sc.Scan() { line := sc.Text() } i po pętli sprawdź sc.Err(). Linie dłuższe niż 64 KB sprawiają, że scanner kończy się błędem token too long, chyba że powiększysz jego bufor przez sc.Buffer.

Jak dopisać dane do pliku w Go?

Otwórz go przez os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644), zapisz dane i sprawdź błąd z Close. O_CREATE tworzy plik, jeśli nie istnieje, a O_APPEND sprawia, że każdy zapis trafia na koniec.

Jak sprawdzić, czy plik istnieje w Go?

Wywołaj os.Stat(path) i sprawdź błąd przez errors.Is(err, fs.ErrNotExist). Błąd nil oznacza, że plik istnieje. Każdy inny błąd (na przykład brak uprawnień) oznacza, że nie da się tego stwierdzić, więc obsłuż go osobno, zamiast traktować jak "nie istnieje".

Powiązane zagadnienia