Rust文件I/O操作多种场景应用笔记

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);
}

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");
}

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());
    }
}

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");
    // 临时文件会在离开作用域时自动删除
}

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);
}

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");
}

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");
}

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");
}

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),
        }
    }
}