Ausführbare Go-Docs: Dateien lesen und schreiben

Q: Wie lese ich in Go eine ganze Datei in einen String?

data, err := os.ReadFile("notes.txt") gibt den Inhalt als []byte zurück; konvertiere mit string(data). Es öffnet, liest und schließt die Datei für dich. Nimm es für Dateien, die bequem in den Speicher passen; große Dateien liest du mit bufio.Scanner Zeile für Zeile.

Q: Wie lese ich in Go eine Datei Zeile für Zeile?

Öffne die Datei mit os.Open, defer f.Close(), verpack sie in bufio.NewScanner(f), lauf mit for sc.Scan() { line := sc.Text() } darüber und prüf nach der Schleife sc.Err(). Zeilen über 64 KB lassen den Scanner mit token too long scheitern, außer du vergrößerst seinen Puffer mit sc.Buffer.

Q: Wie hänge ich in Go etwas an eine Datei an?

Öffne sie mit os.OpenFile(name, os.OAPPEND|os.OCREATE|os.OWRONLY, 0o644), schreib und prüf den Fehler von Close. OCREATE legt die Datei an, falls sie nicht existiert, und O_APPEND sorgt dafür, dass jeder Schreibzugriff am Ende landet.

Q: Wie prüfe ich in Go, ob eine Datei existiert?

Ruf os.Stat(path) auf und prüf den Fehler mit errors.Is(err, fs.ErrNotExist). Ein nil-Fehler bedeutet, dass sie existiert. Jeder andere Fehler (etwa fehlende Berechtigung) bedeutet, dass du es nicht sagen kannst, also behandle ihn separat, statt ihn als „existiert nicht“ zu werten.

Eine ganze Datei lesen und schreiben

os.WriteFile und os.ReadFile decken die meisten Fälle ab. Sie öffnen, schreiben oder lesen und schließen in einem Aufruf.

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

Die Beispiele auf dieser Seite arbeiten in einem temporären Verzeichnis aus os.MkdirTemp und entfernen es mit defer os.RemoveAll(dir), hinterlassen also nichts. In deinem eigenen Code wird ein relativer Pfad wie "config.json" gegen das Arbeitsverzeichnis des Prozesses aufgelöst, und das ist nicht unbedingt das Verzeichnis der Quelldatei oder des Binarys.

os.WriteFile legt die Datei bei Bedarf an und kürzt sie, wenn sie existiert. Das dritte Argument ist die Unix-Berechtigung für eine neu angelegte Datei: 0o644 bedeutet, dass der Besitzer lesen und schreiben und alle anderen lesen dürfen. Bei einer bereits existierenden Datei wird es ignoriert, und die umask des Prozesses kann Bits entfernen.

os.ReadFile liest alles in den Speicher. Für Konfigurationsdateien und kleine Eingaben ist das richtig, für ein Log mit mehreren Gigabyte falsch.

Zeilenweise lesen mit bufio.Scanner

Für große Dateien, oder wenn du ohnehin Zeilen willst, nimm bufio.Scanner. Er liest in Blöcken und gibt dir jeweils eine Zeile ohne Zeilenumbruch.

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

Drei Details:

Prüf nach der Schleife sc.Err(). Scan gibt sowohl am Dateiende als auch bei einem Fehler false zurück, und nur Err unterscheidet die beiden.
Das Zeilenlimit von 64 KB. Standardmäßig stoppt eine einzelne Zeile über 64 KB den Scanner mit bufio.Scanner: token too long. Bei Dateien mit langen Zeilen (minifiziertes JSON, manche Logs) hebst du das Limit vor der Schleife an: sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
Andere Einheiten. sc.Split(bufio.ScanWords) liefert Wörter; bufio.ScanRunes liefert Zeichen.

Um einen Stream in Blöcken fester Größe statt in Zeilen zu lesen, nimm f.Read(buf) in einer Schleife oder io.Copy in einen anderen Writer.

Schreiben: os.Create, os.OpenFile und Anhängen

os.Create(name) öffnet eine Datei zum Schreiben und legt sie an oder kürzt sie. os.OpenFile gibt dir über Flags volle Kontrolle:

Flag	Bedeutung
`os.O_RDONLY`, `os.O_WRONLY`, `os.O_RDWR`	zum Lesen, Schreiben oder beidem öffnen (eins davon wählen)
`os.O_CREATE`	die Datei anlegen, wenn sie nicht existiert
`os.O_TRUNC`	die Datei beim Öffnen leeren
`os.O_APPEND`	jeder Schreibzugriff landet am Ende
`os.O_EXCL`	mit `O_CREATE`: fehlschlagen, wenn die Datei schon existiert

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

Beim Schreiben zählt der Fehler von Close. Manche Dateisysteme melden Schreibfehler erst beim Schließen, also kann ein alleiniges defer f.Close() verlorene Daten verbergen. Bei Dateien, die du schreibst, prüfst du Close explizit, so wie appendLine es tut. Bei Dateien, die du nur liest, ist defer f.Close() in Ordnung.

fmt.Fprintln und die übrigen Ausgabefunktionen von fmt akzeptieren jeden io.Writer, auch eine Datei. Ein bufio.Writer sammelt kleine Schreibzugriffe im Speicher. w.Flush() zu vergessen ist ein klassischer Bug: Das Programm endet normal, und die letzten paar Kilobyte erreichen die Datei nie.

Existiert die Datei?

Go hat kein os.Exists. Ruf os.Stat auf und untersuche den Fehler:

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) ist das aktuelle Idiom. Es ersetzt das ältere os.IsNotExist(err), das gewrappte Fehler nicht durchschaut.

Vor dem Öffnen zu prüfen ist oft unnötig und anfällig für Race Conditions: Die Datei kann zwischen Prüfung und Öffnen auftauchen oder verschwinden. Meist öffnest du sie einfach und behandelst fs.ErrNotExist beim Öffnen. Um eine Datei nur anzulegen, wenn sie noch nicht existiert, nimm O_CREATE|O_EXCL, das Prüfung und Anlegen zu einem atomaren Schritt macht.

Verzeichnisse

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

Aufgabe	Funktion
ein Verzeichnis anlegen	`os.Mkdir(path, 0o755)`
einen Pfad samt Elternverzeichnissen anlegen	`os.MkdirAll(path, 0o755)`
ein Verzeichnis auflisten	`os.ReadDir(path)`
einen Baum durchlaufen	`filepath.WalkDir(root, fn)`
eine Datei oder ein leeres Verzeichnis löschen	`os.Remove(path)`
einen Baum löschen	`os.RemoveAll(path)`
umbenennen oder verschieben	`os.Rename(old, new)`
temporäre Datei oder temporäres Verzeichnis	`os.CreateTemp("", "prefix-*")`, `os.MkdirTemp("", "prefix")`
Pfadteile verbinden	`filepath.Join(a, b, c)`

Nimm path/filepath für Pfade im Dateisystem: Es verwendet das richtige Trennzeichen für das Betriebssystem (\ unter Windows). Das Paket path ist für Pfade mit Schrägstrichen gedacht, etwa URLs.

Go 1.24 hat außerdem os.Root (os.OpenRoot(dir)) eingeführt, das Dateien nur innerhalb eines Verzeichnisses öffnet und Pfade ablehnt, die per .. oder Symlinks daraus ausbrechen. Nutz es, wenn Dateinamen von Nutzern kommen.

Häufige Fehler

Fehler nicht prüfen. Jeder dieser Aufrufe kann fehlschlagen. Eine Datei, die sich nicht öffnen ließ, ist nil, und jedes spätere Read, Write oder Close darauf gibt invalid argument zurück. Das verbirgt die eigentliche Ursache (die Datei fehlte oder die Berechtigung wurde verweigert).
sc.Err() nach einer Scan-Schleife vergessen. Ein Lesefehler sieht dann aus wie das Dateiende.
Flush bei einem bufio.Writer vergessen. Das Ende der Datei fehlt.
Den Fehler von Close nach dem Schreiben ignorieren. Schreibfehler können erst dort auftauchen.
defer f.Close() in einer Schleife über viele Dateien. Die Dateien bleiben offen, bis die Funktion zurückkehrt, und dir können die File Descriptors ausgehen. Verschieb den Rumpf in eine Funktion, damit jede Datei pro Durchlauf geschlossen wird.
Berechtigungen dezimal geschrieben. 644 ist nicht 0o644. Go liest 644 als Dezimalzahl, also 0o1204, und setzt seltsame Bits.

Häufig gestellte Fragen

Wie lese ich in Go eine ganze Datei in einen String?

data, err := os.ReadFile("notes.txt") gibt den Inhalt als []byte zurück; konvertiere mit string(data). Es öffnet, liest und schließt die Datei für dich. Nimm es für Dateien, die bequem in den Speicher passen; große Dateien liest du mit bufio.Scanner Zeile für Zeile.

Wie lese ich in Go eine Datei Zeile für Zeile?

Öffne die Datei mit os.Open, defer f.Close(), verpack sie in bufio.NewScanner(f), lauf mit for sc.Scan() { line := sc.Text() } darüber und prüf nach der Schleife sc.Err(). Zeilen über 64 KB lassen den Scanner mit token too long scheitern, außer du vergrößerst seinen Puffer mit sc.Buffer.

Wie hänge ich in Go etwas an eine Datei an?

Öffne sie mit os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644), schreib und prüf den Fehler von Close. O_CREATE legt die Datei an, falls sie nicht existiert, und O_APPEND sorgt dafür, dass jeder Schreibzugriff am Ende landet.

Wie prüfe ich in Go, ob eine Datei existiert?

Ruf os.Stat(path) auf und prüf den Fehler mit errors.Is(err, fs.ErrNotExist). Ein nil-Fehler bedeutet, dass sie existiert. Jeder andere Fehler (etwa fehlende Berechtigung) bedeutet, dass du es nicht sagen kannst, also behandle ihn separat, statt ihn als „existiert nicht“ zu werten.

Verwandte Konzepte