Arbeiten mit JSON in Rust: Parsing, Serialisierung und praktische Beispiele

Einführung in JSON in Rust

JSON (JavaScript Object Notation) bleibt eines der beliebtesten Datenformate für den Datenaustausch in der Webentwicklung, Konfigurationsdateien und APIs. Die Sprache Rust, bekannt für ihre Leistung und Speichersicherheit, bietet leistungsstarke Werkzeuge für die Arbeit mit JSON durch die Crate serde_json. In diesem Artikel werden wir detailliert behandeln, wie man JSON in Rust parst und serialisiert, unter Verwendung moderner Ansätze und bewährter Praktiken.

Die Bibliothek serde (Serialization/Deserialization framework) ist der De-facto-Standard für die Arbeit mit Datenformaten im Rust-Ökosystem. In Kombination mit serde_json ermöglicht sie es, Rust-Strukturen einfach in JSON und zurück zu konvertieren.

Projekt einrichten und Abhängigkeiten installieren

Erstellen Sie zunächst ein neues Cargo-Projekt und fügen Sie die erforderlichen Abhängigkeiten in der Datei Cargo.toml hinzu:

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

Das Flag features = ["derive"] für die Crate serde aktiviert die Makros #[derive(Serialize, Deserialize)], die automatisch Code für die Serialisierung und Deserialisierung von Strukturen generieren.

Grundlagen des JSON-Parsings in Rust

Parsen eines JSON-Strings in einen dynamischen Wert

Der einfachste Weg, JSON zu parsen, ist die Verwendung des Typs serde_json::Value, der einen universellen JSON-Wert darstellt:

use serde_json::Value;

fn main() {    let data = r#"    {        "name": "Alexej",        "age": 30,        "is_student": false,        "hobbies": ["Lesen", "Programmieren", "Fahrradfahren"]    }"#;

    let parsed: Value = serde_json::from_str(data).expect("Fehler beim JSON-Parsing");        println!("Name: {}", parsed["name"]);    println!("Alter: {}", parsed["age"]);    println!("Student: {}", parsed["is_student"]);    println!("Erstes Hobby: {}", parsed["hobbies"][0]);}

Der Typ Value ist eine Aufzählung, die Null, Bool, Number, String, Array oder Object enthalten kann. Dies ist praktisch für schnelles Prototyping, aber für Produktionscode sollten besser streng typisierte Strukturen verwendet werden.

Parsen von JSON in streng typisierte Strukturen

Für die sichere Arbeit mit Daten definieren Sie eine Struktur, die dem JSON-Schema entspricht, und verwenden Sie die serde-Makros:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]struct Person {    name: String,    age: u32,    is_student: bool,    hobbies: Vec<String>,}

fn main() {    let json_str = r#"    {        "name": "Maria",        "age": 25,        "is_student": true,        "hobbies": ["Zeichnen", "Musik"]    }"#;

    let person: Person = serde_json::from_str(json_str)        .expect("Fehler bei der Deserialisierung");        println!("{:?}", person);    println!("{} studiert: {}", person.name, person.is_student);}

Der Vorteil dieses Ansatzes ist, dass der Compiler die Typen zur Kompilierzeit überprüft, was Laufzeitfehler durch falschen Zugriff auf Felder ausschließt.

Serialisierung von Daten in JSON

Konvertierung von Strukturen in einen JSON-String

Die Serialisierung erfolgt mit der Funktion serde_json::to_string():

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Product {    id: u64,    name: String,    price: f64,    in_stock: bool,}

fn main() {    let product = Product {        id: 42,        name: "Laptop".to_string(),        price: 89999.99,        in_stock: true,    };

    let json_string = serde_json::to_string(&product)        .expect("Fehler bei der Serialisierung");        println!("JSON: {}", json_string);        // Schöne Ausgabe mit