nugine-rust-utils：提升Rust开发效率的实用工具集合

简介

nugine-rust-utils 是一个Rust实用工具库，旨在提供一系列常用功能的便捷实现，帮助开发者提高日常编码效率。这个库包含字符串处理、集合操作、错误处理、并发工具等多个方面的实用功能。

安装

在Cargo.toml中添加依赖：

[dependencies]
nugine-rust-utils = "0.1"  # 请使用最新版本号

主要功能及使用示例

1. 字符串处理工具

use nugine_rust_utils::string_utils;

// 快速字符串连接
let parts = vec!["Hello", " ", "world", "!"];
let joined = string_utils::fast_join(&parts);
println!("{}", joined); // 输出: Hello world!

// 字符串分割保留空项
let text = "a,,b,c";
let parts = string_utils::split_keep_empty(text, ',');
assert_eq!(parts, vec!["a", "", "b", "c"]);

2. 集合操作工具

use nugine_rust_utils::collection_utils;

let nums = vec![1, 2, 3, 4, 5];

// 快速查找最大值及其索引
let (max_val, max_idx) = collection_utils::find_max(&nums).unwrap();
println!("Max value: {} at index: {}", max_val, max_idx);

// 集合分块处理
let chunks = collection_utils::chunked(&nums, 2);
assert_eq!(chunks, vec![vec![1, 2], vec![3, 4], vec![5]]);

3. 错误处理工具

use nugine_rust_utils::error_utils;
use std::io::{self, ErrorKind};

// 快速构建错误
let err = error_utils::quick_err("Something went wrong", io::ErrorKind::Other);
println!("Error: {:?}", err);

// 错误链式处理
fn fallible_op() -> Result<(), Box<dyn std::error::Error>> {
    Err("original error".into())
}

let result = error_utils::with_context(fallible_op, "additional context");
println!("{:?}", result); // 包含原始错误和附加上下文

4. 并发工具

use nugine_rust_utils::concurrency_utils;
use std::time::Duration;

// 带超时的异步任务
async fn long_running_task() -> u32 {
    tokio::time::sleep(Duration::from_secs(2).await);
    42
}

#[tokio::main]
async fn main() {
    match concurrency_utils::timeout(Duration::from_secs(1), long_running_task()).await {
        Ok(result) => println!("Got result: {}", result),
        Err(_) => println!("Task timed out"),
    }
}

5. 日志和调试工具

use nugine_rust_utils::debug_utils;

// 快速测量代码执行时间
let result = debug_utils::measure_time(|| {
    // 模拟耗时操作
    std::thread::sleep(std::time::Duration::from_millis(100));
    42
});
println!("Result: {}, took {} ms", result.0, result.1.as_millis());

// 漂亮打印调试信息
let complex_data = vec![
    vec![1, 2, 3],
    vec![4, 5, 6],
    vec![7, 8, 9]
];
debug_utils::pretty_print(&complex_data);

高级用法

自定义配置

许多工具函数允许通过配置参数自定义行为：

use nugine_rust_utils::string_utils::JoinOptions;

let options = JoinOptions {
    separator: " | ",
    prefix: "[",
    suffix: "]",
    skip_empty: true,
};

let parts = vec!["a", "", "b", "c"];
let joined = string_utils::join_with_options(&parts, options);
println!("{}", joined); // 输出: [a | b | c]

扩展trait

nugine-rust-utils 为常见类型提供了扩展方法：

use nugine_rust_utils::extensions::VecExt;

let mut vec = vec![1, 2, 3, 4];
vec.remove_if(|&x| x % 2 == 0);
assert_eq!(vec, vec![1, 3]);

完整示例

下面是一个综合使用nugine-rust-utils多个功能的完整示例：

use nugine_rust_utils::{string_utils, collection_utils, error_utils, debug_utils};
use std::io::ErrorKind;

fn main() {
    // 1. 字符串处理示例
    let names = vec!["Alice", "Bob", "Charlie"];
    let joined_names = string_utils::fast_join(&names);
    println!("Joined names: {}", joined_names);
    
    // 2. 集合操作示例
    let numbers = vec![10, 5, 20, 15];
    if let Some((max_val, max_idx)) = collection_utils::find_max(&numbers) {
        println!("Max value {} at index {}", max_val, max_idx);
    }
    
    // 3. 错误处理示例
    let err = error_utils::quick_err("Custom error", ErrorKind::Other);
    println!("Created error: {:?}", err);
    
    // 4. 调试工具示例
    let (result, duration) = debug_utils::measure_time(|| {
        let mut sum = 0;
        for i in 1..=1000 {
            sum += i;
        }
        sum
    });
    println!("Sum: {}, took {:?}", result, duration);
    
    // 5. 使用扩展方法
    use nugine_rust_utils::extensions::VecExt;
    let mut data = vec![1, 2, 3, 4, 5, 6];
    data.remove_if(|&x| x % 2 == 1);
    println!("After removing odds: {:?}", data);
}

#[tokio::main]
async fn async_example() {
    use nugine_rust_utils::concurrency_utils;
    use std::time::Duration;
    
    async fn task() -> &'static str {
        tokio::time::sleep(Duration::from_millis(500)).await;
        "Task completed"
    }
    
    match concurrency_utils::timeout(Duration::from_millis(300), task()).await {
        Ok(res) => println!("Success: {}", res),
        Err(_) => println!("Task timed out"),
    }
}

最佳实践

1. 只导入需要的模块而不是整个库，以减少编译时间
2. 对于性能敏感的代码，先测试工具函数的性能表现
3. 查看文档了解每个函数的边缘情况处理方式

总结

nugine-rust-utils 提供了一系列经过实战检验的实用工具，可以显著减少样板代码，让开发者更专注于业务逻辑。它的模块化设计使得可以轻松地只使用需要的部分功能，而不会引入不必要的依赖。