写给Rust 新人的一封信：AI 时代，你的学习方法可以完全不同

原创于 2026-07-31 17:27:21 发布 · 32 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

写给Rust 新人的一封信：AI 时代，你的学习方法可以完全不同

一、写在前面

今天是 7 月 31 日，是我在 CSDN 日更 10 篇文章的第 31 天，也是 7 月月度终章的最后一篇。

310 篇文章，累计约 40 万字，涵盖 AI CLI 开发、Rust 系统编程、WASM 工程化、AI 辅助学习四个核心板块。最后一篇我想写点不一样的东西——不是技术教程，不是复盘总结，而是以"过来人"的身份，给正在考虑或者刚开始学 Rust 的同学写一封信。

我 2023 年底开始自学 Rust，彼时我在地产行业做 PHP 后端，大学学的是市场营销，跟计算机没有一毛钱关系。转码两年半，现在我的 Rust 项目 dayuan 在 GitHub 上有 270 个 star，我的技术文章有人看、有人评论、有人催更。

这条路走得艰难，但绝对走得通。下面是我最想对你说的一些话。

二、学 Rust 的核心障碍（不是你以为的那些）

障碍一：概念密度 —— 别人是一个一个概念学，你是被一堆概念同时轰炸

科班生学 C/C++，所有权是分开学的——先学 malloc/free，再学指针，再学 const，再学 RAII。这些概念散落在 4 门课程里，花了 2 年时间消化。

而你学 Rust，第一章就是所有权，第二章借用，第三章生命周期。这些概念打包在一起，压缩成一个月的学习量。

解法：不要在概念和概念之间追求完美理解。先写代码，把概念当成"规则"记下来——"不能同时有可变和不可变引用"、"函数返回的引用不能比参数活得长"——先按规则写，写多了自然理解为什么有这些规则。

/// 不要试图"理解"所有权，先把它当成游戏规则来玩：
/// 
/// 规则1：每个值同时只能有一个所有者
/// 规则2：所有者离开作用域，值就被释放
/// 规则3：要共享访问用 &（不可变借用），要修改用 &mut（可变借用）
/// 规则4：不可变借用可以有多个，可变借用同时只能有一个
/// 
/// 先记住这四条，写代码时反复对照。理解是副产品，不是前置条件。
fn main() {
    // 规则1 验证
    let s1 = String::from("hello");
    let s2 = s1;  // s1 的所有权转移给了 s2
    // println!("{}", s1);  // ❌ s1 已被 move，不能再用
    
    // 规则2 验证
    {
        let temp = String::from("temp");
        println!("{}", temp);
    } // temp 离开作用域，自动调用 drop，内存被释放
    
    // 规则3+4 验证
    let mut data = vec![1, 2, 3];
    let r1 = &data;   // 不可变借用1
    let r2 = &data;   // 不可变借用2（多个不可变借用 ✅）
    println!("{:?} {:?}", r1, r2);
    // r1, r2 最后一次使用后，借用结束
    
    let r3 = &mut data;  // 可变借用（无其他借用存在 ✅）
    r3.push(4);
    println!("{:?}", r3);
}

障碍二：反馈延迟 —— 两周写不出一个能跑的程序

这是最消磨意志力的阶段。Python 第一天就能做个爬虫，Rust 两周还在和编译器搏斗。

解法：主动降低目标复杂度。我的第一个 Rust 程序不是什么"系统工具"，而是一个只做一件事的计数器：

/// 我的第一个"有成就感"的 Rust 程序
/// 功能：统计一个目录下所有 .rs 文件的代码行数
/// 复杂度：够低，但足够学到 fs、Iterator、Path、Result

use std::path::Path;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let dir = Path::new("./src");
    let mut total_lines = 0usize;  // usize: 无符号整数，大小等于指针宽度
    
    // 遍历目录中的每个条目
    for entry in std::fs::read_dir(dir)? {
        // ?: 如果 read_dir 失败，把错误传递出去
        let entry = entry?;         // ?: 如果读取单个条目失败，也传递出去
        let path = entry.path();
        
        // 只处理 .rs 文件
        if path.extension().map_or(false, |ext| ext == "rs") {
            // 读取文件内容，统计行数
            let content = std::fs::read_to_string(&path)?;
            let lines = content.lines().count();
            
            println!("{}: {} 行", path.display(), lines);
            total_lines += lines;
        }
    }
    
    println!("总计: {} 行代码", total_lines);
    Ok(())  // Ok(()): 程序正常结束，返回空元组
}

这个程序 20 行，但涵盖了 Rust 最核心的四个概念：Result 错误处理、Path 文件操作、Iterator 链式操作、? 错误传播。而且它真的"有用"——我至今还在用它的增强版统计 dayuan 的代码量。

障碍三：孤独感 —— 全世界都在学 Python，只有你在学 Rust

解法：输出倒逼输入。我从第三个月开始写技术文章，不是因为我懂了，恰恰是因为我不懂。写文章是一种"最诚实的学"——你哪里含糊，读者一眼就能看出来。逼着自己把一个概念讲清楚，是你理解它最快的方式——没有之一。

障碍四：目标模糊 —— "Rust 岗位那么少，学了干嘛？"

这是最现实的问题。截至 2026 年 7 月，Rust 在国内的招聘市场确实远不如 Go 和 Java。

但我的看法是：Rust 不是让你"多一个选择"，而是让你获得了一种看问题的视角。学会 Rust 之后，我写 Python 时会本能地思考"这个函数的参数会不会被意外修改"，写 TypeScript 时会关注"这个对象的所有权周期是多久"。

这种底层视角在任何语言、任何框架中都有用。而且 Rust 社区有个不成文的传统："Rust 程序员之所以少，不是因为它难学，而是因为它会把不合格的开发者拦在门外"——虽然这句话有点苛刻，但它反映了一个事实：Rust 学习者本身就是经过筛选的、更有耐心的那一批。

三、AI 时代的学习方法应该完全重写

传统的学习路径：看理论 → 做练习 → 写项目

AI 时代的路径：让 AI 写 → 自己读 → 自己改 → 复查差异 → 追问原理

这个流程的效率比"自己从头写"高 3-5 倍，因为：

AI 的代码是参考系，不是抄袭源——你对比的是"正确的写法"和"你的理解"
追问环节是你真正学习的环节——"为什么"比"怎么做"重要十倍
知识卡片让你把碎片化学习变成结构化知识

四、给你的三句实话

第一句：不要怕 clone()。

学习阶段频繁使用 clone() 不是坏习惯，是聪明的策略。你先把所有权的坑绕过去，把业务逻辑跑通，再回来优化。我见过太多人因为死磕"零拷贝"而放弃 Rust——不值得。

第二句：编译器报错是你最好的老师，但你要学会"翻译"它。

# 编译器的原话：
error[E0597]: `config` does not live long enough
  --> src/main.rs:10:20
   |
10 |     let ref_to_config = &config;
   |                          ^^^^^^ borrowed value does not live long enough
...
15 | }
   | - `config` dropped here while still borrowed

# 翻译成人话：
# "你在第10行借用了 config，但 config 在第15行就被销毁了。
#  你拿着借书卡，但书已经被还回去了——借的东西不能比被借的东西活得久。
#  解决方法：要么延长 config 的生命周期，要么让 ref_to_config 在 config 死亡之前释放。"

第三句：你不需要在学 Rust 之前学过 C/C++。

这是最大的误解。"不会 C 就学不会 Rust"的说法是错误的。Rust 不是 C 的升级版，它是从头设计的新语言。不懂 C 可能让你在某些"为什么 Rust 长这样"的问题上困惑久一点，但绝对不影响你学会 Rust。我到现在都不会写 C 的 malloc，但我能用 Rust 写一套完整的内存池。