Learn X in Y Minutes 系列之 Rust 速成指南:es/rust.md 深度解析

原创2026-10-07 22:26:541,967 阅读
文章标签:文档教程

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 大板块:

  1. 概念基础(Basics):函数、变量、数字、字符串、数组、元组
  2. 类型系统(Types):结构体、枚举、泛型、方法、trait
  3. 模式匹配(Pattern matching):match 表达式
  4. 控制流(Control flow):for、while、loop、if
  5. 内存安全与指针(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 内存安全的三大支柱:

  1. 所有权与移动(Ownership & Move):Box<i32> 是堆上分配的智能指针,同一时刻只有一个变量拥有它。let mut now_its_mine = mine 把所有权移动给新变量,旧变量 mine 此后不可再用(代码中的注释 // println!("{}", mine); 若取消注释将无法编译)。离开作用域时 Box 自动释放堆内存——无需 GC,也不会有双重释放。
  2. 不可变借用(Borrowing):let ref_var: &i32 = &var 创建引用,期间 var 不能被修改或移动;但借用结束(最后一次使用之后)即可恢复写权限。英文原版明确这一点对应非词法生命周期(NLL):借用的有效期是"创建处到最后一次使用",而非整个词法作用域,因此示例中 ref_var 最后使用后,var = 2 得以合法执行。
  3. 可变借用(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 程序的第一步。

登录后查看全文
learnxinyminutes-docs