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:
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
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
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:
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
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
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
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
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
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
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
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
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
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
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
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 := "📄"
if entry.IsDir() {
mark = "📁"
}
fmt.Printf("%s %s\n", mark, entry.Name())
}
// Leeres Verzeichnis löschen
os.Remove("newdir")
// Verzeichnis und alle seine Inhalte rekursiv löschen (⚠ mit Vorsicht verwenden)
os.RemoveAll("path")
}
9. Erweiterte Operationen
9.1 Dateien kopieren
Nutzungio.CopyDaten effizient zwischen zwei Dateien kopieren:
Beispiel
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
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
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") |
Weitere ErweiterungenBeschreibung 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)