Arbeiten mit dem Dateisystem in Rust: Vollständiger Leitfaden für Anfänger

Einführung in die Arbeit mit dem Dateisystem in Rust

Rust ist eine moderne systemnahe Programmiersprache, die großen Wert auf Sicherheit, Leistung und Speicherkontrolle legt. Die Arbeit mit dem Dateisystem ist eine der grundlegenden Aufgaben, mit denen jeder Entwickler konfrontiert wird. In diesem Artikel werden wir im Detail besprechen, wie man Dateien liest und schreibt, Verzeichnisse erstellt, Fehler behandelt und die Standardbibliothek std::fs für eine effiziente Interaktion mit dem Dateisystem nutzt.

Wir beginnen mit den Grundlagen und gehen schrittweise zu komplexeren Szenarien über. Alle Codebeispiele sind in Rust geschrieben und bereit zur Ausführung. Wenn Sie gerade erst anfangen, Rust zu lernen, ist dieser Artikel ein ausgezeichneter Ausgangspunkt, um die Ein-/Ausgabe (I/O) in dieser Sprache zu meistern.

Grundlegende Module und Typen für die Arbeit mit dem Dateisystem

In Rust ist die gesamte Funktionalität für die Arbeit mit Dateien und Verzeichnissen im Modul std::fs gebündelt. Darüber hinaus spielen die Typen Path und PathBuf aus dem Modul std::path eine wichtige Rolle, die Pfade zu Dateien und Verzeichnissen darstellen.

Die Typen Path und PathBuf

Path ist ein Slice (Ausschnitt) für die Arbeit mit Pfaden ohne Datenbesitz. PathBuf ist die besitzende Version, die geändert werden kann. Sie bieten praktische Methoden zur Pfadmanipulation.

use std::path::Path;use std::path::PathBuf;

fn main() {    // Erstellen eines PathBuf    let mut path = PathBuf::from("/tmp");    path.push("example.txt");    println!("Pfad: {}", path.display());

    // Umwandlung in Path    let path_ref: &Path = path.as_path();    println!("Elternverzeichnis: {:?}", path_ref.parent());}

Das Modul std::fs

Das Modul std::fs enthält die wichtigsten Funktionen für die Arbeit mit dem Dateisystem. Hier sind die am häufigsten verwendeten:

• read_to_string — Lesen einer Datei in einen String
• write — Schreiben von Daten in eine Datei
• create_dir und create_dir_all — Erstellen von Verzeichnissen
• remove_file und remove_dir — Löschen von Dateien und Verzeichnissen
• metadata — Abrufen von Dateiinformationen
• copy und rename — Kopieren und Umbenennen

Lesen und Schreiben von Dateien in Rust

Der einfachste Weg, eine Datei zu lesen oder zu schreiben, ist die Verwendung von Wrapper-Funktionen, die die gesamte Arbeit in einem einzigen Aufruf erledigen. Sie eignen sich für kleine Dateien, die vollständig in den Speicher passen.

Eine Datei vollständig lesen

use std::fs;

fn main() -> Result<(), std::io::Error> {    let content = fs::read_to_string("hello.txt")?;    println!("Dateiinhalt:{}", content);    Ok(())}

Die Funktion read_to_string gibt ein Result<String> zurück. Wenn die Datei nicht existiert oder keine Leserechte vorhanden sind, wird ein Fehler zurückgegeben. Beachten Sie den Operator ? — er gibt den Fehler automatisch nach oben weiter.

In eine Datei schreiben

use std::fs;

fn main() -> Result<(), std::io::Error> {    let data = "Hallo, Rust!";    fs::write("output.txt", data)?;    println!("Datei erfolgreich geschrieben");    Ok(())}

Die Funktion write überschreibt die Datei, falls sie existiert, oder erstellt eine neue. Verwenden Sie OpenOptions, um Daten an das Ende einer Datei anzuhängen.

Arbeiten mit Binärdateien

Verwenden Sie zum Lesen und Schreiben von Binärdaten read und write mit einem Vektor von Bytes:

use std::fs;

fn main() -> Result<(), std::io::Error> {    // Schreiben von Binärdaten    let bytes: Vec<u8> = vec![0, 1, 2, 3, 255];    fs::write("binary.dat", &bytes)?;

    // Lesen als Bytes    let read_bytes = fs::read("binary.dat")?;    println!("Gelesen