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 操作的核心概念和实际应用：

主要内容回顾

IO 基础概念：理解 Rust IO 系统的特点和优势
基础文件操作：掌握文件的读取、写入、创建和删除
目录管理：学会目录的创建、遍历和管理
高级 IO 操作：了解缓冲 IO 和性能优化技巧
错误处理：掌握完善的错误处理策略
路径操作：学会路径的创建、分析和操作
网络 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 在不同操作系统上工作
错误处理：强制的错误处理机制

最佳实践建议

::: tip 性能优化

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

::: tip 错误处理

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

::: tip 路径处理

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

::: warning 注意事项

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

下一步学习建议

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

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

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

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

#Rust 文件与 IO

#🎯 学习目标

#📖 IO 基础概念

#Rust IO 的特点

#常用的 IO 相关模块

#📁 基础文件操作

#文件读取的多种方式

#文件写入的多种方式

#文件和目录的基本操作

#🚀 高级文件操作

#缓冲 IO 和性能优化

#📚 总结

#主要内容回顾

#关键概念总结

#Rust IO 的优势

#最佳实践建议

#下一步学习建议