CodeBlanks Logo Icon CodeBlanks
Login Register

Field rename

Rename fields with #[serde(rename)].

Field renaming

Rust fields use snake_case, while many JSON APIs use camelCase. serde attributes map the names without changing the code:

#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct Kullanici {
    ad: String,
    kayit_tarihi: String,          // "kayitTarihi"
    #[serde(rename = "e-posta")]
    eposta: String,                // "e-posta"
}

rename_all applies to all fields, rename to a single one. Options: camelCase, PascalCase, kebab-case, SCREAMING_SNAKE_CASE.

Writing the conversion by hand

The conversion that rename_all = "camelCase" does is simple: drop the underscore and uppercase the next letter:

fn camel(s: &str) -> String {
    let mut sonuc = String::new();
    let mut buyut = false;
    for c in s.chars() {
        if c == '_' {
            buyut = true;
        } else if buyut {
            sonuc.extend(c.to_uppercase());
            buyut = false;
        } else {
            sonuc.push(c);
        }
    }
    sonuc
}

Practice camelCase conversion

Write the camel function above. Print the results for "kayit_tarihi", "ad" and "son_giris_zamani" separated by spaces.

Starter code

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

Sample solution

main.rs
fn camel(s: &str) -> String {
    let mut sonuc = String::new();
    let mut buyut = false;
    for c in s.chars() {
        if c == '_' {
            buyut = true;
        } else if buyut {
            sonuc.extend(c.to_uppercase());
            buyut = false;
        } else {
            sonuc.push(c);
        }
    }
    sonuc
}

fn main() {
    println!("{} {} {}", camel("kayit_tarihi"), camel("ad"), camel("son_giris_zamani"));
}

Expected output

kayitTarihi ad sonGirisZamani

Questions and answers

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

1 What is <code>#[serde(alias = "name")]</code> for?

  • Produces two names when writing
  • It doesn't compile
  • Accepts an extra name when reading; uses the real name when writing Correct answer
  • Hides the field

Explanation: It's handy for reading both old and new JSON formats at the same time.

2 Rename all

Question 
#[serde(____ = "camelCase")]
struct Kullanici {
    kayit_tarihi: String,
}
Answer 
#[serde(rename_all = "camelCase")]
struct Kullanici {
    kayit_tarihi: String,
}

Explanation: rename_all applies a naming rule to all fields.

3 Field and camelCase JSON name

Term Meaning
ad ad
kayit_tarihi kayitTarihi
son_giris_zamani sonGirisZamani
#[serde(rename = "e-posta")] e-posta

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