Rust 文件与 IO

Rust 提供了强大而安全的文件和 IO 操作功能，通过标准库中的 std::fs 和 std::io 模块，您可以进行各种文件操作、目录管理、网络 IO 等任务。本教程将深入介绍 Rust 中文件与 IO 操作的各种方法和最佳实践。

🎯 学习目标

通过本教程，您将掌握：

• 文件的创建、读取、写入和删除操作
• 目录的创建、遍历和管理
• 不同的 IO 操作方式和性能优化
• 错误处理和异常情况的处理
• 文件权限和元数据的操作
• 高级 IO 操作技巧
• 网络 IO 和其他 IO 类型

📖 IO 基础概念

Rust IO 的特点

Rust 的 IO 系统具有以下特点：

• 安全性：编译时检查，避免常见的 IO 错误
• 零成本抽象：高性能的 IO 操作
• 错误处理：强制错误处理，避免程序崩溃
• 跨平台：统一的 API 在不同操作系统上工作
• 异步支持：支持异步 IO 操作

常用的 IO 相关模块

模块	功能描述
std::fs	文件系统操作（文件和目录）
std::io	通用 IO 操作和 trait
std::path	文件路径操作
std::env	环境变量和程序参数
std::net	网络 IO 操作

📁 基础文件操作

文件读取的多种方式

use std::fs;
use std::io::{self, Read};
use std::path::Path;

fn main() -> io::Result<()> {
    // 方法1：一次性读取整个文件为字符串
    println!("=== 方法1：读取整个文件为字符串 ===");
    match fs::read_to_string("示例文件.txt") {
        Ok(内容) => {
            println!("文件内容：\n{}", 内容);
        },
        Err(错误) => {
            println!("读取文件失败：{}", 错误);
            
            // 如果文件不存在，创建一个示例文件
            let 示例内容 = "你好，这是一个示例文件！\n第二行内容\n第三行内容";
            fs::write("示例文件.txt", 示例内容)?;
            println!("已创建示例文件");
            
            // 再次尝试读取
            let 内容 = fs::read_to_string("示例文件.txt")?;
            println!("文件内容：\n{}", 内容);
        }
    }
    
    // 方法2：读取文件为字节数组
    println!("\n=== 方法2：读取文件为字节数组 ===");
    let 字节数据 = fs::read("示例文件.txt")?;
    println!("文件大小：{} 字节", 字节数据.len());
    println!("前20个字节：{:?}", &字节数据[..20.min(字节数据.len())]);
    
    // 方法3：使用 File 和 Read trait
    println!("\n=== 方法3：使用 File 和 Read trait ===");
    let mut 文件 = fs::File::open("示例文件.txt")?;
    let mut 缓冲区 = String::new();
    文件.read_to_string(&mut 缓冲区)?;
    println!("通过 Read trait 读取的内容：\n{}", 缓冲区);
    
    Ok(())
}

文件写入的多种方式

use std::fs::{self, File, OpenOptions};
use std::io::{self, Write, BufWriter};

fn main() -> io::Result<()> {
    println!("=== 文件写入示例 ===");
    
    // 方法1：一次性写入整个内容（覆盖）
    println!("1. 使用 fs::write 覆盖写入");
    let 新内容 = "这是新的文件内容\n使用 fs::write 写入\n";
    fs::write("输出文件.txt", 新内容)?;
    println!("已写入文件：输出文件.txt");
    
    // 方法2：追加内容到文件
    println!("\n2. 追加内容到文件");
    let mut 文件 = OpenOptions::new()
        .create(true)      // 如果文件不存在则创建
        .append(true)      // 追加模式
        .open("输出文件.txt")?;
    
    writeln!(文件, "这是追加的第一行")?;
    writeln!(文件, "这是追加的第二行")?;
    writeln!(文件, "当前时间：{}", chrono::Local::now().format("%Y-%m-%d %H:%M:%S"))?;
    
    // 方法3：使用 BufWriter 提高写入性能
    println!("\n3. 使用 BufWriter 批量写入");
    let 文件 = File::create("批量输出.txt")?;
    let mut 写入器 = BufWriter::new(文件);
    
    for i in 1..=1000 {
        writeln!(写入器, "第 {} 行数据：随机数 {}", i, rand::random::<u32>())?;
    }
    写入器.flush()?; // 确保所有数据都写入到文件
    
    println!("已写入1000行数据到 批量输出.txt");
    
    // 方法4：写入不同数据类型
    println!("\n4. 写入不同数据类型");
    let 二进制数据 = vec![0u8, 1, 2, 3, 255, 128, 64];
    fs::write("二进制文件.bin", &二进制数据)?;
    
    // 读取并验证二进制数据
    let 读取的二进制 = fs::read("二进制文件.bin")?;
    println!("写入的二进制数据：{:?}", 二进制数据);
    println!("读取的二进制数据：{:?}", 读取的二进制);
    println!("数据一致性检查：{}", 二进制数据 == 读取的二进制);
    
    Ok(())
}

文件和目录的基本操作

use std::fs::{self, DirEntry};
use std::io;
use std::path::Path;

fn main() -> io::Result<()> {
    println!("=== 文件和目录基本操作 ===");
    
    // 创建目录
    let 目录名 = "测试目录";
    if !Path::new(目录名).exists() {
        fs::create_dir(目录名)?;
        println!("已创建目录：{}", 目录名);
    } else {
        println!("目录已存在：{}", 目录名);
    }
    
    // 创建嵌套目录
    let 嵌套目录 = "测试目录/子目录/深层目录";
    fs::create_dir_all(嵌套目录)?;
    println!("已创建嵌套目录：{}", 嵌套目录);
    
    // 在目录中创建文件
    for i in 1..=5 {
        let 文件路径 = format!("测试目录/文件{}.txt", i);
        let 内容 = format!("这是文件{}的内容\n创建时间：{}", i, chrono::Local::now());
        fs::write(&文件路径, 内容)?;
    }
    println!("已在目录中创建5个文件");
    
    // 遍历目录
    println!("\n=== 遍历目录内容 ===");
    遍历目录("测试目录")?;
    
    // 复制文件
    println!("\n=== 文件复制 ===");
    let 源文件 = "测试目录/文件1.txt";
    let 目标文件 = "测试目录/文件1_副本.txt";
    fs::copy(源文件, 目标文件)?;
    println!("已复制文件：{} -> {}", 源文件, 目标文件);
    
    // 重命名文件
    println!("\n=== 文件重命名 ===");
    let 旧名称 = "测试目录/文件2.txt";
    let 新名称 = "测试目录/重命名的文件2.txt";
    fs::rename(旧名称, 新名称)?;
    println!("已重命名文件：{} -> {}", 旧名称, 新名称);
    
    // 删除文件
    println!("\n=== 删除文件 ===");
    let 要删除的文件 = "测试目录/文件3.txt";
    if Path::new(要删除的文件).exists() {
        fs::remove_file(要删除的文件)?;
        println!("已删除文件：{}", 要删除的文件);
    }
    
    // 获取文件元数据
    println!("\n=== 文件元数据 ===");
    获取文件信息("测试目录/文件1.txt")?;
    
    Ok(())
}

fn 遍历目录(目录路径: &str) -> io::Result<()> {
    println!("目录 '{}' 的内容：", 目录路径);
    
    let 条目列表 = fs::read_dir(目录路径)?;
    
    for 条目结果 in 条目列表 {
        let 条目 = 条目结果?;
        let 路径 = 条目.path();
        let 元数据 = 条目.metadata()?;
        
        let 类型 = if 元数据.is_dir() {
            "[目录]"
        } else if 元数据.is_file() {
            "[文件]"
        } else {
            "[其他]"
        };
        
        let 大小 = if 元数据.is_file() {
            format!(" ({} 字节)", 元数据.len())
        } else {
            String::new()
        };
        
        println!("  {} {}{}", 类型, 路径.display(), 大小);
        
        // 递归遍历子目录
        if 元数据.is_dir() {
            if let Some(路径字符串) = 路径.to_str() {
                遍历目录(路径字符串)?;
            }
        }
    }
    
    Ok(())
}

fn 获取文件信息(文件路径: &str) -> io::Result<()> {
    let 元数据 = fs::metadata(文件路径)?;
    
    println!("文件信息：{}", 文件路径);
    println!("  文件大小：{} 字节", 元数据.len());
    println!("  是否为文件：{}", 元数据.is_file());
    println!("  是否为目录：{}", 元数据.is_dir());
    println!("  是否只读：{}", 元数据.permissions().readonly());
    
    // 获取修改时间
    if let Ok(修改时间) = 元数据.modified() {
        if let Ok(系统时间) = 修改时间.duration_since(std::time::UNIX_EPOCH) {
            let 秒数 = 系统时间.as_secs();
            println!("  修改时间：{} (Unix时间戳)", 秒数);
        }
    }
    
    Ok(())
}

🚀 高级文件操作

缓冲 IO 和性能优化

use std::fs::File;
use std::io::{self, BufRead, BufReader, BufWriter, Read, Write};
use std::time::Instant;

fn main() -> io::Result<()> {
    println!("=== 缓冲 IO 性能比较 ===");
    
    // 创建测试数据
    创建大型测试文件("大文件.txt", 100000)?;
    
    // 比较不同读取方式的性能
    比较读取性能("大文件.txt")?;
    
    // 比较不同写入方式的性能
    比较写入性能()?;
    
    // 演示逐行读取
    println!("\n=== 逐行读取大文件 ===");
    逐行读取文件("大文件.txt")?;
    
    Ok(())
}

fn 创建大型测试文件(文件名: &str, 行数: usize) -> io::Result<()> {
    println!("创建包含 {} 行的测试文件...", 行数);
    
    let 开始时间 = Instant::now();
    let 文件 = File::create(文件名)?;
    let mut 写入器 = BufWriter::new(文件);
    
    for i in 1..=行数 {
        writeln!(写入器, "这是第 {} 行，包含一些测试数据和随机数字：{}", i, rand::random::<u64>())?;
    }
    
    写入器.flush()?;
    let 耗时 = 开始时间.elapsed();
    println!("文件创建完成，耗时：{:?}", 耗时);
    
    Ok(())
}

fn 比较读取性能(文件名: &str) -> io::Result<()> {
    println!("\n=== 读取性能比较 ===");
    
    // 方法1：无缓冲读取
    let 开始时间 = Instant::now();
    let mut 文件 = File::open(文件名)?;
    let mut 内容 = String::new();
    文件.read_to_string(&mut 内容)?;
    let 无缓冲耗时 = 开始时间.elapsed();
    println!("无缓冲读取耗时：{:?}，读取字符数：{}", 无缓冲耗时, 内容.len());
    
    // 方法2：缓冲读取
    let 开始时间 = Instant::now();
    let 文件 = File::open(文件名)?;
    let mut 读取器 = BufReader::new(文件);
    let mut 内容 = String::new();
    读取器.read_to_string(&mut 内容)?;
    let 缓冲耗时 = 开始时间.elapsed();
    println!("缓冲读取耗时：{:?}，读取字符数：{}", 缓冲耗时, 内容.len());
    
    // 方法3：一次性读取
    let 开始时间 = Instant::now();
    let 内容 = std::fs::read_to_string(文件名)?;
    let 一次性耗时 = 开始时间.elapsed();
    println!("一次性读取耗时：{:?}，读取字符数：{}", 一次性耗时, 内容.len());
    
    Ok(())
}

fn 比较写入性能() -> io::Result<()> {
    println!("\n=== 写入性能比较 ===");
    let 数据行数 = 50000;
    
    // 方法1：无缓冲写入
    let 开始时间 = Instant::now();
    let mut 文件 = File::create("无缓冲输出.txt")?;
    for i in 1..=数据行数 {
        writeln!(文件, "无缓冲写入第 {} 行数据", i)?;
    }
    let 无缓冲耗时 = 开始时间.elapsed();
    println!("无缓冲写入 {} 行耗时：{:?}", 数据行数, 无缓冲耗时);
    
    // 方法2：缓冲写入
    let 开始时间 = Instant::now();
    let 文件 = File::create("缓冲输出.txt")?;
    let mut 写入器 = BufWriter::new(文件);
    for i in 1..=数据行数 {
        writeln!(写入器, "缓冲写入第 {} 行数据", i)?;
    }
    写入器.flush()?;
    let 缓冲耗时 = 开始时间.elapsed();
    println!("缓冲写入 {} 行耗时：{:?}", 数据行数, 缓冲耗时);
    
    println!("性能提升倍数：{:.2}x", 无缓冲耗时.as_nanos() as f64 / 缓冲耗时.as_nanos() as f64);
    
    Ok(())
}

fn 逐行读取文件(文件名: &str) -> io::Result<()> {
    let 文件 = File::open(文件名)?;
    let 读取器 = BufReader::new(文件);
    
    let mut 行计数 = 0;
    let 开始时间 = Instant::now();
    
    for (行号, 行结果) in 读取器.lines().enumerate() {
        let _行内容 = 行结果?;
        行计数 += 1;
        
        // 只显示前5行和最后5行
        if 行号 < 5 || 行号 >= 行计数 - 5 {
            println!("第 {} 行: {}", 行号 + 1, _行内容);
        } else if 行号 == 5 {
            println!("... (省略中间行) ...");
        }
    }
    
    let 耗时 = 开始时间.elapsed();
    println!("逐行读取完成，总行数：{}，耗时：{:?}", 行计数, 耗时);
    
    Ok(())
}

---

继续学习：下一章 - Rust 集合与字符串

📚 总结

本教程全面介绍了 Rust 文件与 IO 操作的核心概念和实际应用：

主要内容回顾

1. IO 基础概念：理解 Rust IO 系统的特点和优势
2. 基础文件操作：掌握文件的读取、写入、创建和删除
3. 目录管理：学会目录的创建、遍历和管理
4. 高级 IO 操作：了解缓冲 IO 和性能优化技巧
5. 错误处理：掌握完善的错误处理策略
6. 路径操作：学会路径的创建、分析和操作
7. 网络 IO：了解基本的网络 IO 操作

关键概念总结

功能领域	主要 API	使用场景
文件读取	fs::read_to_string(), fs::read()	小文件一次性读取
文件写入	fs::write(), File::create()	小文件一次性写入
缓冲 IO	BufReader, BufWriter	大文件或高频操作
目录操作	fs::create_dir(), fs::read_dir()	目录管理和遍历
路径处理	Path, PathBuf	跨平台路径操作
错误处理	io::Result, ErrorKind	健壮的错误处理

Rust IO 的优势

• 安全性：编译时防止常见的 IO 错误
• 性能：零成本抽象和高效的缓冲机制
• 跨平台：统一的 API 在不同操作系统上工作
• 错误处理：强制的错误处理机制

最佳实践建议

性能优化

• 对于大文件或高频 IO 操作，使用 BufReader 和 BufWriter
• 对于小文件，直接使用 fs::read_to_string() 和 fs::write()
• 逐行读取大文件时使用 BufReader::lines()
• 批量写入时记得调用 flush() 确保数据写入

错误处理

• 始终使用 Result 类型处理 IO 操作的返回值
• 根据 ErrorKind 的不同类型实现不同的错误处理逻辑
• 在生产环境中避免使用 expect() 和 unwrap()
• 考虑使用重试机制处理临时性错误

路径处理

• 使用 Path 和 PathBuf 进行跨平台的路径操作
• 避免直接使用字符串拼接路径
• 使用 join() 方法组合路径组件
• 在操作文件前检查路径的存在性

注意事项

• 文件 IO 操作可能失败，始终要做好错误处理
• 大文件操作时注意内存使用量
• 跨平台开发时注意路径分隔符的差异
• 文件权限问题在不同操作系统上可能不同

下一步学习建议

1. 异步 IO：学习 tokio 等异步运行时的文件 IO 操作
2. 网络编程：深入学习 TCP/UDP 网络编程
3. 数据序列化：学习 JSON、TOML 等数据格式的处理
4. 数据库：学习使用 Rust 连接和操作数据库

通过本教程的学习，您现在应该能够：

• 安全、高效地进行文件和目录操作
• 正确处理 IO 操作中的错误
• 使用适当的 IO 方法进行性能优化
• 进行跨平台的路径处理
• 在实际项目中应用 Rust 的 IO 能力

Rust 的文件与 IO 系统为您提供了强大的工具来构建高性能、可靠的应用程序。