CodeBlanks Logo Icon CodeBlanks
Login Register

Serialize and Deserialize

Learn serde's core Serialize and Deserialize traits.

Serialize and Deserialize

serde is the standard way to convert Rust data structures to formats like JSON, TOML and YAML (serialization) and read them back (deserialization). It's built on two traits: Serialize and Deserialize. Formats are separate crates: serde_json, toml, serde_yaml.

// Cargo.toml
// serde = { version = "1", features = ["derive"] }
// serde_json = "1"
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct Kitap {
    ad: String,
    yil: u16,
}
// {"ad":"Dune","yil":1965}

Serializing by hand

Since there are no external crates in the exercises, we'll write serialization by hand; this is essentially what the derive generates behind the scenes. Text fields go in quotes, numbers are written as they are:

impl Kitap {
    fn json(&self) -> String {
        format!("{{\"ad\":\"{}\",\"yil\":{}}}", self.ad, self.yil)
    }
}

Inside format!, braces are written as {{ and }}, quotes as \". Real serde also escapes special characters in the text.

Practice Book to JSON

Write the json method above for Kitap { ad: String, yil: u16 }. Print the result for Kitap { ad: "Dune".into(), yil: 1965 }.

Starter code

main.rs
fn main() {
    // buraya yaz
}

Sample solution

main.rs
struct Kitap {
    ad: String,
    yil: u16,
}

impl Kitap {
    fn json(&self) -> String {
        format!("{{\"ad\":\"{}\",\"yil\":{}}}", self.ad, self.yil)
    }
}

fn main() {
    let k = Kitap { ad: "Dune".into(), yil: 1965 };
    println!("{}", k.json());
}

Expected output

{"ad":"Dune","yil":1965}

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What is the benefit of serde separating the data structure from the format?

  • It only supports JSON
  • The same struct can be used with JSON, TOML or another format unchanged Correct answer
  • Smaller files
  • It provides encryption

Explanation: The struct only says "how to walk it"; the format crate turns that into text.

2 Writing trait

Question 
#[derive(____, Deserialize)]
struct Kitap {
    ad: String,
}
Answer 
#[derive(Serialize, Deserialize)]
struct Kitap {
    ad: String,
}

Explanation: Serialize makes it possible to write the value to a format.

3 Concept and meaning

Term Meaning
Serialize Data → format
Deserialize Format → data
serde_json JSON format
{{ and }} (format!) Escaped braces

All lessons in Intermediate

1 Traits

  1. What is a trait?
  2. Implementing a trait
  3. Default methods
  4. Traits as parameters
  5. Multiple traits
  6. Summary - Traits

2 Generics

  1. Generic function
  2. Generic struct
  3. Generic method
  4. Generic enum
  5. Turbofish
  6. Summary - Generics

3 Lifetimes

  1. What is a lifetime?
  2. Explicit lifetimes
  3. Function lifetimes
  4. Struct lifetimes
  5. Elision rules
  6. Summary - Lifetimes

4 Trait bounds

  1. Trait bound
  2. Multiple bounds
  3. where clause
  4. impl Trait
  5. dyn Trait
  6. Summary - Trait bounds

5 Project: Library crate

  1. Crate skeleton
  2. Public API
  3. Generic structure
  4. Searching with traits
  5. Test infrastructure

6 Smart pointers

  1. Box<T>
  2. Rc<T>
  3. Arc<T>
  4. Box and recursion
  5. Deref
  6. Summary - Smart pointers

7 Interior mutability

  1. RefCell<T>
  2. borrow and borrow_mut
  3. Rc<RefCell<T>>
  4. Cell<T>
  5. External mutation
  6. Summary - Interior mutability

8 Closures

  1. Closure syntax
  2. Type inference
  3. Capturing
  4. Fn, FnMut, FnOnce
  5. Closure and iterator
  6. Summary - Closures

9 Iterators

  1. Iterator trait
  2. next method
  3. map and filter
  4. collect
  5. Lazy evaluation
  6. Summary - Iterators

10 Collections

  1. HashMap
  2. BTreeMap
  3. HashSet
  4. Entry API
  5. Iterating collections
  6. Summary - Collections

11 Project: CLI app

  1. Command skeleton
  2. State with Vec
  3. Result and commands
  4. Processing with iterators
  5. Error and exit

12 Advanced error handling

  1. Error trait
  2. thiserror
  3. anyhow
  4. Error conversion
  5. Adding context
  6. Summary - Advanced error handling

13 Modules

  1. Defining modules
  2. use
  3. pub
  4. File modules
  5. crate and super
  6. Summary - Modules

14 Crates and packages

  1. Binary and library crate
  2. Cargo.toml
  3. Versions
  4. Features
  5. Workspace
  6. Summary - Crates and packages

15 Testing

  1. Unit test
  2. assert! macro
  3. Integration test
  4. Doc test
  5. should_panic
  6. Summary - Testing

16 File I/O

  1. Reading a file
  2. Writing a file
  3. Append mode
  4. BufReader
  5. Directory operations
  6. Summary - File I/O

17 CLI with clap

  1. Introducing clap
  2. Derive macro
  3. Positional argument
  4. Option flag
  5. Subcommand
  6. Summary - CLI with clap

18 Serialization with serde

  1. Serialize and Deserialize
  2. derive
  3. JSON
  4. Field rename
  5. Option and default
  6. Summary - Serde

19 Project: Blog API

  1. Model skeleton
  2. Reading JSON
  3. Error handling
  4. Listing records
  5. CLI

20 Intermediate final

  1. Generic stack
  2. Shapes with traits
  3. Iterator adapter
  4. JSON config reader