// 示例代码
let mut buf = String::new();

{
    let mut obj = write_json::object(&mut buf);
    obj.string("name", "Peter").number("favorite number", 92.0);
    obj.array("films")
        .string("Drowning By Numbers")
        .string("A Zed & Two Noughts");
    obj.null("suitcase");
}

assert_eq!(
    buf,
    r#"{"name":"Peter","favorite number":92,"films":["Drowning By Numbers","A Zed & Two Noughts"],"suitcase":null}"#
)

// 完整示例demo
use std::io::{self, Write};

fn main() -> io::Result<()> {
    // 创建一个字符串缓冲区来存储JSON数据
    let mut buf = String::new();
    
    // 开始构建JSON对象
    {
        // 创建JSON对象写入器
        let mut obj = write_json::object(&mut buf);
        
        // 添加字符串字段
        obj.string("name", "Alice");
        
        // 添加数字字段
        obj.number("age", 25.0);
        
        // 添加布尔字段
        obj.boolean("is_student", true);
        
        // 添加数组字段
        obj.array("hobbies")
            .string("reading")
            .string("swimming")
            .number(3.0); // 数组中可以混合类型
        
        // 添加嵌套对象
        {
            let mut address = obj.object("address");
            address.string("street", "123 Main St");
            address.string("city", "New York");
            address.string("zip", "10001");
        }
        
        // 添加null值
        obj.null("optional_field");
    }
    
    // 输出生成的JSON
    println!("Generated JSON:");
    println!("{}", buf);
    
    // 验证JSON格式是否正确
    assert!(serde_json::from_str::<serde_json::Value>(&buf).is_ok());
    
    Ok(())
}

// Cargo.toml依赖配置
// [dependencies]
// write-json = "0.1.4"
// serde_json = "1.0"  # 用于验证JSON格式

write-json是一个简单、无依赖、无特征、无宏的JSON序列化库。它提供了一个简洁的API来生成JSON数据，不需要复杂的配置或派生宏。

主要特性：

零依赖：不依赖任何其他库
简单API：直观的方法链式调用
类型安全：编译时类型检查
高性能：直接写入缓冲区，避免不必要的分配

使用方法：

创建一个字符串缓冲区
使用write_json::object()开始构建对象
使用链式方法添加各种类型的字段
自动处理JSON转义和格式化

支持的字段类型：

string(): 字符串值
number(): 数字值
boolean(): 布尔值
null(): null值
array(): 数组
object(): 嵌套对象

该库特别适合需要轻量级JSON生成而不想引入复杂依赖的场景。

sinazl 1楼作者

Rust JSON写入库write-json的使用指南

概述

write-json是一个轻量级、高性能的Rust库，专门用于JSON数据的生成和序列化。它提供了简洁直观的API，让开发者能够高效地创建和操作JSON数据结构。

主要特性

零拷贝序列化
类型安全的API设计
支持所有标准JSON数据类型
内存高效，性能优异
简洁的链式调用语法

安装方法

在Cargo.toml中添加依赖：

[dependencies]
write-json = "0.3"

基本使用方法

1. 创建简单JSON对象

use write_json::JsonWriter;

let json = JsonWriter::new_object()
    .string("name", "Alice")
    .number("age", 25)
    .bool("is_student", true)
    .null("nickname")
    .finish();

println!("{}", json);
// 输出: {"name":"Alice","age":25,"is_student":true,"nickname":null}

2. 创建嵌套JSON对象

use write_json::JsonWriter;

let json = JsonWriter::new_object()
    .string("name", "Bob")
    .object("address", |obj| {
        obj.string("street", "Main St")
           .string("city", "New York")
           .number("zip", 10001)
    })
    .finish();

println!("{}", json);
// 输出: {"name":"Bob","address":{"street":"Main St","city":"New York","zip":10001}}

3. 创建JSON数组

use write_json::JsonWriter;

let json = JsonWriter::new_array()
    .string("first")
    .number(42)
    .bool(true)
    .null()
    .finish();

println!("{}", json);
// 输出: ["first",42,true,null]

4. 复杂嵌套结构

use write_json::JsonWriter;

let json = JsonWriter::new_object()
    .string("project", "write-json")
    .array("contributors", |arr| {
        arr.object(|obj| {
            obj.string("name", "Alice")
               .string("role", "maintainer")
        })
        .object(|obj| {
            obj.string("name", "Bob")
               .string("role", "contributor")
        })
    })
    .finish();

println!("{}", json);
// 输出: {"project":"write-json","contributors":[{"name":"Alice","role":"maintainer"},{"name":"Bob","role":"contributor"}]}

高级用法

批量添加属性

use write_json::JsonWriter;

let mut writer = JsonWriter::new_object();
writer.string("name", "Charlie");
writer.number("score", 95.5);
writer.bool("passed", true);

let json = writer.finish();
println!("{}", json);

错误处理

use write_json::{JsonWriter, JsonError};

fn create_json() -> Result<String, JsonError> {
    let json = JsonWriter::new_object()
        .string("name", "David")?
        .number("age", 30)?
        .finish();
    Ok(json)
}

完整示例demo

// 完整示例：使用write-json库创建复杂的JSON数据结构
use write_json::{JsonWriter, JsonError};

fn main() -> Result<(), JsonError> {
    // 示例1：创建用户信息JSON对象
    println!("=== 示例1：简单用户信息 ===");
    let user_json = JsonWriter::new_object()
        .string("username", "john_doe")?          // 添加字符串字段
        .number("user_id", 12345)?               // 添加数字字段
        .bool("is_active", true)?                // 添加布尔字段
        .null("middle_name")?                    // 添加null值
        .finish();
    println!("{}\n", user_json);

    // 示例2：创建嵌套的地址信息
    println!("=== 示例2：嵌套地址信息 ===");
    let address_json = JsonWriter::new_object()
        .string("name", "John Doe")?
        .object("address", |obj| {               // 嵌套对象
            obj.string("street", "123 Main St")?
               .string("city", "San Francisco")?
               .string("state", "CA")?
               .number("zip_code", 94102)?
        })?
        .array("phone_numbers", |arr| {          // 嵌套数组
            arr.string("+1-555-0100")?
               .string("+1-555-0101")?
        })?
        .finish();
    println!("{}\n", address_json);

    // 示例3：复杂的企业数据结构
    println!("=== 示例3：企业数据 ===");
    let company_json = JsonWriter::new_object()
        .string("company_name", "Tech Corp")?
        .number("founded_year", 2010)?
        .array("departments", |arr| {
            arr.object(|obj| {
                obj.string("name", "Engineering")?
                   .array("employees", |emp_arr| {
                       emp_arr.object(|emp| {
                           emp.string("name", "Alice")?
                              .string("position", "Senior Developer")?
                              .number("salary", 95000)?
                       })?
                       .object(|emp| {
                           emp.string("name", "Bob")?
                              .string("position", "Junior Developer")?
                              .number("salary", 75000)?
                       })?
                   })?
            })?
            .object(|obj| {
                obj.string("name", "Marketing")?
                   .array("employees", |emp_arr| {
                       emp_arr.object(|emp| {
                           emp.string("name", "Carol")?
                              .string("position", "Marketing Manager")?
                              .number("salary", 85000)?
                       })?
                   })?
            })?
        })?
        .object("metadata", |meta| {
            meta.string("version", "1.0")?
                .bool("verified", true)?
                .array("tags", |tags| {
                    tags.string("technology")?
                        .string("startup")?
                        .string("SaaS")?
                })?
        })?
        .finish();
    println!("{}\n", company_json);

    // 示例4：错误处理示例
    println!("=== 示例4：错误处理 ===");
    match create_complex_json() {
        Ok(json) => println!("成功生成JSON: {}", json),
        Err(e) => eprintln!("生成JSON时出错: {:?}", e),
    }

    Ok(())
}

fn create_complex_json() -> Result<String, JsonError> {
    let json = JsonWriter::new_object()
        .string("project", "write-json-demo")?
        .number("version", 1.0)?
        .array("features", |arr| {
            arr.string("fast")?
               .string("safe")?
               .string("easy-to-use")?
        })?
        .object("author", |obj| {
            obj.string("name", "Developer")?
               .string("email", "dev@example.com")?
        })?
        .finish();
    Ok(json)
}

性能建议

对于大量数据，考虑重用JsonWriter实例
预分配足够的内存空间
使用try_系列方法进行错误处理以避免panic

注意事项

确保所有JSON键都是有效的UTF-8字符串
数值类型会自动转换为JSON number格式
使用null()方法显式添加null值

write-json库提供了简单而强大的JSON生成功能，适合各种规模的Rust项目使用。

Rust JSON写入库write-json的使用：高效便捷的JSON数据生成与序列化工具