简单英语学 Rust on 编程那些事儿

01-更新

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_0.html

中文参考：kumakichi/easy_rust_chs

更新

2023 年 1 月 19 日：Learn Rust in a Month of Lunches 已在 Manning 上架。该书基于原版 Easy Rust，并根据读者反馈做了更新、改进与扩充（篇幅大约翻倍）。

02-介绍

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_1.html

中文参考：kumakichi/easy_rust_chs

介绍

Rust是一种新的语言，已经有了很好的教科书。但是有时候它的教材很难，因为它的教材是给以英语为母语的人看的。现在很多公司和人学习Rust，如果有一本英语简单的书，他们可以学得更快。这本教材就是给这些公司和人用简单的英语来学习Rust的。

03-我是谁？

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_2.html

中文参考：kumakichi/easy_rust_chs

我是谁？

我是一个生活在韩国的加拿大人，我在写Easy Rust的同时，也在思考如何让这里的公司开始使用它。我希望其他不以英语为第一语言的国家也能使用它。

04-简单英语学 Rust

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_3.html

中文参考：kumakichi/easy_rust_chs

简单英语学 Rust

简单英语学Rust写于2020年7月至8月，长达400多页。如果你有任何问题，可以在这里或在LinkedIn上或在Twitter上联系我。如果你发现有什么不对的地方，或者要提出pull request，请继续。已经有超过20人帮助我们修复了代码中的错别字和问题，所以你也可以。我不是世界上最好的Rust专家，所以我总是喜欢听到新的想法，或者看看哪里可以让这本书变得更好。

05-Rust Playground

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_4.html

中文参考：kumakichi/easy_rust_chs

Rust Playground

也许你还不想安装Rust，这也没关系。你可以去https://play.rust-lang.org/，在不离开浏览器的情况下开始写Rust。你可以在那里写下你的代码，然后点击Run来查看结果。你可以在浏览器的Playground里面运行本书中的大部分示例。只有在接近结尾的时候，你才会看到无法在Playground运行的示例(比如打开文件)。

以下是使用Rust Playground时的一些提示。

用"Run"来运行你的代码

06-🚧 和 ⚠️

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_5.html

中文参考：kumakichi/easy_rust_chs

🚧 和 ⚠️

有时书中的代码例子不能用。如果一个例子不工作，它将会有一个🚧或⚠️在里面。🚧就像 “正在建设中"一样:它意味着代码不完整。Rust需要一个fn main()(一个主函数)来运行，但有时我们只是想看一些小的代码，所以它不会有fn main()。这些例子是正确的，但需要一个fn main()让你运行。而有些代码示例向你展示了一个问题，我们将解决这个问题。那些可能有一个fn main()，但会产生一个错误，所以它们会有一个⚠️。

07-注释

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_6.html

中文参考：kumakichi/easy_rust_chs

注释

注释是给程序员看的，而不是给电脑看的。写注释是为了帮助别人理解你的代码。这也有利于帮助你以后理解你的代码。 (很多人写了很好的代码，但后来却忘记了他们为什么要写它。)在Rust中写注释，你通常使用 //．

08-类型

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_7.html

中文参考：kumakichi/easy_rust_chs

类型

Rust有很多类型，让你可以处理数字、字符等。有些类型很简单，有些类型比较复杂，你甚至可以创建自己的类型。

原始类型

Rust有简单的类型，这些类型被称为原始类型(原始=非常基本)。我们将从整数和char(字符)开始。整数是没有小数点的整数。整数有两种类型。

09-类型推导

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_8.html

中文参考：kumakichi/easy_rust_chs

类型推导

类型推导的意思是，如果你不告诉编译器类型，但它可以自己决定，它就会决定。编译器总是需要知道变量的类型，但你并不总是需要告诉它。实际上，通常你不需要告诉它。例如，对于let my_number = 8，my_number将是一个i32。这是因为如果你不告诉它，编译器会选择i32作为整数。但是如果你说let my_number: u8 = 8，它就会把my_number变成u8，因为你告诉它u8。

10-打印 hello, world!

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_9.html

中文参考：kumakichi/easy_rust_chs

打印 hello, world!

当你启动一个新的Rust程序时，它总是有这样的代码。

1
2
3


fn main() {
 println!("Hello, world!");
}

fn的意思是函数。

11-显示和调试

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_10.html

中文参考：kumakichi/easy_rust_chs

显示和调试

Rust中简单的变量可以用{}里面的println!打印。但是有些变量不能，你需要debug print。Debug打印是给程序员打印的，因为它通常会显示更多的信息。Debug有时看起来并不漂亮，因为它有额外的信息来帮助你。

12-可变性

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_11.html

中文参考：kumakichi/easy_rust_chs

可变性

当你用let声明一个变量时，它是不可改变的(不能改变)。

这将无法工作:

1
2
3
4


fn main() {
 let my_number = 8;
 my_number = 10; // ⚠️
}

编译器说:error[E0384]: cannot assign twice to immutable variable my_number。这是因为如果你只写let，变量是不可变的。

13-栈、堆和指针

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_12.html

中文参考：kumakichi/easy_rust_chs

栈、堆和指针

栈、堆和指针在Rust中非常重要。

栈和堆是计算机中保存内存的两个地方。重要的区别是:

栈的速度非常快, 但堆的速度就不那么快了. 它也不是超慢，但栈总是更快。但是你不能一直使用栈，因为:

14-关于打印的更多信息

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_13.html

中文参考：kumakichi/easy_rust_chs

关于打印的更多信息

在Rust中，你几乎可以用任何你想要的方式打印东西。这里有一些关于打印的事情需要知道。

添加 \n 将会产生一个新行，而 \t 将会产生一个标签。

15-字符串

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_14.html

中文参考：kumakichi/easy_rust_chs

字符串

Rust有两种主要类型的字符串。String和&str. 有什么区别呢？

&str是一个简单的字符串。当你写let my_variable = "Hello, world!"时，你会创建一个&str。&str是非常快的。
String是一个更复杂的字符串。它比较慢，但它有更多的功能。String是一个指针，数据在堆上。

另外注意，&str前面有&，因为你需要一个引用来使用str。这是因为我们上面看到的原因:堆需要知道大小。所以我们给它一个&，它知道大小，然后它就高兴了。另外，因为你用一个&与一个str交互，你并不拥有它。但是一个String是一个拥有的类型。我们很快就会知道为什么这一点很重要。

16-const 和 static

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_15.html

中文参考：kumakichi/easy_rust_chs

const 和 static

有两种声明值的方法，不仅仅是用let。它们是const和static。另外，Rust不会使用类型推理：你需要为它们编写类型。这些都是用于不改变的值（const意味着常量）。区别在于:

17-关于引用的更多信息

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_16.html

中文参考：kumakichi/easy_rust_chs

关于引用的更多信息

引用在Rust中非常重要。Rust使用引用来确保所有的内存访问是安全的。我们知道，我们使用&来创建一个引用。

18-可变引用

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_17.html

中文参考：kumakichi/easy_rust_chs

可变引用

如果您想使用一个引用来改变数据，您可以使用一个可变引用。对于可变引用，您可以写 &mut 而不是 &。

1
2
3
4


fn main() {
 let mut my_number = 8; // 别忘了这里要写 mut！
 let num_ref = &mut my_number;
}

那么这两种类型是什么呢？my_number是i32，num_ref是&mut i32(我们说是 “可变引用i32")。

19-向函数传递引用

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_18.html

中文参考：kumakichi/easy_rust_chs

向函数传递引用

引用对函数非常有用。Rust中关于值的规则是:一个值只能有一个所有者。

这段代码将无法工作:

1
2
3
4
5
6
7
8
9


fn print_country(country_name: String) {
 println!("{}", country_name);
}

fn main() {
 let country = String::from("Austria");
 print_country(country); // 我们打印 "Austria"
 print_country(country); // ⚠️ 挺好玩，再来一次！
}

它不能工作，因为country被破坏了。下面是如何操作的。

20-拷贝类型

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_19.html

中文参考：kumakichi/easy_rust_chs

拷贝类型

Rust中的一些类型非常简单。它们被称为拷贝类型。这些简单的类型都在栈中，编译器知道它们的大小。这意味着它们非常容易复制，所以当你把它发送到一个函数时，编译器总是会复制。它总是复制，因为它们是如此的小而简单，没有理由不复制。所以你不需要担心这些类型的所有权问题。

21-集合类型

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_20.html

中文参考：kumakichi/easy_rust_chs

集合类型

Rust有很多类型用于创建集合。当你需要在一个地方有多个值时，就可以使用集合。例如，你可以在一个变量中包含你所在国家的所有城市的信息。我们先从数组开始，数组的速度最快，但功能也最少。它们在这方面有点像&str。

22-向量

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_21.html

中文参考：kumakichi/easy_rust_chs

向量

就像我们有&str和String一样，我们有数组和向量。数组的功能少了就快，向量的功能多了就慢。(当然，Rust的速度一直都是非常快的，所以向量并不慢，只是比数组慢一点)。类型写成Vec，你也可以直接叫它 “vec”。

23-元组

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_22.html

中文参考：kumakichi/easy_rust_chs

元组

Rust中的元组使用()。我们已经见过很多空元组了，因为函数中的nothing实际上意味着一个空元组。

1

fn do_something() {}

其实是它的简写:

24-控制流

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_23.html

中文参考：kumakichi/easy_rust_chs

控制流

控制流的意思是告诉你的代码在不同的情况下该怎么做。最简单的控制流是if。

1
2
3
4
5
6


fn main() {
 let my_number = 5;
 if my_number == 7 {
 println!("It's seven");
 }
}

另外注意，你用的是==而不是=。==是用来比较的，=是用来赋值的(给一个值)。另外注意，我们写的是if my_number == 7而不是if (my_number == 7)。在Rust中，你不需要用if的括号。

25-结构体

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_24.html

中文参考：kumakichi/easy_rust_chs

结构体

有了结构体，你可以创建自己的类型。在 Rust 中，你会一直使用结构体，因为它们非常方便。结构体是用关键字 struct 创建的。结构体的名称应该用UpperCamelCase(每个字用大写字母，不要用空格)。如果你用全小写的结构，编译器会告诉你。

26-枚举

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_25.html

中文参考：kumakichi/easy_rust_chs

枚举

enum是enumerations的简称。它们看起来与结构体非常相似，但又有所不同。这就是区别:

当你想要一个东西和另一个东西时，使用struct.
当你想要一个东西或另一个东西时，请使用 enum。

所以，结构体是用于多个事物在一起，而枚举则是用于多个选择在一起。

27-循环

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_26.html

中文参考：kumakichi/easy_rust_chs

循环

有了循环，你可以告诉 Rust 继续某事，直到你想让它停止。您使用 loop 来启动一个不会停止的循环，除非您告诉它何时break。

28-实现结构体和枚举

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_27.html

中文参考：kumakichi/easy_rust_chs

实现结构体和枚举

在这里你可以开始赋予你的结构体和枚举一些真正的力量。要调用 struct 或 enum 上的函数，请使用 impl 块。这些函数被称为方法。impl块中有两种方法。

29-解构

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_28.html

中文参考：kumakichi/easy_rust_chs

解构

我们再来看一些解构。你可以通过使用let倒过来从一个结构体或枚举中获取值。我们了解到这是destructuring，因为你得到的变量不是结构体的一部分。现在你分别得到了它们的值。首先是一个简单的例子。

30-引用和点运算符

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_29.html

中文参考：kumakichi/easy_rust_chs

引用和点运算符

我们了解到，当你有一个引用时，你需要使用*来获取值。引用是一种不同的类型，所以这是无法运行的:

1
2
3
4
5
6


fn main() {
 let my_number = 9;
 let reference = &my_number;

 println!("{}", my_number == reference); // ⚠️
}

编译器打印。

31-泛型

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_30.html

中文参考：kumakichi/easy_rust_chs

泛型

在函数中，你要写出采取什么类型作为输入。

1
2
3
4
5
6
7
8


fn return_number(number: i32) -> i32 {
 println!("Here is your number.");
 number
}

fn main() {
 let number = return_number(5);
}

但是如果你想用的不仅仅是i32呢？你可以用泛型来解决。Generics的意思是 “也许是一种类型，也许是另一种类型”。

32-Option 和 Result

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_31.html

中文参考：kumakichi/easy_rust_chs

Option 和 Result

我们现在理解了枚举和泛型，所以我们可以理解Option和Result。Rust使用这两个枚举来使代码更安全。

33-其他集合类型

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_32.html

中文参考：kumakichi/easy_rust_chs

其他集合类型

Rust还有很多集合类型。你可以在标准库中的 https://doc.rust-lang.org/beta/std/collections/ 看到它们。那个页面对为什么要使用一种类型有很好的解释，所以如果你不知道你想要什么类型，就去那里。这些集合都在标准库的std::collections里面。使用它们的最好方法是使用 use 语句。就像我们的enums一样。我们将从HashMap开始，这是很常见的。

34-? 操作符

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_33.html

中文参考：kumakichi/easy_rust_chs

? 操作符

有一种更短的方法来处理Result(和Option)，它比match和if let更短。它叫做 “问号运算符”，就是?。在返回结果的函数后，可以加上?。这样就会:

35-Trait（特性）

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_34.html

中文参考：kumakichi/easy_rust_chs

Trait（特性）

我们以前见过trait:Debug、Copy、Clone都是trait。要给一个类型一个trait，就必须实现它。因为Debug和其他的trait都很常见，所以我们有自动实现的属性。这就是当你写下#[derive(Debug)]所发生的事情:你自动实现了Debug。

36-链式方法

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_35.html

中文参考：kumakichi/easy_rust_chs

链式方法

Rust是一种系统编程语言，就像C和C++一样，它的代码可以写成独立的命令，单独成行，但它也有函数式风格。两种风格都可以，但函数式通常比较短。下面以非函数式(称为 “命令式”)为例，让Vec从1到10。

37-迭代器

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_36.html

中文参考：kumakichi/easy_rust_chs

迭代器

迭代器是一个构造，它可以给你集合中的元素，一次一个。实际上，我们已经使用了很多迭代器:for循环给你一个迭代器。当你想在其他时候使用迭代器时，你必须选择什么样的迭代器:

38-闭包

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_37.html

中文参考：kumakichi/easy_rust_chs

闭包

闭包就像快速函数，不需要名字。有时它们被称为lambda。Closures很容易辨识，因为它们使用||而不是()。它们在 Rust 中非常常见，一旦你学会了使用它们，你就会爱不释手。

39-dbg! 宏和 .inspect

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_38.html

中文参考：kumakichi/easy_rust_chs

dbg! 宏和 .inspect

dbg!是一个非常有用的宏，可以快速打印信息。它是 println! 的一个很好的替代品，因为它的输入速度更快，提供的信息更多。

40-&str 的类型

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_39.html

中文参考：kumakichi/easy_rust_chs

&str 的类型

&str的类型不止一种。我们有。

字符串：当你写let my_str = "I am a &str"的时候，你就会产生这些字符。它们在整个程序中持续存在，因为它们是直接写进二进制中的，它们的类型是 &'static str。'的意思是它的生命期，字符串字元有一个叫static的生命期。
借用str：这是常规的 &str 形式，没有 static 生命期。如果你创建了一个String，并得到了它的引用，当你需要它时，Rust会把它转换为&str。比如说

1
2
3
4
5
6
7
8


fn prints_str(my_str: &str) { // 可以把 &String 当作 &str 用
 println!("{}", my_str);
}

fn main() {
 let my_string = String::from("I am a string");
 prints_str(&my_string); // 传给 prints_str 一个 &String
}

那么什么是lifetime呢？我们现在就来了解一下。

41-生命周期

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_40.html

中文参考：kumakichi/easy_rust_chs

生命周期

生命期的意思是 “变量的生命期有多长”。你只需要考虑引用的生命期。这是因为引用的生命期不能比它们来自的对象更长。例如，这个函数就不能用。

42-内部可变性

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_41.html

中文参考：kumakichi/easy_rust_chs

内部可变性

Cell

内部可变性的意思是在内部有一点可变性。还记得在Rust中，你需要用mut来改变一个变量吗？也有一些方法可以不用mut这个词来改变它们。这是因为Rust有一些方法可以让你安全地在一个不可变的结构里面改变值。每一种方法都遵循一些规则，确保改变值仍然是安全的。

43-Cow

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_42.html

中文参考：kumakichi/easy_rust_chs

Cow

Cow是一个非常方便的枚举。它的意思是 “写时克隆”，如果你不需要String，可以返回一个&str，如果你需要，可以返回一个String。(它也可以对数组与Vec等做同样的处理)。

44-类型别名

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_43.html

中文参考：kumakichi/easy_rust_chs

类型别名

类型别名的意思是 “给某个类型一个新的名字”。类型别名非常简单。通常，当您有一个很长的类型，而又不想每次都写它时，您就会使用它们。当您想给一个类型起一个更好的名字，便于记忆时，也可以使用它。下面是两个类型别名的例子。

45-todo! 宏

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_44.html

中文参考：kumakichi/easy_rust_chs

todo! 宏

有时你想粗略写点写代码帮助你想象你的项目。例如，想象一个简单的项目，用书籍做一些事情。下面是你写的时候的想法:

46-Rc

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_45.html

中文参考：kumakichi/easy_rust_chs

Rc

Rc的意思是 “reference counter”(引用计数器)。你知道在Rust中，每个变量只能有一个所有者。这就是为什么这个不能工作的原因:

47-多线程

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_46.html

中文参考：kumakichi/easy_rust_chs

多线程

如果你使用多个线程，你可以同时做很多事情。现代计算机有一个以上的核心，所以它们可以同时做多件事情，Rust让你使用它们。Rust使用的线程被称为 “OS线程”。OS线程意味着操作系统在不同的核上创建线程。(其他一些语言使用 “green threads”，功能较少)

48-函数中的闭包

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_47.html

中文参考：kumakichi/easy_rust_chs

函数中的闭包

闭包是伟大的。那么我们如何把它们放到自己的函数中呢？

你可以创建自己的函数来接受闭包，但是在函数里面就不那么自由了，你必须决定类型。在函数外部，一个闭包可以在Fn、FnMut和FnOnce之间自行决定，但在函数内部你必须选择一个。最好的理解方式是看几个函数签名。这里是.all()的那个。我们记得，它检查一个迭代器，看看所有的东西是否是true(取决于你决定是true还是false)。它的部分签名是这样说的。

49-impl Trait

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_48.html

中文参考：kumakichi/easy_rust_chs

impl Trait

impl Trait与泛型类似。你还记得，泛型使用一个类型 T(或任何其他名称)，然后在程序编译时决定。首先我们来看一个具体的类型:

50-Arc

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_49.html

中文参考：kumakichi/easy_rust_chs

Arc

你还记得我们用Rc来给一个变量一个以上的所有者。如果我们在线程中做同样的事情，我们需要一个 Arc。Arc的意思是 “atomic reference counter”(原子引用计数器)。原子的意思是它使用计算机的处理器，所以每次只写一次数据。这一点很重要，因为如果两个线程同时写入数据，你会得到错误的结果。例如，想象一下，如果你能在Rust中做到这一点。

51-Channels（通道）

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_50.html

中文参考：kumakichi/easy_rust_chs

Channels（通道）

A channel is an easy way to use many threads that send to one place.它们相当流行，因为它们很容易组合在一起。你可以在Rust中用std::sync::mpsc创建一个channel。mpsc的意思是 “多个生产者，单个消费者”，所以 “many threads sending to one place”。要启动一个通道，你可以使用 channel()。这将创建一个 Sender 和一个 Receiver，它们被绑在一起。你可以在函数签名中看到这一点。

52-阅读 Rust 文档

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_51.html

中文参考：kumakichi/easy_rust_chs

阅读 Rust 文档

知道如何阅读Rust中的文档是很重要的，这样你就可以理解其他人写的东西。这里有一些Rust文档中需要知道的事情。

53-属性

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_52.html

中文参考：kumakichi/easy_rust_chs

属性

你以前见过#[derive(Debug)]这样的代码:这种类型的代码叫做属性。这些属性是给编译器提供信息的小段代码。它们不容易创建，但使用起来非常方便。如果你只用#写一个属性，那么它将影响下一行的代码。但如果你用#!来写，那么它将影响自己空间里的一切。

54-Box

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_53.html

中文参考：kumakichi/easy_rust_chs

Box

Box 是 Rust 中一个非常方便的类型。当你使用Box时，你可以把一个类型放在堆上而不是栈上。要创建一个新的 Box，只需使用 Box::new() 并将元素放在里面即可。

55-用 Box 包裹 trait

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_54.html

中文参考：kumakichi/easy_rust_chs

用 Box 包裹 trait

Box对于返回trait非常有用。你可以像这个例子一样用泛型函数写trait:

1
2
3
4
5
6
7
8
9


use std::fmt::Display;

struct DoesntImplementDisplay {}

fn displays_it<T: Display>(input: T) {
 println!("{}", input);
}

fn main() {}

这个只能接受Display的东西，所以它不能接受我们的DoesntImplementDisplay结构。但是它可以接受很多其他的东西，比如String。

56-默认值和建造者模式

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_55.html

中文参考：kumakichi/easy_rust_chs

默认值和建造者模式

你可以实现 Default trait，给你认为最常见的 struct 或 enum 赋值。建造者模式可以很好地与之配合，让用户在需要时轻松地进行修改。首先我们来看看Default。实际上，Rust中的大多数通用类型已经有Default。它们并不奇怪。0, “"(空字符串), false, 等等。

57-Deref 和 DerefMut

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_56.html

中文参考：kumakichi/easy_rust_chs

Deref 和 DerefMut

Deref是让你用*来解引用某些东西的trait。我们知道，一个引用和一个值是不一样的。

1
2
3
4
5
6


// ⚠️
fn main() {
 let value = 7; // 这是 i32
 let reference = &7; // 这是 &i32
 println!("{}", value == reference);
}

而Rust连false都不给，因为它甚至不会比较两者。

58-Crate 和模块

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_57.html

中文参考：kumakichi/easy_rust_chs

Crate 和模块

每次你在 Rust 中写代码时，你都是在 crate 中写的。crate是一个或多个文件，一起为你的代码服务。在你写的文件里面，你也可以创建一个mod。mod是存放函数、结构体等的空间，因为这些原因被使用:

59-测试

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_58.html

中文参考：kumakichi/easy_rust_chs

测试

现在我们已经了解了模块,就可以谈谈测试了。在Rust中测试你的代码是非常容易的，因为你可以在你的代码旁边写测试。

60-外部 crate

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_59.html

中文参考：kumakichi/easy_rust_chs

外部 crate

外部crate的意思是 “别人的crate”。

在本节中，你差不多需要安装Rust，但我们仍然可以只使用Playground。现在我们要学习如何导入别人写的crate。这在Rust中很重要，原因有二。

61-标准库之旅

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_60.html

中文参考：kumakichi/easy_rust_chs

标准库之旅

现在你已经知道了很多Rust的知识，你将能够理解标准库里面的大部分东西。它里面的代码已经不是那么可怕了。让我们来看看它里面一些我们还没有学过的部分。本篇游记将介绍标准库的大部分部分，你不需要安装Rust。我们将重温很多我们已经知道的内容，这样我们就可以更深入地学习它们。

62-编写宏

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_61.html

中文参考：kumakichi/easy_rust_chs

编写宏

编写宏是非常复杂的。你可能永远都不需要写宏，但有时你可能会想写，因为它们非常方便。写宏很有趣，因为它们几乎是不同的语言。要写一个宏，你实际上是用另一个叫macro_rules!的宏。然后你添加你的宏名称，并打开一个{}块。里面有点像match语句。

63-cargo

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_62.html

中文参考：kumakichi/easy_rust_chs

cargo

rustc的意思是Rust编译器，实际的编译工作由它完成。一个rust文件的结尾是.rs。但大多数人不会写出类似 rustc main.rs 的东西来编译。他们使用的是名为 cargo 的东西，它是 Rust 的主包管理器。

64-接受用户输入

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_63.html

中文参考：kumakichi/easy_rust_chs

接受用户输入

一个简单的方法是用std::io::stdin来接受用户的输入。这意味着 “标准输入”，也就是来自键盘的输入。用stdin()可以获得用户的输入，但是接下来你就会想用.read_line()把它放到&mut String中。下面是一个简单的例子，但它既能工作，也不能工作:

65-使用文件

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_64.html

中文参考：kumakichi/easy_rust_chs

使用文件

现在我们在电脑上使用Rust，我们可以开始处理文件了。你会注意到，现在我们会开始在代码中越来越多的看到Result。这是因为一旦你开始处理文件和类似的事情，很多事情都会出错。一个文件可能不在那里，或者计算机无法读取它。

66-cargo 文档

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_65.html

中文参考：kumakichi/easy_rust_chs

cargo 文档

你可能已经注意到，Rust文档看起来总是几乎一样。在左边你可以看到struct和trait，代码例子在右边等等。这是因为你只要输入cargo doc就可以自动创建文档。

67-结束了吗？

Fri, 21 Aug 2026 12:46:00 +0800

译文 · 基于 Easy Rust

原文链接: https://dhghomon.github.io/easy_rust/Chapter_66.html

中文参考：kumakichi/easy_rust_chs

结束了吗？

简单英语学Rust就这样结束了。但是我还在这里，如果你有什么问题可以告诉我。欢迎在Twitter上联系我或者添加一个pull request、issue等。如果有些地方不容易理解，你也可以告诉我。简单英语学Rust需要非常容易理解，所以请告诉我英语太难的地方。当然，Rust本身也可能是很难理解的，但我们至少可以确保英语是容易的。