Learn Rust Coding · Lektion

Serialisieren und Deserialisieren

Derive-Makros

Serialisieren und Deserialisieren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was ist Serde?

Serde (SERialize/DEserialize) ist Rusts Framework zum Konvertieren von Datenstrukturen in Formate wie JSON und YAML sowie aus diesen Formaten.

Formatunabhängiger Kern plus Format-Crates
Gesteuert durch Derive-Makros

serde hinzufügen

Fügen Sie serde mit dem Feature derive sowie einem Format-Crate wie serde_json hinzu. Dadurch wird Cargo.toml bearbeitet.

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Die Traits ableiten

Annotieren Sie eine Struktur mit #[derive(Serialize, Deserialize)], damit sie konvertiert werden kann. Jedes Feld muss selbst serialisierbar sein.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
}

Serialize bedeutet: in ein Format

Serialize wandelt einen Wert in Bytes oder Text eines bestimmten Formats um. Die Struktur kennt das Format nicht; das Format-Crate legt es fest.

Deserialize bedeutet: aus einem Format

Deserialize parst Text oder Bytes zurück in einen Rust-Wert und überprüft dabei Typen und erforderliche Felder.

Serialize manuell modellieren

Um das Prinzip zu veranschaulichen, sehen Sie hier einen von Hand geschriebenen Serializer für eine einfache Struktur. serde erzeugt solchen Code für Sie.

struct User { id: u32, name: String }

fn serialize(u: &User) -> String {
    format!("id={};name={}", u.id, u.name)
}

fn main() {
    let u = User { id: 7, name: "Alice".to_string() };
    println!("{}", serialize(&u));
}

Deserialize manuell modellieren

Und hier die Umkehrung: Text wird zurück in die Struktur geparst. Der von serde generierte Code erledigt dies robust für verschiedene Formate.

struct User { id: u32, name: String }

fn deserialize(s: &str) -> User {
    let parts: Vec<&str> = s.split(',').collect();
    let id = parts[0].parse().unwrap();
    let name = parts[1].to_string();
    User { id, name }
}

fn main() {
    let u = deserialize("42,Bob");
    println!("{} {}", u.id, u.name);
}

Ableiten für Enums

Auch Enums funktionieren. Standardmäßig wird jede Variante anhand ihres Namens serialisiert, wobei enthaltene Daten darin verschachtelt werden.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
enum Shape {
    Circle { radius: f64 },
    Square { side: f64 },
}

Verschachtelte Strukturen

serde arbeitet automatisch rekursiv. Eine Struktur, die andere abgeleitete Strukturen oder Vecs enthält, funktioniert direkt.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Address { city: String }

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    addresses: Vec<Address>,
}

Nur Serialize oder nur Deserialize

Sie können auch nur ein Trait ableiten. Ein Typ für eine API-Antwort könnte nur Serialize implementieren, ein Typ für eingehende Anfragen nur Deserialize.

use serde::Serialize;

#[derive(Serialize)]
struct ApiResponse {
    status: u16,
    message: String,
}

Voraussetzungen für derive

Jeder Feldtyp muss das abgeleitete Trait implementieren. Standardtypen und Collections tun dies bereits; eigene Typen benötigen ihr eigenes derive.

use serde::Serialize;

#[derive(Serialize)]
struct Inner { x: i32 }

#[derive(Serialize)]
struct Outer { inner: Inner }

Kurzer Test

Testen Sie Ihr Verständnis von Serialize und Deserialize.

Zusammenfassung

Sie haben die Grundlagen von serde gelernt:

serde ist ein formatunabhängiges Framework für (De-)Serialisierung
#[derive(Serialize, Deserialize)] erzeugt den Konvertierungscode
Funktioniert mit Strukturen, Enums und verschachtelten Typen
Bei Bedarf können Sie nur eine Richtung ableiten

Als Nächstes: Arbeiten mit JSON über serde_json.

Häufig gestellte Fragen

Ist die Lektion „Serialisieren und Deserialisieren“ kostenlos?

Ja — der vollständige Text von „Serialisieren und Deserialisieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Serialisieren und Deserialisieren“?

Derive-Makros Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Serialisieren und Deserialisieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding