JSON in Rust für Anfänger: Parsing und Serialisierung von Daten

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einführung in die Arbeit mit JSON in Rust

JSON (JavaScript Object Notation) ist eines der beliebtesten Formate für den Datenaustausch in der Webentwicklung, Konfigurationsdateien und APIs. Wenn Sie Rust lernen und effizient mit JSON arbeiten möchten, ist dieser Artikel genau das Richtige für Sie. Wir betrachten die wichtigsten Bibliotheken, die Prinzipien des Parsings und der Serialisierung und analysieren praktische Codebeispiele.

In Rust ist das Ökosystem für die Arbeit mit JSON um die Crate serde herum aufgebaut – ein leistungsstarkes Framework für die Serialisierung und Deserialisierung von Daten. In Kombination mit serde_json ermöglicht es, Datenstrukturen einfach in JSON und zurück zu konvertieren. Lassen Sie uns verstehen, wie das funktioniert.

Installation und Konfiguration der Abhängigkeiten

Zunächst erstellen wir ein neues Projekt und fügen die notwendigen Abhängigkeiten in der Datei Cargo.toml hinzu:

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

Die Crate serde stellt die Makros #[derive(Serialize, Deserialize)] bereit, die automatisch die notwendigen Traits für Ihre Strukturen implementieren. serde_json ist direkt für die Arbeit mit dem JSON-Format zuständig.

JSON-Parsing: Vom String zur Struktur

Angenommen, wir haben einen JSON-String mit Informationen über einen Benutzer. Wir möchten ihn in eine typisierte Rust-Struktur umwandeln. So geht das:

use serde::{Deserialize, Serialize};

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

fn main() {    let json_data = r#"        {            "name": "Alexej",            "age": 28,            "email": "alex@example.com",            "is_active": true        }    "#;

    // JSON in eine Struktur parsen    let user: User = serde_json::from_str(json_data).expect("Fehler beim JSON-Parsing");        println!("Benutzer: {:?}", user);    println!("Name: {}", user.name);    println!("Alter: {}", user.age);}

Beachten Sie das Attribut #[derive(Debug, Deserialize, Serialize)]. Debug ermöglicht die Ausgabe der Struktur in der Konsole, während Deserialize und Serialize die Konvertierung von Daten in JSON und zurück ermöglichen.

Verarbeitung von verschachtelten Objekten

JSON enthält oft verschachtelte Objekte. Betrachten wir ein Beispiel mit einer Benutzeradresse:

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

#[derive(Debug, Deserialize, Serialize)]struct User {    name: String,    age: u32,    address: Address,}

fn main() {    let json_data = r#"        {            "name": "Maria",            "age": 32,            "address": {                "city": "Moskau",                "street": "Twerskaja, 15",                "zip_code": "101000"            }        }    "#;

    let user: User = serde_json::from_str(json_data).unwrap();    println!("Stadt: {}", user.address.city);}

Arbeiten mit JSON-Arrays

Arrays in JSON werden in Vec oder andere Rust-Sammlungen umgewandelt:

use serde::Deserialize;

#[derive(Debug, Deserialize)]struct Product {    id: u32,    name: String,    price: f64,}

fn main() {    let json_array = r#"        [            {"id": 1, "name": "Laptop", "price": 75000.50},            {"id": 2, "name": "Maus", "price": 1500.00},            {"id": 3, "name": "Tastatur", "price": 3500.00}        ]    "#;

    let products: Vec<Product> = serde_json::from_str(json_array).unwrap();        for product in &products {        println!("{}: {} Rubel", product.name, product.price);    }}