📖 导读

本文是一份8000+字的 Rust 完全指南，覆盖 8 大章节、22 个小节、20+ 段可运行代码、6 张对比表格与 5 张原创插图。
适合人群：Python/Java/JS 开发者想转系统级编程、C/C++ 工程师想摆脱内存 Bug、AI 工程师想参与底层框架贡献。
预计阅读时长：45-60 分钟。
配套代码仓库：github.com/rust-lang/rust

核心收获：

  1. 理解 Rust 三大核心范式：内存安全、零成本抽象、无畏并发
  2. 掌握所有权/借用/生命周期三大铁律
  3. 看清 Rust 在 AI 时代的独特定位与 Python 的最佳拍档模式
  4. 拿到一份 12 周可执行的 Rust 学习路线图

1. 引言：Rust 的崛起——一场编程语言的革命

想象一下，你正在建造一座摩天大楼。你可以选择用木头（Python）快速搭建，但到了第 20 层，结构开始摇晃；你也可以用钢筋混凝土（C/C++），但每一根钢筋都需要你亲手焊接，稍有不慎整栋楼就会坍塌。现在，有一种新型材料出现了——它像木头一样容易施工，却拥有钢筋混凝土的强度，甚至还能在你犯错时自动提醒你：「这里少了一根承重柱！」

这种材料，就是 Rust。

从 2015 年第一个稳定版发布至今，Rust 已经连续 8 年蝉联 Stack Overflow「最受开发者喜爱的语言」榜首。微软、Google、亚马逊、Meta 等科技巨头纷纷将核心系统迁移到 Rust。Linux 内核从 6.1 版本开始正式支持 Rust，Android 系统 20% 以上的新原生代码用 Rust 编写，甚至美国白宫都公开呼吁开发者使用 Rust 来构建关键基础设施。

为什么 Rust 如此受欢迎？它到底有什么魔力？如果你是一个 Python 开发者、Java 开发者，甚至是 C/C++ 老兵，为什么要学习 Rust？更重要的是——如何从零开始掌握这门语言？

这篇文章将为你一一解答。我们会用生动的比喻、丰富的例子和清晰的路线图，带你走进 Rust 的世界。

2. Rust 的核心优势：为什么它如此「香」？

2.1 内存安全——没有「段错误」的 C 语言

比喻：图书馆的借书系统

想象你管理着一个巨大的图书馆。在 C 语言的世界里，读者借书后，你需要手动记录谁借了什么书，什么时候还。如果忘记记录，书可能永远丢失（内存泄漏）；如果读者还了书你还继续让他看，他看到的可能是别人的书（悬垂指针）；如果两个读者同时借同一本书，系统会崩溃（数据竞争）。

Rust 引入了一个天才般的系统——所有权（Ownership）。这就像给每本书装上了 RFID 标签：

  • 每本书只有一个主人（所有权唯一）
  • 你可以临时借给别人看（借用/Borrowing）
  • 借出去的时候，你自己不能修改（不可变借用）
  • 还回来之后，你才能继续操作（生命周期检查）

这一切都在编译时检查完毕，不需要垃圾回收器（GC）的额外开销。这意味着 Rust 既拥有 C/C++ 的性能，又拥有 Java/Python 的安全性。

// 所有权示例
fn main() {
    let book = String::from("Rust 编程之道");  // book 是所有者
    let reader = &book;  // 不可变借用，可以读
    println!("{}", reader);  // 输出：Rust 编程之道
    // book 仍然可用
    println!("{}", book);  // 输出：Rust 编程之道
}

2.2 零成本抽象——写高级代码，得底层性能

比喻：自动驾驶汽车

Python 就像一辆手动挡汽车——你写起来很轻松，但引擎盖下有很多不必要的空转（运行时开销）。C++ 像一辆手动挡赛车——性能极佳，但你需要精确控制每一个换挡时机。

Rust 则像一辆自动驾驶的特斯拉——你只需要告诉它「去机场」，它会自动选择最优路线、控制油门刹车，而且比手动挡还省油。

Rust 的迭代器、闭包、泛型等高级特性，在编译时会被优化成与手写底层代码几乎相同的机器码。你不需要在「开发效率」和「运行效率」之间做取舍。

// 零成本抽象示例：迭代器
fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    // 高级写法——可读性强
    let sum: i32 = numbers.iter()
        .filter(|&&x| x % 2 == 0)  // 只取偶数
        .map(|&x| x * 2)           // 每个乘以2
        .sum();                     // 求和
    
    // 编译后等价于手写的 for 循环
    println!("结果: {}", sum);  // 输出：60
}

2.3 无畏并发——让多线程编程不再可怕

比喻：厨房里的多位厨师

想象一个繁忙的厨房，多位厨师同时工作。在 C/C++ 中，如果两个厨师同时去拿同一个锅（共享数据），轻则烧焦菜，重则厨房着火（数据竞争）。你需要用锁（mutex）来协调，但锁用不好就会死锁——所有厨师都拿着一个锅盖等另一个锅盖，谁也动不了。

Rust 的类型系统在编译时就保证了：要么你拥有数据的唯一访问权（可变引用），要么你有多个只读访问权（不可变引用），两者不可兼得。这就是著名的「要么一个写者，要么多个读者」原则。

use std::thread;

fn main() {
    let data = vec![1, 2, 3];
    
    // 错误示例——编译不通过！
    // let handle = thread::spawn(|| {
    //     println!("{:?}", data);
    // });
    
    // 正确做法：使用 move 关键字转移所有权
    let handle = thread::spawn(move || {
        println!("{:?}", data);  // data 的所有权被转移到了新线程
    });
    
    handle.join().unwrap();
    // 这里不能再使用 data，因为所有权已经转移
}

2.4 与 C 语言的 FFI 互操作性——站在巨人的肩膀上

Rust 可以无缝调用 C 语言库，这意味着你可以直接使用 Python 的 C 扩展库、操作系统的系统调用、甚至现有的 C/C++ 代码库。Rust 不是要取代 C，而是要继承 C 的生态，同时修复 C 的安全问题。

// 调用 C 标准库的 printf
extern "C" {
    fn printf(format: *const u8, ...) -> i32;
}

fn main() {
    let msg = b"Hello from Rust!\n\0";
    unsafe {
        printf(msg.as_ptr());
    }
}

2.5 出色的工具链——开箱即用的开发体验

Rust 的工具链是编程语言中最优秀的之一：

工具 功能 类比
rustup 版本管理 像 nvm（Node.js）但更好
cargo 包管理+构建 像 pip + npm + make 合体
rustfmt 代码格式化 像 Prettier
clippy 代码检查 像 ESLint 但更严格
rust-analyzer IDE 支持 像 IntelliJ 的智能提示 
# 一行命令创建新项目
cargo new my_project
cd my_project

# 运行
cargo run

# 测试
cargo test

# 发布
cargo build --release

3. Rust 在 AI 时代的独特地位

3.1 为什么 AI 需要 Rust？

你可能在想：「AI 不是用 Python 吗？Rust 跟 AI 有什么关系？」

这是一个非常好的问题。让我们看看 AI 系统的实际架构：

┌─────────────────────────────────────────┐
│           应用层 (Python)                │
│  PyTorch / TensorFlow / Transformers     │
├─────────────────────────────────────────┤
│           框架层 (C++/CUDA)              │
│  自动求导 / 算子库 / 内存管理            │
├─────────────────────────────────────────┤
│           基础设施层 (Rust)              │
│  数据管道 / 模型服务 / 推理引擎          │
├─────────────────────────────────────────┤
│           硬件层 (GPU/TPU)               │
└─────────────────────────────────────────┘

Python 是 AI 的「指挥家」——它负责编排、调度、实验。但真正「演奏」的是底层的 C++/CUDA 代码。而 Rust 正在成为连接 Python 和底层硬件的最佳桥梁。

3.2 Rust 在 AI 领域的实际应用

案例 1：Hugging Face 的 Tokenizer

Hugging Face 用 Rust 重写了他们的 Tokenizer（分词器），性能提升了 5-10 倍。现在 transformers 库底层使用的 tokenizers 包就是用 Rust 编写的，通过 Python 绑定暴露接口。

# Python 代码，底层是 Rust
from tokenizers import Tokenizer

tokenizer = Tokenizer.from_pretrained("bert-base-uncased")
output = tokenizer.encode("Hello, Rust is fast!")
print(output.tokens())
# ['hello', ',', 'rust', 'is', 'fast', '!']

案例 2：Candle——轻量级深度学习框架

Hugging Face 还推出了 Candle，一个纯 Rust 实现的深度学习框架。它没有 Python 依赖，没有 CUDA 运行时，甚至可以在浏览器中通过 WebAssembly 运行！

use candle_core::{Device, Tensor};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let device = Device::Cpu;
    
    // 创建张量
    let a = Tensor::new(&[[1.0f32, 2.0], [3.0, 4.0]], &device)?;
    let b = Tensor::new(&[[5.0f32, 6.0], [7.0, 8.0]], &device)?;
    
    // 矩阵乘法
    let c = a.matmul(&b)?;
    println!("{:?}", c.to_vec2::<f32>()?);
    // [[19.0, 22.0], [43.0, 50.0]]
    
    Ok(())
}

案例 3：数据管道与模型服务

  • Polars：比 Pandas 快 10-100 倍的 DataFrame 库，纯 Rust 实现
  • Burn：纯 Rust 深度学习框架，支持 GPU 加速
  • Tract：ONNX 推理引擎，适合边缘设备部署

3.3 Rust + Python：最佳拍档

你不需要在 Rust 和 Python 之间二选一。实际上，Rust + Python 的组合正在成为 AI 工程化的黄金标准：

Python（快速原型） → Rust（生产优化）
     ↓                      ↓
  实验阶段              部署阶段
  数据探索              高性能服务
  模型训练              推理引擎

使用 PyO3 库，你可以用 Rust 编写 Python 扩展模块：

// Rust 代码
use pyo3::prelude::*;

#[pyfunction]
fn fast_process(data: Vec<f64>) -> Vec<f64> {
    data.iter().map(|x| x * 2.0).collect()
}

#[pymodule]
fn my_rust_module(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(fast_process, m)?)?;
    Ok(())
}

# Python 代码
import my_rust_module

result = my_rust_module.fast_process([1.0, 2.0, 3.0])
print(result)  # [2.0, 4.0, 6.0]

4. Rust 基础知识点全览

下面是一个完整的 Rust 知识点地图，按照学习路径排列：

4.1 第一阶段：基础语法（1-2 周）

4.1.1 变量与可变性
fn main() {
    // 默认不可变
    let x = 5;
    // x = 6;  // 编译错误！
    
    // 使用 mut 声明可变变量
    let mut y = 5;
    y = 6;  // 可以
    
    // 常量
    const MAX_POINTS: u32 = 100_000;
    
    // 变量遮蔽（Shadowing）
    let spaces = "   ";
    let spaces = spaces.len();  // 现在 spaces 是数字类型
}
4.1.2 基本数据类型
类型 描述 示例
i8, i16, i32, i64, i128 有符号整数 let x: i32 = 42;
u8, u16, u32, u64, u128 无符号整数 let y: u8 = 255;
f32, f64 浮点数 let pi: f64 = 3.14159;
bool 布尔值 let flag = true;
char 字符（4 字节，支持 Unicode） let c = '🦀';
String 动态字符串 let s = String::from("hello");
&str 字符串切片 let s: &str = "hello";
4.1.3 控制流
fn main() {
    // if 表达式
    let number = 6;
    if number % 4 == 0 {
        println!("能被4整除");
    } else if number % 3 == 0 {
        println!("能被3整除");
    } else {
        println!("其他");
    }
    
    // if 作为表达式
    let condition = true;
    let number = if condition { 5 } else { 6 };
    
    // 循环
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;  // 返回值
        }
    };
    
    // while 循环
    let mut number = 3;
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    
    // for 循环（最常用）
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("值是: {}", element);
    }
    
    // 范围
    for number in (1..4).rev() {
        println!("{}!", number);
    }
}

4.2 第二阶段：所有权与借用（2-3 周）

这是 Rust 最核心、也最独特的概念。理解所有权，你就理解了 Rust 的灵魂。

4.2.1 所有权规则
  1. 每个值都有一个所有者
  2. 同一时间只能有一个所有者
  3. 当所有者离开作用域，值被自动释放
fn main() {
    // 规则 1：s 是字符串的所有者
    let s = String::from("hello");
    
    // 规则 2：移动（Move）——所有权转移
    let s1 = String::from("hello");
    let s2 = s1;  // s1 的所有权移动到 s2
    // println!("{}", s1);  // 编译错误！s1 已失效
    
    // 克隆（Clone）——深拷贝
    let s1 = String::from("hello");
    let s2 = s1.clone();
    println!("s1 = {}, s2 = {}", s1, s2);  // 都可以用
    
    // 规则 3：作用域结束自动释放
    {
        let s = String::from("hello");
        // s 在这里有效
    }  // 作用域结束，s 被自动释放
    // println!("{}", s);  // 编译错误！s 已释放
    
    // 函数传参也会转移所有权
    let s = String::from("world");
    take_ownership(s);
    // println!("{}", s);  // 编译错误！所有权已转移
}

fn take_ownership(some_string: String) {
    println!("{}", some_string);
}  // some_string 在这里被释放
4.2.2 借用与引用

所有权规则虽然安全，但有时过于严格。比如我们只想「读」一个值，不想获取它的所有权——这时就需要借用。

fn main() {
    let s1 = String::from("hello");
    
    // 不可变引用（&T）——只读借用
    let len = calculate_length(&s1);
    println!("'{}' 的长度是 {}", s1, len);  // s1 仍然可用
}

fn calculate_length(s: &String) -> usize {  // s 是对 String 的引用
    s.len()
}  // s 离开作用域，但不会释放它引用的值

借用规则：

  1. 任意时刻，只能有一个可变引用，或者任意多个不可变引用
  2. 引用必须始终有效（不会出现悬垂引用）
fn main() {
    let mut s = String::from("hello");
    
    // 不可变引用可以有多个
    let r1 = &s;
    let r2 = &s;
    println!("{} 和 {}", r1, r2);
    // 注意：r1 和 r2 在这里之后不再使用
    
    // 可变引用只能有一个
    let r3 = &mut s;
    r3.push_str(", world");
    println!("{}", r3);
}
4.2.3 切片（Slice）

切片是另一种不持有所有权的数据类型，它允许你引用集合中的一段连续元素。

fn main() {
    let s = String::from("hello world");
    
    // 字符串切片
    let hello = &s[0..5];   // "hello"
    let world = &s[6..11];  // "world"
    let whole = &s[..];     // "hello world"
    
    println!("{} {}", hello, world);
    
    // 数组切片
    let a = [1, 2, 3, 4, 5];
    let slice = &a[1..3];  // [2, 3]
    assert_eq!(slice, &[2, 3]);
}

小结：所有权、借用和切片是 Rust 内存安全的三驾马车。虽然初学时需要适应，但一旦掌握，你将写出既安全又高效的代码，再也不用担心内存泄漏或悬垂指针。

5. 实战项目：从入门到进阶

理论知识学得再多，不动手写代码都是纸上谈兵。下面按照难度递进，推荐几个 Rust 实战项目：

5.1 入门级项目（1-2 周）

项目 核心知识点 难度
命令行猜数字游戏 变量、控制流、标准输入输出 ⭐
文件内容统计工具（wc 克隆） 文件读写、字符串处理、命令行参数 ⭐
简易计算器 枚举、模式匹配、Result 错误处理 ⭐⭐

5.2 进阶级项目（2-4 周）

项目 核心知识点 难度
HTTP 静态文件服务器 TCP 监听、HTTP 协议、多线程 ⭐⭐⭐
Markdown 解析器 状态机、所有权、迭代器 ⭐⭐⭐
简易数据库（Bitcask 模型） 文件 I/O、序列化、哈希表 ⭐⭐⭐

5.3 高级项目（4-8 周）

项目 核心知识点 难度
简易 Redis 实现 网络编程、协议解析、并发模型 ⭐⭐⭐⭐
命令行 JSON 查询工具（jq 克隆） 泛型、trait、递归数据结构 ⭐⭐⭐⭐
简易操作系统内核（配合教程） 裸机编程、内存管理、中断处理 ⭐⭐⭐⭐⭐

6. 常见踩坑指南与最佳实践

6.1 生命周期标注恐惧症

// ❌ 新手常见错误：试图避免生命周期标注
fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();
    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}
// ✅ 实际上编译器会自动省略生命周期，上面的代码完全合法！

核心心法：生命周期标注不是惩罚，而是帮助编译器理解你的意图。大多数情况下，编译器会自动推断。

6.2 字符串类型选择困难

// ❌ 过度使用 String
let mut result = String::new();
for word in words {
    result.push_str(word);
    result.push_str(", ");
}

// ✅ 使用 Vec<String> 最后 join
let result = words.join(", ");

选择原则：

  • 函数参数：优先用 &str（最灵活）
  • 函数返回值：用 String（所有权转移）
  • 字符串字面量：用 &str
  • 需要修改：用 String

6.3 错误处理：unwrap 滥用

// ❌ 生产代码中大量 unwrap
let file = File::open("config.txt").unwrap();
let content = read_to_string(file).unwrap();
let config: Config = toml::from_str(&content).unwrap();

// ✅ 使用 ? 运算符传播错误
fn load_config() -> Result<Config, Box<dyn Error>> {
    let file = File::open("config.txt")?;
    let content = read_to_string(file)?;
    let config: Config = toml::from_str(&content)?;
    Ok(config)
}

7. 学习资源推荐

📚 书籍（按阅读顺序）

《Rust 程序设计语言》
（The Book）

《Rust 实战》

《Rust 程序设计》
（Programming Rust）

《Rust 原子操作与锁》
（Rust Atomics and Locks）

《Rust 权威指南》
（Rust in Action）

🌐 在线资源

资源 地址 推荐理由
Rust 官方文档 doc.rust-lang.org 最权威，必读
Rust By Example doc.rust-lang.org/stable/rust-by-example 边练边学
Rustlings github.com/rust-lang/rustlings 交互式练习
Rust 语言圣经 course.rs 中文最佳教程
Rust 设计模式 rust-unofficial.github.io/patterns 进阶必看

🛠️ 开发工具推荐

必备工具链

Cargo（包管理/构建）

Clippy（代码检查）

rustfmt（代码格式化）

cargo doc（文档生成）

编辑器选择

VS Code + rust-analyzer

CLion + IntelliJ Rust

Helix（Rust 原生编辑器）

8. 总结：Rust 的未来与你的学习之路

回顾全文

让我们回顾一下这篇文章的核心脉络：

为什么 Rust 这么香？

内存安全

零成本抽象

无畏并发

与 C 的 FFI

出色工具链

Rust 在 AI 时代

AI 基础设施层

深度学习框架

Python+Rust 黄金组合

学习路线图

基础语法

所有权与借用

实战项目

持续进阶

Rust 的未来趋势

  1. 系统编程领域：Linux 内核、Android、Windows 都在引入 Rust，未来 5 年 Rust 将成为系统编程的主流选择之一
  2. AI 基础设施：随着 Candle、Burn 等纯 Rust 框架成熟，Rust 在 AI 推理、边缘计算领域将占据重要位置
  3. WebAssembly：Rust 是 WASM 的一等公民，在 Serverless、边缘计算场景大有可为
  4. 嵌入式与 IoT：Rust 的零成本抽象和内存安全特性，使其成为嵌入式开发的理想选择

给你的学习建议

第 9-12 周

实战项目
并发编程

第 7-8 周

泛型/Trait
错误处理

第 5-6 周

结构体/枚举
模式匹配

第 3-4 周

所有权/借用
生命周期

第 1-2 周

基础语法
变量/类型/控制流

第 3-4 周
所有权/借用

第 7-8 周
泛型/Trait

最后送你一句话：学习 Rust 就像学习一门新的乐器——开头几天手指会疼，和弦会按错，节奏会乱。但当你第一次完整弹出一首曲子时，那种成就感是无与伦比的。Rust 的学习曲线确实陡峭，但翻过这座山，你会发现一个更安全、更高效、更优雅的编程世界。

9. 常见问题 FAQ

Q1：Rust 真的能在 2026 年取代 C/C++ 吗？

A：不会完全取代，但在新增项目中占比会持续上升。Linux 内核、Android、Chromium 等大型项目正在逐步用 Rust 重写新模块；老代码则保持 C/C++ 不动。可以预见未来 5-10 年的格局是：新项目优先 Rust，老项目逐步迁移，关键基础设施双轨并行。

Q2：Rust 的学习曲线真的有那么陡峭吗？

A：是的，前 2-3 周会非常痛苦（主要是和借用检查器"打架"）。但一旦过了所有权这一关，后续学习曲线就趋于平缓。经验值：每天投入 2 小时，6-8 周可以独立写项目；3 个月可以达到能上生产环境的水平。Rust 的设计哲学是"把 Bug 拦在编译期"，所以一旦编译通过，运行时几乎不会出意外。

Q3：Rust 适合写 Web 后端吗？

A：非常适合。Axum（基于 Tokio 的 Web 框架）+ SQLx（异步数据库）+ Tower（中间件生态）是目前最主流的组合。性能上碾压 Python/Node，接近 Go 的水平。字节跳动内部已大规模使用 Rust 写后端服务。推荐栈：Axum + Tokio + SQLx + Serde。

Q4：AI 工程师要不要学 Rust？

A：强烈建议。原因有三：

  1. 性能：Hugging Face 的 tokenizers 库、Polars 数据处理框架都是 Rust 写的，速度比 Python 快 5-50 倍
  2. 就业：Rust 工程师是 2025-2026 年最稀缺的岗位之一，年薪普遍比同级别 Python 高 30-50%
  3. 底层贡献：PyTorch、TensorFlow 等核心模块的 PR 中 Rust 占比越来越高

Q5：Rust 和 Go 怎么选？

A：定位不同——

  • Go：简单易学、并发原语完善、部署方便（单二进制），适合写微服务、CLI、DevOps 工具
  • Rust：性能极强、内存安全、零成本抽象，适合写系统级、嵌入式、高性能计算、WebAssembly

如果团队人手紧张、追求快速交付，选 Go；如果项目对性能/安全有极致要求，选 Rust。两者并不冲突，可以混用。

Q6：Rust 的 WebAssembly 支持怎么样？

A：业界最成熟。WASM 是 Rust 的"杀手级应用"之一：

  • wasm-pack 一行命令把 Rust 代码编译为 npm 包
  • wasm-bindgen 实现 JS/Rust 双向调用
  • Yew、Leptos 等 Rust 前端框架正在挑战 React 的地位
  • Figma、Photoshop Web 版都用 Rust+WASM 加速

Q7：Rust 编译太慢怎么办？

A：这是 Rust 目前的最大短板。缓解方法：

  1. sccache：分布式编译缓存，命中后秒级编译
  2. mold 链接器：比默认 ld 快 5-10 倍
  3. 增量编译 + 工作区：把项目拆成多个 crate
  4. cargo build --release 配合 lto="thin" 优化

未来 Rust 团队正在推进的「并行编译」和「数据库跟踪」会进一步改善。

Q8：Rust 的异步编程难学吗？

A：异步是 Rust 进阶的第二大门槛（第一大是所有权）。核心概念：

  • async/await 语法糖
  • Future trait 理解
  • Tokio 运行时
  • Pin 和 Self-referential 结构

建议：先把同步 Rust 写熟，再学异步。过早接触异步会陷入"所有权 + 生命周期 + Pin"三连击。

10. 参考文献与延伸阅读

📚 经典书籍

  1. 《The Rust Programming Language》（官方书，俗称"the Book"）— 免费在线阅读，必读入门
  2. 《Programming Rust》（O’Reilly，Jim Blandy）— 深入底层原理
  3. 《Rust for Rustaceans》（Jon Gjengset）— 进阶必读，覆盖异步/unsafe/macro
  4. 《Rust 权威指南》（中译本，Steve Klabnik）— 中文社区首选
  5. 《Rust 实战》（中译本）— 项目驱动学习

🌐 官方资源

🎥 视频教程

🛠️ 实战项目推荐

项目 难度 学到什么
Too Many Web Links 入门 Web 抓取 + 文件 I/O
ripgrep 进阶 高性能文本搜索
Tokio 高阶 异步运行时
TiKV 专家 分布式存储

📊 行业报告

11. 课后练习（动手才能真正学会）

练习 1：所有权实验

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // 这行发生了什么？
    println!("{}", s1);  // 这一行能编译通过吗？为什么？
}

任务：自己动手运行，修复编译错误，理解 Move 语义。

练习 2：编写一个猜数字游戏

要求：

  1. 程序生成 1-100 的随机数
  2. 用户输入猜测
  3. 程序提示"大了"/“小了”/“猜中了”
  4. 统计猜测次数
  5. 用 Result 和 ? 操作符处理输入错误

提示：use std::io; + use rand::Rng;

练习 3：用 Tokio 写一个并发 HTTP 爬虫

要求：

  1. 启动 10 个并发任务
  2. 同时请求 10 个 URL
  3. 统计每个 URL 的响应时间
  4. 用 tokio::spawn + join! / select! 实现

提示：reqwest = { version = "0.12", features = ["json"] }

练习 4：实现一个简单的 LRU 缓存

要求：

  1. 泛型实现 LRUCache<K, V>
  2. 使用 HashMap + VecDeque 或 std::collections::hash_map::Entry
  3. 实现 get、put、容量检查
  4. 写 5 个单元测试

挑战：用 unsafe 实现零拷贝版本，对比性能差异。

现在，打开终端，输入 cargo new hello_rust，开始你的 Rust 之旅吧！🚀

# rust # 人工智能 # 开发语言
Logo
AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

cover

AtomGit 首发开源｜光轮智能发布全球首个十万小时级全模态人类行为开源数据集 EgoSuite-Open100K

avatar AtomGit开源社区
cover

构筑赋能金融行业应用 Agent｜20 强决战北京，一场金融 Agent 的硬核答卷

avatar AtomGit开源社区
cover

最高赢取价值万元大奖，仓颉生态创新开发挑战赛开启！

avatar AtomGit开源社区