Skip to content
Modul 18 — Input & Output: Lesen, Schreiben, Dateien & Netzwerk
1

Readers & Writers: Rasts einheitliches I/O-System

Lektion 1 von 7

Das Problem: Viele Quellen, viele Ziele

Wo kommen Daten her? Aus Dateien, dem Netzwerk, der Tastatur oder einfach aus einem Byte-Array im Speicher. Und wo gehen sie hin? In Dateien, ins Netz, auf die Konsole oder in einen Vec<u8>.

Rust löst das mit zwei Traits, die jede dieser Quellen und Ziele einheitlich machen:

  • Reader liefern Bytes. Sie implementieren std::io::Read.
  • Writer nehmen Bytes entgegen. Sie implementieren std::io::Write.
use std::io::Read;

fn main() {
    // Ein Reader aus einem Byte-Array im Speicher
    let mut reader = std::io::Cursor::new(b"hello, world".to_vec());

    let mut buf = String::new();
    reader.read_to_string(&mut buf).unwrap();
    println!("{buf}"); // hello, world
}

Bekannte Reader

  • File::open(filename) — bestehende Datei lesen
  • TcpStream — Daten über das Netzwerk empfangen
  • stdin() — Standard-Eingabe des Prozesses
  • Cursor<&[u8]>, Cursor<Vec<u8>> — aus einem Byte-Array "lesen"

Bekannte Writer

  • File::create(filename) — neue Datei schreiben
  • TcpStream — Daten über das Netzwerk senden
  • stdout(), stderr() — auf den Bildschirm schreiben
  • Vec<u8> — der write-Methode hängt ans Ende an
  • Cursor<Vec<u8>> — lesen und schreiben mit freiem Positionieren

Ein Trait, viele Quellen

Der Zauber: Eine Funktion, die eine generische Read- oder Write-Implementierung annimmt, funktioniert identisch für Dateien, Netzwerk-Sockets und Buffer.

use std::io::{self, Read};

// Arbeitet mit jeder Quelle, die bytes liefern kann:
fn drucke_inhalt(mut quelle: impl Read) -> io::Result<()> {
    let mut text = String::new();
    quelle.read_to_string(&mut text)?;
    println!("{text}");
    Ok(())
}

Läuft für File, TcpStream, Cursor, Stdin — ohne eine Zeile zu ändern.

Praxis-Szenario: Das Gigabyte-Log

Zur Fehlersuche soll ein 2-GB-Logfile ausgewertet werden. Der erste Versuch lädt die ganze Datei mit fs::read_to_string — der Container stirbt mit OOM. Du suchst einen Weg, zeilenweise zu arbeiten.

Übung: Zeilen mit BufRead lesen

🧩 Übung m18-l81-e1

🔮 Vorhersage: Was passiert beim Ausführen?

Editor wird geladen…
KI-Tutor (sokratisch — keine Komplettlösungen)

⚠ Häufiger Fehler: read_to_string verlangt gültiges UTF-8 — Binärdateien oder defekte Encodings brechen mit InvalidData: stream did not contain valid UTF-8 ab. Wer nur die Bytes braucht, liest stattdessen mit read_to_end in einen Byte-Buffer.

✅ Wichtige Erkenntnisse

0/3

Haken setzen, um deinen Lernfortschritt zu markieren:

  • Rufe dir die Kernpunkte in Erinnerung, bevor du die Liste aufdeckst.

Erinnerungstraining

Tippe den fehlenden Begriff aus dem Gedächtnis ein und prüfe.

Rusts I/O ruht auf zwei Traits: Reader liefern Bytes und implementieren std::io:: — Dateien, TcpStream und stdin alike.
Writer nehmen Bytes entgegen (std::io::Write): File::create, TcpStream, stdout() — und sogar ein einfaches .
Ein über b"hello, world" macht ein Byte-Array im Speicher zum Reader — praktisch für Tests ohne Datei.
0 von 3 richtig

This site uses essential cookies for Stripe payments. No tracking cookies.