Praca z JSON
serde_json
Praca z JSON to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.
Crate serde_json
serde_json to implementacja formatu JSON dla serde. Udostępnia funkcje do konwersji między wartościami Rust a tekstem JSON.
to_string/from_strdo pracy z tekstemValuedo obsługi dynamicznego JSON-u
Struktura do tekstu JSON
serde_json::to_string serializuje dowolną wartość implementującą Serialize do tekstu JSON.
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);
}Tekst JSON do struktury
serde_json::from_str analizuje JSON i tworzy wartość określonego typu, zwracając Result, dzięki czemu możesz obsłużyć niepoprawne dane wejściowe.
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);
}Formatowanie z wcięciami
Użyj to_string_pretty, aby uzyskać czytelny dla człowieka JSON z wcięciami — przydaje się to w plikach konfiguracyjnych i podczas debugowania.
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());
}Makro json!
Twórz JSON bezpośrednio w kodzie za pomocą makra json!, które tworzy wartość Value bez definiowania struktury.
use serde_json::json;
fn main() {
let v = json!({
"name": "Alice",
"roles": ["admin", "user"]
});
println!("{}", v);
}Typ Value
serde_json::Value to enum reprezentujący dowolny węzeł JSON: null, wartość logiczną, liczbę, tekst, tablicę lub obiekt. Użyj go, gdy struktura danych jest nieznana.
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"]);
}Bezpieczne odczytywanie z Value
Dostęp indeksowany zwraca Value. Aby bezpiecznie odczytać dane określonego typu, użyj metod dostępowych, takich jak as_str lub as_i64, które zwracają Option.
use serde_json::Value;
fn name_of(v: &Value) -> Option<&str> {
v.get("name")?.as_str()
}Modelowanie dostępu do JSON-u w czystym Rust
Odczytywanie wartości według klucza wraz z wartością zastępczą na wypadek jej braku odzwierciedla sposób odpytywania obiektu Value. Oto przykład z użyciem 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);
}Bajty i obiekty zapisujące
Ze względów wydajnościowych to_vec serializuje dane do bajtów, a to_writer przesyła je bezpośrednio do dowolnego obiektu io::Write, takiego jak plik lub gniazdo.
use serde::Serialize;
#[derive(Serialize)]
struct Msg { text: String }
fn to_bytes(m: &Msg) -> Vec<u8> {
serde_json::to_vec(m).unwrap()
}Obsługa błędów analizy
from_str zwraca Result. Dopasuj błąd, aby wyświetlić użytkownikom pomocny komunikat zamiast wywoływać panic.
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),
}
}Konwersja między Value a strukturami
serde_json::from_value i to_value konwertują między strukturą określonego typu a dynamicznym Value, gdy potrzebujesz obu tych reprezentacji.
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);
}Szybkie sprawdzenie
Sprawdź, czy rozumiesz pracę z JSON-em.
Podsumowanie
Poznałeś obsługę JSON-u za pomocą serde_json:
to_string/from_strkonwertują struktury i tekst JSONto_string_prettyformatuje dane w czytelny sposób- Makro
json!i typValueobsługują dynamiczny JSON - Do bezpiecznego odczytu i analizowania używaj metod dostępowych oraz
Result
Następnie: dostosowywanie serializacji za pomocą atrybutów pól.
Często zadawane pytania
Czy lekcja „Praca z JSON” jest bezpłatna?
Tak — pełny tekst „Praca z JSON” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.
Co nauczysz się w „Praca z JSON”?
serde_json Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?
Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.
Ile czasu zajmuje lekcja „Praca z JSON”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?
Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.