Rust文件大小格式化库human-size使用指南

human-size是一个Rust库，用于将字节大小转换为人类可读的格式（如KB、MB、GB等），它会自动选择最合适的单位。

安装

在Cargo.toml中添加依赖：

[dependencies]
human-size = "0.4"

基本用法

use human_size::{Size, SpecificSize, Multiple, Kilobyte, Megabyte, Gigabyte};

fn main() {
    // 自动选择最合适的单位
    let size = Size::from_bytes(1500).to_string();
    println!("{}", size); // 输出: "1.5 KB"
    
    // 指定特定单位
    let specific = SpecificSize::new(1.5, Megabyte).unwrap();
    println!("{}", specific); // 输出: "1.5 MB"
}

主要功能

1. 自动转换

let sizes = [
    500,        // 500 B
    1500,       // 1.5 KB
    1_500_000,  // 1.5 MB
    1_500_000_000 // 1.5 GB
];

for bytes in sizes {
    println!("{}", Size::from_bytes(bytes));
}

2. 自定义单位

use human_size::{SpecificSize, Kilobyte};

let size = SpecificSize::new(2.5, Kilobyte).unwrap();
println!("{}", size); // 2.5 KB

3. 自定义精度

let size = Size::from_bytes(1555);
println!("{:.1}", size); // "1.5 KB"
println!("{:.3}", size); // "1.555 KB"

4. 解析字符串

use human_size::ParsingError;

let size: Result<SpecificSize<Multiple>, ParsingError> = "1.5 MB".parse();
match size {
    Ok(s) => println!("Parsed size: {} bytes", s.to_bytes()),
    Err(e) => println!("Error parsing: {}", e),
}

5. 数学运算

let size1 = SpecificSize::new(1.0, Megabyte).unwrap();
let size2 = SpecificSize::new(500.0, Kilobyte).unwrap();

let sum = size1 + size2;
println!("{}", sum); // "1.5 MB"

高级用法

自定义单位系统

use human_size::{Multiple, CustomUnits};

#[derive(Debug, Clone, Copy)]
enum MyUnits {
    Bytes,
    Blocks,
}

impl CustomUnits for MyUnits {
    fn base_unit(&self) -> Self {
        MyUnits::Bytes
    }
    
    fn ratio(&self) -> f64 {
        match self {
            MyUnits::Bytes => 1.0,
            MyUnits::Blocks => 512.0, // 假设1块=512字节
        }
    }
    
    fn identifier(&self) -> &'static str {
        match self {
            MyUnits::Bytes => "B",
            MyUnits::Blocks => "blks",
        }
    }
}

fn main() {
    let size = SpecificSize::new(1024.0, MyUnits::Blocks).unwrap();
    println!("{}", size); // 输出: "1024 blks"
    println!("{} bytes", size.to_bytes()); // 输出: "524288 bytes"
}

完整示例Demo

下面是一个综合使用human-size库的完整示例：

use human_size::{
    Size, SpecificSize, Multiple, 
    Kilobyte, Megabyte, Gigabyte,
    CustomUnits, ParsingError
};

// 自定义单位系统
#[derive(Debug, Clone, Copy)]
enum CustomUnit {
    Bytes,
    Sectors,
}

impl CustomUnits for CustomUnit {
    fn base_unit(&self) -> Self {
        CustomUnit::Bytes
    }
    
    fn ratio(&self) -> f64 {
        match self {
            CustomUnit::Bytes => 1.0,
            CustomUnit::Sectors => 4096.0, // 假设1扇区=4096字节
        }
    }
    
    fn identifier(&self) -> &'static str {
        match self {
            CustomUnit::Bytes => "B",
            CustomUnit::Sectors => "sectors",
        }
    }
}

fn main() {
    // 1. 自动转换示例
    println!("--- 自动转换示例 ---");
    let auto_sizes = [500, 1500, 1_500_000, 1_500_000_000];
    for bytes in auto_sizes {
        println!("{}", Size::from_bytes(bytes));
    }

    // 2. 指定单位示例
    println!("\n--- 指定单位示例 ---");
    let kb_size = SpecificSize::new(2.5, Kilobyte).unwrap();
    let mb_size = SpecificSize::new(1.2, Megabyte).unwrap();
    println!("KB: {}, MB: {}", kb_size, mb_size);

    // 3. 自定义精度示例
    println!("\n--- 自定义精度示例 ---");
    let precise_size = Size::from_bytes(1555555);
    println!("默认: {}", precise_size);
    println!("1位小数: {:.1}", precise_size);
    println!("3位小数: {:.3}", precise_size);

    // 4. 字符串解析示例
    println!("\n--- 字符串解析示例 ---");
    match "2.7 GB".parse::<SpecificSize<Multiple>>() {
        Ok(s) => println!("解析成功: {} = {} bytes", s, s.to_bytes()),
        Err(e) => println!("解析错误: {}", e),
    }

    // 5. 数学运算示例
    println!("\n--- 数学运算示例 ---");
    let size1 = SpecificSize::new(1.0, Megabyte).unwrap();
    let size2 = SpecificSize::new(500.0, Kilobyte).unwrap();
    println!("{} + {} = {}", size1, size2, size1 + size2);

    // 6. 自定义单位系统示例
    println!("\n--- 自定义单位系统示例 ---");
    let sector_size = SpecificSize::new(8.0, CustomUnit::Sectors).unwrap();
    println!("{} = {} bytes", sector_size, sector_size.to_bytes());
}

注意事项

1. 当使用SpecificSize时，如果值对于所选单位无效（如负数），new会返回None
2. 默认使用二进制前缀（KiB、MiB等），如果需要十进制前缀（KB、MB等），可以使用Multiple和Decimal枚举
3. 格式化输出时可以使用Rust的标准格式化语法控制小数位数

这个库非常适合需要显示文件大小、内存使用情况等场景，能自动选择最合适的单位使显示更友好。