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

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

1. 文件 I/O 基础

Rust 的文件 I/O 操作主要通过 std::fs 模块实现，支持同步和异步操作。

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

fn main() {
    // 写入文件
    let mut file = File::create("output.txt").expect("Failed to create file");
    file.write_all(b"Hello, World!").expect("Failed to write to file");
    
    // 读取文件
    let mut file = File::open("output.txt").expect("Failed to open file");
    let mut content = String::new();
    file.read_to_string(&mut content).expect("Failed to read from file");
    println!("File content: {}", content);
}

2. 高级文件 I/O 技巧

2.1 目录操作

use std::fs;
use std::path::Path;

fn main() {
    // 创建目录
    fs::create_dir("test_dir").expect("Failed to create directory");
    
    // 创建嵌套目录
    fs::create_dir_all("test_dir/nested").expect("Failed to create nested directory");
    
    // 读取目录内容
    let entries = fs::read_dir("test_dir").expect("Failed to read directory");
    for entry in entries {
        let entry = entry.expect("Failed to get entry");
        println!("{:?}", entry.path());
    }
    
    // 删除目录
    fs::remove_dir_all("test_dir").expect("Failed to remove directory");
}

2.2 文件元数据

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

fn main() {
    let file = File::open("output.txt").expect("Failed to open file");
    let metadata = file.metadata().expect("Failed to get metadata");
    
    println!("File size: {} bytes", metadata.len());
    println!("Is file: {}", metadata.is_file());
    println!("Is directory: {}", metadata.is_dir());
    println!("Permissions: {:?}", metadata.permissions());
    
    // Unix-specific metadata
    #[cfg(unix)]
    {
        println!("UID: {}", metadata.uid());
        println!("GID: {}", metadata.gid());
    }
}

2.3 临时文件

use std::fs::File;
use std::io::Write;
use tempfile::tempfile;

fn main() {
    // 创建临时文件
    let mut file = tempfile().expect("Failed to create temp file");
    
    // 写入数据
    file.write_all(b"Temporary data").expect("Failed to write to temp file");
    
    // 临时文件会在离开作用域时自动删除
}

2.4 异步文件 I/O

use tokio::fs::File;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() {
    // 异步写入文件
    let mut file = File::create("async_output.txt").await.expect("Failed to create file");
    file.write_all(b"Hello, Async World!").await.expect("Failed to write to file");
    
    // 异步读取文件
    let mut file = File::open("async_output.txt").await.expect("Failed to open file");
    let mut content = String::new();
    file.read_to_string(&mut content).await.expect("Failed to read from file");
    println!("File content: {}", content);
}

3. 实际应用场景

3.1 配置文件处理

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

#[derive(Debug, Serialize, Deserialize)]
struct Config {
    host: String,
    port: u16,
    debug: bool,
}

fn main() {
    // 读取配置文件
    let mut file = File::open("config.toml").expect("Failed to open config file");
    let mut content = String::new();
    file.read_to_string(&mut content).expect("Failed to read config file");
    
    // 解析配置
    let config: Config = toml::from_str(&content).expect("Failed to parse config");
    println!("Config: {:?}", config);
    
    // 修改配置
    let mut config = config;
    config.debug = true;
    
    // 写入配置文件
    let mut file = File::create("config.toml").expect("Failed to create config file");
    let content = toml::to_string(&config).expect("Failed to serialize config");
    file.write_all(content.as_bytes()).expect("Failed to write config file");
}

3.2 日志文件

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

fn log(message: &str) {
    let mut file = OpenOptions::new()
        .create(true)
        .append(true)
        .open("app.log")
        .expect("Failed to open log file");
    
    let timestamp = SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
        .expect("Failed to get timestamp")
        .as_secs();
    
    writeln!(file, "[{}] {}", timestamp, message).expect("Failed to write to log file");
}

fn main() {
    log("Application started");
    log("Processing data");
    log("Application exited");
}

3.3 文件复制

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

// 方法 1: 使用 copy 函数
fn copy_file_1(src: &str, dst: &str) {
    copy(src, dst).expect("Failed to copy file");
}

// 方法 2: 手动复制
fn copy_file_2(src: &str, dst: &str) {
    let mut src_file = File::open(src).expect("Failed to open source file");
    let mut dst_file = File::create(dst).expect("Failed to create destination file");
    
    let mut buffer = [0; 1024];
    loop {
        let n = src_file.read(&mut buffer).expect("Failed to read from source");
        if n == 0 {
            break;
        }
        dst_file.write_all(&buffer[0..n]).expect("Failed to write to destination");
    }
}

fn main() {
    copy_file_1("input.txt", "output1.txt");
    copy_file_2("input.txt", "output2.txt");
}

3.4 文件监控

use notify::{RecommendedWatcher, RecursiveMode, Watcher};
use std::sync::mpsc::channel;
use std::time::Duration;

fn main() {
    // 创建通道
    let (tx, rx) = channel();
    
    // 创建监控器
    let mut watcher: RecommendedWatcher = RecommendedWatcher::new(tx, Duration::from_secs(1))
        .expect("Failed to create watcher");
    
    // 监控目录
    watcher.watch(".", RecursiveMode::Recursive)
        .expect("Failed to start watching");
    
    // 处理事件
    loop {
        match rx.recv() {
            Ok(event) => println!("Event: {:?}", event),
            Err(e) => println!("Error: {:?}", e),
        }
    }
}

4. 最佳实践

1. 错误处理：使用 Result 类型和 ? 操作符处理文件 I/O 错误。
2. 资源管理：使用 File 类型的析构函数自动关闭文件，或使用 drop 显式释放资源。
3. 缓冲区：对于大文件操作，使用缓冲区提高性能。
4. 异步 I/O：对于 I/O 密集型应用，使用异步 I/O 提高并发性能。
5. 权限管理：注意文件权限，避免安全问题。
6. 路径处理：使用 std::path::Path 处理路径，提高代码的跨平台兼容性。
7. 临时文件：使用 tempfile 库创建临时文件，自动管理生命周期。

5. 总结

Rust 的文件 I/O 操作提供了丰富的功能，从基本的文件读写到高级的目录操作、元数据获取、临时文件和异步 I/O。通过掌握这些高级应用，我们可以编写更加高效、可靠的文件操作代码。

在实际应用中，文件 I/O 操作可以用于配置文件处理、日志记录、文件复制、文件监控等多种场景，大大提高应用程序的功能性和可靠性。

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