Learn Rust Coding · Lektion

Arbeiten mit JSON

serde_json

Arbeiten mit JSON ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 2 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.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

The serde_json crate

serde_json is the JSON format implementation for serde. It provides functions to convert between Rust values and JSON text.

to_string / from_str for text
Value for dynamic JSON

Struct to JSON string

serde_json::to_string serializes any Serialize value to a JSON string.

use serde::Serialize;

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

fn main() {
    let u = User { id: 1, name: "Alice".to_string() };
    let json = serde_json::to_string(&u).unwrap();
    println!("{}", json);
}

JSON string to struct

serde_json::from_str parses JSON into a typed value, returning a Result so you can handle malformed input.

use serde::Deserialize;

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

fn main() {
    let data = r#"{"id":1,"name":"Alice"}"#;
    let u: User = serde_json::from_str(data).unwrap();
    println!("{:?}", u);
}

Pretty printing

Use to_string_pretty for human-readable, indented JSON, handy for config files and debugging.

use serde::Serialize;

#[derive(Serialize)]
struct Cfg { debug: bool, level: u8 }

fn main() {
    let c = Cfg { debug: true, level: 3 };
    println!("{}", serde_json::to_string_pretty(&c).unwrap());
}

The json! macro

Build JSON inline with the json! macro, which produces a Value without defining a struct.

use serde_json::json;

fn main() {
    let v = json!({
        "name": "Alice",
        "roles": ["admin", "user"]
    });
    println!("{}", v);
}

The Value type

serde_json::Value is an enum representing any JSON node: null, bool, number, string, array, or object. Use it when the shape is unknown.

use serde_json::Value;

fn main() {
    let data = r#"{"name":"Bob","age":30}"#;
    let v: Value = serde_json::from_str(data).unwrap();
    println!("{}", v["name"]);
    println!("{}", v["age"]);
}

Safely reading from Value

Index access returns a Value; use accessor methods like as_str or as_i64 that return Option to read typed data safely.

use serde_json::Value;

fn name_of(v: &Value) -> Option<&str> {
    v.get("name")?.as_str()
}

Modeling JSON access in plain Rust

Reading a value by key, with a fallback when absent, mirrors how you query a Value object. Here it is with a HashMap.

use std::collections::HashMap;

fn main() {
    let mut obj: HashMap<&str, &str> = HashMap::new();
    obj.insert("name", "Alice");
    let name = obj.get("name").copied().unwrap_or("unknown");
    let city = obj.get("city").copied().unwrap_or("unknown");
    println!("name={} city={}", name, city);
}

Bytes and writers

For performance, to_vec serializes to bytes, and to_writer streams directly into any io::Write such as a file or socket.

use serde::Serialize;

#[derive(Serialize)]
struct Msg { text: String }

fn to_bytes(m: &Msg) -> Vec<u8> {
    serde_json::to_vec(m).unwrap()
}

Handling parse errors

from_str returns Result. Match on the error to give users a helpful message instead of panicking.

use serde::Deserialize;

#[derive(Deserialize)]
struct User { id: u32 }

fn parse(s: &str) -> String {
    match serde_json::from_str::<User>(s) {
        Ok(u) => format!("id {}", u.id),
        Err(e) => format!("invalid JSON: {}", e),
    }
}

Converting between Value and structs

serde_json::from_value and to_value convert between a typed struct and the dynamic Value when you need both.

use serde::Deserialize;
use serde_json::json;

#[derive(Deserialize)]
struct User { name: String }

fn main() {
    let v = json!({"name": "Eve"});
    let u: User = serde_json::from_value(v).unwrap();
    println!("{}", u.name);
}

Quick Check

Test your understanding of working with JSON.

Recap

You learned JSON handling with serde_json:

to_string / from_str convert structs and JSON text
to_string_pretty formats readably
The json! macro and Value handle dynamic JSON
Use accessors and Result to read and parse safely

Next: customizing serialization with field attributes.

Häufig gestellte Fragen

Ist die Lektion „Arbeiten mit JSON“ kostenlos?

Ja — der vollständige Text von „Arbeiten mit JSON“ 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 „Arbeiten mit JSON“?

serde_json 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 2 von 4.

Wie lange dauert die Lektion „Arbeiten mit JSON“?

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