JSON-Verarbeitung in Rust: Bibliothek serde_json für Bildungswebsite

JSON-Verarbeitung in Rust: Vollständiger Leitfaden mit serde_json

JSON (JavaScript Object Notation) ist eines der beliebtesten Formate für den Datenaustausch in der Webentwicklung. In Rust erfolgt die JSON-Verarbeitung mit der leistungsstarken Bibliothek serde_json, die Teil des Serde-Ökosystems ist – einem Framework zur Serialisierung und Deserialisierung von Datenstrukturen. In diesem Artikel werden wir im Detail besprechen, wie man mit JSON in Rust arbeitet: von der Installation bis zu komplexen Beispielen mit verschachtelten Strukturen.

Installation und Konfiguration

Fügen Sie zunächst die Abhängigkeiten in Ihre Cargo.toml-Datei ein:

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

Die Bibliothek serde stellt die Makros #[derive(Serialize, Deserialize)] bereit, während serde_json für die Umwandlung von Daten in JSON und zurück verantwortlich ist.

Basis-Serialisierung und -Deserialisierung

Betrachten wir ein einfaches Beispiel: Wir erstellen eine Struktur User und lernen, sie in JSON und zurück zu konvertieren.

use serde::{Serialize, Deserialize};use serde_json;

#[derive(Debug, Serialize, Deserialize)]struct User {    name: String,    age: u8,    email: String,}

fn main() {    // Erstellen einer Instanz der Struktur    let user = User {        name: "Alexei".to_string(),        age: 30,        email: "alex@example.com".to_string(),    };

    // Serialisierung in einen JSON-String    let json_string = serde_json::to_string(&user).unwrap();    println!("JSON: {}", json_string);

    // Deserialisierung von JSON zurück in die Struktur    let deserialized_user: User = serde_json::from_str(&json_string).unwrap();    println!("Deserialisiert: {:?}", deserialized_user);}

Ausgabe:

JSON: {"name":"Alexei","age":30,"email":"alex@example.com"}Deserialisiert: User { name: "Alexei", age: 30, email: "alex@example.com" }

Arbeiten mit verschachtelten Strukturen

JSON enthält oft verschachtelte Objekte und Arrays. Rust ermöglicht es, solche Strukturen einfach zu modellieren:

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

#[derive(Debug, Serialize, Deserialize)]struct Person {    name: String,    age: u8,    address: Address,    hobbies: Vec<String>,}

fn main() {    let person = Person {        name: "Maria".to_string(),        age: 25,        address: Address {            city: "Moskau".to_string(),            street: "Twerskaja".to_string(),            house: 10,        },        hobbies: vec!["Lesen".to_string(), "Sport".to_string()],    };

    // Schöne JSON-Ausgabe mit Einrückungen    let pretty_json = serde_json::to_string_pretty(&person).unwrap();    println!("{}", pretty_json);}

Ausgabe:

{  "name": "Maria",  "age": 25,  "address": {    "city": "Moskau",    "street": "Twerskaja",    "house": 10  },  "hobbies": [    "Lesen",    "Sport"  ]}

Fehlerbehandlung und optionale Felder

In realen Projekten können Daten unvollständig sein. Rust bietet elegante Möglichkeiten, mit solchen Situationen umzugehen:

• Option<T> – für optionale Felder
• Result<T, E> – zur Behandlung von Parsing-Fehlern
• Serde-Attribute – zur Konfiguration des Serialisierungsverhaltens

use serde::{Serialize, Deserialize};use serde_json::Result;

#[derive(Debug, Serialize, Deserialize)]struct Product {    name: String,    price: f64,    #[serde(default)] // Standardwert, wenn das Feld fehlt    description: Option<String>,    #[serde(skip_serializing_if = "Option::is_none")] // Überspringen, wenn None    discount: