Learn X in Y Minutes 系列之 Rust 速成指南:es/rust.md 深度解析
Learn X in Y Minutes 系列之 Rust 速成指南:es/rust.md 深度解析
本指南以 learnxinyminutes-docs 仓库中的 es/rust.md(西班牙语版 Rust 教学文档)为骨架,结合英文原版 rust.md 的补充细节,逐节拆解 Rust 的语法、类型系统、模式匹配、控制流与内存安全模型。读完本文,你将掌握一份可编译、可运行、带完整注释的 Rust 入门代码(learnrust.rs),并理解 Rust 如何在无垃圾回收器(GC)与无运行时的情况下实现"高性能 + 内存安全"的设计目标。
1. 文档在仓库中的定位与校验机制
learnxinyminutes-docs 是一个以"用代码书写的文档"为核心形态的编程语言速成教程仓库,正如 README.md 所述,它提供"以合法、带注释的代码形式呈现并逐行讲解"的多种语言教程。仓库根目录下的 rust.md 是英文原版,而 es/rust.md 是由译者 Razican 翻译的西班牙语版本;同一教程在仓库中还拥有 de/rust.md、fr/rust.md、ja/rust.md、zh-cn/rust.md、ru/rust.md、pt-br/rust.md 等 11 个语言版本,体现了该项目"多语言协作翻译"的运营方式。
每篇文档顶部都带有 YAML frontmatter,声明 name、contributors、translators、filename 等元信息。仓库用 lint/frontmatter.py 统一校验这些键的合法性与类型(例如 contributors 必须是二元字符串列表、filename 必须是字符串),并用 lint/encoding.sh 强制所有 .md 文件保持 UTF-8 无 BOM 编码。es/rust.md 的 frontmatter 中 filename: learnrust.rs 提示:整篇教程的代码主体可以直接保存为一个可编译的 Rust 源文件。
2. Rust 语言背景:无 GC、无运行时的高性能系统语言
文档引言部分交代了 Rust 的核心定位:它由 Mozilla Research 开发,将低层性能控制与高层语言的便利性、安全保障结合在一起。最关键的承诺是:Rust 不需要垃圾回收器(garbage collector),也不需要重量级运行时,因此 Rust 库可以成为 C 语言的"即插即用替代品"(drop-in replacement)。
从版本演进看,Rust 0.1 于 2012 年 1 月发布,此后 3 年迭代极快,社区一度建议使用 nightly 构建而非稳定版;2015 年 5 月 15 日发布的 Rust 1.0 带来了完整的向后兼容保证,并确立了每 6 周一个版本的 train-based 发布模型(1.0 发布的同时发布了 1.1 beta)。文档同时指出,尽管 Rust 属于相对底层的语言,它也吸收了高阶语言中常见的函数式概念,因此"既快又易写"。这些背景与仓库中 C、C++ 等系统语言教程的定位形成对照——Rust 试图在安全性与底层控制之间取得平衡。
3. 代码教程总览:一份可编译的 learnrust.rs
教程的核心是一段约 270 行的完整 Rust 程序,按主题分为 5 大板块:
- 概念基础(Basics):函数、变量、数字、字符串、数组、元组
- 类型系统(Types):结构体、枚举、泛型、方法、trait
- 模式匹配(Pattern matching):match 表达式
- 控制流(Control flow):for、while、loop、if
- 内存安全与指针(Memory safety & pointers):Box、所有权移动、借用
下面按板块逐节讲解。为使中文读者易读,代码注释依据 es/rust.md 的内容译成中文,并融入英文原版 rust.md 中更完整的细节(如文档注释、非词法生命周期说明等)。
3.1 注释:行注释、块注释与文档注释
// 这是注释。单行注释长这样...
// 可以连续多行。
/* 块注释
/* 块注释可以嵌套。 */ */
/// 文档注释长这样,支持 Markdown 语法。
/// # Examples
///
/// ```
/// let five = 5
/// ```
Rust 提供三类注释:// 行注释、可嵌套的 /* ... */ 块注释,以及 /// 文档注释(支持 Markdown,可配合 cargo doc 生成 API 文档)。文档注释中的代码块会被当作 doctest 运行,这是 Rust 文档驱动开发的重要特性。
3.2 概念基础:函数、变量与数字
#[allow(dead_code)]
// 函数
// `i32` 是 32 位有符号整数类型
fn add2(x: i32, y: i32) -> i32 {
// 隐式返回(不加分号)
x + y
}
#[allow(unused_variables)]
#[allow(unused_assignments)]
#[allow(dead_code)]
// 主函数
fn main() {
// 数字 //
// 不可变绑定
let x: i32 = 1;
// 整数/浮点数字面量后缀
let y: i32 = 13i32;
let f: f64 = 1.3f64;
// 类型推断
// 大多数情况下,Rust 编译器能推断变量类型,因此无需显式标注类型。
// 本教程多处显式标注类型,仅为演示目的;多数场景交给类型推断即可。
let implicit_x = 1;
let implicit_f = 1.3;
// 算术运算
let sum = x + y + 13;
// 可变变量
let mut mutable = 1;
mutable = 4;
mutable += 2;
这一节确立了 Rust 的几个核心心智模型:
- 函数签名:
fn 名称(参数: 类型) -> 返回类型;函数体最后一个不带分号的表达式即为返回值(隐式返回),带分号则是语句、返回()。 - let 绑定默认不可变:要声明可变变量必须显式写
let mut,这是 Rust 默认安全取向的体现——编译器会拒绝未声明mut却尝试复制的代码。 - 字面量后缀:
13i32、1.3f64直接指定字面量类型,便于在推断不明确时消除歧义。 - 类型推断:
let implicit_x = 1无需标注类型,编译器自动推断为i32。 - 代码顶部出现的
#[allow(dead_code)]、#[allow(unused_variables)]等属性是刻意为之:因为本教程只演示语法,并不真正"使用"所有变量,这些属性可以压制编译告警,保证示例直接通过编译。
3.3 字符串:&str、String 与切片
// 字符串 //
// 字符串字面量
let x: &str = "hello world!";
// 打印到控制台
println!("{} {}", f, x); // 1.3 hello world!
// `String` —— 在堆(heap)上分配的字符串
// 存储为 `Vec<u8>`,始终保存合法的 UTF-8 序列,且不以 null 结尾。
let s: String = "hello world".to_string();
// 字符串切片(slice)—— 对另一字符串的不可变视图
// 它本质上是指向字符串内容的不可变指针 + 长度,并不真正持有字符数据,
// 只是指向一段静态分配或属于其他对象(此处是 `s`)的缓冲区的开头与长度。
// 字符串切片之于字符串,就像 `&[u8]` 之于 `Vec<T>`。
let s_slice: &str = &s;
println!("{} {}", s, s_slice); // hello world hello world
Rust 区分两种字符串:&str(字符串切片) 是栈上的"指针 + 长度"视图,不持有数据;String 是堆分配的、可变增长的所有权字符串。&s 对 String 取切片是借用操作(详见第 3.7 节)。println!("{} {}", f, x) 演示了格式化占位符 {}(Display 格式)。
3.4 数组、向量与切片
// 数组(Vectors/arrays)//
// 固定大小的数组
let four_ints: [i32; 4] = [1, 2, 3, 4];
// 动态数组(向量)
let mut vector: Vec<i32> = vec![1, 2, 3, 4];
vector.push(5);
// 切片 —— 对向量或数组的不可变视图
// 与字符串切片类似,只不过针对的是数组/向量
let slice: &[i32] = &vector;
// 用 `{:?}` 以调试风格打印
println!("{:?} {:?}", vector, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
[T; N] 是编译期定长的数组,Vec<T> 是堆上可增长的动态数组(通过 vec! 宏创建、push 追加),&[T] 切片则是对两者的不可变视图。{:?} 使用 Debug 格式化输出,是调试打印的惯用手段(对应的 {} 是 Display)。
3.5 元组:异构定长集合
// 元组 //
// 元组是固定大小的值集合,元素类型可以不同
let x: (i32, &str, f64) = (1, "hello", 3.4);
// 解构 `let`
let (a, b, c) = x;
println!("{} {} {}", a, b, c); // 1 hello 3.4
// 索引访问
println!("{}", x.1); // hello
元组把多种类型的值组合成一个定长集合:(1, "hello", 3.4) 的类型是 (i32, &str, f64)。可以通过 let (a, b, c) = x 一次性解构,也可以通过 x.1 按下标索引——这一"模式 + 解构"的思想会在 match 一节进一步放大。
3.6 类型系统:结构体、枚举、泛型、方法与 trait
// 类型 //
// 结构体
struct Point {
x: i32,
y: i32,
}
let origin: Point = Point { x: 0, y: 0 };
// 字段无名的结构体,称为"元组结构体"
struct Point2(i32, i32);
let origin2 = Point2(0, 0);
// 类似 C 的基本枚举
enum Direction {
Left,
Right,
Up,
Down,
}
let up = Direction::Up;
// 带字段的枚举
// 如果你想让某个值"可选",标准库提供了 `Option`
enum OptionalI32 {
AnI32(i32),
Nothing,
}
let two: OptionalI32 = OptionalI32::AnI32(2);
let nothing = OptionalI32::Nothing;
// 泛型 //
struct Foo<T> { bar: T }
// 标准库中以 `Option` 形式定义了这个模式
// `Option` 被用于通常需要空指针(null)的场合
enum Optional<T> {
SomeVal(T),
NoVal,
}
// 方法 //
impl<T> Foo<T> {
// 方法接收显式的 `self` 参数
fn bar(&self) -> &T { // self 被不可变借用
&self.bar
}
fn bar_mut(&mut self) -> &mut T { // self 被可变借用
&mut self.bar
}
fn into_bar(self) -> T { // 这里 self 被消费(所有权转移)
self.bar
}
}
let a_foo = Foo { bar: 1 };
println!("{}", a_foo.bar()); // 1
// trait(其他语言中的接口或 typeclass)//
trait Frobnicate<T> {
fn frobnicate(self) -> Option<T>;
}
impl<T> Frobnicate<T> for Foo<T> {
fn frobnicate(self) -> Option<T> {
Some(self.bar)
}
}
let another_foo = Foo { bar: 1 };
println!("{:?}", another_foo.frobnicate()); // Some(1)
// 函数指针类型 //
fn fibonacci(n: u32) -> u32 {
match n {
0 => 1,
1 => 1,
_ => fibonacci(n - 1) + fibonacci(n - 2),
}
}
type FunctionPointer = fn(u32) -> u32;
let fib : FunctionPointer = fibonacci;
println!("Fib: {}", fib(4)); // 5
这一板块覆盖 Rust 类型系统的核心构件:
- 结构体(struct):命名命段的
Point { x, y },以及字段匿名的元组结构体Point2(i32, i32)(可通过origin2.0索引)。 - 枚举(enum):从类似 C 的无字段枚举(
Direction::Up)到携带数据的枚举(OptionalI32::AnI32(2))。这种"代数数据类型"是 Rust 表达可空值与错误的核心;标准库Option<T>就是Some(T) / None的泛型化,用于替代空指针。 - 泛型:
struct Foo<T> { bar: T }让类型参数化;教程中手写的Optional<T>正是标准库Option<T>的教学复刻。 - 方法与 self 的三种形态:
impl<T> Foo<T>中的方法必须显式接收self——&self(不可变借用)、&mut self(可变借用)、self(消费所有权)。三种签名对应三种调用语义,是 Rust"所有权贯穿 API 设计"的直接体现。 - trait:类似其他语言的接口/typeclass,
impl<T> Frobnicate<T> for Foo<T>为类型实现行为,返回值Option<T>与标准库衔接。 - 函数指针类型(英文原版补充):
type FunctionPointer = fn(u32) -> u32将函数作为一等公民赋值给变量,fib(4)输出 5。
3.7 模式匹配:match 表达式的威力
// 模式匹配 //
let foo = OptionalI32::AnI32(1);
match foo {
OptionalI32::AnI32(n) => println!("it's an i32: {}", n),
OptionalI32::Nothing => println!("it's nothing!"),
}
// 进阶模式匹配
struct FooBar { x: i32, y: OptionalI32 }
let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
match bar {
FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
println!("The numbers are zero!"),
FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
println!("The numbers are the same"),
FooBar { x: n, y: OptionalI32::AnI32(m) } =>
println!("Different numbers: {} {}", n, m),
FooBar { x: _, y: OptionalI32::Nothing } =>
println!("The second number is Nothing!"),
}
match 是 Rust 最强大的控制结构,要求穷尽所有分支(编译器强制),且每个分支可以绑定变量、嵌套解构并附加 if 守卫(guard):
- 第一段匹配解构
OptionalI32::AnI32(n),把内部值绑定到n; - 第二段展示结构体模式:
FooBar { x: n, y: OptionalI32::AnI32(m) }同时解构外层结构体与内层枚举,if n == m是守卫条件,_通配符匹配任意值。
这种"穷尽 + 解构 + 守卫"的组合,正是 Rust 用类型系统消灭空指针与未处理分支的根基。
3.8 控制流:for、if、while 与 loop
// 控制流 //
// `for` 循环/迭代
let array = [1, 2, 3];
for i in array {
println!("{}", i);
}
// 范围(Range)
for i in 0u32..10 {
print!("{} ", i);
}
println!("");
// 输出 `0 1 2 3 4 5 6 7 8 9 `
// `if`
if 1 == 1 {
println!("Maths is working!");
} else {
println!("Oh no...");
}
// `if` 作为表达式
let value = if true {
"good"
} else {
"bad"
};
// `while` 循环
while 1 == 1 {
println!("The universe is operating normally.");
// break 语句跳出 while 循环,避免无用迭代
break
}
// 无限循环
loop {
println!("Hello!");
// break 语句跳出循环
break
}
}
要点:
for遍历:直接对数组/向量/范围迭代,无需手写索引。- 范围语法:
0u32..10表示左闭右开区间[0, 10),输出0 1 2 ... 9。 - if 是表达式:
let value = if true { "good" } else { "bad" }—— 每个分支的最后一个表达式即分支值,Rust 中几乎所有控制结构都是表达式。 - while 与 loop:
loop是永远循环的原生结构,与while true等价但语义更明确;教程中通过break立即退出,避免死循环——这也说明直接复制本节代码运行时,break保证了程序可以正常结束。
3.9 内存安全与指针:所有权、移动与借用
// 内存安全与指针 //
// 所有权指针(owned pointer)——同一时刻只能有一个东西"拥有"这个指针
// 这意味着当 `Box` 离开作用域时,会被安全地自动释放。
let mut mine: Box<i32> = Box::new(3);
*mine = 5; // 解引用
// 这里 `now_its_mine` 取得了 `mine` 的所有权。换句话说,`mine` 被移动(moved)。
let mut now_its_mine = mine;
*now_its_mine += 2;
println!("{}", now_its_mine); // 7
// println!("{}", mine); // 这行无法编译,因为 `now_its_mine` 现在拥有该指针
// 引用(Reference)——指向其他数据的不可变指针
// 当对一个值取引用时,我们说这个值被"借用"(borrowed)。
// 当一个值被不可变借用时,它不能被修改或移动。
// 借用从创建处持续到其最后一次使用(非词法生命周期,Non-Lexical Lifetimes)。
let mut var = 4;
var = 3;
let ref_var: &i32 = &var;
println!("{}", var); // 与 `mine` 不同,`var` 仍可继续使用
println!("{}", *ref_var);
// *ref_var = 6; // 这行无法编译,因为 `ref_var` 是不可变引用
// 上面 `ref_var` 最后一次使用之后,借用结束,因此下面的重新赋值是允许的。
var = 2;
// 可变引用
// 当一个值被可变借用时,它完全不能被访问。
let mut var2 = 4;
let ref_var2: &mut i32 = &mut var2;
*ref_var2 += 2; // '*' 用于解引用指向被可变借用的 var2
println!("{}", *ref_var2); // 6
// ref_var2 的类型是 &mut i32,存的是对 i32 的引用,而非值本身。
// 上面 `ref_var2` 最后一次使用之后,借用结束,因此下面的重新赋值是允许的。
var2 = 2;
}
这一节是全篇的灵魂,阐释 Rust 内存安全的三大支柱:
- 所有权与移动(Ownership & Move):
Box<i32>是堆上分配的智能指针,同一时刻只有一个变量拥有它。let mut now_its_mine = mine把所有权移动给新变量,旧变量mine此后不可再用(代码中的注释// println!("{}", mine);若取消注释将无法编译)。离开作用域时Box自动释放堆内存——无需 GC,也不会有双重释放。 - 不可变借用(Borrowing):
let ref_var: &i32 = &var创建引用,期间var不能被修改或移动;但借用结束(最后一次使用之后)即可恢复写权限。英文原版明确这一点对应非词法生命周期(NLL):借用的有效期是"创建处到最后一次使用",而非整个词法作用域,因此示例中ref_var最后使用后,var = 2得以合法执行。 - 可变借用(Mutable Reference):
let ref_var2: &mut i32 = &mut var2期间,var2完全不能被其他路径访问(防止数据竞争),解引用*ref_var2 += 2修改原值;借用结束后var2 = 2才被允许。
这组规则被编译器在编译期强制检查,使 Rust 在不引入运行时开销的前提下杜绝悬垂指针、数据竞争与 use-after-free——这正是文档引言所称"无 GC、无运行时即实现安全保证"的底层机制。
4. 亲手运行:从文档到可执行程序
教程 frontmatter 中的 filename: learnrust.rs 表明:你可以把第 3 节各代码片段按顺序拼接成一个 learnrust.rs 文件(fn main() 及全部 struct/enum/trait 定义放在同一文件内),然后使用 Rust 工具链编译运行:
rustc learnrust.rs
./learnrust
若尚未安装 Rust,可通过官方推荐的 rustup 工具链管理器安装 rustc 与 cargo。需要注意:示例中的 while 1 == 1 与 loop 均带有 break,因此程序能正常退出;而 #[allow(dead_code)]、#[allow(unused_variables)] 等属性则是为了压制教学代码中"未使用变量/未调用的函数"告警,使示例可以零警告通过编译。
5. 版本差异与仓库延伸
对比英文原版 rust.md 与西班牙语版 es/rust.md 可以看到:es 版完整继承并翻译了原版结构(同样分为 Basics、Types、Pattern matching、Control flow、Memory safety & pointers 五大板块),原版额外包含的文档注释示例、bar/bar_mut/into_bar 三种 self 方法形态、fibonacci 函数指针以及 NLL 借用说明,在本指南第 3 节中均已融合讲解;中文读者还可以对照 zh-cn/rust.md 查看中译版本。这种"同源多语言"的组织方式,正是 learnxinyminutes-docs 项目的协作模式:每个语言目录下都维护着同一套教程骨架的本地化版本。
若想继续深入,可以:
- 对照同仓库中 C 与 C++ 的入门文档(c.md、c++.md),体会 Rust 在"无 GC 系统语言"路线上的取舍;
- 阅读仓库根目录 CONTRIBUTING.md 了解贡献规范,参考 README.md 了解项目"以代码书写文档"的格式约定;
- 将本教程代码放入 Rust 官方 Playground 在线运行验证(文档 es/rust.md 末尾的"Lectura adicional"部分也推荐了该途径)。
es/rust.md 本身也提示:这只是理解 Rust 最重要概念的基础入门,Rust 远不止于此——但掌握这五大板块(基础语法、类型系统、模式匹配、控制流、内存安全),已经足以读懂绝大多数 Rust 示例代码,并迈出编写自己第一个安全、高性能 Rust 程序的第一步。