Working with JSON in Rust: Parsing, Serialization, and Practical Examples

Introduction to JSON in Rust

JSON (JavaScript Object Notation) remains one of the most popular data exchange formats in web development, configuration files, and APIs. The Rust language, known for its performance and memory safety, provides powerful tools for working with JSON through the serde_json crate. In this article, we will thoroughly examine how to perform JSON parsing and serialization in Rust using modern approaches and best practices.

The serde library (Serialization/Deserialization framework) is the de facto standard for working with data formats in the Rust ecosystem. Combined with serde_json, it allows you to easily convert Rust structures to JSON and back.

Project Setup and Dependency Installation

To get started, create a new Cargo project and add the necessary dependencies to the Cargo.toml file:

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

The features = ["derive"] flag for the serde crate enables the #[derive(Serialize, Deserialize)] macros, which automatically generate code for serializing and deserializing structures.

Basics of JSON Parsing in Rust

Parsing a JSON String into a Dynamic Value

The simplest way to parse JSON is to use the serde_json::Value type, which represents a generic JSON value:

use serde_json::Value;

fn main() {    let data = r#"    {        "name": "Alexey",        "age": 30,        "is_student": false,        "hobbies": ["reading", "programming", "cycling"]    }"#;

    let parsed: Value = serde_json::from_str(data).expect("JSON parsing error");        println!("Name: {}", parsed["name"]);    println!("Age: {}", parsed["age"]);    println!("Student: {}", parsed["is_student"]);    println!("First hobby: {}", parsed["hobbies"][0]);}

The Value type is an enum that can contain Null, Bool, Number, String, Array, or Object. This is convenient for quick prototyping, but for production code it is better to use strongly typed structures.

Parsing JSON into Strongly Typed Structures

For safe data handling, define a structure that matches the JSON schema and use the serde macros:

use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]struct Person {    name: String,    age: u32,    is_student: bool,    hobbies: Vec<String>,}

fn main() {    let json_str = r#"    {        "name": "Maria",        "age": 25,        "is_student": true,        "hobbies": ["drawing", "music"]    }"#;

    let person: Person = serde_json::from_str(json_str)        .expect("Deserialization error");        println!("{:?}", person);    println!("{} is studying: {}", person.name, person.is_student);}

The advantage of this approach is that the compiler checks types at compile time, eliminating runtime errors related to incorrect field access.

Serializing Data to JSON

Converting Structures to a JSON String

Serialization is performed using the serde_json::to_string() function:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct Product {    id: u64,    name: String,    price: f64,    in_stock: bool,}

fn main() {    let product = Product {        id: 42,        name: "Laptop".to_string(),        price: 89999.99,        in_stock: true,    };

    let json_string = serde_json::to_string(&product)        .expect("Serialization error");        println!("JSON: {}", json_string);        // Pretty print with o