Serialisera och deserialisera
Derive-makron
Serialisera och deserialisera är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad är Serde?
Serde (SERialize/DEserialize) är Rusts ramverk för att konvertera datastrukturer till och från format som JSON, YAML med flera.
- Formatoberoende kärna samt format-crates
- Drivs av derive-makron
Lägga till serde
Lägg till serde med funktionen derive samt en format-crate som serde_json. Detta redigerar Cargo.toml.
[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"Härleda traiten
Annotera en struct med #[derive(Serialize, Deserialize)] för att göra den konverterbar. Varje fält måste själv kunna serialiseras.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct User {
id: u32,
name: String,
}Serialize betyder till ett format
Serialize omvandlar ett värde till byte eller text i ett visst format. Structen känner inte till vilket format det är; det avgörs av formatets crate.
Deserialize betyder från ett format
Deserialize tolkar text eller byte tillbaka till ett Rust-värde och validerar samtidigt typer och obligatoriska fält.
Modellera serialisering manuellt
För att bygga upp förståelsen visas här en handskriven serialiserare för en enkel struct. serde genererar kod som denna åt dig.
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));
}Modellera deserialisering manuellt
Här är motsatsen: text tolkas tillbaka till structen. serdes genererade kod gör detta robust för olika format.
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);
}Härleda för enum-typer
Enum-typer fungerar också. Som standard serialiseras varje variant med sitt namn och eventuella data bäddas in.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
enum Shape {
Circle { radius: f64 },
Square { side: f64 },
}Kapslade strukturer
serde går automatiskt igenom kapslade strukturer. En struct som innehåller andra härledda structar eller Vec-värden fungerar direkt.
use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct Address { city: String }
#[derive(Serialize, Deserialize)]
struct Person {
name: String,
addresses: Vec<Address>,
}Endast Serialize eller endast Deserialize
Du kan härleda endast ett av traiten. En typ för ett API-svar kan vara endast Serialize, medan en typ för en inkommande begäran kan vara endast Deserialize.
use serde::Serialize;
#[derive(Serialize)]
struct ApiResponse {
status: u16,
message: String,
}Krav för härledning
Varje fälttyp måste implementera det trait som du härleder. Standardtyper och samlingar gör redan det; anpassade typer behöver en egen härledning.
use serde::Serialize;
#[derive(Serialize)]
struct Inner { x: i32 }
#[derive(Serialize)]
struct Outer { inner: Inner }Snabbtest
Testa dina kunskaper om serialisering och deserialisering.
Sammanfattning
Du har lärt dig grunderna i serde:
- serde är ett formatoberoende ramverk för serialisering och deserialisering
#[derive(Serialize, Deserialize)]genererar konverteringskoden- Fungerar med structar, enum-typer och kapslade typer
- Du kan vid behov härleda endast den ena riktningen
Nästa steg: arbeta med JSON via serde_json.
Lär dig Rust med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 39
- Lektioner
- 144
Vanliga frågor
Är lektionen ”Serialisera och deserialisera” gratis?
Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”Serialisera och deserialisera”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.
Vad lär jag mig i ”Serialisera och deserialisera”?
Derive-makron Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?
Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Serialisera och deserialisera”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?
Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Serialisera och deserialisera
- Arbeta med JSON
- Anpassad serialisering
- Andra format