Arbeiten mit dem Dateisystem in Rust: vollständiger Leitfaden

Einführung in die Arbeit mit dem Dateisystem in Rust

Rust ist eine moderne systemnahe Programmiersprache, die leistungsstarke und sichere Mittel für die Interaktion mit dem Dateisystem bietet. Im Gegensatz zu vielen anderen Sprachen garantiert Rust Sicherheit bei der Arbeit mit Speicher und Threads, was besonders bei Ein-/Ausgabeoperationen wichtig ist. In diesem Artikel werden wir im Detail besprechen, wie man Dateien und Verzeichnisse erstellt, liest, schreibt, Pfade verwaltet und Fehler mit Hilfe der Standardbibliothek std::fs und std::path behandelt.

Das Material wird sowohl für Anfänger nützlich sein, die gerade Rust kennenlernen, als auch für erfahrene Entwickler, die ihr Wissen auffrischen möchten. Alle Codebeispiele sind startbereit und mit Kommentaren versehen.

Grundlegende Module und Importe

Für die Arbeit mit dem Dateisystem in Rust werden zwei Schlüsselmodule verwendet:

• std::fs — stellt Funktionen für Operationen mit Dateien und Ordnern bereit (Lesen, Schreiben, Löschen, Kopieren usw.).
• std::path — enthält die Typen Path und PathBuf für die Arbeit mit Pfaden.

Für die meisten Aufgaben reicht es, die folgenden Importe hinzuzufügen:

use std::fs;use std::path::Path;use std::io::prelude::*; // für die Arbeit mit Streams

Arbeit mit Dateien: Lesen und Schreiben

Inhalt einer Datei lesen

Der einfachste Weg, eine gesamte Datei in einen String zu lesen, ist die Verwendung der Funktion fs::read_to_string. Sie gibt ein Result<String> zurück, daher muss ein möglicher Fehler behandelt werden.

use std::fs;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let content = fs::read_to_string(path)?;    Ok(content)}

fn main() {    match read_file("example.txt") {        Ok(text) => println!("Dateiinhalt:{}", text),        Err(e) => eprintln!("Lesefehler: {}", e),    }}

Wenn Sie eine Datei als Binärdaten lesen müssen, verwenden Sie fs::read, das ein Vec<u8> zurückgibt.

In eine Datei schreiben

Zum Schreiben eines Strings in eine Datei wird fs::write verwendet. Es erstellt die Datei, falls sie nicht existiert, oder überschreibt eine vorhandene.

use std::fs;

fn write_file(path: &str, content: &str) -> Result<(), std::io::Error> {    fs::write(path, content)?;    println!("Datei erfolgreich geschrieben");    Ok(())}

fn main() {    let data = "Hello, Rust!Zweite Zeile.";    if let Err(e) = write_file("output.txt", data) {        eprintln!("Schreibfehler: {}", e);    }}

Zum Anhängen an das Ende einer Datei oder für eine feinere Kontrolle verwenden Sie OpenOptions:

use std::fs::OpenOptions;use std::io::Write;

fn append_to_file(path: &str, line: &str) -> Result<(), std::io::Error> {    let mut file = OpenOptions::new()        .append(true)        .create(true)        .open(path)?;    writeln!(file, "{}", line)?;    Ok(())}

Arbeit mit Verzeichnissen

Ordner erstellen und löschen

Zum Erstellen eines Verzeichnisses verwenden Sie fs::create_dir (ein Ordner) oder fs::create_dir_all (rekursiv, wie mkdir -p).

use std::fs;

fn main() -> Result<(), std::io::Error> {    // Einen Ordner erstellen    fs::create_dir("my_folder")?;

    // Rekursives Erstellen von verschachtelten Ordnern    fs::create_dir_all("data/subdir/logs")?;

    // Leeren Ordner löschen    fs::remove_dir("my_folder")?;

    // Ordner mitsamt Inhalt rekursiv löschen    fs::remove_dir_all("data")?;

    Ok(())}

Inhalt eines Verzeichnisses lesen

Die Funktion fs::read_dir gibt einen Iterator über die Einträge eines Verzeichnisses zurück. Jeder Eintrag ist ein DirEntry, aus dem Name, Typ und Metadaten abgerufen werden können.

use std::fs;

fn list_directory(path:
```