Rust学习文档（一）

|----------|------------------------------------|
| 维度 | Rust |
| 类型系统 | 静态、强、编译期推断 |
| 内存管理 | 所有权 + 借用检查器（无 GC） |
| 并发模型 | "无畏并发"：编译器保证线程安全 |
| 抽象层级 | 零成本抽象，泛型/生命周期/trait |
| 编译模型 | 单步编译为原生二进制（LLVM 后端） |
| 包管理 | Cargo（构建、测试、发布一体化） |
| 典型场景 | 系统编程、CLI 工具、WebAssembly、嵌入式、Web 后端 |

2. 版本基线（2026 年中）

|--------------|---------------------------|---------------------------------------------------------------|
| 项目 | 版本 | 说明 |
| Rust Edition | 2024 Edition（Rust 1.85+） | 默认 edition，含 gen-blocks、unsafe extern blocks、cargo 目标相关改进 |
| 稳定版编译器 | 1.85+（推荐最新 stable） | rustup update 获取 |
| 包管理器 | Cargo（随编译器一起安装） | 2024 edition 默认支持 edition-aware 依赖解析 |
| 异步运行时 | tokio 1.x / async-std | tokio 为生态事实标准 |
| Web 框架 | axum 0.8+ / actix-web 4.x | axum 基于 tower，生态最活跃 |

3. 与其他语言的定位对比

|-----------|-----------------------|----------------|---------------|---------------------|
| 特性 | C | C++ | Go | Rust |
| 内存安全 | 手动（unsafe by default） | 手动 + RAII | GC | 编译期所有权检查 |
| 空安全 | 无保障 | 无保障（nullptr） | 有（nil） | Option 编译期排除 |
| 数据竞争 | 程序员负责 | 程序员负责 | 部分保障（channel） | 编译期排除 |
| 性能天花板 | 极高 | 极高 | 高（GC 开销） | 极高（零成本抽象） |
| 学习曲线 | 中 | 高 | 低 | 高（所有权、生命周期） |
| 编译速度 | 快 | 慢 | 快 | 中等偏慢 |

4. 学习路线图（四个阶段）

阶段一：基础入门（1-2 周）

┌─────────────────────────────────────────┐

│ 安装 → Hello World → 变量/类型/控制流 │

│ 所有权 & 借用（核心难点，反复理解） │

│ 结构体、枚举、模式匹配 │

└─────────────────────────────────────────┘

↓

阶段二：中级能力（3-4 周）

┌─────────────────────────────────────────┐

│ 集合类型（Vec, String, HashMap） │

│ 模块系统、包管理、Cargo │

│ 错误处理（Result, panic） │

│ 泛型、Trait、生命周期（第二个难点） │

│ 测试编写与组织 │

└─────────────────────────────────────────┘

↓

阶段三：进阶特性（4-6 周）

┌─────────────────────────────────────────┐

│ 闭包与迭代器（函数式特性） │

│ 智能指针（Box, Rc, RefCell） │

│ 无畏并发（线程、通道、共享状态） │

│ 面向对象特性与 Trait 对象 │

│ 高级模式匹配 │

└─────────────────────────────────────────┘

↓

阶段四：高级与实战（持续）

┌─────────────────────────────────────────┐

│ unsafe Rust、高级 Trait、高级类型 │

│ 宏（声明宏与过程宏） │

│ 实战项目（CLI / Web Server） │

│ 与前端结合：Wasm、Tauri、Neon │

└─────────────────────────────────────────┘

5. 文档地图

|--------|---------------------|-----------|--------------------------------|
| 编号 | 文件 | 覆盖章节 | 内容概要 |
| 00 | 本文件 | --- | 总览、版本、学习路线、文档地图 |
| 01 | $01-入门基础$ | Ch 1-3 | 安装、Hello World、变量、类型、函数、控制流 |
| 02 | $02-所有权与借用$ | Ch 4 | 所有权规则、引用、借用、Slices、生命周期预告 |
| 03 | $03-结构体与枚举$ | Ch 5-6 | 结构体定义与方法、枚举定义、match、if let |
| 04 | $04-集合类型$ | Ch 8 | Vec、String（UTF-8）、HashMap |
| 05 | $05-模块与包管理$ ( | Ch 7, 14 | 包/Crate/模块、路径、use、Cargo 进阶 |
| 06 | $06-错误处理与测试$ | Ch 9, 11 | panic/Result、测试编写/运行/组织 |
| 07 | $07-泛型Trait与生命周期$ | Ch 10 | 泛型、Trait 定义与实现、生命周期标注 |
| 08 | $08-闭包与迭代器$ | Ch 13 | 闭包捕获、trait 约束、迭代器适配器 |
| 09 | $09-智能指针$ | Ch 15 | Box、Deref/Drop、Rc、RefCell、循环引用 |
| 10 | $10-无畏并发$ | Ch 16 | 线程、消息传递、Mutex/Arc、Sync/Send |
| 11 | $11-面向对象与模式匹配$ | Ch 17-18 | Trait 对象、状态模式、模式语法全集 |
| 12 | $12-高级特征$ | Ch 19 | unsafe、高级 Trait、高级类型、宏 |
| 13 | $13-项目实战$ | Ch 12, 20 | CLI 项目、多线程 Web Server |
| 14 | $14-附录速查$ | Ch 21 | 关键字、运算符、可派生 Trait、工具链 |

6. Rust 核心心智模型（学习前必读）

6.1 所有权（Ownership）------Rust 最重要的概念

三条铁律：

每个值有且只有一个 owner
同一时刻只能有 one mutable reference 或 N 个 immutable references（不可同时存在）

3.引用必须始终有效

6.2 类型系统设计哲学

|----------|---------------------|----------------------------|
| 概念 | Rust 做法 | 对比其他语言 |
| 空值 | Option<T> 替代 null | Java/C# 有 null，Go 有 nil |
| 错误 | Result<T, E> 替代异常 | Java/Python 用异常，Go 用多返回值 |
| 多态 | Trait + 泛型（单态化） | Java 用接口+擦除/桥接，Go 1.18+ 泛型 |
| 继承 | 组合 + Trait（无继承） | Java/C++ 有 class 继承 |
| 生命周期 | 显式标注（编译器推断辅助） | C/C++ 手动管理，GC 语言自动回收 |

6.3 编译器是你的伙伴

Rust 编译器的错误信息质量在所有语言中名列前茅：

编译器会给出具体的修复建议（"consider using clone()"）
借用检查器的错误会指向精确的冲突位置
学会阅读编译器错误本身就是 Rust 学习的重要部分

7. 学习建议

|--------------------|----------------------------------------|
| 建议 | 说明 |
| 不要跳过所有权 | 所有权是 Rust 的灵魂，后续所有概念都建立在其之上 |
| 多写小练习 | rustlings 练习题库（官方）是最佳入门伴侣 |
| 学会读错误 | 编译器报错不是惩罚，而是教学 |
| 先理解再记忆 | Rust 的规则都有内存安全层面的原因，理解"为什么"比死记"怎么做"重要 |
| 利用 Rust by Example | 配合 The Book 阅读，代码示例密集，适合快速查阅 |
| 关注 Edition 差异 | 2024 Edition 有语法改进，网上的旧代码可能基于旧 edition |

01 入门基础

1.1 安装与环境配置

安装 rustup

bash 复制代码

# macOS / Linux

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



# 安装完成后验证

rustc --version    # 如: rustc 1.85.0 (...)

cargo --version    # 如: cargo 1.85.0 (...)

核心工具链

|-------------------|-----------------------------|
| 工具 | 用途 |
| rustup | Rust 工具链管理器（版本切换、组件管理） |
| rustc | Rust 编译器（日常开发通常不直接调用） |
| cargo | 包管理 + 构建系统 + 测试运行器（最常用） |
| rustfmt | 代码格式化工具 |
| clippy | Lint 工具（发现常见错误和改进点） |
| rust-analyzer | IDE 支持（VSCode/JetBrains） |

关键命令速查

bash 复制代码

rustup update              # 更新到最新稳定版

rustup default stable      # 设置默认工具链

rustup component add clippy # 安装 clippy

cargo new my_project       # 创建新项目（二进制）

cargo new my_lib --lib     # 创建库项目

cargo build                # 编译

cargo run                  # 编译 + 运行

cargo test                 # 运行测试

cargo check                # 快速类型检查（不生成二进制，比 build 快）

cargo clippy               # 运行 lint

cargo fmt                  # 格式化代码

版本与 Edition

|-------------------------------------------------|------------------------------------------------|
| 概念 | 说明 |
| 版本号 （ 1.xx ） | 每 6 周发布，向后兼容 |
| Edition （ 2015/2018/2021/2024 ） | 语言语法演进，每个 Edition 可引入不兼容语法变化 |
| 2024 Edition 新增 | gen blocks（生成器）、更精确的 unsafe extern 块、 Cargo 改进 |
| Cargo.toml 中设置 | edition = "2024" |

Cargo.toml影响版本更新命令的效果，在该文件可以设置最新版本，若设置了*.3.*,则更新版本不会超过*.3

1.2 Hello, World!

直接用 rustc 编译（理解编译过程）

rust 复制代码

// main.rs

fn main() {

    println!("Hello, world!");

}

bash 复制代码

rustc main.rs    # 编译为 main（macOS/Linux）或 main.exe（Windows）

./main           # 运行

用 Cargo 编译（推荐日常使用）

bash 复制代码
cargo new hello_cargo

cd hello_cargo
生成结构：

hello_cargo/

├── Cargo.toml (项目清单/配置)

├── src/

│ └── main.rs (源码入口)

bash 复制代码

cargo run          # 编译并运行

Cargo.toml 基本结构：

$package$
name = "hello_cargo"

version = "0.1.0"

edition = "2024"
$dependencies$
在这里添加外部 crate

外部crate，就是第三方库，也是外部依赖

编译产物目录

target/

├── debug/ # cargo build / cargo run 的输出

│ └── hello_cargo

└── release/ # cargo build --release 的输出（优化编译）
复制代码
    └── hello_cargo

1.3 变量与可变性

变量声明与不可变性

rust 复制代码

let x = 5;           // 默认不可变（immutable）

// x = 6;            // 编译错误！cannot assign twice to immutable variable



let mut y = 5;       // mut 关键字使其可变

y = 6;               // OK



const MAX_POINTS: u32 = 100_000; // 常量：必须标注类型，不可 mut，编译时求值

默认不可变的变量，没有添加mut，就不能另外设置值。

|----------|----------------|----------------------|
| 特性 | let 变量 | const 常量 |
| 可变性 | 默认不可变，可加 mut | 永远不可变 |
| 类型标注 | 可省略（编译器推断） | 必须标注 |
| 值类型 | 运行时计算 | 编译时计算 |
| 命名规范 | snake_case | SCREAMING_SNAKE_CASE |
| 作用域 | 当前块 | 可全局可见 |

变量遮蔽（Shadowing）

rust 复制代码

let x = 5;

let x = x + 1;       // 遮蔽之前的 x，类型可变

let x = "hello";     // 合法！遮蔽允许改变类型



// 与 mut 的区别：

// shadowing 创建新变量，可以改变类型和重新绑定

// mut 只是修改同一变量的值，类型不能变

shadow后以前的声明定义就被销毁了

数据类型

Rust 是静态类型语言，编译器必须知道所有变量的类型。支持类型推断。

标量类型（Scalar）

|-------------------------------------------------|----------------------|-----------|
| 类型 | 说明 | 示例 |
| i8 , i16 , i32 , i64 , i128 | 有符号整数 | 42i32 |
| u8 , u16 , u32 , u64 , u128 | 无符号整数 | 42u32 |
| usize , isize | 指针大小的整数 | 数组索引 |
| f32 , f64 | 浮点数（IEEE 754），默认 f64 | 3.14 |
| bool | 布尔值 true / false | true |
| char | Unicode 标量值（4 字节） | '中', '🦀' |

标量类型：整数型，整数字面量，浮点型，布尔型，字符型

有符号：正负与0

无符号：非负

usize与isize，同计算机架构有关

复合类型（Compound）

元组，数组，切片

rust 复制代码

// 元组（Tuple）：固定长度，可包含不同类型

let tup: (i32, f64, char) = (500, 6.4, '中');

let (x, y, z) = tup;         // 解构

let first = tup.0;            // 索引访问

rust 复制代码

// 数组（Array）：固定长度，所有元素同类型

let arr: [i32; 5] = [1, 2, 3, 4, 5];

let first = arr[0];          // 索引访问

let zeros = [0; 5];          // [0, 0, 0, 0, 0] 语法糖

注意：数组越界访问会在运行时 panic（安全保证）

复合类型在离开作用域后被drop，不能再使用

但是可以通过引用，不交出所有权，可继续使用。

可变引用要么一个，要么没有

不可变引用可以多个

类型转换

rust 复制代码

let x: i32 = 42;

let y: f64 = x as f64;        // 显式转换（as）

// Rust 不支持隐式数值类型转换！

// let y: f64 = x;           // 编译错误

复制代码

数字字面量增强可读性

rust 复制代码

let million = 1_000_000;      // 下划线分隔符

let hex = 0xff;                // 十六进制

let octal = 0o77;              // 八进制

let binary = 0b1111_0000;      // 二进制

let byte = b'A';               // 字节（仅限 u8）

复制代码

1.4 函数

基本定义

rust 复制代码

fn main() {

    another_function(5, '中');

}



fn another_function(x: i32, unit_label: char) -> i32 {

    println!("x 的值是: {x}, 单位: {unit_label}");

    x + 1  // 最后一个表达式就是返回值（无分号）

}



// 无返回值的函数

fn make_no_return() {

    // 返回单元类型 ()

}

在函数中，与golang一样，所有的参数和函数返回值必须指明类型

语句 vs 表达式

|------------------------------------|-----------|----------------------------|
| 概念 | 说明 | 示例 |
| 语句（ Statement ） | 执行操作，不返回值 | let x = 5; |
| 表达式 （ Expression ） | 求值并返回结果 | 5 + 6、{ let x = 3; x + 1 } |

没有分号就是表达式，只有表达式可以赋值，语句不能赋值（会让值变成（））

rust 复制代码

// 重要：语句不以分号结尾就不是语句，是表达式

let y = {

    let x = 3;

    x + 1    // 注意：没有分号！这是一个表达式，值为 4

};           // y = 4



let z = {

    let x = 3;

    x + 1;   // 加了分号，变成语句，返回 ()

};           // z = () ------ 类型不匹配会报错

函数参数与所有权

rust 复制代码

fn main() {

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

    takes_ownership(s);      // s 的值移动到函数内

    // println!("{s}");      // 编译错误！s已经失去所有权 （已被Move）



    let x = 5;

    makes_copy(x);           // i32 是 Copy 类型，x 被复制

    println!("{x}");         // OK，x 仍然有效

}



fn takes_ownership(some_string: String) { /* ... */ }

fn makes_copy(some_integer: i32) { /* ... */ }

copy类型基本是标量类型

返回值与所有权

rust 复制代码

fn gives_ownership() -> String {

    String::from("yours")    // 移动给调用者

}



fn takes_and_gives_back(s: String) -> String {

    s                        // 原样返回

}

复制代码

1.5 注释

rust 复制代码

// 单行注释



/*

 * 多行注释

 * 第二行

 */



/// 文档注释（用于生成 HTML 文档）

/// 支持 Markdown 格式

/// 使用 `cargo doc` 生成文档

fn documented_function() {}



//! 模块级文档注释

//! 描述整个模块的用途

复制代码

1.6 控制流

if 表达式

rust 复制代码

let number = 6;



// if 是表达式，可用于赋值

let condition = true;

let number = if condition { 5 } else { 6 };



// if 条件必须是 bool（不像 C/JS 自动转换）

// if number { ... }  // 编译错误！

if number != 0 { /* ... */ }

有点类似Python里，number = if condition 5 else 6

循环

loop ------ 无限循环

rust 复制代码

let mut counter = 0;

let result = loop {

    counter += 1;

    if counter == 10 {

        break counter * 2;    // break 可返回值

    }

};

// result = 20



// 循环标签：在嵌套循环中精确 break/continue

'outer: loop {

    println!("外层循环");

    loop {

        println!("内层循环");

        break 'outer;         // 跳出外层循环

    }

}

loop无限循环的效果和golang里for{}的效果一样，可以通过break终止循环或者通过continue进入下一次循环

while ------ 条件循环

rust 复制代码

let mut number = 3;

while number != 0 {

    println!("{number}!");

    number -= 1;

}

复制代码

for ------ 遍历集合（最常用）

rust 复制代码

let arr = [10, 20, 30, 40, 50];

for element in arr {

    println!("值是: {element}");

}



// 范围

for number in 1..5 {        // 1, 2, 3, 4（不包含 5）

    println!("{number}");

}

for number in 1..=5 {       // 1, 2, 3, 4, 5（包含 5）

    println!("{number}");

}



// 反向

for number in (1..4).rev() { // 3, 2, 1

    println!("{number}!");

}

这里更Python类似，可以通过.iter().enumerate()来同时遍历index,item,不需要的可以用_

循环建议

|-----------------------|------------------|
| 场景 | 推荐 |
| 遍历数组 / 集合 | for（安全，不会越界） |
| 不确定迭代次数 | loop + break |
| 有明确条件 | while |

1.7 猜数字游戏教程知识点

第一个完整项目覆盖的关键概念：

|-----------------------------|---------------------------------------------------|
| 概念 | 知识点 |
| use | 引入标准库模块 |
| std::io | 输入输出 |
| String::new() | 创建空字符串 |
| io::stdin().read_line() | 读取用户输入（返回 Result） |
| expect() | 处理错误（Result 的方法） |
| rand crate | 使用外部依赖 |
| extern crate | 2024 Edition 不再需要（use 即可） |
| match | 模式匹配处理 Ordering |
| 变量遮蔽 | let guess: u32 = guess.trim().parse().expect(...) |
| trim() / parse() | 字符串处理与类型转换 |

rust 复制代码

use std::io;

use rand::Rng;

use std::cmp::Ordering;



fn main() {

    println!("猜数字！");

    let secret_number = rand::thread_rng().gen_range(1..=100);

   

    loop {

        println!("请输入你的猜测：");

        let mut guess = String::new();

        io::stdin().read_line(&mut guess).expect("读取输入失败");

       

        // 遮蔽 guess，将类型从 String 转为 u32

        let guess: u32 = match guess.trim().parse() {

            Ok(num) => num,

            Err(_) => continue,    // 非数字则重新输入

        };



        println!("你猜的是: {guess}");

       

        match guess.cmp(&secret_number) {

            Ordering::Less => println!("太小了！"),

            Ordering::Greater => println!("太大了！"),

            Ordering::Equal => {

                println!("你赢了！");

                break;

            }

        }

    }

}

复制代码

学习目标检验

能独立完成 cargo new → 编写 → cargo run 全流程
理解 let vs let mut vs const 的区别
能列举所有标量类型并说明取值范围
理解语句 vs 表达式的区别（无分号 vs 有分号）
能编写函数并正确返回值
能使用 if、loop、while、for 控制流
能独立完成猜数字游戏并理解每一行代码