Dateiverarbeitung in Go

Die Dateiverarbeitung ist eine der häufigsten Operationen in Go – das Lesen von Konfigurationen, das Schreiben von Logs und die Datenpersistenz hängen alle davon ab. Die Standardbibliothek von Go bietet eine prägnante und dennoch leistungsstarke Sammlung von Datei-I/O-Schnittstellen, die Szenarien von einmaligem Lesen/Schreiben bis hin zur Streaming-Verarbeitung abdecken.

Es gibt 5 Kernpakete im Zusammenhang mit der Dateiverarbeitung, jedes mit seiner eigenen Rolle:

Go File Handling Core Packages os Core: create, read/write, delete, permissions io Generic Reader/Writer Interface bufio Buffered read/write, performance optimization filepath Cross-platform path handling ioutil ⚠ Deprecated in Go 1.16 → os / io Typical usage flow os.Open() bufio.Scanner Process data defer Close()

Versionshinweis:ioutilDas Paket wurde in Go 1.16 als veraltet markiert, und seine Funktionalität wurde verschoben nachos(wie z. B.os.ReadFile、os.WriteFile) undio(wie z. B.io.ReadAll). Neuer Code sollte direktosundiodas Paket verwenden.


1. Dateierstellung

os.CreateErstellen Sie eine neue Datei. Wenn die Datei bereits existiert,wird sie abgeschnitten (Inhalt gelöscht). Das zurückgegebene Dateiobjekt muss geschlossen werden, um Systemressourcen freizugeben:

Beispiel

package main

import (
        "log"
        "os"
)

func main() {
        // os.Create erstellt eine Datei (kürzt sie, falls sie bereits existiert)
        file, err := os.Create("test.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close() // defer stellt sicher, dass die Datei geschlossen wird, wenn die Funktion endet

        // Inhalt schreiben, um zu überprüfen, ob die Erstellung erfolgreich war
        file.WriteString("File created successfully\n")
        log.Println("File created successfully")
}

defer file.Close()ist eine bewährte Methode für Go-Dateioperationen.deferstellt sicher, dass die Datei auch dann korrekt geschlossen wird, wenn nachfolgender Code eine Panik auslöst, wodurch Dateideskriptor-Lecks vermieden werden.


2. Öffnen und Schließen von Dateien

osDas Paket bietet drei Möglichkeiten, Dateien zu öffnen, geeignet für verschiedene Szenarien:

Funktion Mode Beschreibung
os.Open(name) Nur Lesen Der einfachste Weg ist, schreibgeschützt zu öffnen
os.Create(name) Lesen/Schreiben + Erstellen/Kürzen Eine neue Datei erstellen oder eine vorhandene Datei leeren
os.OpenFile(name, flag, perm) Individuell Sie können Flags wie Lesen/Schreiben, Anhängen, Erstellen usw. angeben.

Beispiel

package main

import (
        "fmt"
        "os"
)

func main() {
        // Methode 1: schreibgeschützt öffnen
        file, err := os.Open("example.txt")
        if err != nil {
                fmt.Println("Öffnen fehlgeschlagen:, err)
                return
        }
        defer file.Close()
        fmt.Println("Datei erfolgreich geöffnet")

        // Methode 2: OpenFile benutzerdefinierter Modus
        // os.O_WRONLY nur Schreibzugriff
        // os.O_CREATE erstellen, wenn nicht vorhanden
        // os.O_APPEND Anhängemodus
        // os.O_TRUNC kürzen, wenn vorhanden
        f, err := os.OpenFile("log.txt",
                os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
        if err != nil {
                fmt.Println("Öffnen fehlgeschlagen:, err)
                return
        }
        defer f.Close()
        f.WriteString("Eine Zeile an das Log anhängen\n")
}

OpenFile-Flag-Beschreibungen

Flags Beschreibung
os.O_RDONLY Nur Lesen (Standard)
os.O_WRONLY Nur Schreiben
os.O_RDWR Lesen/Schreiben
os.O_APPEND Anhängemodus, schreibt Inhalte an das Ende der Datei angehängt
os.O_CREATE Erstellen, wenn die Datei nicht existiert
os.O_TRUNC Dateiinhalt beim Öffnen leeren
os.O_EXCL Wird mit CREATE verwendet, erzeugt einen Fehler, wenn die Datei bereits existiert

3. Dateien lesen

Go bietet drei Hauptmöglichkeiten zum Lesen von Dateien; wählen Sie je nach Dateigröße und Verarbeitungsanforderungen:

Three ways to read files Read all at once os.ReadFile("file.txt") Suitable for small files (config, JSON, etc.) Automatically opens/closes, simplest Line-by-line reading bufio.NewScanner(file) Suitable for large files (logs, CSV, etc.) Memory-friendly, processes line by line Streaming read io.ReadAll(reader) Suitable for network responses and already-open files Generic Reader interface

3.1 Einmaliges Lesen (empfohlen für kleine Dateien)

os.ReadFileist der einfachste Weg – öffnet, liest und schließt die Datei automatisch in einem Schritt:

Beispiel

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        // Gesamte Datei auf einmal lesen (Go 1.16+)
        data, err := os.ReadFile("config.json")
        if err != nil {
                log.Fatal(err)
        }

        fmt.Println(string(data))
}

3.2 Zeilenweises Lesen (empfohlen für große Dateien)

Verwenden Sie für große Dateienbufio.ScannerVerarbeiten Sie Zeile für Zeile, um zu vermeiden, alles auf einmal in den Speicher zu laden:

Beispiel

package main

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

func main() {
        file, err := os.Open("large-file.log")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // Zeile für Zeile scannen
        scanner := bufio.NewScanner(file)
        lineNum := 0
        for scanner.Scan() {
                lineNum++
                line := scanner.Text() // Inhalt der aktuellen Zeile abrufen
                fmt.Printf("Zeile %d: %s\n", lineNum, line)
        }

        // Prüfen, ob während des Scannens ein Fehler aufgetreten ist
        if err := scanner.Err(); err != nil {
                log.Fatal("Lesefehler:", err)
        }
}

Hinweis:bufio.ScannerDie standardmäßige maximale Zeilenlänge beträgt 64KB. Wenn die Datei übermäßig lange Zeilen enthält, müssen Sie beim AufrufScan()Presetscanner.Buffer(make([]byte, 0), maxSize)um den Puffer zu vergrößern.

3.3 Lesen mit io.ReadAll

Wenn Sie bereits einen offenenio.Reader(wie Netzwerkantworten, geöffnete Dateien), können Sie verwendenio.ReadAll:

Beispiel

package main

import (
        "fmt"
        "io"
        "log"
        "os"
)

func main() {
        file, err := os.Open("example.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // Alle Daten von Reader lesen
        data, err := io.ReadAll(file)
        if err != nil {
                log.Fatal(err)
        }

        fmt.Println(string(data))
}

4. Schreiben in Dateien

Go bietet mehrere Möglichkeiten zum Schreiben, von einfachen einmaligen Schreibvorgängen bis hin zu gepufferten Schreibvorgängen mit hoher Leistung:

4.1 Einmaliges Schreiben

os.WriteFileDaten in einem Durchgang in die Datei schreiben (vorhandenen Inhalt überschreiben):

Beispiel

package main

import (
        "log"
        "os"
)

func main() {
        content := []byte("Hello, Go!\nThis is the second line\n")

        // 0644: Eigentümer Lesen/Schreiben, andere nur Lesen
        err := os.WriteFile("output.txt", content, 0644)
        if err != nil {
                log.Fatal(err)
        }
        log.Println("Erfolgreich geschrieben")
}

4.2 Schreiben mit dem File-Objekt

Das Schreiben über das File-Objekt ermöglicht es, Inhalte in mehreren Durchgängen zu schreiben:

Beispiel

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        file, err := os.Create("output.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // Methode 1: String schreiben
        file.WriteString("String direkt schreiben\n")

        // Methode 2: Byte-Slice schreiben
        data := []byte("Byte-Slice schreiben\n")
        file.Write(data)

        // Methode 3: Formatiert schreiben
        fmt.Fprintf(file, "Formatiertes Schreiben: %d + %d = %d\n", 3, 4, 7)
}

4.3 Gepuffertes Schreiben (Empfohlen für große Datenmengen)

bufio.WriterEs schreibt Daten zuerst in einen In-Memory-Puffer und dann in Stapeln auf die Festplatte, sobald genug angesammelt wurde, wodurch die Anzahl der I/O-Operationen erheblich reduziert wird.Achten Sie darauf, vor dem Beenden aufzurufenFlush():

Beispiel

package main

import (
        "bufio"
        "log"
        "os"
)

func main() {
        file, err := os.Create("buffered-output.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // Gepufferten Writer erstellen
        writer := bufio.NewWriter(file)

        // Mehrere Zeilen schreiben (zuerst in den Puffer schreiben, nicht sofort auf die Festplatte)
        for i := 0; i < 1000; i++ {
                writer.WriteString("Dies ist Zeile " + itoa(i) + " Zeile\n")
        }

        // Flush schreibt die verbleibenden gepufferten Daten in die Datei
        if err := writer.Flush(); err != nil {
                log.Fatal("Puffer konnte nicht geleert werden:", err)
        }
        log.Println("Gepuffertes Schreiben abgeschlossen")
}

// Einfache Hilfsfunktion zum Umwandeln von int in string
func itoa(n int) string {
        return fmt.Sprintf("%d", n)
}

5. Anhängen an Dateien

Nutzungos.O_APPENDDas Flag hängt Inhalt an das Ende der Datei an, ohne vorhandene Daten zu überschreiben:

Beispiel

package main

import (
        "log"
        "os"
        "time"
)

func main() {
        // O_APPEND: Anhängemodus
        // O_CREATE: erstellen, falls nicht vorhanden
        // O_WRONLY: nur schreiben
        file, err := os.OpenFile("app.log",
                os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // Hängt bei jedem Lauf an, überschreibt nicht
        timestamp := time.Now().Format("2006-01-02 15:04:05")
        file.WriteString("[" + timestamp + "] Anwendung gestartet\n")
}

Vergleich:os.CreateEs löscht den vorhandenen Inhalt;os.OpenFileKoordinationO_APPENDEs hängt den Inhalt an. In Logging-Szenarien sollte unbedingt der Anhängemodus verwendet werden.


6. Löschen und Umbenennen von Dateien

Beispiel

package main

import (
        "log"
        "os"
)

func main() {
        // Datei umbenennen / verschieben
        err := os.Rename("old.txt", "new.txt")
        if err != nil {
                log.Fatal("Umbenennen fehlgeschlagen:", err)
        }
        log.Println("Umbenennen erfolgreich")

        // Datei löschen
        err = os.Remove("temp.txt")
        if err != nil {
                log.Fatal("Löschen fehlgeschlagen:", err)
        }
        log.Println("Löschen erfolgreich")
}

7. Dateiinformationen und Überprüfung

7.1 Dateiinformationen abrufen

Beispiel

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        info, err := os.Stat("test.txt")
        if err != nil {
                log.Fatal(err)
        }

        fmt.Println("Dateiname: ", info.Name())
        fmt.Println("Größe: ", info.Size(), "bytes")
        fmt.Println("Berechtigungen: ", info.Mode())
        fmt.Println("Geändert: ", info.ModTime())
        fmt.Println("Ist Verzeichnis: ", info.IsDir())
}

7.2 Prüfen, ob eine Datei existiert

Go hat keine dedizierte "Datei existiert"-Funktion; durchos.Stat + os.IsNotExistErmitteln:

Beispiel

package main

import (
        "fmt"
        "os"
)

// fileExists prüft, ob die Datei existiert
func fileExists(path string) bool {
        _, err := os.Stat(path)
        return !os.IsNotExist(err)
}

func main() {
        if fileExists("test.txt") {
                fmt.Println("Datei existiert")
        } else {
                fmt.Println("Datei existiert nicht")
        }
}

8. Verzeichnisoperationen

Beispiel

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        // Ein einzelnes Verzeichnis erstellen
        err := os.Mkdir("newdir", 0755)
        if err != nil {
                log.Fatal(err)
        }

        // Mehrstufige Verzeichnisse rekursiv erstellen (erstellt automatisch übergeordnete Verzeichnisse, auch wenn sie nicht existieren)
        err = os.MkdirAll("path/to/deep/dir", 0755)
        if err != nil {
                log.Fatal(err)
        }

        // Verzeichnisinhalt lesen
        entries, err := os.ReadDir(".")
        if err != nil {
                log.Fatal(err)
        }
        for _, entry := range entries {
                mark := "&#x1f4c4;"
                if entry.IsDir() {
                        mark = "&#x1f4c1;"
                }
                fmt.Printf("%s %s\n", mark, entry.Name())
        }

        // Leeres Verzeichnis löschen
        os.Remove("newdir")

        // Verzeichnis und alle seine Inhalte rekursiv löschen (&#x26a0; mit Vorsicht verwenden)
        os.RemoveAll("path")
}

9. Erweiterte Operationen

9.1 Dateien kopieren

Nutzungio.CopyDaten effizient zwischen zwei Dateien kopieren:

Beispiel

package main

import (
        "io"
        "log"
        "os"
)

// copyFile ist eine generische Funktion zum Kopieren von Dateien
func copyFile(src, dst string) (int64, error) {
        srcFile, err := os.Open(src)
        if err != nil {
                return 0, err
        }
        defer srcFile.Close()

        dstFile, err := os.Create(dst)
        if err != nil {
                return 0, err
        }
        defer dstFile.Close()

        // io.Copy verwaltet den Puffer automatisch für effizientes Kopieren
        return io.Copy(dstFile, srcFile)
}

func main() {
        n, err := copyFile("source.txt", "destination.txt")
        if err != nil {
                log.Fatal(err)
        }
        log.Printf("Kopieren abgeschlossen, %d Bytes insgesamt", n)
}

9.2 Temporäre Dateien und Verzeichnisse

Beispiel

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        // Temporäre Datei erstellen (automatisch benannt, Präfix ist "app-")
        tmpFile, err := os.CreateTemp("", "app-*.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer os.Remove(tmpFile.Name()) // Nach Gebrauch aufräumen
        fmt.Println("Temporäre Datei:", tmpFile.Name())

        // Temporäres Verzeichnis erstellen
        tmpDir, err := os.MkdirTemp("", "app-*")
        if err != nil {
                log.Fatal(err)
        }
        defer os.RemoveAll(tmpDir) // Nach Gebrauch aufräumen
        fmt.Println("Temporäres Verzeichnis:", tmpDir)
}

9.3 Rekursives Durchlaufen von Verzeichnissen

filepath.WalkSie können alle Dateien und Unterverzeichnisse im Verzeichnisbaum rekursiv durchlaufen:

Beispiel

package main

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

func main() {
        root := "." // Beginne mit dem Durchlaufen vom aktuellen Verzeichnis

        err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
                if err != nil {
                        return err // Wenn ein Fehler auftritt, kannst du wählen, ob du überspringst oder zurückgibst.
                }

                // Pfad und Größe ausgeben
                size := ""
                if !info.IsDir() {
                        size = fmt.Sprintf(" (%d bytes)", info.Size())
                }
                fmt.Println(path + size)
                return nil
        })

        if err != nil {
                log.Fatal(err)
        }
}

9.4 Plattformübergreifendes Zusammenfügen von Pfaden

Verwende niemals Zeichenkettenverkettung, um Pfade zu erstellen(wie zum Beispieldir + "/" + file), verwenden Siefilepath.JoinUm plattformübergreifende Kompatibilität sicherzustellen:

// 错误:Windows 上路径分隔符是 \
path := "dir" + "/" + "file.txt"

// 正确:自动适配当前操作系统
path := filepath.Join("dir", "file.txt")

Schnellreferenz für Szenarien

Szenarien Empfohlene Vorgehensweise Schlüsselcode
Kleine Datei lesen os.ReadFile data, err := os.ReadFile("file.txt")
Große Dateien Zeile für Zeile lesen bufio.Scanner scanner := bufio.NewScanner(file)
Kleine Datei schreiben os.WriteFile os.WriteFile("f.txt", data, 0644)
Schreiben großer Datenmengen bufio.Writer writer := bufio.NewWriter(file)
Log anhängen os.OpenFile + O_APPEND os.OpenFile("log", os.O_APPEND|os.O_WRONLY, 0644)
Datei kopieren io.Copy io.Copy(dst, src)
Verzeichnis durchlaufen filepath.Walk filepath.Walk(".", callback)
Pfad zusammenfügen filepath.Join filepath.Join("dir", "file.txt")
Dateiexistenz prüfen os.Stat + os.IsNotExist _, err := os.Stat(path)
Temporäre Dateien erstellen os.CreateTemp os.CreateTemp("", "prefix-*.txt")

Beschreibung der Dateiberechtigungen:0644Gibt an, dass der Eigentümer lesen und schreiben darf (6=4+2), während Gruppe und andere Benutzer nur lesen dürfen (4). Verzeichnisse verwenden typischerweise0755(fügt Ausführungsberechtigung hinzu, andernfalls kann man das Verzeichnis nicht betreten)

Weitere Erweiterungen