Rust 文件 I/O 高级应用指南

Rust 文件 I/O 高级应用指南

1. 基本文件操作

在 Rust 中，文件 I/O 操作主要通过 std::fs 模块来实现。

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 读取文件
    let content = fs::read_to_string("example.txt")?;
    println!("File content: {}", content);
    
    // 写入文件
    fs::write("output.txt", "Hello, World!")?;
    println!("File written successfully");
    
    Ok(())
}

2. 高级文件操作

2.1 文件元数据

use std::fs;
use std::os::unix::fs::MetadataExt;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let metadata = fs::metadata("example.txt")?;
    
    println!("File size: {} bytes", metadata.len());
    println!("Is file: {}", metadata.is_file());
    println!("Is directory: {}", metadata.is_dir());
    println!("Permissions: {:?}", metadata.permissions());
    
    // Unix 特有的元数据
    println!("Inode: {}", metadata.ino());
    println!("Mode: {:o}", metadata.mode());
    
    Ok(())
}

2.2 目录操作

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建目录
    fs::create_dir("new_dir")?;
    println!("Directory created");
    
    // 创建多级目录
    fs::create_dir_all("parent/child/grandchild")?;
    println!("Nested directories created");
    
    // 读取目录内容
    let entries = fs::read_dir(".")?;
    for entry in entries {
        let entry = entry?;
        let path = entry.path();
        if path.is_dir() {
            println!("Directory: {:?}", path);
        } else {
            println!("File: {:?}", path);
        }
    }
    
    // 删除目录
    fs::remove_dir("new_dir")?;
    println!("Directory deleted");
    
    // 删除多级目录
    fs::remove_dir_all("parent")?;
    println!("Nested directories deleted");
    
    Ok(())
}

2.3 文件权限

use std::fs;
use std::fs::Permissions;
use std::os::unix::fs::PermissionsExt;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 设置文件权限
    let mut permissions = Permissions::default();
    permissions.set_mode(0o644); // rw-r--r--
    fs::set_permissions("example.txt", permissions)?;
    println!("Permissions set");
    
    // 获取文件权限
    let metadata = fs::metadata("example.txt")?;
    println!("Permissions: {:o}", metadata.permissions().mode());
    
    Ok(())
}

3. 低级文件操作

3.1 使用 File 结构

use std::fs::File;
use std::io::{Read, Write};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 打开文件（只读）
    let mut file = File::open("example.txt")?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    println!("File content: {}", content);
    
    // 创建文件（写入）
    let mut file = File::create("output.txt")?;
    file.write_all(b"Hello, World!")?;
    println!("File written successfully");
    
    Ok(())
}

3.2 使用 OpenOptions

use std::fs::OpenOptions;
use std::io::Write;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut file = OpenOptions::new()
        .write(true)
        .create(true)
        .truncate(true)
        .open("output.txt")?;
    
    file.write_all(b"Hello, World!")?;
    println!("File written successfully");
    
    // 追加内容
    let mut file = OpenOptions::new()
        .append(true)
        .open("output.txt")?;
    
    file.write_all(b"\nAppended content")?;
    println!("Content appended");
    
    Ok(())
}

4. 缓冲 I/O

使用 BufReader 和 BufWriter 可以提高 I/O 性能。

use std::fs::File;
use std::io::{BufRead, BufReader, BufWriter, Write};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 缓冲读取
    let file = File::open("example.txt")?;
    let reader = BufReader::new(file);
    
    for line in reader.lines() {
        let line = line?;
        println!("Line: {}", line);
    }
    
    // 缓冲写入
    let file = File::create("output.txt")?;
    let mut writer = BufWriter::new(file);
    
    for i in 0..10 {
        writeln!(writer, "Line {}", i)?;
    }
    
    writer.flush()?;
    println!("File written successfully");
    
    Ok(())
}

5. 异步文件操作

使用 tokio::fs 模块可以进行异步文件操作。

use tokio::fs;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 异步读取文件
    let content = fs::read_to_string("example.txt").await?;
    println!("File content: {}", content);
    
    // 异步写入文件
    fs::write("output.txt", "Hello, World!").await?;
    println!("File written successfully");
    
    // 异步创建目录
    fs::create_dir("new_dir").await?;
    println!("Directory created");
    
    // 异步读取目录
    let entries = fs::read_dir(".").await?;
    for entry in entries {
        let entry = entry?;
        let path = entry.path();
        if path.is_dir() {
            println!("Directory: {:?}", path);
        } else {
            println!("File: {:?}", path);
        }
    }
    
    Ok(())
}

6. 实际应用场景

6.1 读取大文件

对于大文件，我们可以使用流式读取，避免一次性加载全部内容到内存。

use std::fs::File;
use std::io::{BufRead, BufReader};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let file = File::open("large_file.txt")?;
    let reader = BufReader::new(file);
    
    let mut line_count = 0;
    for line in reader.lines() {
        let line = line?;
        // 处理每一行
        line_count += 1;
    }
    
    println!("Total lines: {}", line_count);
    
    Ok(())
}

6.2 写入大文件

对于大文件，我们可以使用流式写入。

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

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let file = File::create("large_output.txt")?;
    let mut writer = BufWriter::new(file);
    
    for i in 0..1000000 {
        writeln!(writer, "Line {}", i)?;
    }
    
    writer.flush()?;
    println!("File written successfully");
    
    Ok(())
}

6.3 文件复制

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    fs::copy("source.txt", "destination.txt")?;
    println!("File copied successfully");
    
    Ok(())
}

6.4 文件重命名

use std::fs;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    fs::rename("old_name.txt", "new_name.txt")?;
    println!("File renamed successfully");
    
    Ok(())
}

7. 最佳实践

1. 使用 Result 类型：对于可能失败的文件操作，使用 Result 类型返回错误。
2. 使用 ? 运算符：使用 ? 运算符简洁地传播错误。
3. 使用缓冲区：对于大文件，使用 BufReader 和 BufWriter 来提高 I/O 性能。
4. 异步 I/O：对于 I/O 密集型应用，使用异步 I/O 来提高性能。
5. 错误处理：提供清晰的错误信息，便于调试。
6. 资源管理：使用 drop 或作用域来确保文件资源被正确释放。
7. 权限管理：在需要时设置适当的文件权限。

8. 总结

Rust 的文件 I/O 系统提供了丰富的功能，从基本的文件读写到高级的文件元数据操作。通过掌握文件 I/O 的高级应用，我们可以编写更加高效、可靠的文件处理代码。

在实际应用中，我们可以根据具体需求选择合适的文件操作方法，从简单的 fs::read_to_string 到复杂的异步文件操作。

希望本文对你理解和应用 Rust 文件 I/O 有所帮助！