Rust通用代码库codes-common使用指南

概述

codes-common是一个Rust通用代码库，提供了一系列高效开发工具和实用功能集，旨在提高Rust开发者的生产力。它包含了常用的数据结构、算法、工具函数和开发辅助功能。

主要功能

1. 常用数据结构扩展
2. 高效算法实现
3. 开发工具辅助
4. 实用宏定义
5. 性能优化工具

安装方法

在Cargo.toml中添加依赖：

[dependencies]
codes-common = "0.1"  # 使用最新版本号

使用示例

1. 集合操作扩展

use codes_common::collections::ExtendedCollection;

fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    
    // 分块处理
    for chunk in vec.chunks_with_step(2, 1) {
        println!("Chunk: {:?}", chunk);
    }
    
    // 安全获取
    println!("Safe get: {:?}", vec.get_or_default(10, &0));
}

2. 字符串处理工具

use codes_common::string_utils;

fn main() {
    let s = "hello world";
    
    // 字符串转换为驼峰命名
    println!("Camel case: {}", string_utils::to_camel_case(s));
    
    // 生成随机字符串
    println!("Random string: {}", string_utils::random_string(10));
}

3. 性能测量工具

use codes_common::perf;

fn main() {
    // 测量代码执行时间
    let result = perf::measure_time(|| {
        // 需要测量的代码
        let mut sum = 0;
        for i in 0..1000000 {
            sum += i;
        }
        sum
    });
    
    println!("Sum: {}, took {} ms", result.value, result.time_ms);
}

4. 错误处理增强

use codes_common::error::{CommonError, ResultExt};

fn risky_operation() -> Result<(), CommonError> {
    // ... 可能失败的操作
    Err(CommonError::new("Something went wrong"))
}

fn main() {
    // 增强的错误处理
    let result = risky_operation()
        .context("Additional context info")?
        .wrap_error("Wrapped error");
    
    if let Err(e) = result {
        eprintln!("Error occurred: {}", e.full_message());
    }
}

高级功能

并发模式

use codes_common::concurrency::parallel_map;

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    
    // 并行处理
    let results = parallel_map(data, |x| x * 2, 4); // 使用4个线程
    
    println!("Results: {:?}", results);
}

缓存工具

use codes_common::caching::{Cache, LruCache};

fn main() {
    let mut cache = LruCache::new(100); // 容量100
    
    cache.insert("key1", "value1");
    
    if let Some(value) = cache.get(&"key1") {
        println!("Got value: {}", value);
    }
}

最佳实践

1. 在大型项目中，按需导入特定模块而不是整个库
2. 充分利用提供的性能分析工具优化热点代码
3. 使用增强的错误处理来改善错误报告
4. 对集合操作优先使用库提供的并行版本

版本更新

建议定期检查更新，库会持续添加新功能和优化性能。可以通过cargo update codes-common获取最新版本。

这个库特别适合需要快速开发原型或构建生产级应用的Rust开发者，它提供的工具集可以显著减少样板代码的编写。

完整示例demo

下面是一个综合使用codes-common库功能的完整示例：

use codes_common::{
    collections::ExtendedCollection,
    string_utils,
    perf,
    error::{CommonError, ResultExt},
    concurrency::parallel_map,
    caching::{Cache, LruCache}
};

fn main() {
    // 1. 集合操作示例
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
    println!("原始集合: {:?}", numbers);
    
    // 分块处理
    println!("分块处理结果:");
    for (i, chunk) in numbers.chunks_with_step(3, 1).enumerate() {
        println!("块 {}: {:?}", i, chunk);
    }
    
    // 2. 字符串处理示例
    let text = "hello_codes_common";
    println!("\n原始字符串: {}", text);
    println!("驼峰命名: {}", string_utils::to_camel_case(text));
    println!("随机字符串: {}", string_utils::random_string(8));
    
    // 3. 性能测量示例
    println!("\n性能测量:");
    let result = perf::measure_time(|| {
        let processed = parallel_map(&numbers, |x| x * x, 2); // 使用2个线程
        processed.into_iter().sum::<i32>()
    });
    println!("计算结果: {}, 耗时: {}ms", result.value, result.time_ms);
    
    // 4. 错误处理示例
    println!("\n错误处理演示:");
    match risky_operation() {
        Ok(_) => println!("操作成功"),
        Err(e) => println!("操作失败: {}", e.full_message())
    }
    
    // 5. 缓存使用示例
    println!("\n缓存演示:");
    let mut cache = LruCache::new(3);
    cache.insert("one", 1);
    cache.insert("two", 2);
    cache.insert("three", 3);
    
    println!("缓存大小: {}", cache.len());
    if let Some(val) = cache.get(&"two") {
        println!("获取缓存值: {}", val);
    }
}

fn risky_operation() -> Result<(), CommonError> {
    // 模拟可能失败的操作
    if rand::random() {
        Ok(())
    } else {
        Err(CommonError::new("随机操作失败"))
            .context("在risky_operation中发生错误")?
            .wrap_error("包装后的错误")
    }
}

这个完整示例展示了如何综合使用codes-common库的多个功能模块，包括：

1. 集合扩展操作（分块处理）
2. 字符串处理工具
3. 性能测量
4. 增强的错误处理
5. 并发处理
6. 缓存使用

您可以根据实际需求选择使用其中的特定模块功能。