Rust序列化数据处理库serde_trim的使用，高效修剪与清理序列化数据中的空白字符

支持修剪的类型

• String
• Option<String>
• Vec<String>
• BTreeSet<String>
• HashSet<String>
• VecDeque<String>
• LinkedList<String>
• BinaryHeap<String>

支持多种标准集合类型，当前也支持非空修剪

支持的功能集合

• binaryheap_non_empty_string_trim
• binaryheap_string_trim
• btreeset_non_empty_string_trim
• btreeset_string_trim
• hashset_non_empty_string_trim
• hashset_string_trim
• inkedlist_non_empty_string_trim
• linkedlist_string_trim
• option_string_trim
• string_trim
• vec_non_empty_string_trim
• vec_string_trim
• vecdeque_non_empty_string_trim
• vecdeque_string_trim

如何使用

以下是内容中提供的示例代码：

use serde_derive::Deserialize;
use serde_trim::*;
use std::collections::*;

fn main() {
    // 示例1: 基本String修剪
    #[derive(Deserialize)]
    struct Foo {
        #[serde(deserialize_with = "string_trim")]
        name: String,
    }
    let json = r#"{"name":" "}"#;
    let foo = serde_json::from_str::<Foo>(json).unwrap();
    assert_eq!(foo.name, "");

    // 示例2: Option<String>修剪
    #[derive(Deserialize)]
    struct OptionFoo {
        #[serde(deserialize_with = "option_string_trim")]
        name: Option<String>,
    }
    let json = r#"{"name":" "}"#;
    let foo = serde_json::from_str::<OptionFoo>(json).unwrap();
    assert_eq!(foo.name, None);

    // 示例3: 带默认值的Option<String>修剪
    #[derive(Deserialize)]
    struct OptionBar {
        #[serde(default, deserialize_with = "option_string_trim")]
        name: Option<String>,
        addr: String,
    }
    let json = r#"{"addr":"ABC"}"#;
    let foo = serde_json::from_str::<OptionBar>(json).unwrap();
    assert_eq!(foo.name, None);
    assert_eq!(foo.addr, "ABC");

    // 示例4: Vec<String>修剪
    #[derive(Deserialize)]
    struct VecFoo {
        #[serde(deserialize_with = "vec_string_trim")]
        name: Vec<String>,
    }
    let json = r#"{"name":["   ","foo","b ar","hello ","  rust"]}"#;
    let foo = serde_json::from_str::<VecFoo>(json).unwrap();
    assert_eq!(foo.name, vec!["", "foo", "b ar", "hello", "rust"]);

    // 示例5: BTreeSet<String>修剪
    #[derive(Deserialize)]
    struct BTreeSetFoo {
        #[serde(deserialize_with = "btreeset_string_trim")]
        name: BTreeSet<String>,
    }
    let json = r#"{"name":["   ","foo","b ar","hello ","  rust"]}"#;
    let foo = serde_json::from_str::<BTreeSetFoo>(json).unwrap();
    let expected: BTreeSet<String> = BTreeSet::from_iter([
        "".into(),
        "foo".into(),
        "b ar".into(),
        "hello".into(),
        "rust".into(),
    ]);
    assert_eq!(foo.name, expected);

    // 示例6: HashSet<String>修剪
    #[derive(Deserialize)]
    struct HashSetFoo {
        #[serde(deserialize_with = "hashset_string_trim")]
        name: HashSet<String>,
    }
    let json = r#"{"name":["   ","foo","b ar","hello ","  rust"]}"#;
    let foo = serde_json::from_str::<HashSetFoo>(json).unwrap();
    let expected: HashSet<String> = HashSet::from_iter([
        "".into(),
        "foo".into(),
        "b ar".into(),
        "hello".into(),
        "rust".into(),
    ]);
    assert_eq!(foo.name, expected);

    // 示例7: VecDeque<String>修剪
    #[derive(Deserialize)]
    struct VecDequeFoo {
        #[serde(deserialize_with = "vecdeque_string_trim")]
        name: VecDeque<String>,
    }
    let json = r#"{"name":["   ","foo","b ar","hello ","  rust"]}"#;
    let foo = serde_json::from_str::<VecDequeFoo>(json).unwrap();
    assert_eq!(foo.name, vec!["", "foo", "b ar", "hello", "rust"]);

    // 示例8: LinkedList<String>修剪
    #[derive(Deserialize)]
    struct LinkedListFoo {
        #[serde(deserialize_with = "linkedlist_string_trim")]
        name: LinkedList<String>,
    }
    let json = r#"{"name":["   ","foo","b ar","hello ","  rust"]}"#;
    let foo = serde_json::from_str::<LinkedListFoo>(json).unwrap();
    assert_eq!(
        foo.name,
        LinkedList::from_iter([
            "".into(),
            "foo".into(),
            "b ar".into(),
            "hello".into(),
            "rust".into(),
        ])
    );

    // 示例9: BinaryHeap<String>修剪
    #[derive(Deserialize)]
    struct BinaryHeapFoo {
        #[serde(deserialize_with = "binaryheap_string_trim")]
        name: BinaryHeap<String>,
    }
    let json = r#"{"name":["   ","foo","b ar","hello ","  rust"]}"#;
    let foo = serde_json::from_str::<BinaryHeapFoo>(json).unwrap();
    assert_eq!(
        foo.name.into_vec(),
        vec!["rust", "hello", "b ar", "", "foo"]
    );
}

完整示例

以下是使用serde_trim的完整示例代码：

use serde::{Deserialize, Serialize};
use serde_trim::*;
use std::collections::*;

fn main() {
    // 示例1: 用户信息修剪
    #[derive(Debug, Deserialize, Serialize)]
    struct User {
        #[serde(deserialize_with = "string_trim")]
        username: String,
        #[serde(deserialize_with = "string_trim")]
        email: String,
    }

    let json = r#"{"username":"  john_doe  ","email":"  john@example.com  "}"#;
    let user: User = serde_json::from_str(json).unwrap();
    println!("修剪后的用户信息: {:?}", user); // 用户名和邮箱的空白已被修剪
    
    // 示例2: 用户资料修剪
    #[derive(Debug, Deserialize)]
    struct Profile {
        #[serde(deserialize_with = "option_string_trim")]
        bio: Option<String>,
        #[serde(deserialize_with = "option_string_trim")]
        website: Option<String>,
    }

    let json = r#"{"bio":"  This is my bio  ","website":"  "}"#;
    let profile: Profile = serde_json::from_str(json).unwrap();
    println!("修剪后的资料信息: {:?}", profile); // 空白website变为None
    
    // 示例3: 标签列表修剪
    #[derive(Debug, Deserialize)]
    struct Tags {
        #[serde(deserialize_with = "vec_string_trim")]
        items: Vec<String>,
    }

    let json = r#"{"items":["  rust  ","  serde ","  json ","  "],"}"#;
    let tags: Tags = serde_json::from_str(json).unwrap();
    println!("修剪后的标签: {:?}", tags); // 所有字符串项都被修剪
    
    // 示例4: 唯一单词集合修剪
    #[derive(Debug, Deserialize)]
    struct UniqueWords {
        #[serde(deserialize_with = "hashset_string_trim")]
        words: HashSet<String>,
    }

    let json = r#"{"words":["  hello ","  world ","  hello ","  rust  "]}"#;
    let unique_words: UniqueWords = serde_json::from_str(json).unwrap();
    println!("修剪后的唯一单词集合: {:?}", unique_words); // 修剪并去重
}

安装

在项目中添加以下依赖到Cargo.toml:

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

serde_trim提供了一种简单高效的方式来处理序列化数据中的空白字符，适用于各种常见的数据结构和集合类型，可以帮助开发者轻松实现数据清理和规范化。