《Rust编程实战》系列第120篇
前面我们已经连续学习了Rust中的变量、所有权、生命周期、集合、文件、网络、并发、时间、进程、错误处理等大量知识。本篇不再引入某一个新的crate，而是对Rust最重要的基础设施之一进行系统总结：

std
Rust Standard Library
Rust标准库

Rust标准库覆盖：

基础类型
集合
字符串
文件系统
路径
IO
网络
线程
同步
时间
进程
环境变量
错误处理
迭代器
智能指针

可以先记住：

第三方crate决定一个Rust项目能做多丰富的事情，而标准库决定你是否真正理解Rust程序是怎样工作的。

std是什么

Rust标准库统一放在：

std

命名空间下。
例如：

use std::fs;
use std::path::PathBuf;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;

这些都不需要在Cargo.toml额外添加依赖。
标准库可以理解为：

Rust语言
+
std
↓
绝大多数Rust程序的基础运行能力

Prelude

我们写：

let data=Vec::new();
let value=Some(10);
let result:Result<i32,String>=Ok(1);

并没有：

use std::vec::Vec;
use std::option::Option;
use std::result::Result;

原因是Rust会自动导入：

Prelude

也就是一组最常用类型和Trait。
因此很多Rust基础能力看起来像“语言自带”，实际上部分来自标准库Prelude。

String与str

Rust字符串体系最重要：

String
&str

String：

拥有数据
可增长
通常分配在堆上

&str：

借用字符串切片
不拥有底层数据

例如：

fn print_name(
    name:&str,
) {
    println!("{}",name);
}

调用：

let name=
    String::from("Rust");

print_name(&name);
print_name("Hello");

函数参数只需要读取字符串时，&str通常比&String更加通用。

Vec

动态数组：

let mut values=
    Vec::new();

values.push(10);
values.push(20);

或者：

let values=
    vec![1,2,3];

Vec<T>是Rust项目中最常见的数据结构之一。
适合：

文件列表
接口结果
任务集合
数据批次
动态数组

很多批量程序最终都会形成：

输入
↓
Vec<T>
↓
Iterator
↓
处理

HashMap

键值映射：

use std::collections::HashMap;

let mut map=
    HashMap::new();

map.insert(
    "name",
    "Rust",
);

适合：

配置映射
缓存
统计
索引
去重辅助

需要理解：

Key
通常要求Hash+Eq

前面Hash章节学习的Trait就在这里大量使用。

Option

Rust没有鼓励到处使用：

null

而是：

Option<T>

例如：

let value:
    Option<String>=
    Some(
        "Rust".into()
    );

或者：

None

处理：

match value {
    Some(v)=>{
        println!("{}",v);
    }
    None=>{
        println!("无数据");
    }
}

Option的意义是：

“可能不存在”本身就是类型的一部分。

Result<T,E>

可恢复错误：

fn load()
    ->Result<
        String,
        std::io::Error
    >
{
    std::fs::read_to_string(
        "data.txt"
    )
}

Result：

Ok(T)
Err(E)

结合：

?

可以形成Rust非常核心的错误传播方式。
例如：

fn run()
    ->Result<
        (),
        std::io::Error
    >
{
    let text=
        std::fs::read_to_string(
            "data.txt"
        )?;

    println!("{}",text);

    Ok(())
}

Box

Box<T>表示堆上拥有的数据：

let value=
    Box::new(100);

它经常用于：

递归数据结构
Trait Object
大对象
间接所有权

例如：

enum Node {
    Value(i32),
    Next(
        Box<Node>
    ),
}

如果没有Box，递归类型大小无法确定。

Rc

单线程共享所有权：

use std::rc::Rc;

let data=
    Rc::new(
        String::from(
            "hello"
        )
    );

let a=
    Rc::clone(&data);

let b=
    Rc::clone(&data);

形成：

data
↑
a
b

多个所有者共享同一份数据。
但：

Rc
不能安全跨线程

Arc

多线程共享：

use std::sync::Arc;

let data=
    Arc::new(
        String::from(
            "hello"
        )
    );

Arc使用原子引用计数，适合：

线程池
Tokio任务
共享配置
共享Client

经常看到：

Arc<AppState>

就是这个原因。

Cell与RefCell

Rust通常在编译期检查借用规则，但某些场景需要：

Interior Mutability
内部可变性

单线程常见：

Cell<T>
RefCell<T>

RefCell把部分借用检查从：

编译期

推迟到：

运行期

如果违反规则会panic。
所以它解决的是特殊所有权结构，不是绕开Rust安全模型。

Mutex

多线程共享可变数据：

use std::sync::Mutex;

let count=
    Mutex::new(0);

{
    let mut value=
        count.lock()
            .unwrap();

    *value+=1;
}

典型组合：

Arc<Mutex<T>>

表示：

跨线程共享
+
互斥修改

但锁竞争严重时会降低性能。

RwLock

如果业务：

读很多
写很少

可以考虑：

RwLock<T>

允许多个Reader同时读取：

let data=
    lock.read()
        .unwrap();

写入：

let mut data=
    lock.write()
        .unwrap();

是否比Mutex更快，需要根据实际负载判断。

Path与PathBuf

文件路径不要直接使用String表示。
借用路径：

&Path

拥有路径：

PathBuf

例如：

use std::path::PathBuf;

let path=
    PathBuf::from(
        "data"
    )
    .join(
        "a.txt"
    );

优点：

跨平台
支持非UTF-8路径
方便join
方便extension
方便file_name

这是文件工具开发非常重要的基础。

std::fs

常见文件操作：

std::fs::read(...)
std::fs::read_to_string(...)
std::fs::write(...)
std::fs::copy(...)
std::fs::rename(...)
std::fs::remove_file(...)
std::fs::create_dir_all(...)
std::fs::read_dir(...)

例如：

let text=
    std::fs::read_to_string(
        "config.toml"
    )?;

如果只是简单文件操作，标准库已经非常够用。

File

需要更底层控制：

use std::fs::File;

let file=
    File::open(
        "data.txt"
    )?;

写：

let file=
    File::create(
        "output.txt"
    )?;

还可以通过：

OpenOptions

实现：

追加
读写
创建
截断

BufReader

频繁小读取时：

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

let file=
    File::open(
        "data.txt"
    )?;

let reader=
    BufReader::new(
        file
    );

读取行：

for line in
    reader.lines()
{
    println!(
        "{}",
        line?
    );
}

它通过缓冲减少系统调用。

BufWriter

大量小写入：

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

let file=
    File::create(
        "output.txt"
    )?;

let mut writer=
    BufWriter::new(
        file
    );

writeln!(
    writer,
    "hello"
)?;

批量文件、CSV、日志生成等场景非常常见。

Read与Write

Rust IO大量围绕Trait：

Read
Write
BufRead
Seek

例如：

reader.read(
    &mut buffer
)?;

writer.write_all(
    data
)?;

理解这些Trait后，文件、TCP、内存Buffer等API会变得非常相似。

std::env

环境变量：

let value=
    std::env::var(
        "APP_PORT"
    )?;

命令行参数：

let args:
    Vec<String>=
    std::env::args()
        .collect();

当前目录：

let dir=
    std::env::current_dir()?;

临时目录：

let temp=
    std::env::temp_dir();

前面的dotenv和config最终都大量建立在这些基础能力上。

Command

运行外部程序：

use std::process::Command;

let output=
    Command::new(
        "ffmpeg"
    )
    .arg("-version")
    .output()?;

可以获得：

stdout
stderr
status

例如：

println!(
    "{}",
    String::from_utf8_lossy(
        &output.stdout
    )
);

批量PDF、CAD、视频、图片工具经常需要调用第三方命令行程序，这时Command非常重要。

Process

通过：

Command::spawn()

可以获得：

Child

然后：

child.wait()?;

也可以管理：

stdin
stdout
stderr

适合：

长时间外部任务
实时读取输出
进度解析
停止子进程

Duration

表示时间长度：

use std::time::Duration;

let timeout=
    Duration::from_secs(5);

还可以：

Duration::from_millis(500)
Duration::from_secs(60)

常用于：

超时
Sleep
网络
重试
性能统计

Instant

测量耗时：

use std::time::Instant;

let start=
    Instant::now();

do_work();

println!(
    "{:?}",
    start.elapsed()
);

性能测试、慢任务检测应该优先考虑Instant，而不是SystemTime。

SystemTime

用于：

系统时间点
文件时间
Unix时间戳

例如：

use std::time::{
    SystemTime,
    UNIX_EPOCH,
};

let timestamp=
    SystemTime::now()
        .duration_since(
            UNIX_EPOCH
        )?
        .as_secs();

SystemTime与Instant解决的问题不同：

SystemTime
现在几点

Instant
过去多久

TCP

标准库：

use std::net::{
    TcpListener,
    TcpStream,
};

服务器：

let listener=
    TcpListener::bind(
        "127.0.0.1:8080"
    )?;

客户端：

let stream=
    TcpStream::connect(
        "127.0.0.1:8080"
    )?;

它们是同步阻塞网络API。

UDP

use std::net::UdpSocket;

let socket=
    UdpSocket::bind(
        "0.0.0.0:9000"
    )?;

发送：

socket.send_to(
    b"hello",
    "127.0.0.1:9001"
)?;

标准库已经能完成基础Socket开发。
复杂异步服务则通常使用Tokio。

thread

创建线程：

use std::thread;

let handle=
    thread::spawn(
        ||{
            println!(
                "worker"
            );
        }
    );

handle.join()
    .unwrap();

但实际项目中大量短任务一般不会为每个任务直接创建新线程，而是采用：

线程池
Rayon
Tokio

等更高层抽象。

Channel

线程间消息通信：

use std::sync::mpsc;

let (
    tx,
    rx
)=mpsc::channel();

tx.send(100)?;

let value=
    rx.recv()?;

形成：

线程A
↓send
Channel
↓recv
线程B

很多并发系统都可以从“共享内存”和“消息传递”两个方向思考。

Atomic

简单共享计数：

use std::sync::atomic::{
    AtomicUsize,
    Ordering,
};

let count=
    AtomicUsize::new(0);

count.fetch_add(
    1,
    Ordering::Relaxed
);

比Mutex更加轻量，但只适合有限的原子操作。
复杂共享状态仍然需要更合适的同步结构。

Iterator

Rust标准库中极其重要的一套抽象：

values.iter()
    .filter(...)
    .map(...)
    .take(...)
    .collect::<Vec<_>>();

核心思想：

数据源
↓
一系列转换
↓
最终消费

很多第三方库，例如Rayon，也正是沿用了Iterator式API。

IntoIterator

为什么：

for item in values {
}

可以工作？
因为类型可以实现：

IntoIterator

所以Rust中的：

for
Iterator
IntoIterator

实际上是一套统一体系。

From与Into

类型转换：

let value=
    String::from(
        "hello"
    );

如果：

From<A> for B

成立，那么通常就可以获得对应：

Into<B> for A

这也是很多Rust API能够自然进行类型转换的原因。

AsRef

如果函数只想接受“能够借用成某类型”的值：

fn open_file(
    path:impl AsRef<Path>,
) {
}

调用可以：

open_file(
    "a.txt"
);

open_file(
    PathBuf::from(
        "a.txt"
    )
);

这比只接受某一个具体路径类型更加灵活。

Borrow

Borrow与AsRef都有借用转换的含义，但Borrow还包含更强的等价语义约束，经常和集合查找有关。
例如HashMap可以用：

String作为Key
&str进行查询

背后就涉及Borrow等标准Trait设计。
普通业务API中更常见的是：

AsRef

Error Trait

Rust标准错误接口：

std::error::Error

通常配合：

Debug
Display
source

前面学习的：

anyhow
thiserror

其实都是围绕标准库Error体系构建的。
因此第三方错误库并没有绕开Rust标准机制，而是在它之上提供更方便的抽象。

Drop

资源生命周期结束：

impl Drop
    for MyResource
{
    fn drop(
        &mut self
    ) {
        println!(
            "释放资源"
        );
    }
}

Rust很多资源管理都依赖：

RAII

例如：

File
MutexGuard
Socket
WorkerGuard

对象离开作用域时自动清理资源。

Default

提供默认值：

#[derive(Default)]
struct Config {
    debug:bool,
    workers:usize,
}

然后：

let config=
    Config::default();

Serde配置、Builder和测试数据中都非常常见。

Clone与Copy

Copy：

按位复制即可
原值仍可继续使用

Clone：

显式复制
可能发生堆内存分配

例如：

let a=10;
let b=a;

i32实现Copy。
String：

let a=
    String::from("hello");

let b=
    a.clone();

理解Clone与Copy有助于避免为了通过编译而到处无脑clone()。

Debug与Display

Debug：

println!("{:?}",value);

主要给开发者。
Display：

println!("{}",value);

主要用于用户可读展示。
错误类型通常应该同时考虑：

Debug
Display

这也是thiserror自动处理的重要内容。

标准库和第三方crate怎么选

一个很实用的原则：

标准库已经简单解决
→优先std

标准库需要大量重复代码
且成熟crate已经解决
→使用crate

例如：

单层目录
→std::fs::read_dir

复杂递归目录
→walkdir

简单线程
→std::thread

数据并行
→rayon

同步TCP
→std::net

异步高并发HTTP
→Tokio+Axum

简单错误
→Result

应用复杂错误
→anyhow

不要为了“纯标准库”重复造大量基础设施，也不要为了几行代码无脑引入几十个依赖。

Rust工程知识地图

经过前面120篇内容，可以逐渐形成：

Rust语言基础
├──变量
├──类型
├──函数
├──控制流
└──模式匹配

数据结构
├──Array
├──Tuple
├──Vec
├──HashMap
├──String
├──Option
└──Result

核心机制
├──所有权
├──Borrow
├──生命周期
├──Trait
├──泛型
└──Iterator

内存与并发
├──Box
├──Rc
├──Arc
├──RefCell
├──Mutex
├──RwLock
├──Send
└──Sync

系统开发
├──File
├──Path
├──Process
├──Command
├──TCP
├──UDP
└──时间

工程生态
├──Serde
├──Clap
├──Config
├──Tracing
├──Anyhow
├──Thiserror
├──Rayon
└──WalkDir

这已经覆盖了大量真实Rust项目的基础能力。

学标准库真正要学什么

不是背：

所有std函数

而是建立：

遇到问题
↓
知道应该去哪个模块

例如：

文件
→std::fs

路径
→std::path

IO
→std::io

网络
→std::net

线程
→std::thread

同步
→std::sync

时间
→std::time

进程
→std::process

环境
→std::env

集合
→std::collections

知道这些模块以后，再查具体API会非常快。

常见错误

什么都用String

路径用PathBuf，时间用Duration，错误用Result，数据要尽量强类型。

能unwrap就unwrap

外部输入、文件、网络、配置都可能正常失败，应合理传播错误。

为了并发到处Arc<Mutex>

优先考虑所有权拆分、消息传递和无共享状态计算。

所有功能都自己造

成熟crate能明显降低工程复杂度。

什么都找第三方crate

简单功能标准库已经足够时，没有必要增加依赖。

clone解决所有权问题

大量clone有时意味着所有权设计还可以改进。

文件路径转String太早

尽量使用Path、PathBuf和OsStr。

标准库学习最佳实践

• • 先理解类型和Trait，再记具体函数。
• • 文件代码优先掌握Path、File、Read、Write。
• • 并发代码先理解Send、Sync、Arc和Mutex。
• • 网络开发先理解Socket、TCP和UDP，再学习HTTP框架。
• • 错误处理先掌握Result和Error，再使用anyhow/thiserror。
• • 性能优化先测量，再考虑线程、Rayon和缓存。
• • 尽量让错误和非法状态在类型层被表达出来。
• • 标准库解决基础问题，第三方crate解决更高层工程问题。

本章小结

Rust标准库不是一堆零散API，而是一套围绕所有权、Trait和强类型构建起来的基础开发体系。
本文回顾了：

• • String与str负责字符串所有权和借用
• • Vec与HashMap负责常见集合
• • Option与Result表达可选值和错误
• • Box、Rc、Arc管理不同所有权结构
• • Mutex、RwLock、Atomic处理并发共享
• • Path与PathBuf负责跨平台路径
• • fs、File、BufReader、BufWriter负责文件和IO
• • env和Command负责环境与外部进程
• • Duration、Instant、SystemTime负责时间
• • TcpStream、TcpListener、UdpSocket负责基础网络
• • thread、Channel负责线程和消息通信
• • Iterator、From、Into、AsRef等Trait构成大量Rust API共同语言
  可以记住：

真正熟悉Rust标准库，不是记住几百个函数，而是看到需求时能够迅速判断：应该使用哪个类型、哪个Trait、哪个模块，以及是否真的需要第三方crate。
当这些基础形成体系以后，学习Web框架、数据库、微服务和大型工程就会容易很多。

下一篇预告

从下一篇开始，我们正式进入Rust Web后端实战：

Rust Axum入门：从第一个HTTP Server到REST API实战

内容包括：

• • Axum是什么
• • Axum与Tokio关系
• • 创建项目
• • 安装axum
• • Router
• • Route
• • get
• • post
• • Handler
• • 启动HTTP Server
• • TcpListener
• • Path参数
• • Query参数
• • JSON请求
• • JSON响应
• • StatusCode
• • State
• • Extension
• • Middleware概念
• • REST API
• • 错误处理
• • tracing日志
• • Axum项目目录设计
• • 第一个完整Web API项目