# rust-study

**Repository Path**: XiXiaoFan/rust-study

## Basic Information

- **Project Name**: rust-study
- **Description**: rust学习
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-07-17
- **Last Updated**: 2026-07-27

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 🦀 Rust 全知识点学习项目

一个从零开始、系统覆盖 Rust 所有核心知识点的学习项目。包含 **22 个知识模块** + **5 个综合实战示例** + **可视化 Web 教程页面** + **语法速查手册**。

---

## 📦 环境要求

| 工具 | 版本要求 | 说明 |
|------|----------|------|
| Rust | 1.70+（推荐最新稳定版） | [安装地址](https://rustup.rs) |
| Cargo | 随 Rust 自动安装 | 包管理 & 构建工具 |

> **依赖说明**：Web 教程模式依赖 `axum`（Web 框架）和 `tokio`（异步运行时），运行 `cargo build` 时会自动下载。命令行演示模式无额外依赖。

### 安装 Rust

```bash
# Windows：下载并运行 rustup-init.exe（https://rustup.rs）

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

# 验证安装
rustc --version
cargo --version
```

### 推荐 IDE

- **VS Code** + rust-analyzer 扩展（推荐）
- **CLion** + Rust 插件
- **IntelliJ IDEA** + Rust 插件

---

## 🚀 使用方式

### 方式一：命令行演示模式

运行所有模块的演示输出，在终端中学习各知识点：

```bash
cargo run
```

### 方式二：Web 可视化教程模式

启动内置 Web 服务器，在浏览器中浏览带语法高亮的教程页面：

```bash
cargo run -- --web
```

然后在浏览器中打开 **http://127.0.0.1:3000**

Web 教程包含以下页面：

| 页面 | 路径 | 内容 |
|------|------|------|
| 🏠 首页 | `/` | 所有模块的卡片导航入口 |
| ⚙️ 环境搭建 | `/setup` | 安装 Rust、创建项目、运行调试、部署的完整指南 |
| 📝 语法速查 | `/syntax` | `::` 双冒号的 6 种用法、14 个常见符号速查表、`::` 与 `.` 的区别 |
| 📖 知识模块 | `/module/{id}` | 22 个模块各自的详细讲解 + 语法高亮代码示例 |
| 🎮 综合示例 | `/examples` | 5 个实战项目的代码展示和知识点说明 |

### 其他常用命令

```bash
cargo build              # 编译项目
cargo build --release    # 以优化模式编译
cargo test               # 运行测试
cargo clippy             # 代码质量检查
cargo fmt                # 格式化代码
```

---

## 📖 知识模块一览

项目按学习顺序组织为 22 个模块，从基础到进阶循序渐进：

### 基础篇（第 1~7 章）

| 模块 | 文件 | 知识点 |
|------|------|--------|
| 🔀 **控制流** | `control_flow.rs` | `if`/`else` 表达式、`loop` 无限循环 + `break` 返回值、`while` 条件循环、`for` 遍历（Range/集合/enumerate）、循环标签（`'label:` + `break/continue`）、变量遮蔽（shadowing） |
| 📊 **数据类型** | `data_types.rs` | 整数（i8~i128、u8~u128）、浮点数（f32/f64）、布尔值、字符（Unicode）、元组（Tuple）、数组（Array）、切片（Slice）、类型别名 |
| 🔑 **所有权** | `ownership.rs` | 所有权三大规则、移动语义（Move）、克隆（Clone）、复制语义（Copy trait）、函数传参时的所有权转移、返回值转移所有权 |
| 🔗 **借用与引用** | `borrowing.rs` | 不可变引用（`&T`）、可变引用（`&mut T`）、借用规则（互斥性）、切片作为借用、悬垂引用问题 |
| ⏳ **生命周期** | `lifetime.rs` | 生命周期标注语法（`'a`）、函数中的生命周期、结构体中的生命周期、方法中的生命周期、生命周期省略规则（3 条）、`'static` 生命周期 |
| 🏗️ **结构体与方法** | `structs.rs` | 结构体定义（命名字段/元组/单元）、`impl` 块、`&self`/`&mut self`/`self` 方法、关联函数（构造函数）、结构体更新语法（`..other`）、多个 `impl` 块 |
| 🔢 **枚举** | `enums.rs` | 枚举定义（无数据/元组变体/结构体变体）、枚举方法、`Option<T>` 深入、`Result<T, E>` 深入、枚举与 `match` 模式匹配配合 |

### 核心篇（第 8~11 章）

| 模块 | 文件 | 知识点 |
|------|------|--------|
| 🧬 **泛型** | `generics.rs` | 泛型函数、泛型结构体、泛型枚举（Option/Result）、泛型方法、为特定类型实现专属方法、零成本抽象原理 |
| 🎯 **特征 (Traits)** | `traits.rs` | 定义和实现 trait、trait 默认实现、trait 作为参数（`impl Trait` 语法）、泛型 + trait bound、`where` 子句、返回 `impl Trait`、派生 trait（`#[derive(...)]`）、手动实现 Display |
| 📦 **闭包** | `closures.rs` | 闭包基本语法、捕获环境变量（不可变借用/可变借用/获取所有权）、`move` 关键字、`Fn` / `FnMut` / `FnOnce` 三个 trait 的区别、闭包作为函数参数、返回闭包（`Box<dyn Fn>`）、高阶函数（map/filter/fold） |
| 🔄 **迭代器** | `iterators.rs` | Iterator trait 和 `next()` 方法、三种迭代方式（`iter`/`iter_mut`/`into_iter`）、迭代器适配器（map/filter/take/skip/chain/zip/enumerate/peekable/flat_map）、消费器（collect/sum/count/find/fold/any/all/min/max）、自定义迭代器（斐波那契数列） |

### 进阶篇（第 12~16 章）

| 模块 | 文件 | 知识点 |
|------|------|--------|
| 🛡️ **错误处理** | `error_handling.rs` | `panic!` 宏（不可恢复错误）、`Result<T, E>` 和 `Option<T>`（可恢复错误）、`?` 运算符（错误传播语法糖）、`unwrap`/`expect`/`unwrap_or`/`unwrap_or_else`、自定义错误类型（enum + Display trait） |
| 📍 **智能指针** | `smart_pointers.rs` | `Box<T>`（堆上分配/递归类型/trait 对象）、`Deref` trait 和自动解引用（deref coercion）、`Drop` trait（自定义清理逻辑）、`Rc<T>`（引用计数/多所有权）、`RefCell<T>`（内部可变性/运行时借用检查）、`Rc<RefCell<T>>` 组合模式 |
| ⚡ **并发编程** | `concurrency.rs` | `thread::spawn` 创建线程、`join` 等待线程完成、`move` 闭包与线程、消息传递（`mpsc::channel`/多生产者/单消费者）、共享状态（`Arc<Mutex<T>>`/原子引用计数/互斥锁）、并行计算实战 |
| 🎨 **模式匹配** | `pattern_matching.rs` | `match` 表达式（穷举匹配）、匹配范围（`..=`）、解构枚举/结构体/元组、模式守卫（`if` 条件）、`@` 绑定、`if let` 简写、`while let` 循环、`let else` 语句、`_` 通配符和 `..` 展开 |
| 📂 **模块系统** | `module_system.rs` | `mod` 关键字（模块层级/嵌套）、`pub` 可见性控制、`use` 引入路径、`crate::`/`self::`/`super::` 路径关键字、文件与模块的对应关系、预导入（prelude） |

### 高级篇（第 17~22 章）

| 模块 | 文件 | 知识点 |
|------|------|--------|
| 📚 **集合** | `collections.rs` | `Vec<T>`（动态数组/排序/查找）、`String`（UTF-8 字符串/拼接/遍历/常用方法）、`HashMap<K, V>`（键值映射/entry API）、`HashSet<T>`（唯一值/集合运算：交集/并集/差集）、`BTreeMap<K, V>`（有序映射/范围查询） |
| 🔄 **类型转换** | `type_casting.rs` | `as` 关键字（原始类型转换/截断行为）、`From<T>` / `Into<T>` trait（安全转换/自定义实现）、`TryFrom<T>` / `TryInto<T>` trait（可能失败的转换）、`parse()` 字符串解析 |
| ⚠️ **不安全 Rust** | `unsafe_rust.rs` | 原始指针（`*const T` / `*mut T`）、解引用原始指针、unsafe 函数、用安全接口包装 unsafe 代码（最佳实践）、可变静态变量（`static mut`）、`Send` 和 `Sync` trait（线程安全标记） |
| 🔨 **宏** | `macros.rs` | `macro_rules!` 声明式宏（基本语法/重复匹配/自定义宏）、宏的元变量（`expr`/`ty`/`ident` 等）、内置宏（`println!`/`vec!`/`format!`/`assert!`/`dbg!`）、过程宏概念（派生宏/属性宏） |
| 📝 **字符串** | `strings.rs` | `&str` 与 `String` 的区别、单行字符串（字面量/原始字符串/`r#""#`）、多行字符串（`\n`/原始字符串/format!/join）、拼接（`+`/`push_str`/`format!`）、查找与替换、遍历字符与字节、常见陷阱 |
| 🚀 **异步编程** | `async_await.rs` | 同步 vs 异步概念、`async`/`await` 基本语法、`Future` trait、异步函数定义与调用、`tokio::join!` 并发任务、`tokio::spawn` 异步任务、异步编程模式（Web服务器/并发HTTP/异步通道） |

---

## 🎮 综合练习示例

5 个实战项目，每个项目综合运用多个知识点：

| 示例 | 文件 | 综合运用 |
|------|------|----------|
| **猜数字游戏** | `guessing_game.rs` | 控制流（loop/match）、字符串处理（trim/parse）、比较（Ordering）、错误处理、标准 IO |
| **命令行计算器** | `calculator.rs` | 枚举（运算符）、模式匹配、字符串解析（split/parse）、自定义错误类型、闭包（函数式计算） |
| **TODO 列表** | `todo_list.rs` | 结构体 + 枚举（数据建模）、impl 方法、Vec 动态数组、Option 处理、迭代器（filter/find/position）、Display trait |
| **链表实现** | `linked_list.rs` | 泛型、枚举 + Box（递归类型）、Option、模式匹配、std::mem::replace、链表操作（增删查反转） |
| **宏示例** | `macro_examples.rs` | `macro_rules!` 声明式宏、模式匹配元变量、自定义结构体生成宏、过程宏概念介绍 |

---

## 📁 项目结构

```
src/
├── main.rs                  # 入口文件（支持 --web 参数启动教程网页）
├── modules/                 # 知识点模块（22 个）
│   ├── mod.rs               # 模块声明
│   ├── control_flow.rs      # 控制流
│   ├── data_types.rs        # 数据类型
│   ├── ownership.rs         # 所有权
│   ├── borrowing.rs         # 借用与引用
│   ├── lifetime.rs          # 生命周期
│   ├── structs.rs           # 结构体与方法
│   ├── enums.rs             # 枚举
│   ├── generics.rs          # 泛型
│   ├── traits.rs            # 特征
│   ├── closures.rs          # 闭包
│   ├── iterators.rs         # 迭代器
│   ├── error_handling.rs    # 错误处理
│   ├── smart_pointers.rs    # 智能指针
│   ├── concurrency.rs       # 并发编程
│   ├── pattern_matching.rs  # 模式匹配
│   ├── collections.rs       # 集合
│   ├── type_casting.rs      # 类型转换
│   ├── unsafe_rust.rs       # 不安全 Rust
│   ├── module_system.rs     # 模块系统
│   ├── macros.rs            # 宏
│   ├── strings.rs           # 字符串
│   └── async_await.rs       # 异步编程
├── examples/                # 综合练习示例（5 个）
│   ├── mod.rs               # 示例声明
│   ├── guessing_game.rs     # 猜数字游戏
│   ├── calculator.rs        # 命令行计算器
│   ├── todo_list.rs         # TODO 列表
│   ├── linked_list.rs       # 链表实现
│   └── macro_examples.rs    # 宏示例
└── web/                     # Web 教程服务器
    └── mod.rs               # Axum 路由 + HTML 页面生成
```

---

## 🔧 调试指南

```bash
# 方法一：println! 调试（最常用）
println!("调试信息: {:?}", variable);
dbg!(variable);  // 自动打印文件名、行号、变量值

# 方法二：VS Code 断点调试
# 1. 安装 CodeLLDB 扩展
# 2. 在代码行号旁点击设置断点
# 3. 按 F5 启动调试

# 方法三：命令行调试器
rust-gdb ./target/debug/rust_demo    # Linux/macOS
rust-cdb ./target/debug/rust_demo    # Windows
```

---

## 📦 部署

```bash
# 编译 release 版本
cargo build --release
# 可执行文件位于 target/release/ 目录

# 交叉编译（例如 Linux → Windows）
rustup target add x86_64-pc-windows-gnu
cargo build --release --target x86_64-pc-windows-gnu

# Docker 部署示例
# FROM rust:latest AS builder
# WORKDIR /app
# COPY . .
# RUN cargo build --release
# FROM debian:latest
# COPY --from=builder /app/target/release/rust_demo /usr/local/bin/
# CMD ["rust_demo"]
```

---

## 📚 建议学习路径

1. **环境搭建** → 安装 Rust，运行 `cargo run` 和 `cargo run -- --web`
2. **语法速查** → 打开 Web 教程的「语法速查」页面，熟悉 `::`、`&`、`*`、`=>` 等基础符号
3. **基础篇**（控制流 → 数据类型 → 所有权 → 借用 → 生命周期 → 结构体 → 枚举）→ 打好 Rust 基础
4. **核心篇**（泛型 → 特征 → 闭包 → 迭代器）→ 掌握 Rust 的抽象能力
5. **进阶篇**（错误处理 → 智能指针 → 并发 → 模式匹配 → 模块系统）→ 应对实际开发场景
6. **高级篇**（集合 → 类型转换 → 不安全 Rust → 宏 → 字符串 → 异步编程）→ 补全知识体系
7. **综合示例** → 通过实战项目巩固所学
8. **动手修改代码** → 故意制造编译错误，阅读错误信息，加深理解

---

## ❓ 新手常见疑问

### `::` 和 `.` 有什么区别？

这是新手最常困惑的问题。简单记忆：

```rust
// :: 用于「不需要实例」的调用（关联函数 / 命名空间 / 枚举变体）
let s = String::from("hello");     // 类型::关联函数
let v = Vec::<i32>::new();         // 类型::关联函数
let opt = Option::Some(42);        // 枚举::变体

// . 用于「需要实例」的调用（实例方法）
let len = s.len();                  // 实例.方法()
v.push(1);                         // 实例.方法()
```

> 详细的 `::` 6 种用法和全部常见符号说明，请查看 Web 教程中的「语法速查」页面。