Arbeiten mit dem Dateisystem in Rust: Vollständiger Leitfaden

Arbeiten mit dem Dateisystem in Rust: Eine vollständige Anleitung

Rust ist eine moderne Systemprogrammiersprache, die leistungsstarke und sichere Werkzeuge für die Arbeit mit dem Dateisystem bietet. Dank seines strengen Typsystems und des Ownership-Modells hilft Rust, viele Fehler im Zusammenhang mit der Dateiverwaltung zu vermeiden, wie z. B. Datenrennen oder Ressourcenlecks. In diesem Artikel werden wir gründlich untersuchen, wie grundlegende Dateisystemoperationen in Rust ausgeführt werden: Erstellen, Lesen, Schreiben, Kopieren und Löschen von Dateien und Verzeichnissen. Alle Codebeispiele wurden mit der Standardbibliothek std::fs geschrieben.

Projekteinrichtung und Modulimporte

Erstellen Sie zunächst ein neues Projekt mit Cargo:

cargo new file_system_democd file_system_demo

Öffnen Sie die Datei src/main.rs und fügen Sie die folgenden Importe hinzu:

use std::fs;use std::io::{self, Write, Read};use std::path::Path;

Das Modul std::fs stellt Funktionen für die Arbeit mit Dateien und Verzeichnissen bereit. std::io enthält Traits für die Ein-/Ausgabe, und std::path::Path dient der Arbeit mit Pfaden.

Dateien erstellen und schreiben

Der einfachste Weg, eine Datei zu erstellen und Daten hineinzuschreiben, ist die Verwendung der Funktion fs::write. Sie nimmt einen Dateipfad und den Inhalt als Bytes oder einen String entgegen.

fn main() -> io::Result<()> {    // Create a file and write a string to it    fs::write("hello.txt", "Hello, Rust!")?;    println!("Datei erfolgreich erstellt.");    Ok(())}

Wenn Sie mehr Kontrolle benötigen, verwenden Sie fs::File und die Methoden write oder write_all:

fn main() -> io::Result<()> {    let mut file = fs::File::create("data.txt")?;    file.write_all(b"Data string")?;    file.write_all("Another string".as_bytes())?;    Ok(())}

Beachten Sie das ? — dies ist der Fehlerweitergabeoperator. Wenn die Operation fehlschlägt, wird der Fehler von der Funktion zurückgegeben.

Dateien lesen

Um den gesamten Inhalt einer Datei in einen String zu lesen, verwenden Sie fs::read_to_string:

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

Wenn die Datei Binärdaten enthält, verwenden Sie fs::read, das Vec<u8> zurückgibt:

fn main() -> io::Result<()> {    let data = fs::read("image.png")?;    println!("{} Bytes gelesen", data.len());    Ok(())}

Für das zeilenweise Lesen ist die Verwendung von BufReader praktisch:

fn main() -> io::Result<()> {    let file = fs::File::open("data.txt")?;    let reader = io::BufReader::new(file);    for line in reader.lines() {        let line = line?;        println!("{}", line);    }    Ok(())}

Arbeiten mit Verzeichnissen

Das Erstellen eines neuen Verzeichnisses erfolgt mit fs::create_dir oder fs::create_dir_all (für verschachtelte Pfade):

fn main() -> io::Result<()> {    // Ein einzelnes Verzeichnis erstellen    fs::create_dir("my_folder")?;

    // Verschachtelte Verzeichnisse erstellen (analog zu mkdir -p)    fs::create_dir_all("a/b/c")?;    println!("Verzeichnisse erstellt.");    Ok(())}

Um zu prüfen, ob eine Datei oder ein Verzeichnis existiert, verwenden Sie Path::exists:

fn main() {    let path = Path::new("hello.txt");    if path.exists() {        println!("Datei existiert.");    } else {        println!("Datei nicht gefunden.");    }}

Um eine Liste des Inhalts eines Verzeichnisses zu erhalten, verwenden Sie fs::read_dir:

fn main() -> io::Result<()> {    let e