Rust JSON格式化显示库display_json的使用,提供简洁易读的JSON数据展示与美化功能

display_json

display_json 是一个 Rust 库,它允许你轻松地将 serde 的功能与 Rust 标准库中的 std::fmt::{Display, Debug}std::str::FromStr 特性集成,通过自定义派生宏来实现。

功能特性

  • 通过 Rust 标准库的 fmt 特性将对象序列化为 JSON
    • DisplayAsJson: 实现 Display 特性
    • DebugAsJson: 实现 Debug 特性
    • 美化 JSON 输出
    • 混合使用 Display 和 Debug
  • 通过 Rust 标准库的 FromStr 特性从 JSON 反序列化对象
    • FromStrAsJson: 实现 FromStr 特性

安装

在项目目录中运行以下 Cargo 命令:

cargo add display_json

或在 Cargo.toml 中添加:

display_json = "0.2.1"

使用示例

使用 DisplayAsJson 序列化为 JSON

use serde::Serialize;
use display_json::DisplayAsJson;

#[derive(Serialize, DisplayAsJson)]
struct Foo {
    bar: String,
    baz: i32,
    bat: bool,
}

let f = Foo {
    bar: "bar".to_owned(),
    baz: 0,
    bat: true,
};

assert_eq!(f.to_string(), r#"{"bar":"bar","baz":0,"bat":true}"#);

使用 DebugAsJson 序列化为 JSON

use serde::Serialize;
use display_json::DebugAsJson;

#[derive(Serialize, DebugAsJson)]
struct Foo {
    bar: String,
    baz: i32,
    bat: bool,
}

let f = Foo {
    bar: "bar".to_owned(),
    baz: 0,
    bat: true,
};

let f_ser = format!("{:?}", f);
assert_eq!(f_ser, r#"{"bar":"bar","baz":0,"bat":true}"#);

美化 JSON 输出

use serde::Serialize;
use display_json::{DisplayAsJsonPretty, DebugAsJsonPretty};

#[derive(Serialize, DisplayAsJsonPretty, DebugAsJsonPretty)]
struct Foo {
    bar: String,
    baz: i32,
    bat: bool,
}

let f = Foo {
    bar: "bar".to_owned(),
    baz: 0,
    bat: true,
};

let result = r#"{
  "bar": "bar",
  "baz": 0,
  "bat": true
}"#;

let f_ser = format!("{}", f);
let f_ser_dbg = format!("{:?}", f);

assert_eq!(f_ser, result);
assert_eq!(f_ser_dbg, result);

使用 FromStrAsJson 从 JSON 反序列化

use serde::Deserialize;
use display_json::FromStrAsJson;
use std::str::FromStr;

#[derive(Deserialize, FromStrAsJson, PartialEq, Debug)]
struct Foo {
    bar: String,
    baz: i32,
    bat: bool,
}

let f_as_json = r#"{"bar":"bar","baz":0,"bat":true}"#;

let f = Foo {
    bar: "bar".to_owned(),
    baz: 0,
    bat: true,
};

assert_eq!(Foo::from_str(f_as_json).unwrap(), f);

完整示例

以下是 display_json 库的完整使用示例:

use serde::{Serialize, Deserialize};
use display_json::{DisplayAsJson, DebugAsJsonPretty, FromStrAsJson};
use std::str::FromStr;

// 定义数据结构
#[derive(Serialize, Deserialize, DisplayAsJson, DebugAsJsonPretty, FromStrAsJson, PartialEq, Debug)]
struct Person {
    name: String,
    age: u32,
    is_student: bool,
    hobbies: Vec<String>,
}

fn main() {
    // 创建实例
    let person = Person {
        name: "Alice".to_string(),
        age: 25,
        is_student: true,
        hobbies: vec!["reading".to_string(), "swimming".to_string()],
    };

    // 使用 DisplayAsJson 输出紧凑 JSON
    println!("紧凑 JSON:");
    println!("{}", person);
    
    // 使用 DebugAsJsonPretty 输出美化 JSON
    println!("\n美化 JSON:");
    println!("{:?}", person);

    // 从 JSON 字符串反序列化
    let json_str = r#"{"name":"Bob","age":30,"is_student":false,"hobbies":["coding","gaming"]}"#;
    let bob: Person = Person::from_str(json_str).unwrap();
    
    println!("\n反序列化后的对象:");
    println!("{:?}", bob);
}

使用场景

  • 创建易于解析的日志消息
  • 为 HTTP 请求序列化数据
  • 需要实现 FromStr 特性但只想反序列化 JSON 字符串的情况
  • 需要美化的 JSON 输出用于调试

许可证

MIT 许可证


1 回复

Rust JSON格式化显示库display_json的使用指南

display_json是一个Rust库,专门用于将JSON数据格式化为更易读的展示形式。它提供了简洁的API来美化和自定义JSON的输出格式。

主要特性

  • 自动缩进和对齐JSON数据
  • 可配置的缩进大小
  • 语法高亮支持
  • 紧凑和展开两种显示模式
  • 轻量级且无额外依赖

安装

Cargo.toml中添加依赖:

[dependencies]
display_json = "0.1"

基本使用方法

简单格式化

use display_json::DisplayAsJson;
use serde_json::json;

fn main() {
    let data = json!({
        "name": "John Doe",
        "age": 30,
        "address": {
            "street": "123 Main St",
            "city": "New York"
        }
    });

    println!("{}", data.display_json());
}

输出结果:

{
  "name": "John Doe",
  "age": 30,
  "address": {
    "street": "123 Main St",
    "city": "New York"
  }
}

自定义缩进

use display_json::DisplayAsJsonPretty;

let data = json!({"a": 1, "b": 2});
println!("{}", data.display_json_pretty().indent(2));

紧凑模式

use display_json::DisplayAsJsonCompact;

let data = json!({"a": 1, "b": 2});
println!("{}", data.display_json_compact());
// 输出: {"a":1,"b":2}

高级用法

自定义格式化选项

use display_json::{JsonFormat, JsonFormatBuilder};

let format = JsonFormatBuilder::new()
    .indent(4)
    .array_newlines(true)
    .build();

let data = json!([1, 2, 3]);
println!("{}", data.display_json_with_format(&format));

处理错误

use display_json::DisplayAsJson;
use serde_json::{json, Value};

fn process_json(data: &Value) -> String {
    data.display_json().to_string()
}

let invalid data = "not a json".parse::<Value>().unwrap_err();
println!("Error: {}", invalid_data);

与Serde集成

display_json可以与Serde无缝集成,直接格式化实现了Serialize的类型:

use serde::Serialize;

#[derive(Serialize)]
struct Person {
    name: String,
    age: u8,
}

let person = Person {
    name: "Alice".to_string(),
    age: 25,
};

println!("{}", person.display_json());

性能考虑

对于大型JSON数据,建议使用display_json_compact以获得更好的性能,或者考虑流式处理。

display_json是一个简单但强大的工具,特别适合日志输出、调试信息和需要用户友好展示JSON数据的场景。

完整示例代码

// 引入必要的模块
use display_json::{DisplayAsJson, DisplayAsJsonCompact, DisplayAsJsonPretty};
use serde::Serialize;
use serde_json::{json, Value};

// 自定义数据结构
#[derive(Serialize)]
struct User {
    id: u32,
    username: String,
    is_active: bool,
    permissions: Vec<String>,
}

fn main() {
    // 示例1:基本JSON格式化
    let json_data = json!({
        "name": "张三",
        "age": 28,
        "skills": ["Rust", "Python", "JavaScript"],
        "contact": {
            "email": "zhangsan@example.com",
            "phone": "13800138000"
        }
    });
    
    println!("基本格式化输出:");
    println!("{}\n", json_data.display_json());

    // 示例2:自定义缩进
    println!("自定义缩进(2个空格):");
    println!("{}\n", json_data.display_json_pretty().indent(2));

    // 示例3:紧凑模式
    println!("紧凑模式输出:");
    println!("{}\n", json_data.display_json_compact());

    // 示例4:自定义格式化选项
    let custom_format = display_json::JsonFormatBuilder::new()
        .indent(4)
        .array_newlines(true)
        .build();
    
    println!("自定义格式化选项:");
    println!("{}\n", json_data.display_json_with_format(&custom_format));

    // 示例5:处理自定义结构体
    let user = User {
        id: 1001,
        username: "张三".to_string(),
        is_active: true,
        permissions: vec!["read".to_string(), "write".to_string()],
    };
    
    println!("自定义结构体格式化:");
    println!("{}\n", user.display_json());

    // 示例6:错误处理
    match "invalid json".parse::<Value>() {
        Ok(data) => println!("{}", data.display_json()),
        Err(e) => println!("JSON解析错误: {}", e),
    }
}

输出示例:

基本格式化输出:
{
  "name": "张三",
  "age": 28,
  "skills": [
    "Rust",
    "Python",
    "JavaScript"
  ],
  "contact": {
    "email": "zhangsan@example.com",
    "phone": "13800138000"
  }
}

自定义缩进(2个空格):
{
  "name": "张三",
  "age": 28,
  "skills": [
    "Rust",
    "Python",
    "JavaScript"
  ],
  "contact": {
    "email": "zhangsan@example.com",
    "phone": "13800138000"
  }
}

紧凑模式输出:
{"name":"张三","age":28,"skills":["Rust","Python","JavaScript"],"contact":{"email":"zhangsan@example.com","phone":"13800138000"}}

自定义格式化选项:
{
    "name": "张三",
    "age": 28,
    "skills": [
        "Rust",
        "Python",
        "JavaScript"
    ],
    "contact": {
        "email": "zhangsan@example.com",
        "phone": "13800138000"
    }
}

自定义结构体格式化:
{
  "id": 1001,
  "username": "张三",
  "is_active": true,
  "permissions": [
    "read",
    "write"
  ]
}

JSON解析错误: expected value at line 1 column 1
回到顶部