Rust IO 操作一文全解析

在编程领域，输入/输出（IO）是程序与外部环境交互的核心能力，无论是读取文件、接收用户输入，还是跨设备网络数据传输，都离不开IO操作。Rust作为一门注重安全、性能与并发的系统级语言，其标准库对IO操作进行了精细化设计，通过统一Trait抽象接口，既保证了内存安全，又提供了灵活的使用方式。本文将从核心Trait入手，逐步拆解文件IO、标准IO、缓冲IO、内存IO及网络IO等全场景用法，结合详细示例代码，带你全面掌握Rust IO操作的精髓。

一、Rust IO 核心Trait：统一接口规范

Rust标准库通过一系列Trait定义了IO操作的统一接口，核心包括 Read、Write、Seek，它们是所有IO操作的基础。理解这些Trait，就能举一反三应对不同IO场景。

1. Read Trait：读取数据的抽象

Read Trait定义了从数据源读取字节的方法，适用于文件、标准输入、网络流等所有可读场景。核心方法如下：

read(&mut self, buf: &mut [u8]) -> Result<usize, Error>：从数据源读取字节到缓冲区，返回读取的字节数或错误。
read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>：将字节读取为字符串（适用于文本数据）。
衍生方法：read_exact（读取指定长度字节，不足则报错）、by_ref（获取引用而非所有权）等。

示例：使用Read读取字节与字符串

rust 复制代码

use std::io::Read;
use std::fs::File;

fn main() -> std::io::Result<()> {
    // 打开文件（只读模式）
    let mut file = File::open("test.txt")?;
    
    // 1. 读取字节到缓冲区
    let mut buf = [0u8; 1024]; // 定义1KB缓冲区
    let bytes_read = file.read(&mut buf)?;
    println!("读取字节数：{}，内容：{:?}", bytes_read, &buf[..bytes_read]);
    
    // 2. 读取为字符串（需重置文件指针，后续Seek会讲解）
    file.seek(std::io::SeekFrom::Start(0))?; // 回到文件开头
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    println!("读取字符串内容：\n{}", content);
    
    Ok(())
}

注意：File::open 返回 Result<File, Error>，Rust强制要求处理错误，示例中用 ? 运算符将错误向上传播，简化错误处理逻辑。

2. Write Trait：写入数据的抽象

Write Trait定义了向目标写入字节的方法，适用于文件、标准输出、网络流等可写场景。核心方法如下：

write(&mut self, buf: &[u8]) -> Result<usize, Error>：将缓冲区字节写入目标，返回写入的字节数或错误（可能部分写入）。
flush(&mut self) -> Result<(), Error>：刷新缓冲区，确保数据写入底层设备（缓冲IO必备）。
衍生方法：write_all（写入全部字节，失败则报错）、write_fmt（格式化写入）等。

示例：使用Write写入文本与字节

rust 复制代码

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

fn main() -> std::io::Result<()> {
    // 打开文件（写入模式，不存在则创建，存在则覆盖）
    let mut file = File::create("output.txt")?;
    
    // 1. 写入字节
    let bytes = b"Hello, Rust IO!"; // 字节切片
    file.write(bytes)?;
    println!("写入字节数：{}", bytes.len());
    
    // 2. 格式化写入字符串
    file.write_all(b"\n")?; // 换行
    writeln!(file, "当前时间：{}", chrono::Local::now())?; // 需在Cargo.toml添加chrono依赖
    
    // 刷新缓冲区（确保数据写入磁盘）
    file.flush()?;
    Ok(())
}

补充：writeln! 宏类似 println!，但可将内容写入实现了 Write 的对象；示例中用到的 chrono 是第三方时间库，需在 Cargo.toml 中添加 chrono = "0.4"。

3. Seek Trait：移动文件指针

Seek Trait允许移动IO流的"当前位置指针"，适用于随机访问场景（如文件），核心方法：

seek(&mut self, pos: SeekFrom) -> Result<u64, Error>：将指针移动到指定位置，返回新的位置偏移量。

SeekFrom 枚举支持三种位置：Start(u64)（从开头偏移）、Current(i64)（从当前位置偏移）、End(i64)（从结尾偏移）。

示例：使用Seek实现文件追加写入

rust 复制代码

use std::io::{Write, Seek, SeekFrom};
use std::fs::OpenOptions;

fn main() -> std::io::Result<()> {
    // 以追加模式打开文件（保留原有内容，在末尾写入）
    let mut file = OpenOptions::new()
        .write(true)
        .append(true)
        .create(true) // 不存在则创建
        .open("append.txt")?;
    
    // 验证指针位置（追加模式下默认在末尾）
    let pos = file.seek(SeekFrom::Current(0))?;
    println!("当前指针位置：{}", pos);
    
    // 写入内容
    writeln!(file, "追加内容：{}", chrono::Local::now())?;
    Ok(())
}

二、文件IO：本地文件的读写操作

文件IO是最常见的IO场景，Rust标准库 std::fs 模块提供了文件与目录的操作能力，结合上文的核心Trait，可实现复杂的文件处理逻辑。

1. 文件打开模式：OpenOptions

前文用到的 File::open（只读）、File::create（覆盖写入）是简化方法，更灵活的方式是使用 OpenOptions 配置打开模式：

read(true)：只读权限
write(true)：可写权限
append(true)：追加模式（与write互斥，指针默认在末尾）
create(true)：文件不存在时创建
truncate(true)：文件存在时清空内容

2. 文件元数据：获取文件信息

通过 metadata() 方法可获取文件大小、创建时间、权限等信息，返回 Metadata 结构体。

示例：读取文件元数据

rust 复制代码

use std::fs::File;

fn main() -> std::io::Result<()> {
    let file = File::open("test.txt")?;
    let meta = file.metadata()?;
    
    println!("文件大小：{} 字节", meta.len());
    println!("是否为文件：{}", meta.is_file());
    println!("是否为目录：{}", meta.is_dir());
    println!("创建时间：{:?}", meta.created()?);
    println!("修改时间：{:?}", meta.modified()?);
    
    Ok(())
}

std::fs 还提供了目录操作函数，如 create_dir（创建目录）、read_dir（遍历目录内容）。

示例：遍历目录并打印文件信息

rust 复制代码

use std::fs;

fn main() -> std::io::Result<()> {
    let dir_path = "./src";
    // 遍历目录
    for entry in fs::read_dir(dir_path)? {
        let entry = entry?;
        let path = entry.path();
        let meta = entry.metadata()?;
        
        let file_type = if meta.is_file() { "文件" } else if meta.is_dir() { "目录" } else { "其他" };
        println!("{}: {}（大小：{}字节）", file_type, path.display(), meta.len());
    }
    Ok(())
}

三、标准IO：与控制台交互

标准IO指标准输入（stdin）、标准输出（stdout）、标准错误（stderr），Rust通过 std::io::stdin()、std::io::stdout()、std::io::stderr() 提供访问入口，且均实现了核心IO Trait。

1. 读取用户输入（stdin）

示例：交互式获取用户输入

rust 复制代码

use std::io::{self, Read, Write};

fn main() -> std::io::Result<()> {
    let mut stdin = io::stdin();
    let mut stdout = io::stdout();
    
    // 提示用户输入
    stdout.write_all(b"请输入你的名字：")?;
    stdout.flush()?; // 刷新缓冲区，确保提示语立即显示
    
    // 读取用户输入
    let mut name = String::new();
    stdin.read_to_string(&mut name)?;
    let name = name.trim(); // 去除换行符和空格
    
    println!("你好，{}！", name);
    Ok(())
}

2. 标准输出与标准错误

stdout 用于正常输出，stderr 用于错误信息输出，两者的区别在于：stdout可能被缓冲，而stderr通常无缓冲，确保错误信息及时显示。

示例：输出错误信息到stderr

rust 复制代码

use std::io::{self, Write};

fn main() -> std::io::Result<()> {
    let mut stderr = io::stderr();
    writeln!(stderr, "【错误】：文件不存在，请检查路径是否正确")?;
    Ok(())
}

四、进阶拓展：缓冲IO与内存IO

基础IO操作虽直观易懂，但频繁的底层读写会产生大量系统调用，严重影响高吞吐场景下的性能。同时，在单元测试、临时数据处理等场景中，直接操作真实文件或网络资源也不够便捷。为此，Rust提供了缓冲IO和内存IO两种优化方案，既能提升IO效率，又能灵活适配特殊使用场景，下面具体讲解。

1. 缓冲IO：BufReader与BufWriter

缓冲IO通过在内存中维护缓冲区，减少底层系统调用次数（一次读取/写入多个字节），大幅提升性能。std::io::BufReader 和 std::io::BufWriter 分别包装可读、可写对象，实现缓冲功能。

示例：使用缓冲IO读取大文件

rust 复制代码

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

fn main() -> io::Result<()> {
    // 用BufReader包装File，默认缓冲区大小8KB
    let file = File::open("large_file.txt")?;
    let reader = BufReader::new(file);
    
    // 按行读取（BufRead提供lines()方法，高效按行读取）
    let mut line_count = 0;
    for line in reader.lines() {
        let line = line?; // 处理可能的IO错误
        line_count += 1;
        if line_count % 1000 == 0 {
            println!("已读取 {} 行", line_count);
        }
    }
    println!("文件总行数：{}", line_count);
    Ok(())
}

提示：BufRead 是 Read 的拓展Trait，提供 lines()、read_line() 等按行读取方法，需通过 use std::io::BufRead 引入。

2. 内存IO：Cursor

有时候我们需要将内存中的字节切片/向量当作"文件"来操作（支持Seek），此时可使用 std::io::Cursor。Cursor包装一个可读写的内存缓冲区，实现了 Read、Write、Seek Trait。

示例：使用Cursor操作内存数据

rust 复制代码

use std::io::{self, Read, Write, Seek, SeekFrom};
use std::io::Cursor;

fn main() -> io::Result<()> {
    // 初始化内存缓冲区
    let mut buf = Vec::new();
    let mut cursor = Cursor::new(&mut buf);
    
    // 写入数据到内存
    cursor.write_all(b"Rust IO is powerful!")?;
    println!("写入后缓冲区：{:?}", buf);
    
    // 移动指针到开头，读取数据
    cursor.seek(SeekFrom::Start(0))?;
    let mut content = String::new();
    cursor.read_to_string(&mut content)?;
    println!("读取内存内容：{}", content);
    
    Ok(())
}

应用场景：网络传输中临时存储数据、单元测试中模拟文件IO（避免创建真实文件）。

3. IO错误处理最佳实践

Rust的IO错误统一封装为 std::io::Error，包含错误类型（ErrorKind）和描述信息。错误处理建议：

使用 ? 运算符简化正常流程的错误传播，在顶层函数（如main）统一处理。
通过 match 匹配 ErrorKind，针对性处理不同错误（如文件不存在、权限不足）。
结合 thiserror 第三方库自定义业务错误类型，封装IO错误，提升可读性。

示例：针对性处理IO错误

rust 复制代码

use std::io::{self, ErrorKind};
use std::fs::File;

fn main() {
    let file = File::open("missing_file.txt");
    match file {
        Ok(mut file) => {
            let mut content = String::new();
            if let Err(e) = file.read_to_string(&mut content) {
                eprintln!("读取文件失败：{}", e);
            }
        }
        Err(e) => match e.kind() {
            ErrorKind::NotFound => eprintln!("错误：文件不存在"),
            ErrorKind::PermissionDenied => eprintln!("错误：权限不足，无法打开文件"),
            _ => eprintln!("打开文件失败：{}", e),
        }
    }
}

五、网络IO：跨进程数据传输

除了本地IO场景，跨设备、跨进程的网络数据传输也是IO操作的核心场景。Rust标准库std::net模块提供了TCP、UDP两种主流协议的实现，且核心网络结构体（如TcpStream、UdpSocket）均实现了前文提及的Read、Write等Trait，可无缝复用基础IO操作逻辑。网络IO按传输特性分为面向连接（TCP）和无连接（UDP）两类，下面分别讲解其实现方式与适用场景。

1. TCP协议：面向连接的可靠传输

TCP是面向连接、可靠的字节流协议，适用于对数据完整性要求高的场景（如文件传输、HTTP通信）。核心结构体包括TcpListener（服务器端监听）和TcpStream（客户端连接与数据传输）。

示例1：TCP服务器（监听连接并处理数据）

rust 复制代码

use std::io::{self, Read, Write};
use std::net::TcpListener;
use std::thread;

fn main() -> io::Result<()> {
    // 绑定地址并监听（0.0.0.0:8080表示监听所有网卡的8080端口）
    let listener = TcpListener::bind("0.0.0.0:8080")?;
    println!("TCP服务器已启动，监听端口8080...");

    // 循环接受客户端连接（阻塞式）
    for stream in listener.incoming() {
        match stream {
            Ok(mut stream) => {
                println!("新客户端连接：{}", stream.peer_addr()?);
                // 开启线程处理单个客户端（避免阻塞其他连接）
                thread::spawn(move || {
                    let mut buf = [0u8; 1024];
                    // 读取客户端发送的数据
                    while let Ok(bytes_read) = stream.read(&mut buf) {
                        if bytes_read == 0 {
                            println!("客户端{}断开连接", stream.peer_addr().unwrap());
                            break;
                        }
                        println!("收到客户端数据：{}", String::from_utf8_lossy(&buf[..bytes_read]));
                        // 回声响应：将收到的数据回传给客户端
                        let _ = stream.write_all(&buf[..bytes_read]);
                        let _ = stream.flush();
                    }
                });
            }
            Err(e) => eprintln!("接受连接失败：{}", e),
        }
    }
    Ok(())
}

示例2：TCP客户端（连接服务器并发送数据）

rust 复制代码

use std::io::{self, Read, Write};
use std::net::TcpStream;
use std::str;

fn main() -> io::Result<()> {
    // 连接TCP服务器（127.0.0.1:8080为本地测试地址）
    let mut stream = TcpStream::connect("127.0.0.1:8080")?;
    println!("已连接到服务器");

    // 向服务器发送数据
    let msg = b"Hello, TCP Server!";
    stream.write_all(msg)?;
    stream.flush()?;
    println!("已发送数据：{}", str::from_utf8(msg).unwrap());

    // 读取服务器的回声响应
    let mut buf = [0u8; 1024];
    let bytes_read = stream.read(&mut buf)?;
    println!("收到服务器响应：{}", String::from_utf8_lossy(&buf[..bytes_read]));

    Ok(())
}

说明：TCP服务器通过thread::spawn为每个客户端开启独立线程，避免单连接阻塞整体服务；客户端通过TcpStream::connect建立连接后，可直接调用write_all、read方法，完全复用Write、Read Trait能力。

2. UDP协议：无连接的快速传输

UDP是无连接、不可靠的数据包协议，无需建立连接，适用于对实时性要求高、可容忍少量数据丢失的场景（如语音通话、视频流）。核心结构体为UdpSocket，同时负责发送和接收数据包。

示例1：UDP服务器（接收并响应数据包）

rust 复制代码

use std::io;
use std::net::{UdpSocket, SocketAddr};

fn main() -> io::Result<()> {
    // 绑定地址并创建UDP套接字
    let socket = UdpSocket::bind("0.0.0.0:8081")?;
    println!("UDP服务器已启动，监听端口8081...");

    let mut buf = [0u8; 1024];
    let mut client_addr: SocketAddr;

    // 循环接收数据包（阻塞式）
    loop {
        // 读取数据包，同时获取发送方地址
        let (bytes_read, addr) = socket.recv_from(&mut buf)?;
        client_addr = addr;
        println!("收到来自{}的数据：{}", client_addr, String::from_utf8_lossy(&buf[..bytes_read]));

        // 回声响应：向发送方回传数据包
        socket.send_to(&buf[..bytes_read], client_addr)?;
        println!("已向{}回传数据", client_addr);
    }
}

示例2：UDP客户端（发送并接收数据包）

rust 复制代码

use std::io;
use std::net::{UdpSocket, SocketAddr};
use std::str;

fn main() -> io::Result<()> {
    // 创建UDP套接字（客户端可不绑定固定端口，系统自动分配）
    let socket = UdpSocket::bind("0.0.0.0:0")?;
    // 服务器地址
    let server_addr: SocketAddr = "127.0.0.1:8081".parse()?;

    // 向服务器发送数据包
    let msg = b"Hello, UDP Server!";
    socket.send_to(msg, server_addr)?;
    println!("已发送数据：{}", str::from_utf8(msg).unwrap());

    // 接收服务器的回声响应
    let mut buf = [0u8; 1024];
    let (bytes_read, _) = socket.recv_from(&mut buf)?;
    println!("收到服务器响应：{}", String::from_utf8_lossy(&buf[..bytes_read]));

    Ok(())
}

说明：UDP无需建立连接，发送数据时需指定目标地址（send_to），接收数据时可获取发送方地址（recv_from）；由于无连接特性，UDP不存在"断开连接"的概念，且无法保证数据包的顺序和完整性。

3. 网络IO进阶注意事项

同步网络IO虽实现简单，但阻塞式调用在高并发场景下会暴露明显短板，需注意以下优化点与细节：

阻塞与非阻塞 ：标准库网络IO默认是阻塞式的（如listener.incoming()、socket.recv_from()会阻塞线程），高并发场景下多线程方案会产生大量线程切换开销。此时可通过std::os::unix::io::AsRawFd（Unix）或AsRawHandle（Windows）搭配epoll/kqueue实现原生非阻塞IO，或直接使用tokio等成熟异步运行时，大幅提升并发能力。
超时设置 ：可通过TcpStream::set_read_timeout、UdpSocket::set_write_timeout设置读写超时，避免线程因网络异常被永久阻塞，提升程序健壮性。
地址复用 ：服务器重启时可能遇到"地址已在使用"错误，可通过socket.set_reuseaddr(true)（Unix）或set_reuseport(true)开启地址复用，避免端口占用导致服务启动失败。
阻塞与非阻塞 ：标准库网络IO默认是阻塞式的（如listener.incoming()、socket.recv_from()会阻塞线程），若需高并发场景，可结合std::os::unix::io::AsRawFd（Unix）或AsRawHandle（Windows）搭配epoll/kqueue实现非阻塞IO，或使用tokio等异步运行时。
超时设置 ：可通过TcpStream::set_read_timeout、UdpSocket::set_write_timeout设置读写超时，避免线程永久阻塞。
地址复用 ：服务器重启时可能遇到"地址已在使用"错误，可通过socket.set_reuseaddr(true)（Unix）或set_reuseport(true)开启地址复用。

4. 异步网络IO：基于Tokio框架

针对同步网络IO在高并发场景下的性能瓶颈，异步IO成为最优解------它可在单线程内通过事件驱动模型处理海量连接，彻底规避线程切换开销。Rust生态中最成熟的异步运行时是Tokio，其不仅提供了与标准库API风格一致的异步网络结构体，还封装了定时器、任务调度等核心能力，降低异步编程门槛。

前文介绍的网络IO均为阻塞式，高并发场景下多线程方案会带来线程切换开销。异步IO可在单线程内处理多个连接，大幅提升并发效率，Rust生态中最成熟的异步运行时是Tokio，其提供了异步网络IO、定时器、任务调度等能力，且异步结构体（如tokio::net::TcpListener）的API设计与标准库保持一致，降低学习成本。

前置准备 ：需在Cargo.toml中添加Tokio依赖，开启full特性以包含网络IO、运行时等核心功能：

toml 复制代码

[dependencies]
tokio = { version = "1.0", features = ["full"] }

示例1：异步TCP服务器（Tokio）

rust 复制代码

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;

// 异步main函数，需添加#[tokio::main]宏启动异步运行时
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 绑定地址并监听（异步方法，返回Future，需await等待完成）
    let listener = TcpListener::bind("0.0.0.0:8082").await?;
    println!("异步TCP服务器已启动，监听端口8082...");

    // 循环接受客户端连接（异步阻塞，不占用线程）
    loop {
        // await等待连接建立，返回客户端流和地址
        let (mut stream, addr) = listener.accept().await?;
        println!("新客户端连接：{}", addr);

        // 开启异步任务处理客户端（类似线程，但更轻量，由Tokio调度）
        tokio::spawn(async move {
            let mut buf = [0u8; 1024];
            // 异步读取数据，需await
            while let Ok(bytes_read) = stream.read(&mut buf).await {
                if bytes_read == 0 {
                    println!("客户端{}断开连接", addr);
                    break;
                }
                println!("收到客户端{}数据：{}", addr, String::from_utf8_lossy(&buf[..bytes_read]));
                // 异步写入响应数据
                if let Err(e) = stream.write_all(&buf[..bytes_read]).await {
                    eprintln!("向客户端{}写入数据失败：{}", addr, e);
                    break;
                }
                // 异步刷新缓冲区
                if let Err(e) = stream.flush().await {
                    eprintln!("刷新客户端{}缓冲区失败：{}", addr, e);
                    break;
                }
            }
        });
    }
}

示例2：异步TCP客户端（Tokio）

rust 复制代码

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 异步连接服务器
    let mut stream = TcpStream::connect("127.0.0.1:8082").await?;
    println!("已连接到异步TCP服务器");

    // 异步发送数据
    let msg = b"Hello, Async TCP Server!";
    stream.write_all(msg).await?;
    stream.flush().await?;
    println!("已发送数据：{}", String::from_utf8_lossy(msg));

    // 异步读取响应
    let mut buf = [0u8; 1024];
    let bytes_read = stream.read(&mut buf).await?;
    println!("收到服务器响应：{}", String::from_utf8_lossy(&buf[..bytes_read]));

    Ok(())
}

异步网络IO核心知识点

异步运行时 ：Tokio通过#[tokio::main]宏启动异步运行时，负责调度异步任务、管理IO事件，底层基于epoll/kqueue实现事件驱动。
Future与await ：异步操作返回Future对象（代表未完成的计算），需通过await等待结果，期间线程可处理其他任务，无阻塞开销。
异步IO方法 ：Tokio提供的异步结构体（如TcpStream）方法以Async为前缀（如AsyncReadExt、AsyncWriteExt），用法与标准库同步方法一致，仅需添加await。
轻量任务 ：tokio::spawn创建的异步任务比系统线程更轻量（内存占用低、切换快），支持十万级并发连接。

补充说明：异步IO更适合高并发网络场景（如HTTP服务器、即时通讯工具），若业务并发量低，同步IO代码更简洁、易维护，需根据实际需求选择。

六、总结

Rust IO操作的核心设计理念是"Trait抽象统一+安全与性能兼顾"，Read、Write、Seek三大核心Trait贯穿本地IO、标准IO、网络IO全场景，实现了不同数据源操作接口的一致性，让开发者可举一反三、灵活复用代码。从基础的本地文件、控制台交互，到优化性能的缓冲IO、模拟场景的内存IO，再到跨进程通信的同步/异步网络IO，Rust提供了覆盖全场景的IO解决方案。

实际开发中，需结合场景选择合适的IO方案：处理大文件优先用BufReader/BufWriter减少系统调用；单元测试用Cursor模拟文件IO避免副作用；网络通信按可靠性需求选TCP（可靠传输）或UDP（实时性优先）；高并发场景则通过Tokio异步IO提升吞吐量。同时，规范的错误处理（匹配ErrorKind、合理传播错误）能大幅提升程序健壮性。掌握这些内容，即可从容应对Rust各类IO开发需求，为高性能、高可靠系统开发打下基础。

Rust IO操作的核心是"Trait抽象+安全设计"，通过Read、Write、Seek三大Trait实现了本地文件、标准控制台、网络流等不同场景的统一接口，既保证了灵活性，又简化了开发。本地IO（文件、目录）是基础应用场景，缓冲IO（BufReader/BufWriter）和内存IO（Cursor）用于优化性能与模拟场景，网络IO（TCP/UDP）则实现跨进程数据交互，覆盖了从本地到网络的全场景需求。

在实际开发中，需根据场景选择合适的IO方式：处理大文件优先用缓冲IO提升效率，单元测试用Cursor模拟文件避免副作用，网络通信按可靠性需求选择TCP/UDP，错误处理时针对性匹配ErrorKind提升体验。掌握这些内容，即可从容应对Rust中的各类IO需求，同时为后续异步IO、高性能网络编程打下基础。

Rust IO 操作 一文全解析

一、Rust IO 核心Trait：统一接口规范

1. Read Trait：读取数据的抽象

2. Write Trait：写入数据的抽象

3. Seek Trait：移动文件指针

二、文件IO：本地文件的读写操作

1. 文件打开模式：OpenOptions

2. 文件元数据：获取文件信息

3. 目录操作：创建、遍历目录

三、标准IO：与控制台交互

1. 读取用户输入（stdin）

2. 标准输出与标准错误

四、进阶拓展：缓冲IO与内存IO

1. 缓冲IO：BufReader与BufWriter

2. 内存IO：Cursor

3. IO错误处理最佳实践

五、网络IO：跨进程数据传输

1. TCP协议：面向连接的可靠传输

示例1：TCP服务器（监听连接并处理数据）

示例2：TCP客户端（连接服务器并发送数据）

2. UDP协议：无连接的快速传输

示例1：UDP服务器（接收并响应数据包）

示例2：UDP客户端（发送并接收数据包）

3. 网络IO进阶注意事项

4. 异步网络IO：基于Tokio框架

示例1：异步TCP服务器（Tokio）

示例2：异步TCP客户端（Tokio）

异步网络IO核心知识点

六、总结

Rust IO 操作一文全解析