Rust 学习路径规划:非科班转码的 90 天实战路线

一、我的学习背景:从零开始的 Rust 之路
我本科不是计算机专业,考研二战失败后开始自学编程。先学了三个月 Python,写了一些小脚本,然后决定学 Rust——原因很简单,Rust 岗位薪资高,而且编译器能帮我避免很多低级错误。
刚开始学 Rust 的前两周,我差点放弃。所有权、借用、生命周期这些概念完全超出了我的认知范围。Python 里随便赋值的操作,在 Rust 里编译器报一堆错。但坚持下来后发现,Rust 的编译器其实是最好的老师——它逼你理解内存模型,逼你处理每个可能的错误,逼你写出健壮的代码。
这篇文章是我 90 天 Rust 学习路径的总结,专门为非科班转码的同学设计。不追求面面俱到,只追求每一步都能跑通代码、理解原理。
二、90 天学习路径:从 Hello World 到项目实战
学习路径分三个阶段:基础语法(30天)→ 进阶特性(30天)→ 项目实战(30天)。每个阶段有明确的学习目标和可交付成果。
flowchart TB
A[Rust 90 天学习路径] --> B[阶段一: 基础语法<br/>第 1-30 天]
A --> C[阶段二: 进阶特性<br/>第 31-60 天]
A --> D[阶段三: 项目实战<br/>第 61-90 天]
B --> B1[第1周: 变量/类型/函数<br/>完成 Rustlings exercises]
B --> B2[第2周: 所有权/借用/生命周期<br/>写一个字符串处理工具]
B --> B3[第3周: 结构体/枚举/模式匹配<br/>写一个配置文件解析器]
B --> B4[第4周: 错误处理/模块系统<br/>用 thiserror 重构解析器]
C --> C1[第5周: 泛型/trait<br/>实现一个泛型缓存]
C --> C2[第6周: 闭包/迭代器<br/>重构缓存为迭代器版本]
C --> C3[第7周: 智能指针<br/>实现链表/树结构]
C --> C4[第8周: 多线程<br/>实现并发爬虫]
D --> D1[第9周: Tokio 异步编程<br/>异步 HTTP 客户端]
D --> D2[第10周: CLI 工具开发<br/>用 clap 开发命令行工具]
D --> D3[第11周: WASM 入门<br/>编译 Rust 到浏览器]
D --> D4[第12周: 综合项目<br/>完整项目发布到 GitHub]
subgraph 学习资源
E[The Rust Book<br/>主线教材]
F[Rustlings<br/>语法练习]
G[Rust by Example<br/>代码示例]
H[官方标准库文档<br/>API 查询]
end
E --> B
F --> B1
G --> C
H --> D
subgraph 检验标准
I[阶段一: 能独立写<br/>500行以内的CLI工具]
J[阶段二: 能理解<br/>开源项目核心代码]
K[阶段三: 能独立完成<br/>完整项目并发布]
end
B --> I
C --> J
D --> K
关键原则:每天至少写 1 小时代码,每周至少完成一个小项目,遇到编译错误先自己思考 15 分钟再查资料。编译错误是学习机会,不是障碍。
三、每个阶段的学习方法与代码实践
3.1 阶段一:基础语法(第 1-30 天)
// 第 2 周练习:字符串处理工具
// 目标:理解所有权和借用
/// 统计文本中每个单词的出现频率
// 为什么从字符串处理开始:字符串操作
// 涉及所有权转移、借用和生命周期,
// 是理解 Rust 内存模型的最好练习
fn word_frequency(text: &str) -> Vec<(String, usize)> {
use std::collections::HashMap;
let mut freq: HashMap<String, usize> =
HashMap::new();
// text 是 &str 引用,不获取所有权
// 为什么用 &str 而非 String:
// &str 是借用,调用方保留所有权;
// String 参数会消耗调用方的所有权
for word in text.split_whitespace() {
// to_lowercase 返回新的 String
// 为什么需要新的 String:
// to_lowercase 可能改变字符数
// (如德语 ß → ss),
// 无法在原地修改 &str
let word = word.to_lowercase();
// 去除标点
let word: String = word
.chars()
.filter(|c| c.is_alphanumeric())
.collect();
if !word.is_empty() {
*freq.entry(word).or_insert(0) += 1;
}
}
// 转换为 Vec 并按频率排序
let mut result: Vec<(String, usize)> =
freq.into_iter().collect();
// 按频率降序排序
result.sort_by(|a, b| b.1.cmp(&a.1));
result
}
/// 查找文本中最长的行
fn longest_line(text: &str) -> Option<&str> {
// 返回 &str 引用,指向 text 中的某一行
// 为什么返回 Option<&str>:
// text 可能为空,没有最长行;
// Option 强制调用方处理空值
text.lines()
.max_by_key(|line| line.len())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_word_frequency() {
let text = "hello world hello rust world";
let result = word_frequency(text);
assert_eq!(result[0], ("hello".to_string(), 2));
assert_eq!(result[1], ("world".to_string(), 2));
}
#[test]
fn test_longest_line() {
let text = "short\nvery long line\nmid";
assert_eq!(
longest_line(text),
Some("very long line")
);
}
}
3.2 阶段二:进阶特性(第 31-60 天)
use std::collections::HashMap;
use std::hash::Hash;
use std::time::Instant;
/// 泛型 LRU 缓存
// 第 5 周练习:泛型和 trait
// 目标:理解泛型约束和 trait 系统
struct LruCache<K, V> {
capacity: usize,
// K 和 V 是泛型参数
// 为什么用泛型而非具体类型:
// 缓存应该能存任何类型的 key 和 value,
// 泛型让代码可复用
cache: HashMap<K, V>,
// 记录访问顺序
access_order: Vec<K>,
}
// 为 LruCache 实现 trait 约束
// 为什么需要 K: Eq + Hash + Clone:
// HashMap 的 key 需要 Eq + Hash
// 来判断相等和计算哈希;
// access_order 需要 Clone
// 来复制 key
impl<K: Eq + Hash + Clone, V> LruCache<K, V> {
fn new(capacity: usize) -> Self {
assert!(capacity > 0, "容量必须大于 0");
Self {
capacity,
cache: HashMap::new(),
access_order: Vec::new(),
}
}
fn get(&mut self, key: &K) -> Option<&V> {
if self.cache.contains_key(key) {
// 更新访问顺序
self.access_order.retain(|k| k != key);
self.access_order.push(key.clone());
self.cache.get(key)
} else {
None
}
}
fn put(&mut self, key: K, value: V) {
if self.cache.len() >= self.capacity
&& !self.cache.contains_key(&key)
{
// 淘汰最久未使用的
if let Some(old_key) =
self.access_order.first().cloned()
{
self.cache.remove(&old_key);
self.access_order.remove(0);
}
}
// 如果 key 已存在,更新访问顺序
if self.cache.contains_key(&key) {
self.access_order.retain(|k| k != &key);
}
self.cache.insert(key.clone(), value);
self.access_order.push(key);
}
}
/// 用迭代器实现的数据处理管道
// 第 6 周练习:闭包和迭代器
fn process_data(data: &[i32]) -> Vec<i32> {
data.iter()
// 过滤负数
.filter(|&&x| x >= 0)
// 映射:平方
.map(|&x| x * x)
// 只取前 10 个
.take(10)
.collect()
}
3.3 阶段三:项目实战(第 61-90 天)
use clap::Parser;
// 第 10 周项目:命令行 Markdown 工具
/// Markdown 文件处理工具
#[derive(Parser, Debug)]
#[command(name = "md-tool", version)]
struct Cli {
/// 输入文件路径
#[arg(value_name = "FILE")]
input: std::path::PathBuf,
/// 输出格式
#[arg(short, long, default_value = "html")]
format: String,
/// 是否生成目录
#[arg(short, long)]
toc: bool,
}
fn main() -> anyhow::Result<()> {
let cli = Cli::parse();
// 读取文件
let content = std::fs::read_to_string(&cli.input)
.map_err(|e| anyhow::anyhow!(
"读取文件 {:?} 失败: {}",
cli.input, e))?;
// 根据格式处理
match cli.format.as_str() {
"html" => {
let html = markdown_to_html(&content);
println!("{}", html);
}
"stats" => {
let stats = analyze_markdown(&content);
println!("{}", stats);
}
_ => {
anyhow::bail!(
"不支持的格式: {}", cli.format);
}
}
Ok(())
}
/// Markdown 统计分析
fn analyze_markdown(content: &str) -> String {
let headings: Vec<_> = content
.lines()
.filter(|l| l.starts_with('#'))
.collect();
let code_blocks = content
.matches("```")
.count() / 2;
let words = content
.split_whitespace()
.count();
format!(
"标题数: {}\n代码块数: {}\n词数: {}",
headings.len(),
code_blocks,
words
)
}
/// 简单的 Markdown 转 HTML
fn markdown_to_html(content: &str) -> String {
content
.lines()
.map(|line| {
if let Some(text) = line.strip_prefix("# ") {
format!("<h1>{}</h1>", text)
} else if let Some(text) =
line.strip_prefix("## ")
{
format!("<h2>{}</h2>", text)
} else if let Some(text) =
line.strip_prefix("### ")
{
format!("<h3>{}</h3>", text)
} else if line.starts_with("- ") {
format!("<li>{}</li>",
&line[2..])
} else if line.is_empty() {
String::new()
} else {
format!("<p>{}</p>", line)
}
})
.collect::<Vec<_>>()
.join("\n")
}
四、学习路径的边界:什么不适合初学者
不要从 unsafe 开始:unsafe 是高级特性,需要深入理解 Rust 的内存模型才能安全使用。初学阶段应该完全避免 unsafe,等理解了所有权和借用后再学。
不要过早学宏:过程宏和声明宏是强大的元编程工具,但调试困难,编译错误信息不友好。建议在阶段二后期再接触,先从简单的 macro_rules! 开始。
不要同时学多个框架:异步编程选 Tokio,Web 选 Axum,CLI 选 Clap。不要同时学 Tokio + async-std,Axum + Actix,Clap + StructOpt。每个领域选一个学精,比每个都学皮毛好。
不要跳过 Rustlings:Rustlings 看起来简单,但它是建立肌肉记忆的最好工具。每天做 5-10 个练习,坚持两周,编译错误会从"看不懂"变成"秒懂"。
五、总结
非科班学 Rust 的 90 天路径分三个阶段:基础语法建立所有权心智模型,进阶特性掌握泛型和并发,项目实战产出可展示的作品。每个阶段的核心不是"看完书",而是"写出能跑的代码"。学习资源以 The Rust Book 为主线,Rustlings 做练习,Rust by Example 做参考。遇到编译错误先思考 15 分钟,这是最好的学习机会。不要追求速度,每天 1 小时代码比周末 8 小时更有效。90 天后你应该能独立开发 CLI 工具和简单的 Web 服务,这足以通过初级 Rust 岗位的面试。
281



被折叠的 条评论
为什么被折叠?



