Learn Rust Coding · Lekcja

Serializacja i deserializacja

Makra derive

Serializacja i deserializacja to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 1 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.

Czym jest Serde?

Serde (SERialize/DEserialize) to framework Rusta służący do konwertowania struktur danych z formatów takich jak JSON i YAML oraz do tych formatów.

Rdzeń niezależny od formatu oraz crate'y obsługujące poszczególne formaty
Działa za pomocą makr derive

Dodawanie serde

Dodaj serde z funkcją derive, a także crate obsługujący format, na przykład serde_json. Ta czynność modyfikuje Cargo.toml.

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

Implementowanie traitów za pomocą derive

Oznacz strukturę atrybutem #[derive(Serialize, Deserialize)], aby można było ją konwertować. Każde pole musi być serializowalne.

use serde::{Serialize, Deserialize};

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

Serialize oznacza konwersję do formatu

Serialize przekształca wartość w bajty lub tekst w określonym formacie. Struktura nie wie, jaki to format — decyduje o nim crate formatu.

Deserialize oznacza konwersję z formatu

Deserialize analizuje tekst lub bajty i z powrotem tworzy wartość Rust, sprawdzając po drodze typy i wymagane pola.

Ręczne modelowanie serializacji

Aby lepiej zrozumieć działanie, zobaczmy ręcznie napisany serializer dla prostej struktury. serde generuje taki kod za Ciebie.

struct User { id: u32, name: String }

fn serialize(u: &User) -> String {
    format!("id={};name={}", u.id, u.name)
}

fn main() {
    let u = User { id: 7, name: "Alice".to_string() };
    println!("{}", serialize(&u));
}

Ręczne modelowanie deserializacji

A oto odwrotna operacja: analiza tekstu i ponowne utworzenie struktury. Wygenerowany przez serde kod robi to niezawodnie w różnych formatach.

struct User { id: u32, name: String }

fn deserialize(s: &str) -> User {
    let parts: Vec<&str> = s.split(',').collect();
    let id = parts[0].parse().unwrap();
    let name = parts[1].to_string();
    User { id, name }
}

fn main() {
    let u = deserialize("42,Bob");
    println!("{} {}", u.id, u.name);
}

Derive dla enumów

Enumy również działają. Domyślnie każdy wariant jest serializowany przy użyciu swojej nazwy, a zawarte w nim dane są zagnieżdżane.

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
enum Shape {
    Circle { radius: f64 },
    Square { side: f64 },
}

Zagnieżdżone struktury

serde automatycznie rekurencyjnie przetwarza dane. Struktura zawierająca inne struktury z derive lub elementy Vec działa bez dodatkowej konfiguracji.

use serde::{Serialize, Deserialize};

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

#[derive(Serialize, Deserialize)]
struct Person {
    name: String,
    addresses: Vec<Address>,
}

Tylko Serialize lub tylko Deserialize

Możesz wyprowadzić tylko jeden trait. Typ odpowiedzi API może implementować wyłącznie Serialize, a typ przychodzącego żądania — wyłącznie Deserialize.

use serde::Serialize;

#[derive(Serialize)]
struct ApiResponse {
    status: u16,
    message: String,
}

Wymagania dla derive

Typ każdego pola musi implementować wyprowadzany trait. Typy standardowe i kolekcje już go implementują, natomiast typy niestandardowe wymagają własnego derive.

use serde::Serialize;

#[derive(Serialize)]
struct Inner { x: i32 }

#[derive(Serialize)]
struct Outer { inner: Inner }

Szybkie sprawdzenie

Sprawdź, czy rozumiesz serializację i deserializację.

Podsumowanie

Poznałeś podstawy serde:

serde to niezależny od formatu framework do serializacji i deserializacji
#[derive(Serialize, Deserialize)] generuje kod konwersji
Działa ze strukturami, enumami i typami zagnieżdżonymi
W razie potrzeby możesz wyprowadzić tylko jeden kierunek konwersji

Następnie: praca z JSON-em za pomocą serde_json.

Często zadawane pytania

Czy lekcja „Serializacja i deserializacja” jest bezpłatna?

Tak — pełny tekst „Serializacja i deserializacja” 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 „Serializacja i deserializacja”?

Makra derive Ć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 1 z 4.

Ile czasu zajmuje lekcja „Serializacja i deserializacja”?

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.

Wszystkie lekcje w tym kursie

Serializacja i deserializacja
Praca z JSON
Własna serializacja
Inne formaty

← Powrót do Learn Rust Coding