Rust字节大小处理库re_byte_size的使用，高效解析和转换文件/内存字节大小的实用工具

re_byte_size是rerun系列crate的一部分，用于在运行时计算值的堆分配大小。

安装

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

cargo add re_byte_size

或者在Cargo.toml中添加以下行：

re_byte_size = "0.24.1"

许可证

MIT 或 Apache-2.0

基本使用示例

以下是使用re_byte_size库的基本示例：

use re_byte_size::ByteSize;

fn main() {
    // 从原始字节数创建ByteSize
    let size = ByteSize::from_bytes(1024);
    println!("Size in bytes: {}", size.bytes());
    
    // 自动选择合适单位显示
    println!("Human readable: {}", size);
    
    // 从不同单位创建
    let size_kb = ByteSize::from_kb(1.5);
    let size_mb = ByteSize::from_mb(2.0);
    
    // 单位转换
    println!("1.5 KB = {} bytes", size_kb.bytes());
    println!("2 MB = {} KB", size_mb.as_kb());
    
    // 算术运算
    let total = size_kb + size_mb;
    println!("Total size: {}", total);
    
    // 解析字符串
    let parsed = "1.5 MB".parse::<ByteSize>().unwrap();
    println!("Parsed size: {} bytes", parsed.bytes());
}

高级用法示例

use re_byte_size::ByteSize;
use std::mem;

struct SampleData {
    id: u64,
    name: String,
    values: Vec<f64>,
}

fn main() {
    // 计算结构体的堆分配大小
    let data = SampleData {
        id: 42,
        name: "Test".to_string(),
        values: vec![1.0, 2.0, 3.0],
    };
    
    // 计算字符串大小
    let name_size = ByteSize::from_bytes(data.name.capacity());
    
    // 计算向量大小
    let vec_size = ByteSize::from_bytes(data.values.capacity() * mem::size_of::<f64>());
    
    // 总堆大小
    let total_heap = name_size + vec_size;
    println!("Total heap size: {}", total_heap);
    
    // 格式化选项
    println!("Compact: {:.2}", total_heap);
    println!("Full precision: {:.6}", total_heap);
    
    // 比较大小
    let limit = ByteSize::from_mb(1);
    if total_heap > limit {
        println!("Warning: Exceeded 1 MB limit!");
    }
}

完整示例demo

use re_byte_size::ByteSize;
use std::mem;

// 自定义数据结构示例
struct MemoryUsage {
    buffer: Vec<u8>,
    description: String,
    metadata: Vec<String>,
}

fn main() {
    // 示例1: 基本单位转换和显示
    println!("--- 基本单位转换示例 ---");
    let file_size = ByteSize::from_mb(5.5);
    println!("文件大小: {}", file_size);
    println!("精确字节数: {}", file_size.bytes());
    println!("转换为KB: {:.2}", file_size.as_kb());
    
    // 示例2: 从字符串解析
    println!("\n--- 字符串解析示例 ---");
    let config_size = "256 KB".parse::<ByteSize>().unwrap();
    println!("配置大小: {}", config_size);
    println!("是否大于200KB? {}", config_size > ByteSize::from_kb(200.0));
    
    // 示例3: 计算自定义结构的内存使用
    println!("\n--- 内存使用计算示例 ---");
    let usage = MemoryUsage {
        buffer: vec![0; 1024 * 1024], // 1MB缓冲区
        description: "这是一个内存使用示例".to_string(),
        metadata: vec!["tag1".to_string(), "tag2".to_string()],
    };
    
    // 计算各部分内存使用
    let buffer_size = ByteSize::from_bytes(usage.buffer.capacity());
    let desc_size = ByteSize::from_bytes(usage.description.capacity());
    let meta_size = ByteSize::from_bytes(
        usage.metadata.capacity() * mem::size_of::<String>() + 
        usage.metadata.iter().map(|s| s.capacity()).sum::<usize>()
    );
    
    // 总内存使用
    let total = buffer_size + desc_size + meta_size;
    println!("总内存使用: {}", total);
    println!("详细分解:");
    println!("- 缓冲区: {}", buffer_size);
    println!("- 描述: {}", desc_size);
    println!("- 元数据: {}", meta_size);
    
    // 示例4: 内存限制检查
    println!("\n--- 内存限制检查示例 ---");
    let memory_limit = ByteSize::from_mb(2);
    if total > memory_limit {
        println!("错误: 内存使用超过{}限制!", memory_limit);
    } else {
        println!("内存使用在安全范围内");
    }
    
    // 示例5: 格式化选项
    println!("\n--- 格式化选项示例 ---");
    println!("默认格式: {}", total);
    println!("两位小数: {:.2}", total);
    println!("完整精度: {:.6}", total);
    println!("强制使用MB显示: {} MB", total.as_mb());
}

特性

• 支持各种单位（字节、KB、MB、GB等）的转换和计算
• 自动选择最合适的单位进行显示
• 精确的浮点数运算
• 支持从字符串解析
• 轻量级，无额外依赖

这个库特别适合需要监控内存使用情况、报告文件大小或进行资源限制的应用程序。通过简单的API，可以轻松地将原始字节数转换为人类可读的格式，或进行各种单位间的转换计算。