1.1 Rust 语言的诞生与发展历史

Rust 是一门由 Mozilla 研究院的 Graydon Hoare 于 2006 年开始设计的系统编程语言。2010 年，Mozilla 正式宣布支持这个项目。2015 年 5 月 15 日，Rust 1.0 正式发布，标志着语言进入稳定阶段。

为什么会有 Rust？

在 Rust 诞生之前，系统编程领域主要由 C 和 C++ 主导。这些语言提供了对硬件的底层控制能力和极高的性能，但也带来了严重的内存安全问题：

• 内存泄漏：忘记释放分配的内存
• 悬垂指针：访问已经释放的内存
• 数据竞争：多线程同时访问同一内存位置
• 缓冲区溢出：写入超出分配范围的内存

这些问题导致了大量的安全漏洞和程序崩溃。根据微软和谷歌的统计，约 70% 的安全漏洞源于内存安全问题。

Rust 的设计目标就是在保持 C/C++ 级别性能的同时，通过编译器在编译期消除这些内存安全问题。

发展里程碑

• 2006：Graydon Hoare 开始个人项目
• 2009：Mozilla 开始赞助
• 2010：项目公开
• 2015：Rust 1.0 发布，承诺向后兼容
• 2018：Rust 2018 Edition 发布，改进模块系统和错误处理
• 2021：Rust 2021 Edition 发布，改进闭包捕获和 Cargo 特性
• 2021：Rust 基金会成立，成员包括 AWS、Google、华为、微软、Mozilla
• 2024：Rust 进入 Linux 内核主线

---

1.2 Rust 的核心设计哲学：安全、并发、高性能

Rust 的设计围绕三大核心理念：

1.2.1 内存安全（Memory Safety）

Rust 通过**所有权系统（Ownership System）**在编译期保证内存安全，无需垃圾回收器（GC）。

核心机制：

• 每个值都有一个所有者
• 同一时间只能有一个所有者
• 当所有者离开作用域，值被自动释放

这意味着：

• ✅ 不会有悬垂指针
• ✅ 不会有双重释放
• ✅ 不会有数据竞争
• ✅ 不需要手动管理内存

1.2.2 并发安全（Concurrency Safety）

Rust 的类型系统和所有权规则在编译期防止数据竞争：

// 编译器会阻止这种不安全的并发访问
let mut data = vec![1, 2, 3];
thread::spawn(|| {
    data.push(4); // 编译错误！
});
data.push(5); // 编译错误！

Rust 的口号是：“无畏并发（Fearless Concurrency）”——你可以放心地编写并发代码，编译器会帮你检查安全性。

1.2.3 零成本抽象（Zero-Cost Abstractions）

Rust 提供高级抽象（如迭代器、闭包、泛型），但不会带来运行时开销：

// 高级抽象
let sum: i32 = (1..=100).filter(|x| x % 2 == 0).sum();

// 编译后的性能等同于手写循环
let mut sum = 0;
for i in 1..=100 {
    if i % 2 == 0 {
        sum += i;
    }
}

Rust 的承诺：“你不使用的功能，不会为其付出代价；你使用的功能，无法手写得更好。”

---

1.3 Rust 能做什么：系统编程、WebAssembly、嵌入式、Web 后端、CLI 工具

Rust 的应用场景非常广泛：

1.3.1 系统编程

• 操作系统：Redox OS（完全用 Rust 编写的操作系统）
• 内核模块：Linux 内核驱动（从 6.1 版本开始支持）
• 文件系统：TiKV（分布式 KV 存储）

1.3.2 WebAssembly

Rust 是 WebAssembly 的首选语言之一：

• 前端性能优化：将计算密集型任务编译为 WASM
• 游戏引擎：Bevy、Amethyst
• 图像处理：在浏览器中运行高性能图像处理

1.3.3 嵌入式开发

• 微控制器编程：支持 ARM Cortex-M 系列
• 物联网设备：低功耗、高可靠性
• 实时系统：无 GC 暂停，可预测的性能

1.3.4 Web 后端

• Web 框架：Axum、Actix-Web、Rocket
• 数据库：TiDB、SurrealDB
• API 服务：Discord、Cloudflare Workers

1.3.5 命令行工具

• ripgrep：比 grep 快得多的搜索工具
• fd：比 find 更友好的文件查找工具
• bat：增强版的 cat
• exa：现代化的 ls 替代品

1.3.6 区块链与加密货币

• Solana：高性能区块链平台
• Polkadot：跨链协议
• Libra/Diem：Facebook 的数字货币项目

---

1.4 Rust 与 C/C++/Go/Java 的对比

特性	C/C++	Java	Go	Rust
内存管理	手动	GC	GC	所有权系统
内存安全	❌ 运行时错误	✅ GC 保证	✅ GC 保证	✅ 编译期保证
并发安全	❌ 需手动保证	⚠️ 运行时检查	⚠️ 运行时检查	✅ 编译期保证
性能	⭐⭐⭐⭐⭐	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
学习曲线	陡峭	平缓	平缓	陡峭
编译速度	快（C）/慢（C++）	中等	快	慢
包管理	无标准（CMake/Conan）	Maven/Gradle	go mod	Cargo
空指针	可能	可能	可能	编译期消除（Option）

从其他语言迁移到 Rust

• C/C++ 开发者：熟悉的性能，但需要适应所有权系统
• Java/C# 开发者：需要理解无 GC 的内存管理
• Go 开发者：更严格的类型系统，更复杂但更安全
• Python/JavaScript 开发者：需要适应静态类型和编译期检查

---

1.5 开发环境搭建（rustup、cargo、VS Code / RustRover）

1.5.1 安装 Rust 工具链

Rust 使用 rustup 作为官方的工具链管理器。

Windows 系统

1. 访问 https://rustup.rs/
2. 下载并运行 rustup-init.exe
3. 按照提示完成安装（通常选择默认选项）
4. 可能需要安装 Visual Studio C++ Build Tools

macOS / Linux 系统

打开终端，运行：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

按照提示完成安装。

验证安装

rustc --version  # 查看 Rust 编译器版本
cargo --version  # 查看 Cargo 版本

输出示例：

rustc 1.95.0 (59807616e 2026-04-14)
cargo 1.95.0 (f2d3ce0bd 2026-03-21)

1.5.2 Rust 工具链组成

安装完成后，你会得到以下工具：

• rustc：Rust 编译器
• cargo：包管理器和构建工具
• rustup：工具链管理器
• rustfmt：代码格式化工具
• clippy：代码检查工具（linter）

1.5.3 配置编辑器

VS Code（推荐初学者）

1. 安装 VS Code：https://code.visualstudio.com/
2. 安装扩展：
   • rust-analyzer（必装）：提供智能提示、跳转、重构等功能
   • CodeLLDB（可选）：调试支持
   • Even Better TOML（可选）：Cargo.toml 语法高亮

RustRover（JetBrains 出品）

1. 下载 RustRover：https://www.jetbrains.com/rust/
2. 开箱即用，无需额外配置
3. 提供强大的代码分析和重构功能

其他编辑器

• Vim/Neovim：rust.vim + coc-rust-analyzer
• Emacs：rust-mode + lsp-mode
• Sublime Text：Rust Enhanced

1.5.4 配置国内镜像（可选，加速下载）

如果你在中国大陆，可以配置镜像源加速依赖下载。

编辑 ~/.cargo/config.toml（如果不存在则创建）：

[source.crates-io]
replace-with = 'ustc'

[source.ustc]
registry = "sparse+https://mirrors.ustc.edu.cn/crates.io-index/"

---

1.6 第一个程序：Hello, World!

1.6.1 创建项目

打开终端，运行：

cargo new hello_rust
cd hello_rust

这会创建以下目录结构：

hello_rust/
├── Cargo.toml      # 项目配置文件
└── src/
    └── main.rs     # 源代码文件

1.6.2 查看代码

打开 src/main.rs，你会看到：

fn main() {
    println!("Hello, world!");
}

代码解析：

• fn main()：定义主函数，程序的入口点
• println!：宏（注意末尾的 !），用于打印文本到控制台
• "Hello, world!"：字符串字面量
• ;：语句结束符

1.6.3 运行程序

cargo run

输出：

   Compiling hello_rust v0.1.0 (/path/to/hello_rust)
    Finished dev [unoptimized + debuginfo] target(s) in 0.50s
     Running `target/debug/hello_rust`
Hello, world!

发生了什么？

1. cargo run 首先编译项目
2. 生成可执行文件到 target/debug/hello_rust
3. 自动运行该可执行文件

1.6.4 修改代码

让我们修改程序，让它更有趣：

fn main() {
    println!("你好，Rust！");
    println!("我的第一个 Rust 程序");
    
    // 这是单行注释
    let name = "学习者";
    println!("欢迎 {} 来到 Rust 世界！", name);
}

再次运行：

cargo run

输出：

你好，Rust！
我的第一个 Rust 程序
欢迎 学习者 来到 Rust 世界！

新知识点：

• //：单行注释
• let name = "学习者";：声明变量
• {}：占位符，用于格式化输出

---

1.7 Cargo 项目管理基础（new、build、run、test、doc）

Cargo 是 Rust 的官方构建工具和包管理器，类似于 Node.js 的 npm、Python 的 pip。

1.7.1 常用 Cargo 命令

创建新项目

cargo new my_project        # 创建二进制项目（可执行程序）
cargo new my_lib --lib      # 创建库项目

构建项目

cargo build                 # 调试构建（快速，未优化）
cargo build --release       # 发布构建（慢，完全优化）

运行项目

cargo run                   # 编译并运行
cargo run --release         # 以发布模式运行

检查代码

cargo check                 # 快速检查代码是否能编译（不生成可执行文件）

运行测试

cargo test                  # 运行所有测试

生成文档

cargo doc --open            # 生成并打开项目文档

清理构建产物

cargo clean                 # 删除 target 目录

1.7.2 Cargo.toml 配置文件

Cargo.toml 是项目的配置文件，使用 TOML 格式：

[package]
name = "hello_rust"          # 项目名称
version = "0.1.0"            # 版本号
edition = "2021"             # Rust 版本（2015/2018/2021）

[dependencies]
# 这里添加依赖库
# 例如：serde = "1.0"

添加依赖

假设我们要使用 rand 库生成随机数：

[dependencies]
rand = "0.8"

然后在代码中使用：

use rand::Rng;

fn main() {
    let random_number = rand::thread_rng().gen_range(1..=100);
    println!("随机数：{}", random_number);
}

运行 cargo run，Cargo 会自动下载并编译 rand 库。

1.7.3 项目结构

标准的 Cargo 项目结构：

my_project/
├── Cargo.toml              # 项目配置
├── Cargo.lock              # 依赖版本锁定（自动生成）
├── src/
│   ├── main.rs             # 二进制项目的入口
│   └── lib.rs              # 库项目的入口
├── tests/                  # 集成测试
├── benches/                # 基准测试
└── target/                 # 构建产物（不提交到版本控制）
    ├── debug/              # 调试构建
    └── release/            # 发布构建

---

1.8 如何阅读 Rust 编译器错误信息

Rust 编译器以其友好的错误信息而闻名。让我们通过实例学习如何阅读错误信息。

1.8.1 示例：忘记分号

fn main() {
    let x = 5
    println!("x = {}", x);
}

编译器输出：

error: expected `;`, found keyword `println`
 --> src/main.rs:3:5
  |
2 |     let x = 5
  |              - help: add `;` here
3 |     println!("x = {}", x);
  |     ^^^^^^^ expected `;`

如何阅读：

1. 错误类型：error（错误）或 warning（警告）
2. 错误描述：expected ';', found keyword 'println'
3. 位置：src/main.rs:3:5（文件:行:列）
4. 代码片段：显示出错的代码
5. 建议：help: add ';' here

修复：

fn main() {
    let x = 5;  // 添加分号
    println!("x = {}", x);
}

1.8.2 示例：类型不匹配

fn main() {
    let x: i32 = "hello";
}

编译器输出：

error[E0308]: mismatched types
 --> src/main.rs:2:18
  |
2 |     let x: i32 = "hello";
  |            ---   ^^^^^^^ expected `i32`, found `&str`
  |            |
  |            expected due to this

解读：

• 错误代码：E0308（可以搜索 rustc --explain E0308 查看详细说明）
• 问题：类型不匹配
• 期望类型：i32（32位整数）
• 实际类型：&str（字符串切片）

修复：

fn main() {
    let x: i32 = 42;        // 使用整数
    // 或者
    let x: &str = "hello";  // 使用字符串
}

1.8.3 示例：未使用的变量

fn main() {
    let x = 5;
}

编译器输出：

warning: unused variable: `x`
 --> src/main.rs:2:9
  |
2 |     let x = 5;
  |         ^ help: if this is intentional, prefix it with an underscore: `_x`
  |
  = note: `#[warn(unused_variables)]` on by default

解读：

• 这是警告（warning），不是错误，程序仍可编译
• 建议：如果故意不使用，可以用 _x 命名

修复方式：

fn main() {
    let _x = 5;  // 前缀 _ 表示故意不使用
    // 或者
    let x = 5;
    println!("{}", x);  // 使用变量
}

1.8.4 使用 rustc --explain

对于任何错误代码，可以查看详细解释：

rustc --explain E0308

这会显示该错误的详细说明和示例。

---

1.9 如何查阅文档（std 文档、docs.rs 导航）

1.9.1 标准库文档

Rust 标准库文档非常详细，包含大量示例。

在线访问：

• 官方：https://doc.rust-lang.org/std/
• 中文：https://rustwiki.org/zh-CN/std/

本地访问：

rustup doc --std

这会在浏览器中打开本地的标准库文档。

如何使用：

1. 搜索功能：按 S 键打开搜索框
2. 查看模块：左侧导航栏列出所有模块
3. 查看示例：每个函数都有使用示例

示例：查找 Vec 的文档

1. 打开标准库文档
2. 搜索 Vec
3. 查看 std::vec::Vec 的文档
4. 阅读方法列表和示例

1.9.2 第三方库文档（docs.rs）

所有发布到 crates.io 的库都会自动在 docs.rs 生成文档。

访问方式：

• 直接访问：https://docs.rs/库名
• 例如：https://docs.rs/serde

从 crates.io 跳转：

1. 访问 https://crates.io/
2. 搜索库名
3. 点击 “Documentation” 链接

1.9.3 查看项目依赖的文档

cargo doc --open

这会生成当前项目及其所有依赖的文档，并在浏览器中打开。

1.9.4 文档注释

Rust 支持文档注释，可以生成 HTML 文档：

/// 计算两个数的和
/// 
/// # 示例
/// 
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
fn add(a: i32, b: i32) -> i32 {
    a + b
}

• ///：文档注释（用于函数、结构体等）
• //!：模块级文档注释

---

常见误区与陷阱

误区 1：混淆 cargo build 和 cargo run

❌ 错误理解：以为 cargo build 会运行程序

✅ 正确理解：

• cargo build：只编译，生成可执行文件
• cargo run：编译并运行

误区 2：忽略编译器警告

❌ 错误做法：只要能编译通过就行，忽略警告

✅ 正确做法：

• 警告通常指出潜在问题
• 养成消除所有警告的习惯
• 可以用 #[allow(unused_variables)] 明确允许特定警告

误区 3：不理解 PATH 环境变量

问题现象：安装 Rust 后，终端提示 cargo: command not found

原因：Cargo 的路径未添加到 PATH 环境变量

解决方案：

• macOS/Linux：在 ~/.bashrc 或 ~/.zshrc 中添加：

  export PATH="$HOME/.cargo/bin:$PATH"
  

  然后运行 source ~/.bashrc

• Windows：rustup 安装时通常会自动配置，如果没有，手动添加 %USERPROFILE%\.cargo\bin 到 PATH

误区 4：混淆 rustc 和 cargo

❌ 错误理解：以为 rustc 是主要的开发工具

✅ 正确理解：

• rustc：底层编译器，通常不直接使用
• cargo：高层构建工具，日常开发的主要工具
• 类比：rustc 像 gcc，cargo 像 make + npm

误区 5：不会读编译错误

❌ 错误做法：看到一堆错误信息就慌了

✅ 正确做法：

1. 从第一个错误开始看
2. 阅读错误描述和建议
3. 查看代码位置
4. 修复后重新编译
5. 很多后续错误会自动消失

---

实战练习

练习 1.1：修改 Hello World

要求：

1. 创建一个新项目 greeting
2. 修改程序，让它打印你的名字和当前日期
3. 使用变量存储名字

提示：

• 使用 let 声明变量
• 使用 println! 的格式化功能

参考答案：

cargo new greeting
cd greeting

编辑 src/main.rs：

fn main() {
    let name = "张三";
    let date = "2024-12-01";
    
    println!("你好，我是 {}！", name);
    println!("今天的日期是：{}", date);
    println!("欢迎来到 Rust 的世界！");
}

输出：

你好，我是 张三！
今天的日期是：2024-12-01
欢迎来到 Rust 的世界！

---

练习 1.2：探索 Cargo 命令

要求：

1. 使用 cargo new 创建一个项目
2. 尝试 cargo build、cargo run、cargo check
3. 观察 target 目录的变化
4. 比较 debug 和 release 构建的文件大小

提示：

• 使用 ls -lh target/debug/ 查看文件大小（Linux/macOS）
• 使用 dir target\debug\ 查看文件（Windows）

参考答案：

# 1. 创建项目
cargo new explore_cargo
cd explore_cargo

# 2. 快速检查（不生成可执行文件，最快）
cargo check

# 3. 调试构建
cargo build
# 观察：生成 target/debug/explore_cargo（或 .exe）

# 4. 编译并运行
cargo run

# 5. 发布构建
cargo build --release
# 观察：生成 target/release/explore_cargo（或 .exe）

# 6. 比较文件大小
# Linux/macOS:
ls -lh target/debug/explore_cargo target/release/explore_cargo
# Windows:
# dir target\debug\explore_cargo.exe target\release\explore_cargo.exe

观察要点：

• cargo check 比 cargo build 快，因为不生成可执行文件
• release 构建比 debug 构建的文件更小（经过优化）
• debug 构建更快但不优化，适合开发；release 构建更慢但运行更快，适合发布

---

练习 1.3：阅读编译错误

要求：
故意制造以下错误，观察编译器输出：

1. 忘记分号
2. 变量名拼写错误
3. 使用未声明的变量

目的：熟悉编译器的错误信息格式

参考答案：

错误 1：忘记分号

fn main() {
    let x = 5
    println!("x = {}", x);
}

编译器会提示在 let x = 5 后面需要添加 ;。

错误 2：变量名拼写错误

fn main() {
    let message = "hello";
    println!("{}", mesage); // 拼写错误：mesage
}

编译器会提示 mesage 未找到，并建议使用 message。

错误 3：使用未声明的变量

fn main() {
    println!("{}", y); // y 未声明
}

编译器会提示 cannot find value 'y' in this scope。

学习要点：Rust 编译器会精确指出错误位置，并给出修复建议（help:）。养成仔细阅读错误信息的习惯，编译器是你最好的老师。

---

练习 1.4：查阅文档

要求：

1. 打开标准库文档
2. 查找 String 类型的文档
3. 找到 to_uppercase() 方法
4. 编写代码将字符串转为大写

参考答案：

fn main() {
    let s = String::from("hello");
    let upper = s.to_uppercase();
    println!("原始：{}", s);
    println!("大写：{}", upper);
}

输出：

原始：hello
大写：HELLO

说明：

• to_uppercase() 返回一个新的 String，不修改原始字符串
• 可以通过 rustup doc --std 打开本地文档，或访问 https://doc.rust-lang.org/std/string/struct.String.html

---

实战项目：个人信息卡片

项目描述：
创建一个程序，打印格式化的个人信息卡片。

功能需求：

1. 显示姓名、年龄、职业
2. 使用变量存储信息
3. 格式化输出

参考答案：

fn main() {
    let name = "张三";
    let age = 25;
    let job = "Rust 开发者";
    let email = "zhangsan@example.com";
    let city = "北京";
    
    println!("╔══════════════════════════════╗");
    println!("║       个人信息卡片           ║");
    println!("╠══════════════════════════════╣");
    println!("║ 姓名：{:<22}║", name);
    println!("║ 年龄：{:<22}║", age);
    println!("║ 职业：{:<22}║", job);
    println!("║ 邮箱：{:<22}║", email);
    println!("║ 城市：{:<22}║", city);
    println!("╚══════════════════════════════╝");
}

输出：

╔══════════════════════════════╗
║       个人信息卡片           ║
╠══════════════════════════════╣
║ 姓名：张三                   ║
║ 年龄：25                     ║
║ 职业：Rust 开发者            ║
║ 邮箱：zhangsan@example.com   ║
║ 城市：北京                   ║
╚══════════════════════════════╝

知识点：

• {:<22} 表示左对齐，占 22 个字符宽度
• Unicode 边框字符让输出更美观

---

本章小结

1. Rust 的核心优势：内存安全、并发安全、零成本抽象，在编译期消除大部分错误
2. 开发工具链：rustup 管理工具链，cargo 管理项目，rustc 编译代码
3. Cargo 是核心工具：cargo new 创建项目，cargo run 运行程序，cargo build 构建项目
4. 编译器是你的朋友：Rust 编译器提供详细的错误信息和修复建议，要仔细阅读
5. 文档是学习的宝库：标准库文档和 docs.rs 包含大量示例，善用搜索功能