Rust插件库jmt的使用：高效处理JSON、Markdown和TOML数据转换与解析

jmt是一个高效的Rust库，专门用于处理JSON、Markdown和TOML格式数据的转换与解析。它提供了简洁的API和强大的功能，特别适合需要在不同数据格式之间进行转换的开发场景。

主要功能

• JSON解析与序列化
• Markdown解析与生成
• TOML解析与序列化
• 三种格式之间的相互转换

安装方法

在Cargo.toml中添加依赖：

[dependencies]
jmt = "0.3"

基本使用方法

JSON处理

use jmt::json;

// 解析JSON字符串
let json_str = r#"{"name": "Alice", "age": 30}"#;
let parsed = json::parse(json_str).unwrap();

// 访问JSON数据
println!("Name: {}", parsed["name"].as_str().unwrap());
println!("Age: {}", parsed["age"].as_u64().unwrap());

// 创建新的JSON对象
let mut new_json = json::JsonObject::new();
new_json.insert("city".to_string(), json::JsonValue::String("New York".to_string()));

// 序列化为字符串
let serialized = json::stringify(&new_json);
println!("{}", serialized);

Markdown处理

use jmt::markdown;

// 解析Markdown
let md_text = "# Heading\n\nThis is a paragraph.";
let parsed_md = markdown::parse(md_text);

// 转换为HTML
let html = markdown::to_html(&parsed_md);
println!("{}", html);

// 从HTML生成Markdown
let html_input = "<h1>Title</h1><p>Content</p>";
let md_output = markdown::from_html(html_input);
println!("{}", md_output);

TOML处理

use jmt::toml;

// 解析TOML字符串
let toml_str = r#"
title = "Example"
[owner]
name = "Bob"
"#;
let parsed_toml = toml::parse(toml_str).unwrap();

// 访问TOML数据
println!("Title: {}", parsed_toml["title"].as_str().unwrap());
println!("Owner: {}", parsed_toml["owner"]["name"].as_str().unwrap());

// 创建新的TOML数据
let mut new_toml = toml::TomlTable::new();
new_toml.insert("version".to_string(), toml::TomlValue::String("1.0".to_string()));

// 序列化为字符串
let serialized_toml = toml::to_string(&new_toml);
println!("{}", serialized_toml);

格式转换示例

JSON转TOML

use jmt::{json, toml};

let json_str = r#"{"title": " Example", "count": 42}"#;
let json_value = json::parse(json_str).unwrap();
let toml_value = toml::from_json(&json_value);
println!("{}", toml::to_string(&toml_value));

Markdown转JSON

use jmt::{markdown, json};

let md_text = "# Document\n\n- Item 1\n- Item 2";
let parsed_md = markdown::parse(md_text);
let json_value = json::from_markdown(&parsed_md);
println!("{}", json::stringify(&json_value));

TOML转Markdown

use jmt::{toml, markdown};

let toml_str = r#"
title = "Report"
content = "This is a sample report"
"#;
let parsed_toml = toml::parse(toml_str).unwrap();
let md_output = markdown::from_toml(&parsed_toml);
println!("{}", md_output);

高级功能

自定义转换选项

use jmt::{json, toml, ConvertOptions};

let json_str = r#"{"user": {"name": "Alice", "active": true}}"#;
let json_value = json::parse(json_str).unwrap();

let options = ConvertOptions {
    flatten_structures: true,
    skip_null_values: true,
    // 其他选项...
};

let toml_value = toml::from_json_with_options(&json_value, &options);
println!("{}", toml::to_string(&toml_value));

流式处理大文件

use jmt::json;
use std::fs::File;

// 流式处理大JSON文件
let file = File::open("large_data.json").unwrap();
let mut stream_parser = json::StreamParser::new(file);

while let Some(item) = stream_parser.next() {
    match item {
        Ok(value) => {
            // 处理每个JSON值
            println!("Processed: {}", value["id"]);
        },
        Err(e) => eprintln!("Error: {}", e),
    }
}

完整示例代码

下面是一个综合使用jmt库处理多种数据格式转换的完整示例：

use jmt::{json, markdown, toml};

fn main() {
    // 示例1: JSON处理
    let json_data = r#"{
        "name": "John Doe",
        "age": 32,
        "address": {
            "street": "123 Main St",
            "city": "New York"
        }
    }"#;
    
    let parsed_json = json::parse(json_data).unwrap();
    println!("JSON解析结果:");
    println!("Name: {}", parsed_json["name"].as_str().unwrap());
    println!("City: {}", parsed_json["address"]["city"].as_str().unwrap());
    
    // 示例2: Markdown处理
    let md_content = "# Personal Profile\n\n- Name: John Doe\n- Age: 32";
    let parsed_md = markdown::parse(md_content);
    let html_output = markdown::to_html(&parsed_md);
    println!("\nMarkdown转HTML结果:");
    println!("{}", html_output);
    
    // 示例3: TOML处理
    let toml_data = r#"
        title = "Configuration"
        [server]
        port = 8080
        enabled = true
    "#;
    let parsed_toml = toml::parse(toml_data).unwrap();
    println!("\nTOML解析结果:");
    println!("Server port: {}", parsed_toml["server"]["port"].as_i64().unwrap());
    
    // 示例4: 格式转换(JSON转TOML)
    let json_config = r#"{
        "database": {
            "host": "localhost",
            "port": 5432
        }
    }"#;
    let json_value = json::parse(json_config).unwrap();
    let toml_config = toml::from_json(&json_value);
    println!("\nJSON转TOML结果:");
    println!("{}", toml::to_string(&toml_config));
    
    // 示例5: 自定义转换选项
    let options = jmt::ConvertOptions {
        flatten_structures: true,
        skip_null_values: true,
    };
    let toml_custom = toml::from_json_with_options(&json_value, &options);
    println!("\n使用自定义选项转换结果:");
    println!("{}", toml::to_string(&toml_custom));
}

性能提示

1. 对于大型文件，使用流式处理API
2. 重复使用的解析器实例可以缓存以提高性能
3. 在不需要完整解析时，考虑使用轻量级的查询方法

jmt库通过提供统一的API和高效的实现，简化了Rust中处理JSON、Markdown和TOML数据的工作流程。