From 7a293c0d643b00b97c2e6f341ce51b04ce36437f Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 19 Sep 2017 10:48:49 +0800 Subject: [PATCH 001/150] fix translation in 01-01 --- src/ch01-01-installation.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch01-01-installation.md b/src/ch01-01-installation.md index 74f2f07..263617c 100644 --- a/src/ch01-01-installation.md +++ b/src/ch01-01-installation.md @@ -57,7 +57,7 @@ $ rustup update ### 卸载 -卸载 Rust 与安装一个简单。在 shell 中执行卸载脚本: +卸载 Rust 与安装同样简单。在 shell 中执行卸载脚本: ```text $ rustup self uninstall From 16d01042a573bc47d697e4955b288aa1fd0b699a Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 19 Sep 2017 11:01:00 +0800 Subject: [PATCH 002/150] =?UTF-8?q?=E4=BC=BC=E4=B9=8E=E6=98=AF=E7=AC=94?= =?UTF-8?q?=E8=AF=AF=EF=BC=8C=E5=A4=9A=E4=B8=AA=E2=80=9C=E6=96=87=E2=80=9D?= =?UTF-8?q?=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch01-02-hello-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index 0910ca9..d99cab4 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -8,7 +8,7 @@ > 注意：本书假设你熟悉基本的命令行操作。Rust 对于你的编辑器、工具，以及代码位于何处并没有特定的要求，如果相比命令行你更倾向于 IDE，请随意使用合意的 IDE。 -### 创建项目文目录 +### 创建项目目录 首先，创建一个存放 Rust 代码的目录。Rust 并不关心代码的位置，不过在本书中，我们建议你在 home 目录中创建一个 *projects* 目录，并把你的所有项目放在这。打开一个终端，输入如下命令为这个项目创建一个文件夹： From 16fae0227be425875c51e5975c0bcb09d68fa505 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 19 Sep 2017 13:15:54 +0800 Subject: [PATCH 003/150] =?UTF-8?q?separate=E7=9D=80=E9=87=8D=E4=BD=93?= =?UTF-8?q?=E7=8E=B0=E4=BA=8C=E8=80=85=E7=9B=B8=E4=BA=92=E7=8B=AC=E7=AB=8B?= =?UTF-8?q?=EF=BC=8C=E9=81=BF=E5=85=8D=E6=97=A0=E7=BC=96=E8=AF=91=E5=9E=8B?= =?UTF-8?q?=E8=AF=AD=E8=A8=80=E7=BB=8F=E9=AA=8C=E7=9A=84=E6=96=B0=E6=89=8B?= =?UTF-8?q?=E6=B7=B7=E6=B7=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch01-02-hello-world.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index d99cab4..1e556b1 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -75,7 +75,7 @@ fn main() { 这几行定义了一个 Rust **函数**。`main` 函数是特殊的：它是每个可执行的 Rust 程序首先执行的。第一行代码表示 “我声明了一个叫做 `main` 的函数，它没有参数也没有返回值。” 如果有参数的话，他们的名称应该出现在括号中，`(`和`)`之间。 -还须注意函数体被包裹在花括号中，`{`和`}` 之间。Rust 要求所有函数体都要用花括号包裹起来（译者注：有些语言，当函数体只有一行时可以省略花括号，但 Rust 中是不行的）。一般来说，将左花括号与函数声明置于同一行并以空格分隔，是良好的代码风格。 +还须注意函数体被包裹在花括号中，`{`和`}` 之间。Rust 要求所有函数体都要用花括号包裹起来（译者注：有些语言，当函数体只有一行时可以省略花括号，但在 Rust 中是不行的）。一般来说，将左花括号与函数声明置于同一行并以空格分隔，是良好的代码风格。 在 `main()` 函数中： @@ -91,7 +91,7 @@ fn main() { 该行以分号结尾（`;`）。`;` 代表一个表达式的结束和下一个表达式的开始。大部分 Rust 代码行以 `;` 结尾。 -### 编译和运行是两个步骤 +### 编译和运行是彼此独立的步骤 “编写并运行 Rust 程序” 部分中展示了如何运行新创建的程序。现在我们将拆分并检查每一步操作。 From bb06a95d5a5ea75bf3fa470028b884dea3d9e08c Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 19 Sep 2017 13:19:10 +0800 Subject: [PATCH 004/150] =?UTF-8?q?=E6=AD=A4=E5=A4=84=E5=BA=94=E6=B3=A8?= =?UTF-8?q?=E6=84=8F=E8=A1=94=E6=8E=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch01-02-hello-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index 1e556b1..3dab7fd 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -122,7 +122,7 @@ main.rs $ ./main # or .\main.exe on Windows ``` -如果 *main.rs* 是 “Hello, world!” 程序，它将会在终端上打印 `Hello, world!`。 +如果 *main.rs* 是上文所述的 “Hello, world!” 程序，它将会在终端上打印 `Hello, world!`。 来自 Ruby、Python 或 JavaScript 这样的动态类型语言背景的同学，可能不太习惯将编译和执行分为两个单独的步骤。Rust 是一种 **预编译静态类型语言**（*ahead-of-time compiled language*），这意味着你可以编译程序并将其交与他人，他们不需要安装 Rust 即可运行。相反如果你给他们一个 `.rb`、`.py` 或 `.js` 文件，他们需要先分别安装 Ruby，Python，JavaScript 实现（运行时环境，VM），不过你只需要一句命令就可以编译和执行程序。这一切都是语言设计上的权衡取舍。 From 6b3fa45d3e48672f58b046675c7a5e92998d1a9b Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 19 Sep 2017 19:03:55 +0800 Subject: [PATCH 005/150] =?UTF-8?q?=E4=B9=8B=E5=89=8D=E7=9A=84=E2=80=9C?= =?UTF-8?q?=E6=89=93=E5=BC=80=E2=80=9D=E7=9A=84=E8=AF=B4=E6=B3=95=E5=AE=B9?= =?UTF-8?q?=E6=98=93=E8=A2=AB=E8=AF=BB=E8=80=85=E8=AF=AF=E4=BB=A5=E4=B8=BA?= =?UTF-8?q?=E6=98=AF=E6=89=93=E5=BC=80binary=E7=A8=8B=E5=BA=8F=E6=89=80?= =?UTF-8?q?=E9=9C=80=E7=9A=84=E6=97=B6=E9=97=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch01-02-hello-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index 3dab7fd..e4de0e7 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -267,7 +267,7 @@ Cargo 的另一个优点是，不管你使用什么操作系统其命令都是 ### 发布（release）构建 -当项目最终准备好发布了，可以使用 `cargo build --release` 来优化编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过打开他们也需要更长的编译时间。这也就是为什么会有两种两种不同的配置：一种为了开发，你需要经常快速重新构建；另一种构建给用户的最终程序，他们不会重新构建，并且希望程序运行得越快越好。如果你在测试代码的运行时间，请确保运行 `cargo build --release` 并使用 *target/release* 下的可执行文件进行测试。 +当项目最终准备好发布了，可以使用 `cargo build --release` 来优化编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。这也就是为什么会有两种不同的配置：一种为了开发，你需要经常快速重新构建；另一种为了构建给用户最终程序，他们不会重新构建，并且希望程序运行得越快越好。如果你在测试代码的运行时间，请确保运行 `cargo build --release` 并使用 *target/release* 下的可执行文件进行测试。 ### 把 Cargo 当作习惯 From 23956f0a4c50814b5918214351a69b89ec79acb1 Mon Sep 17 00:00:00 2001 From: huangjj27 <349373001dc@gmail.com> Date: Sun, 8 Oct 2017 14:24:12 +0800 Subject: [PATCH 006/150] bugfix(gitbook): unrendered title for ch17-00 --- src/ch17-00-oop.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch17-00-oop.md b/src/ch17-00-oop.md index 0bc0f41..355b887 100644 --- a/src/ch17-00-oop.md +++ b/src/ch17-00-oop.md @@ -1,4 +1,4 @@ -## Rust 是一个面向对象的编程语言吗？ +# Rust 是一个面向对象的编程语言吗？ > [ch17-00-oop.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch17-00-oop.md) >
From a1ff12f6d37341483ab738c5ec4c26a5ac7f6a83 Mon Sep 17 00:00:00 2001 From: huangjj27 <349373001dc@gmail.com> Date: Sun, 8 Oct 2017 14:42:46 +0800 Subject: [PATCH 007/150] =?UTF-8?q?chore(introduction):=20"package=20regis?= =?UTF-8?q?try=20site=E7=BF=BB=E8=AF=91=E4=B8=BA"=E5=8C=85=E7=99=BB?= =?UTF-8?q?=E8=AE=B0=E7=BD=91=E7=AB=99"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit close https://github.com/KaiserY/trpl-zh-cn/issues/87 --- src/ch01-00-introduction.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch01-00-introduction.md b/src/ch01-00-introduction.md index dadd9ff..c9fc202 100644 --- a/src/ch01-00-introduction.md +++ b/src/ch01-00-introduction.md @@ -6,7 +6,7 @@ 欢迎阅读 “Rust 程序设计语言”，一本介绍 Rust 的书。Rust 是一门着眼于安全、速度和并发的编程语言。其程序设计兼顾底层语言的性能与控制，并不失高级语言强大的抽象能力。其特性适合那些有类 C 语言经验，正在寻找更安全的替代品的开发者；同样适合有着类 Python 语言背景，寻求在不牺牲表现力的前提下，编写更高性能代码的开发者。 -Rust 编译时执行绝大部分的安全检查和内存管理决策，对运行时性能的影响微不足道。这使其在其他语言不擅长的应用场景中得以大显身手：可预测时间和空间需求的程序，嵌入到其他语言中，以及编写如设备驱动和操作系统这样的底层代码，。Rust 也很擅长 web 程序：它驱动着 Rust 包注册网站（package +Rust 编译时执行绝大部分的安全检查和内存管理决策，对运行时性能的影响微不足道。这使其在其他语言不擅长的应用场景中得以大显身手：可预测时间和空间需求的程序，嵌入到其他语言中，以及编写如设备驱动和操作系统这样的底层代码，。Rust 也很擅长 web 程序：它驱动着 Rust 包登记网站（package registry site），[crates.io]！我们由衷期待**你**使用 Rust 进行创作。 [crates.io]: https://crates.io/ From ccde88e5b5f45a0338facdd1eda342a268febadc Mon Sep 17 00:00:00 2001 From: huangjj27 <349373001dc@gmail.com> Date: Sun, 8 Oct 2017 14:53:22 +0800 Subject: [PATCH 008/150] =?UTF-8?q?trans(liftime=20bound):=20=E7=BF=BB?= =?UTF-8?q?=E8=AF=91=E7=94=B1"=E7=94=9F=E5=91=BD=E5=91=A8=E6=9C=9F=20booun?= =?UTF-8?q?d"=E5=8F=98=E6=9B=B4=E4=B8=BA"=E7=94=9F=E5=91=BD=E5=91=A8?= =?UTF-8?q?=E6=9C=9F=E7=BA=A6=E6=9D=9F"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit close #60 --- src/ch19-02-advanced-lifetimes.md | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/ch19-02-advanced-lifetimes.md b/src/ch19-02-advanced-lifetimes.md index bdcfca2..d55d5df 100644 --- a/src/ch19-02-advanced-lifetimes.md +++ b/src/ch19-02-advanced-lifetimes.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -回顾第十章，我们学习了怎样使用生命周期参数来注解引用来帮助 Rust 理解不同引用的生命周期如何相互联系。见识到了大部分情况 Rust 允许我们省略生命周期，不过每一个引用都有一个生命周期。这里有三个生命周期的高级特征我们还未讲到：**生命周期子类型**（*lifetime subtyping*），**生命周期 bound**（*lifetime bounds*），以及**trait 对象生命周期**（*trait object lifetimes*）。 +回顾第十章，我们学习了怎样使用生命周期参数来注解引用来帮助 Rust 理解不同引用的生命周期如何相互联系。见识到了大部分情况 Rust 允许我们省略生命周期，不过每一个引用都有一个生命周期。这里有三个生命周期的高级特征我们还未讲到：**生命周期子类型**（*lifetime subtyping*），**生命周期约束**（*lifetime bounds*），以及**trait 对象生命周期**（*trait object lifetimes*）。 ### 生命周期子类型 @@ -189,15 +189,15 @@ struct Parser<'c, 's: 'c> { 这是一个非常冗长的例子，不过正如本章的开头所提到的，这类功能是很小众的。你并不会经常需要这个语法，不过当出现类似这样的情形时，却还是有地方可以参考的。 -### 生命周期 bound +### 生命周期约束 -在第十章，我们讨论了如何在泛型类型上使用 trait bound。也可以像泛型那样为生命周期参数增加限制，这被称为**生命周期 bound**。例如，考虑一下一个封装了引用的类型。回忆一下第十五章的 `RefCell` 类型：其 `borrow` 和 `borrow_mut` 方法分别返回 `Ref` 和 `RefMut` 类型。这些类型是引用的封装，他们在运行时记录检查借用规则。`Ref` 结构体的定义如列表 19-16 所示，现在还不带有生命周期 bound： +在第十章，我们讨论了如何在泛型类型上使用 trait bound。也可以像泛型那样为生命周期参数增加限制，这被称为**生命周期约束**。例如，考虑一下一个封装了引用的类型。回忆一下第十五章的 `RefCell` 类型：其 `borrow` 和 `borrow_mut` 方法分别返回 `Ref` 和 `RefMut` 类型。这些类型是引用的封装，他们在运行时记录检查借用规则。`Ref` 结构体的定义如列表 19-16 所示，现在还不带有生命周期约束： ```rust struct Ref<'a, T>(&'a T); ``` -列表 19-16：定义结构体来封装泛型的引用；开始时没有生命周期 bound +列表 19-16：定义结构体来封装泛型的引用；开始时没有生命周期约束 若不限制生命周期 `'a` 为与泛型参数 `T` 有关，会得到一个错误因为 Rust 不知道泛型 `T` 会存活多久： @@ -218,28 +218,28 @@ note: ...so that the reference type `&'a T` does not outlive the data it points 因为 `T` 可以是任意类型，`T` 自身也可能是一个引用，或者是一个存放了一个或多个引用的类型，而他们各自可能有着不同的生命周期。Rust 不能确认 `T` 会与 `'a` 存活的一样久。 -幸运的是，Rust 提供了这个情况下如何指定生命周期 bound 的有用建议： +幸运的是，Rust 提供了这个情况下如何指定生命周期约束 的有用建议： ``` consider adding an explicit lifetime bound `T: 'a` so that the reference type `&'a T` does not outlive the data it points at. ``` -列表 19-17 展示了按照这个建议，在声明泛型 `T` 时指定生命周期 bound。现在代码可以编译了，因为 `T: 'a` 指定了 `T` 可以为任意类型，不过如果它包含任何引用的话，其生命周期必须至少与 `'a` 一样长： +列表 19-17 展示了按照这个建议，在声明泛型 `T` 时指定生命周期约束。现在代码可以编译了，因为 `T: 'a` 指定了 `T` 可以为任意类型，不过如果它包含任何引用的话，其生命周期必须至少与 `'a` 一样长： ```rust struct Ref<'a, T: 'a>(&'a T); ``` -列表19-17：为 `T` 增加生命周期 bound 来指定 `T` 中的任何引用需至少与 `'a` 存活的一样久 +列表19-17：为 `T` 增加生命周期约束 来指定 `T` 中的任何引用需至少与 `'a` 存活的一样久 -我们可以选择不同的方法来解决这个问题，如列表 19-18 中展示的 `StaticRef` 结构体定义所示，通过在 `T` 上增加 `'static` 生命周期 bound。这意味着如果 `T` 包含任何引用，他们必须有 `'static` 生命周期： +我们可以选择不同的方法来解决这个问题，如列表 19-18 中展示的 `StaticRef` 结构体定义所示，通过在 `T` 上增加 `'static` 生命周期约束。这意味着如果 `T` 包含任何引用，他们必须有 `'static` 生命周期： ```rust struct StaticRef(&'static T); ``` -列表 19-18：在 `T` 上增加 `'static` 生命周期 bound 来限制 `T` 为只拥有 `'static` 引用或没有引用的类型 +列表 19-18：在 `T` 上增加 `'static` 生命周期约束 来限制 `T` 为只拥有 `'static` 引用或没有引用的类型 没有任何引用的类型被算作 `T: 'static`。因为 `'static` 意味着引用必须同整个程序存活的一样长，一个不包含引用的类型满足所有引用都与程序存活的一样长的标准（因为他们没有引用）。可以这样理解：如果借用检查器关心的是引用是否存活的够久，那么没有引用的类型与有永远存在的引用的类型并没有真正的区别；对于确定引用是否比其所引用的值存活得较短的目的来说两者是一样的。 @@ -270,6 +270,6 @@ let obj = Box::new(Bar { x: &num }) as Box; * 如果只有 `T: 'a`， 则默认是 `'a`。 * 如果有多个类似 `T: 'a` 的从句，则没有默认值；必须明确指定。 -当必须明确指定时，可以为像 `Box` 这样的 trait 对象增加生命周期 bound，根据需要使用语法 `Box` 或 `Box`。正如其他的 bound，这意味着任何 `Foo` trait 的实现如果在内部包含有引用, 就必须在 trait 对象 bounds 中为那些引用指定生命周期。 +当必须明确指定时，可以为像 `Box` 这样的 trait 对象增加生命周期约束，根据需要使用语法 `Box` 或 `Box`。正如其他的 bound，这意味着任何 `Foo` trait 的实现如果在内部包含有引用, 就必须在 trait 对象 bounds 中为那些引用指定生命周期。 接下来，让我们看看一些其他处理 trait 的功能吧！ From 4a4ca95136779c6547d87a6e088e491c1ddbe718 Mon Sep 17 00:00:00 2001 From: huangjj27 <349373001dc@gmail.com> Date: Sun, 8 Oct 2017 15:02:20 +0800 Subject: [PATCH 009/150] chore(summary): changes ident from tabs to spaces, and trims lines' end --- src/SUMMARY.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 3cb4bf0..79c7607 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -94,11 +94,11 @@ - [共享状态](ch16-03-shared-state.md) - [可扩展的并发：`Sync`和`Send`](ch16-04-extensible-concurrency-sync-and-send.md) -- [面向对象](ch17-00-oop.md) - - [什么是面向对象？](ch17-01-what-is-oo.md) - - [为使用不同类型的值而设计的 trait 对象](ch17-02-trait-objects.md) +- [面向对象](ch17-00-oop.md) + - [什么是面向对象？](ch17-01-what-is-oo.md) + - [为使用不同类型的值而设计的 trait 对象](ch17-02-trait-objects.md) - [面向对象设计模式的实现](ch17-03-oo-design-patterns.md) - + ## 高级主题 - [模式用来匹配值的结构](ch18-00-patterns.md) From 53c7a0104f6309678963bd4b2cfe8f397ea3d173 Mon Sep 17 00:00:00 2001 From: huangjj27 <349373001dc@gmail.com> Date: Sun, 8 Oct 2017 15:11:22 +0800 Subject: [PATCH 010/150] =?UTF-8?q?trans(lifetime=20boud):=20=E4=B8=BA"?= =?UTF-8?q?=E7=94=9F=E5=91=BD=E5=91=A8=E6=9C=9F=E7=BA=A6=E6=9D=9F"?= =?UTF-8?q?=E5=B0=8F=E7=BB=93=E6=8F=90=E4=BE=9B=E5=AF=B9=E5=BA=94=E8=8B=B1?= =?UTF-8?q?=E6=96=87=E6=9C=AF=E8=AF=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch19-02-advanced-lifetimes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch19-02-advanced-lifetimes.md b/src/ch19-02-advanced-lifetimes.md index d55d5df..0b5dec4 100644 --- a/src/ch19-02-advanced-lifetimes.md +++ b/src/ch19-02-advanced-lifetimes.md @@ -189,7 +189,7 @@ struct Parser<'c, 's: 'c> { 这是一个非常冗长的例子，不过正如本章的开头所提到的，这类功能是很小众的。你并不会经常需要这个语法，不过当出现类似这样的情形时，却还是有地方可以参考的。 -### 生命周期约束 +### 生命周期约束(lifetime bound) 在第十章，我们讨论了如何在泛型类型上使用 trait bound。也可以像泛型那样为生命周期参数增加限制，这被称为**生命周期约束**。例如，考虑一下一个封装了引用的类型。回忆一下第十五章的 `RefCell` 类型：其 `borrow` 和 `borrow_mut` 方法分别返回 `Ref` 和 `RefMut` 类型。这些类型是引用的封装，他们在运行时记录检查借用规则。`Ref` 结构体的定义如列表 19-16 所示，现在还不带有生命周期约束： From 57f263c4b7f6871b01def1deb3d94cbfe9cc63d6 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Mon, 9 Oct 2017 17:57:21 +0800 Subject: [PATCH 011/150] check ch15-01 --- src/ch15-01-box.md | 98 ++++++++++++++++++++++++++++++++-------------- 1 file changed, 69 insertions(+), 29 deletions(-) diff --git a/src/ch15-01-box.md b/src/ch15-01-box.md index f94d5dc..9d83515 100644 --- a/src/ch15-01-box.md +++ b/src/ch15-01-box.md @@ -2,9 +2,23 @@ > [ch15-01-box.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-01-box.md) >
-> commit 348d78235faa10375ce5a3554e2c34d3275c174f +> commit 68267b982a226fa252e9afa1a5029396ccf5fa03 -最简单直接的智能指针是 *box*，它的类型是 `Box`。 box 允许你将一个值放在堆上（第四章介绍过栈与堆）。示例 15-1 展示了如何使用 box 在堆上储存一个`i32`： +最简单直接的智能指针是 *box*，它的类型是 `Box`。 box 允许你将一个值放在堆上而不是栈上。留在栈上的则是指向堆数据的指针。如果你想回顾一下栈与堆的区别请参考第四章。 + +除了数据被储存在堆上而不是栈上之外，box 没有性能损失，不过也没有很多额外的功能。他们多用于如下场景： + +- 当有一个在编译时未知大小的类型，而又想要在需要确切大小的上下文中使用这个类型的值的时候 +- 当有大量数据并希望在确保数据不被拷贝的情况下转移所有权的时候 +- 当希望拥有一个值并只关心它的类型是否实现了特定 trait 而不是其具体类型的时候 + +我们将在本部分的余下内容中展示第一种应用场景。作为对另外两个情况更详细的说明：在第二种情况中，转移大量数据的所有权可能会花费很长的时间，因为数据在栈上进行了拷贝。为了改善这种情况下的性能，可以通过 box 将这些数据储存在堆上。接着，只有少量的指针数据在栈上被拷贝。第三种情况被称为 **trait 对象**（*trait object*），第十七章刚好有一整个部分专门讲解这个主题。所以这里所学的内容会在第十七章再次用上！ + +### 使用 `Box` 在堆上储存数据 + +在开始 `Box` 的用例之前，让我们熟悉一下语法和如何与储存在 `Box` 中的值交互。 + +示例 15-1 展示了如何使用 box 在堆上储存一个 `i32`： 文件名: src/main.rs @@ -17,9 +31,29 @@ fn main() { 示例 15-1：使用 box 在堆上储存一个 `i32` 值 -这会打印出 `b = 5`。在这个例子中，我们可以像数据是储存在栈上的那样访问 box 中的数据。正如任何拥有数据所有权的值那样，当像 `b` 这样的 box 在 `main` 的末尾离开作用域时，它将被释放。这个释放过程作用于 box 本身（位于栈上）和它所指向的数据（位于堆上）。 +这里定义了变量 `b`，其值是一个指向被分配在堆上的值 `5` 的 `Box`。这个程序会打印出 `b = 5`。在这个例子中，我们可以像数据是储存在栈上的那样访问 box 中的数据。正如任何拥有数据所有权的值那样，当像 `b` 这样的 box 在 `main` 的末尾离开作用域时，它将被释放。这个释放过程作用于 box 本身（位于栈上）和它所指向的数据（位于堆上）。 -将一个单独的值存放在堆上并不是很有意义，所以像示例 15-1 这样单独使用 box 并不常见。一个 box 的实用场景是当你希望确保类型有一个已知大小的时候。例如，考虑一下示例 15-2，它是一个用于 *cons list* 的枚举定义，这是一个来源于函数式编程的数据结构类型。注意它还不能编译： +将一个单独的值存放在堆上并不是很有意义，所以像示例 15-1 这样单独使用 box 并不常见。将像单个 `i32` 这样的值储存在栈上，也就是其默认存放的地方在大部分使用场景中更为合适。让我们看看一个 box 定义一个不使用 box 时无法定义的类型的例子。 + +### box 允许创建递归类型 + +Rust 需要在编译时知道类型占用多少空间。一种无法在编译时知道大小的类型是 **递归类型**（*recursive type*），其值的一部分可以是相同类型的另一个值。这种值的嵌套理论上可以无限的进行下去，所以 Rust 不知道递归类型需要多少空间。不过 box 有一个已知的大小，所以通过在循环类型定义中插入 box，就可以创建递归类型了。 + +让我们探索一下 *cons list*，一个函数式编程语言中的常见类型，来展示这个（递归类型）概念。除了递归之外，我们将要定义的 cons list 类型是很直白的，所以这个例子中的概念在任何遇到更为复杂的涉及到递归类型的场景时都很实用。 + +cons list 是一个每一项都包含两个部分的列表：当前项的值和下一项。其最后一项值包含一个叫做 `Nil` 的值并没有下一项。 + +> #### cons list 的更多内容 +> +> *cons list* 是一个来源于 Lisp 编程语言及其方言的数据结构。在 Lisp 中，`cons` 函数（“construct function" 的缩写）利用两个参数来构造一个新的列表，他们通常是一个单独的值和另一个列表。 +> +> cons 函数的概念涉及到更通用的函数式编程术语；“将 x 与 y 连接” 通常意味着构建一个新的容器而将 x 的元素放在新容器的开头，其后则是容器 y 的元素。 +> +> cons list 通过递归调用 `cons` 函数产生。代表递归的终止条件（base case）的规范名称是 `Nil`，它宣布列表的终止。注意这不同于第六章中的 “null” 或 “nil” 的概念，他们代表无效或缺失的值。 + +注意虽然函数式编程语言经常使用 cons list，但是它并不是一个 Rust 中常见的类型。大部分在 Rust 中需要列表的时候，`Vec` 是一个更好的选择。其他更为复杂的递归数据类型 **确实** 在 Rust 的很多场景中很使用，不过通过以 cons list 作为开始，我们可以探索如何使用 box 毫不费力的定义一个递归数据类型。 + +示例 15-2 包含一个 cons list 的枚举定义。注意这还不能编译因为这个类型没有已知的大小，之后我们会展示： 文件名: src/main.rs @@ -32,19 +66,11 @@ enum List { 示例 15-2：第一次尝试定义一个代表 `i32` 值的 cons list 数据结构的枚举 -我们实现了一个只存放 `i32` 值的 cons list。也可以选择使用第十章介绍的泛型来实现一个类型无关的 cons list。 +> 注意：出于示例的我们选择实现一个只存放 `i32` 值的 cons list。也可以用泛型实现它，正如第十章讲到的，来定义一个可以存放任何类型值的 cons list 类型。 -> #### cons list 的更多内容 -> -> *cons list* 是一个来源于 Lisp 编程语言及其方言的数据结构。在 Lisp 中，`cons` 函数（“construct function" 的缩写）利用两个参数来构造一个新的列表，他们通常是一个单独的值和另一个列表。 -> -> cons 函数的概念涉及到更通用的函数式编程术语；“将 x 与 y 连接” 通常意味着构建一个新的容器而将 x 的元素放在新容器的开头，其后则是容器 y 的元素。 -> -> cons list 通过递归调用 `cons` 函数产生。代表递归的终止条件（base case）的规范名称是 `Nil`，它宣布列表的终止。注意这不同于第六章中的 “null” 或 “nil” 的概念，他们代表无效或缺失的值。 +使用这个 cons list 来储存列表 `1, 2, 3` 将看起来如示例 15-3 所示： -cons list 是一个每个元素和之后的其余部分都只包含一个值的列表。列表的其余部分由嵌套的 cons list 定义。其结尾由值 `Nil` 表示。cons list 在 Rust 中并不常见；通常 `Vec` 是一个更好的选择。但是实现这个数据结构是 `Box` 实用性的一个好的例子。让我们看看为什么！ - -使用 cons list 来储存列表 `1, 2, 3` 将看起来像这样： +文件名: src/main.rs ```rust,ignore use List::{Cons, Nil}; @@ -54,9 +80,11 @@ fn main() { } ``` -第一个 `Cons` 储存了 `1` 和另一个 `List` 值。这个 `List` 是另一个包含 `2` 的 `Cons` 值和下一个 `List` 值。这又是另一个存放了 `3` 的 `Cons` 值和最后一个值为 `Nil` 的 `List`，非递归成员代表了列表的结尾。 +示例 15-3：使用 `List` 枚举储存列表 `1, 2, 3` -如果尝试编译上面的代码，会得到如示例 15-3 所示的错误： +第一个 `Cons` 储存了 `1` 和另一个 `List` 值。这个 `List` 是另一个包含 `2` 的 `Cons` 值和下一个 `List` 值。接着又有另一个存放了 `3` 的 `Cons` 值和最后一个值为 `Nil` 的 `List`，非递归成员代表了列表的结尾。 + +如果尝试编译上面的代码，会得到如示例 15-4 所示的错误： ```text error[E0072]: recursive type `List` has infinite size @@ -71,9 +99,13 @@ error[E0072]: recursive type `List` has infinite size make `List` representable ``` -示例 15-3：尝试定义一个递归枚举时得到的错误 +示例 15-4：尝试定义一个递归枚举时得到的错误 -这个错误表明这个类型 “有无限的大小”。为什么呢？因为 `List` 的一个成员被定义为是递归的：它存放了另一个相同类型的值。这意味着 Rust 无法计算为了存放 `List` 值到底需要多少空间。让我们一点一点来看：首先了解一下 Rust 如何决定需要多少空间来存放一个非递归类型。回忆一下第六章讨论枚举定义时的示例 6-2 中定义的 `Message` 枚举： +这个错误表明这个类型 “有无限的大小”。其原因是 `List` 的一个成员被定义为是递归的：它直接存放了另一个相同类型的值。这意味着 Rust 无法计算为了存放 `List` 值到底需要多少空间。让我们一点一点来看：首先了解一下 Rust 如何决定需要多少空间来存放一个非递归类型。 + +### 计算非递归类型的大小 + +回忆一下第六章讨论枚举定义时示例 6-2 中定义的 `Message` 枚举： ```rust enum Message { @@ -84,22 +116,30 @@ enum Message { } ``` -当 Rust 需要知道需要为 `Message` 值分配多少空间时，它可以检查每一个成员并发现 `Message::Quit` 并不需要任何空间，`Message::Move` 需要足够储存两个 `i32` 值的空间，依此类推。因此，`Message` 值所需的空间等于储存其最大成员的空间大小。 +当 Rust 需要知道要为 `Message` 值分配多少空间时，它可以检查每一个成员并发现 `Message::Quit` 并不需要任何空间，`Message::Move` 需要足够储存两个 `i32` 值的空间，依此类推。因此，`Message` 值所需的空间等于储存其最大成员的空间大小。 -与此相对当 Rust 编译器检查像示例 15-2 中的 `List` 这样的递归类型时会发生什么呢。编译器尝试计算出储存一个 `List` 枚举需要多少内存，并开始检查 `Cons` 成员，那么 `Cons` 需要的空间等于 `i32` 的大小加上 `List` 的大小。为了计算 `List` 需要多少内存，它检查其成员，从 `Cons` 成员开始。`Cons`成员储存了一个 `i32` 值和一个`List`值，这样的计算将无限进行下去，如图 15-4 所示： +与此相对当 Rust 编译器检查像示例 15-2 中的 `List` 这样的递归类型时会发生什么呢。编译器尝试计算出储存一个 `List` 枚举需要多少内存，并开始检查 `Cons` 成员，那么 `Cons` 需要的空间等于 `i32` 的大小加上 `List` 的大小。为了计算 `List` 需要多少内存，它检查其成员，从 `Cons` 成员开始。`Cons`成员储存了一个 `i32` 值和一个`List`值，这样的计算将无限进行下去，如图 15-5 所示： An infinite Cons list -图 15-4：一个包含无限个 `Cons` 成员的无限 `List` +图 15-5：一个包含无限个 `Cons` 成员的无限 `List` -Rust 无法计算出要为定义为递归的类型分配多少空间，所以编译器给出了示例 15-3 中的错误。这个错误也包括了有用的建议： +### 使用 `Box` 给递归类型一个已知的大小 + +Rust 无法计算出要为定义为递归的类型分配多少空间，所以编译器给出了示例 15-4 中的错误。这个错误也包括了有用的建议： ```text = help: insert indirection (e.g., a `Box`, `Rc`, or `&`) at some point to make `List` representable ``` -因为 `Box` 是一个指针，我们总是知道它需要多少空间：指针需要一个 `usize` 大小的空间。这个 `usize` 的值将是堆数据的地址。而堆数据可以是任意大小，不过这个堆数据开头的地址总是能放进一个 `usize` 中。我们可以将示例 15-2 的定义修改为像这里示例 15-5 中的定义，并修改 `main` 函数对 `Cons` 成员中的值使用 `Box::new`： +在建议中，“indirection” 意味着不同于直接储存一个值，我们将间接的储存一个指向值的指针。 + +因为 `Box` 是一个指针，我们总是知道它需要多少空间：指针的大小并不会根据其指向的数据量而改变。 + +所以可以将 `Box` 放入 `Cons` 成员中而不是直接存放另一个 `List` 值。`Box` 会指向另一个位于堆上的 `List` 值，而不是存放在 `Cons` 成员中。从概念上将，我们仍然有一个通过在其中 “存放” 其他列表创建的列表，不过现在实现这个概念的方式更像是一个项挨着另一项，而不是一项包含另一项。 + +我们可以修改示例 15-2 中 `List` 枚举的定义和示例 15-3 中对 `List` 的应用，如示例 15-6 所示，这是可以编译的： 文件名: src/main.rs @@ -119,14 +159,14 @@ fn main() { } ``` -示例 15-5：为了已知大小使用 `Box` 的 `List` 定义 +示例 15-6：为了已知大小而使用 `Box` 的 `List` 定义 -这样编译器就能够计算出储存一个 `List` 值需要的大小了。Rust 将会检查 `List`，同样的从 `Cons` 成员开始检查。`Cons` 成员需要 `i32` 的大小加上一个 `usize` 的大小，因为 box 总是 `usize` 大小的，不管它指向的是什么。接着 Rust 检查 `Nil` 成员，它并不储存一个值，所以 `Nil` 并不需要任何空间。我们通过 box 打破了这无限递归的连锁。图 15-6 展示了现在 `Cons` 成员看起来像什么： +`Cons` 成员将会需要一个 `i32` 的大小加上储存 box 指针数据的空间。`Nil` 成员不储存值，所以它比 `Cons` 成员需要更少的空间。现在我们知道了任何 `List` 值最多需要一个 `i32` 加上 box 指针数据的大小。通过使用 box ，打破了这无限递归的连锁，这样编译器就能够计算出储存 `List` 值需要的大小了。图 15-7 展示了现在 `Cons` 成员看起来像什么： A finite Cons list -图 15-6：因为 `Cons` 存放一个 `Box` 所以 `List` 不是无限大小的了 +图 15-7：因为 `Cons` 存放一个 `Box` 所以 `List` 不是无限大小的了 -这就是 box 主要应用场景：打破无限循环的数据结构以便编译器可以知道其大小。第十七章讨论 trait 对象时我们将了解另一个 Rust 中会出现未知大小数据的情况。 +box 只提供了间接存储和堆分配；他们并没有任何其他特殊的功能，比如我们将会见到的其他智能指针。他们也没有这些特殊功能带来的性能损失，所以他们可以用于像 cons list 这样间接存储是唯一所需功能的场景。我们还将在第十七章看到 box 的更多应用场景。 -虽然我们并不经常使用 box，他们也是一个了解智能指针模式的好的方式。`Box` 作为智能指针经常被使用的两个方面是他们 `Deref` 和 `Drop` trait 的实现。让我们研究这些 trait 如何工作以及智能指针如何利用他们。 +`Box` 类型是一个智能指针，因为它实现了 `Deref` trait，它允许 `Box` 值被当作引用对待。当 `Box` 值离开作用域时，由于 `Box` 类型 `Drop` trait 的实现，box 所指向的堆数据也会被清除。让我们更详细的探索一下这两个 trait；这些 trait 在本章余下讨论的其他智能指针所提供的功能中将会更为重要。 From eac99c7ccc3cc2b9c54164fa517f5544ad4e3b6f Mon Sep 17 00:00:00 2001 From: Jeff <200006506@qq.com> Date: Mon, 23 Oct 2017 17:59:18 +0800 Subject: [PATCH 012/150] Update ch03-02-data-types.md --- src/ch03-02-data-types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch03-02-data-types.md b/src/ch03-02-data-types.md index 0360670..69a3aec 100644 --- a/src/ch03-02-data-types.md +++ b/src/ch03-02-data-types.md @@ -32,7 +32,7 @@ error[E0282]: unable to infer enough type information about `_` #### 整型 -**整数** 是一个没有小数部分的数字。我们在这一章的前面使用过 `u32` 类型。该类型声明指示，i32 关联的值应该是一个占据 32 比特位的无符号整数（有符号整型类型以 `i` 开头而不是 `u`）。表格 3-1 展示了 Rust 内建的整数类型。每一种变体的有符号和无符号列（例如，*i8*）可以用来声明对应的整数值。 +**整数** 是一个没有小数部分的数字。我们在这一章的前面使用过 `u32` 类型。该类型声明指示，u32 关联的值应该是一个占据 32 比特位的无符号整数（有符号整型类型以 `i` 开头而不是 `u`）。表格 3-1 展示了 Rust 内建的整数类型。每一种变体的有符号和无符号列（例如，*i8*）可以用来声明对应的整数值。 表格 3-1: Rust 中的整型 From f0656196dd6e3fde9eab34dd9fbec44694abcce3 Mon Sep 17 00:00:00 2001 From: Jeff <200006506@qq.com> Date: Wed, 25 Oct 2017 18:01:46 +0800 Subject: [PATCH 013/150] Update ch06-01-defining-an-enum.md --- src/ch06-01-defining-an-enum.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index 2f2792a..c32bde0 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -231,7 +231,7 @@ enum Option { `Option` 是如此有用以至于它甚至被包含在了 prelude 之中：不需要显式导入它。另外，它的成员也是如此：可以不需要 `Option::` 前缀来直接使用 `Some` 和 `None`。即便如此 `Option` 也仍是常规的枚举，`Some(T)` 和 `None` 仍是 `Option` 的成员。 -`` 语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是 `` 味着 `Option` 枚举的 `Some` 成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型 `Option` 值的例子： +`` 语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是 `` 意味着 `Option` 枚举的 `Some` 成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型 `Option` 值的例子： ```rust let some_number = Some(5); From f3501da57e8f8004efad1ac31f8546c3a3dbc1fa Mon Sep 17 00:00:00 2001 From: Jeff <200006506@qq.com> Date: Thu, 26 Oct 2017 13:41:57 +0800 Subject: [PATCH 014/150] Update ch08-03-hash-maps.md --- src/ch08-03-hash-maps.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch08-03-hash-maps.md b/src/ch08-03-hash-maps.md index c850c43..40bcc7c 100644 --- a/src/ch08-03-hash-maps.md +++ b/src/ch08-03-hash-maps.md @@ -170,7 +170,7 @@ println!("{:?}", map); vector、字符串和哈希 map 会在你的程序需要储存、访问和修改数据时帮助你。这里有一些你应该能够解决的练习问题： * 给定一系列数字，使用 vector 并返回这个列表的平均数（mean, average）、中位数（排列数组后位于中间的值）和众数（mode，出现次数最多的值；这里哈希函数会很有帮助）。 -* 将字符串转换为 Pig Latin，也就是每一个单词的第一个辅音字母被移动到单词的结尾并增加 “ay”，所以 “first” 会变成 “irst-fay”。元音字母开头的单词则在结尾增加 “hay”（“apple” 会变成 “apple-hay”）。牢记 UTF-8 编码！ +* 将字符串转换为 Pig Latin，也就是每一个单词的第一个辅音字母被移动到单词的结尾并增加 “ay”，所以 “first” 会变成 “first-fay”。元音字母开头的单词则在结尾增加 “hay”（“apple” 会变成 “apple-hay”）。牢记 UTF-8 编码！ * 使用哈希 map 和 vector，创建一个文本接口来允许用户向公司的部门中增加员工的名字。例如，“Add Sally to Engineering” 或 “Add Amir to Sales”。接着让用户获取一个部门的所有员工的列表，或者公司每个部门的所有员工按照字母顺排序的列表。 标准库 API 文档中描述的这些类型的方法将有助于你进行这些练习！ From 1623c5c60726bb2058c77f4bbf0a7ba5fbaa3641 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 26 Sep 2017 16:41:15 +0800 Subject: [PATCH 015/150] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97=EF=BC=9A?= =?UTF-8?q?=E5=9B=9E->=E4=BC=9A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch03-02-data-types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch03-02-data-types.md b/src/ch03-02-data-types.md index 69a3aec..516b800 100644 --- a/src/ch03-02-data-types.md +++ b/src/ch03-02-data-types.md @@ -209,7 +209,7 @@ fn main() { 数组在需要在栈（stack）而不是在堆（heap）上为数据分配空间时（第四章将讨论栈与堆的更多内容），或者是想要确保总是有固定数量的元素时十分有用。虽然它并不如 vector 类型那么灵活。vector 类型是标准库提供的一个 **允许** 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，你可能应该使用 vector：第八章会详细讨论 vector。 -一个你可能想要使用数组而不是 vector 的例子是当程序需要知道一年中月份的名字时。程序不大可能回去增加或减少月份，这时你可以使用数组因为我们知道它总是含有 12 个元素： +一个你可能想要使用数组而不是 vector 的例子是当程序需要知道一年中月份的名字时。程序不大可能会去增加或减少月份，这时你可以使用数组因为我们知道它总是含有 12 个元素： ```rust let months = ["January", "February", "March", "April", "May", "June", "July", From 79ae936b7c43af97fb2590fa8c502f9b85308e34 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Fri, 27 Oct 2017 13:43:25 +0800 Subject: [PATCH 016/150] =?UTF-8?q?=E6=AD=A4=E5=A4=84=E8=BF=98=E6=98=AF?= =?UTF-8?q?=E9=99=84=E4=B8=8A=E5=8E=9F=E8=AF=8D=EF=BC=8C=E5=90=A6=E5=88=99?= =?UTF-8?q?=E5=A4=AA=E6=AD=A7=E4=B9=89=E4=BA=86=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 7d1c1e3..ea7d9f4 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -106,7 +106,7 @@ println!("{}", s); // This will print `hello, world!` 1. 内存必须在运行时向操作系统请求。 2. 需要一个当我们处理完 `String` 时将内存返回给操作系统的方法。 -第一部分由我们完成：当调用 `String::from` 时，它的实现请求它需要的内存。这在编程语言中是非常通用的。 +第一部分由我们完成：当调用 `String::from` 时，它的实现 (*implementation*) 请求它需要的内存。这在编程语言中是非常通用的。 然而，第二部分实现起来就各有区别了。在有 **垃圾回收**（*garbage collector*，*GC*）的语言中， GC 记录并清除不再使用的内存，而我们作为程序员，并不需要关心他们。没有 GC 的话，识别出不再使用的内存并调用代码显式释放就是我们程序员的责任了，正如请求内存的时候一样。从历史的角度上说正确处理内存回收曾经是一个困难的编程问题。如果忘记回收了会浪费内存。如果过早回收了，将会出现无效变量。如果重复回收，这也是个 bug。我们需要 `allocate` 和 `free` 一一对应。 From c23308305226bf8bb4b346eaade5a563ecab7147 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Fri, 27 Oct 2017 17:44:10 +0800 Subject: [PATCH 017/150] =?UTF-8?q?=E6=AD=A4=E5=A4=84=E8=BF=98=E6=98=AF?= =?UTF-8?q?=E6=84=8F=E8=AF=91=E4=BA=86=E6=AF=94=E8=BE=83=E5=A5=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index ea7d9f4..3e0a298 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -220,7 +220,7 @@ println!("s1 = {}, s2 = {}", s1, s2); 这段代码能正常运行，也是如何显式产生图 4-5 中行为的方式，这里堆上的数据 **确实** 被复制了。 -当出现 `clone` 调用时，你知道一些特有的代码被执行而且这些代码可能相当消耗资源。它作为一个代表发生了不同的行为的可视化的标识。 +当出现 `clone` 调用时，你知道一些特定的代码被执行而且这些代码可能相当消耗资源。你很容易察觉到一些不寻常的事情正在发生。 #### 只在栈上的数据：拷贝 From 5b598d7565a42eb083bcc9dff68b8996967cb500 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Fri, 27 Oct 2017 20:50:54 +0800 Subject: [PATCH 018/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E6=AD=A7=E4=B9=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 3e0a298..03d9431 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -237,7 +237,7 @@ println!("x = {}, y = {}", x, y); 原因是像整型这样的在编译时已知大小的类型被整个储存在栈上，所以拷贝其实际的值是快速的。这意味着没有理由在创建变量 `y` 后使 `x` 无效。换句话说，这里没有深浅拷贝的区别，所以这里调用 `clone` 并不会与通常的浅拷贝有什么不同，我们可以不用管它。 -Rust 有一个叫做 `Copy` trait 的特殊注解，可以用在类似整型这样的储存在栈上的类型（第十章详细讲解 trait）。如果一个类型拥有 `Copy` trait，一个旧的变量在（重新）赋值后仍然可用。Rust 不允许自身或其任何部分实现了 `Drop` trait 的类型使用`Copy` trait。如果我们对其值离开作用域时需要特殊处理的类型使用 `Copy` 注解，将会出现一个编译时错误。关于如何为你的类型增加 `Copy` 注解，请阅读附录 C 中的可导出 trait。 +Rust 有一个叫做 `Copy` trait 的特殊注解，可以用在类似整型这样的储存在栈上的类型（第十章详细讲解 trait）。如果一个类型拥有 `Copy` trait，一个旧的变量在将其赋值给其他变量后仍然可用。Rust 不允许自身或其任何部分实现了 `Drop` trait 的类型使用`Copy` trait。如果我们对其值离开作用域时需要特殊处理的类型使用 `Copy` 注解，将会出现一个编译时错误。关于如何为你的类型增加 `Copy` 注解，请阅读附录 C 中的可导出 trait。 那么什么类型是 `Copy` 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则，任何简单标量值的组合可以是 `Copy` 的，任何需要分配内存，或者本身就是某种形式资源的类型不会是 `Copy `的。如下是一些 `Copy` 的类型： From 598b1bb078e230e413b33d1b411dc08843ed1215 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 28 Oct 2017 00:04:45 +0800 Subject: [PATCH 019/150] fix format error --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 03d9431..1d44922 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -239,7 +239,7 @@ println!("x = {}, y = {}", x, y); Rust 有一个叫做 `Copy` trait 的特殊注解，可以用在类似整型这样的储存在栈上的类型（第十章详细讲解 trait）。如果一个类型拥有 `Copy` trait，一个旧的变量在将其赋值给其他变量后仍然可用。Rust 不允许自身或其任何部分实现了 `Drop` trait 的类型使用`Copy` trait。如果我们对其值离开作用域时需要特殊处理的类型使用 `Copy` 注解，将会出现一个编译时错误。关于如何为你的类型增加 `Copy` 注解，请阅读附录 C 中的可导出 trait。 -那么什么类型是 `Copy` 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则，任何简单标量值的组合可以是 `Copy` 的，任何需要分配内存，或者本身就是某种形式资源的类型不会是 `Copy `的。如下是一些 `Copy` 的类型： +那么什么类型是 `Copy` 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则，任何简单标量值的组合可以是 `Copy` 的，任何需要分配内存，或者本身就是某种形式资源的类型不会是 `Copy` 的。如下是一些 `Copy` 的类型： * 所有整数类型，比如 `u32`。 * 布尔类型，`bool`，它的值是 `true` 和 `false`。 From 1bd9373556eba9108ad3116c36855a3f2888bd00 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 28 Oct 2017 20:34:39 +0800 Subject: [PATCH 020/150] =?UTF-8?q?=E6=AD=A4=E5=A4=84=E5=8E=9F=E6=9C=AC?= =?UTF-8?q?=E7=BF=BB=E8=AF=91=E4=B8=8D=E5=A4=9F=E7=81=B5=E6=B4=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 1d44922..2308d06 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -248,7 +248,7 @@ Rust 有一个叫做 `Copy` trait 的特殊注解，可以用在类似整型这 ### 所有权与函数 -将值传递给函数在语义上与给变量赋值相似。向函数传递值可能会移动或者复制，就像赋值语句一样。示例 4-7 是一个带有变量何时进入和离开作用域标注的例子： +将值传递给函数在语义上与给变量赋值相似。向函数传递值可能会移动或者复制，就像赋值语句一样。示例 4-7 是一个展示变量何时进入和离开作用域的例子： 文件名: src/main.rs From b611e68b8460cdf686803c23474a95fbb7edad4f Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 28 Oct 2017 20:57:39 +0800 Subject: [PATCH 021/150] =?UTF-8?q?=E7=9B=B4=E8=AF=91=E5=BE=88=E5=A7=9C?= =?UTF-8?q?=E7=A1=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 2308d06..fb8f5aa 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -321,7 +321,7 @@ fn takes_and_gives_back(a_string: String) -> String { // a_string comes into 变量的所有权总是遵循相同的模式：将值赋值给另一个变量时移动它。当持有堆中数据值的变量离开作用域时，其值将通过 `drop` 被清理掉，除非数据被移动为另一个变量所有。 -在每一个函数中都获取并接着返回所有权是冗余乏味的。如果我们想要函数使用一个值但不获取所有权改怎么办呢？如果我们还要接着使用它的话，每次都传递出去再传回来就有点烦人了，另外我们也可能想要返回函数体产生的任何（不止一个）数据。 +在每一个函数中都获取并接着返回所有权可能有些冗余。如果我们想要函数使用一个值但不获取所有权改怎么办呢？如果我们还要接着使用它的话，每次都传递出去再传回来就有点烦人了，另外我们也可能想要返回函数体产生的任何（不止一个）数据。 使用元组来返回多个值是可能的，像这样： From ffbf7f975f31e9a67b7efcbff2c1eb9a50de85d0 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 28 Oct 2017 20:58:34 +0800 Subject: [PATCH 022/150] translation enhancement --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index fb8f5aa..2f75103 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -323,7 +323,7 @@ fn takes_and_gives_back(a_string: String) -> String { // a_string comes into 在每一个函数中都获取并接着返回所有权可能有些冗余。如果我们想要函数使用一个值但不获取所有权改怎么办呢？如果我们还要接着使用它的话，每次都传递出去再传回来就有点烦人了，另外我们也可能想要返回函数体产生的任何（不止一个）数据。 -使用元组来返回多个值是可能的，像这样： +可以使用元组来返回多个值，像这样： 文件名: src/main.rs From 7747bee1a4924ad70a9b24aa4dcbdc755034d8b3 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 28 Oct 2017 21:03:10 +0800 Subject: [PATCH 023/150] =?UTF-8?q?=E8=BF=98=E6=98=AF=E9=9C=80=E8=A6=81?= =?UTF-8?q?=E6=84=8F=E8=AF=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 2f75103..d8e9a7a 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -343,4 +343,4 @@ fn calculate_length(s: String) -> (String, usize) { } ``` -但是这不免有些形式主义，同时这离一个通用的观点还有很长距离。幸运的是，Rust 对此提供了一个功能，叫做 **引用**（*references*）。 +但是这不免有些形式主义，而且这种场景应该很常见。幸运的是，Rust 对此提供了一个功能，叫做 **引用**（*references*）。 From ba7fdfedb1b7b1f4439683ef5028d6b4f499c833 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sun, 29 Oct 2017 01:31:43 +0800 Subject: [PATCH 024/150] =?UTF-8?q?=E6=AD=A4=E5=A4=84=E7=BF=BB=E8=AF=91?= =?UTF-8?q?=E6=9E=81=E4=B8=8D=E5=90=88=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-02-references-and-borrowing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-02-references-and-borrowing.md b/src/ch04-02-references-and-borrowing.md index 53edccc..f767ef1 100644 --- a/src/ch04-02-references-and-borrowing.md +++ b/src/ch04-02-references-and-borrowing.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -在上一部分的结尾处的使用元组的代码是有问题的，我们需要将 `String` 返回给调用者函数这样就可以在调用 `calculate_length` 后仍然可以使用 `String` 了，因为 `String` 先被移动到了 `calculate_length`。 +有这样一个问题：在上一部分的结尾处的使用元组的代码中，因为 `String` 先被移动到了 `calculate_length` 内，因此我们不得不将 `String` 作为返回值，这样在调用 `calculate_length` 后才仍然可以使用 `String`。 下面是如何定义并使用一个（新的）`calculate_length` 函数，它以一个对象的 **引用** 作为参数而不是获取值的所有权： From b885bbb89fe7e4bf2e22b98c7e6875c4dd39f0dd Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sun, 29 Oct 2017 23:58:21 +0800 Subject: [PATCH 025/150] fine adjustment --- src/ch04-02-references-and-borrowing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-02-references-and-borrowing.md b/src/ch04-02-references-and-borrowing.md index f767ef1..c1d453d 100644 --- a/src/ch04-02-references-and-borrowing.md +++ b/src/ch04-02-references-and-borrowing.md @@ -184,7 +184,7 @@ immutable 哇哦！我们 **也** 不能在拥有不可变引用的同时拥有可变引用。不可变引用的用户可不希望在它的眼皮底下值突然就被改变了！然而，多个不可变引用是没有问题的因为没有哪个只能读取数据的人有能力影响其他人读取到的数据。 -即使这些错误有时是使人沮丧的。记住这是 Rust 编译器在提早指出一个潜在的 bug（在编译时而不是运行时）并明确告诉你问题在哪，而不是任由你去追踪为何有时数据并不是你想象中的那样。 +尽管这些错误有时使人沮丧，但请牢记这是 Rust 编译器在提早指出一个潜在的 bug（在编译时而不是运行时）并明确告诉你问题在哪，而不是任由你去追踪为何有时数据并不是你想象中的那样。 ### 悬垂引用 From 5d506e9411e0e1b65c93752ce8000581b55660a1 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Mon, 30 Oct 2017 00:54:14 +0800 Subject: [PATCH 026/150] =?UTF-8?q?=E8=B0=83=E6=95=B4=E7=BF=BB=E8=AF=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-03-slices.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-03-slices.md b/src/ch04-03-slices.md index 9e262aa..47096fb 100644 --- a/src/ch04-03-slices.md +++ b/src/ch04-03-slices.md @@ -93,7 +93,7 @@ fn main() { 这个程序编译时没有任何错误，而且在调用 `s.clear()` 之后使用 `word` 也不会出错。这时 `word` 与 `s` 状态就没有联系了，所以 `word `仍然包含值 `5`。可以尝试用值 `5` 来提取变量 `s` 的第一个单词，不过这是有 bug 的，因为在我们将 `5` 保存到 `word` 之后 `s` 的内容已经改变。 -不得不担心 `word` 的索引与 `s` 中的数据不再同步是乏味且容易出错的！如果编写这么一个 `second_word` 函数的话管理索引将更加容易出问题。它的签名看起来像这样： +我们不得不时刻担心 `word` 的索引与 `s` 中的数据不再同步，这是冗余且容易出错的！如果编写这么一个 `second_word` 函数的话，管理索引这件事将更加容易出问题。它的签名看起来像这样： ```rust,ignore fn second_word(s: &String) -> (usize, usize) { From 7dfdb58a9b92ef43a5515d9bf475d3d5d714dfa2 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Mon, 30 Oct 2017 22:53:00 +0800 Subject: [PATCH 027/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=BF=BB=E8=AF=91?= =?UTF-8?q?=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch05-01-defining-structs.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch05-01-defining-structs.md b/src/ch05-01-defining-structs.md index 3347309..8b299f9 100644 --- a/src/ch05-01-defining-structs.md +++ b/src/ch05-01-defining-structs.md @@ -226,4 +226,4 @@ let origin = Point(0, 0, 0); > | ^ expected lifetime parameter > ``` > -> 第十章会讲到如何修复这个问题以便在结构体中储存引用，不过现在，通过从像 `&str` 这样的引用切换到像 `String` 这类拥有所有权的类型来修改修改这个错误。 +> 第十章会讲到如何修复这个问题以便在结构体中储存引用，不过现在，我们会使用像 `String` 这类拥有所有权的类型来替代 `&str` 这样的引用以修正这个错误。 From 11ea8668a9ba18a97e1cc94a8c44c2b7f08ad241 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Mon, 30 Oct 2017 23:31:10 +0800 Subject: [PATCH 028/150] =?UTF-8?q?useful=E8=BF=99=E9=87=8C=E7=BF=BB?= =?UTF-8?q?=E8=AF=91=E6=88=90=E5=AE=9E=E7=94=A8=E7=9A=84=E6=9B=B4=E5=A5=BD?= =?UTF-8?q?=EF=BC=8C=E4=B8=8E=E4=B8=8A=E6=96=87=E4=BF=9D=E6=8C=81=E4=B8=80?= =?UTF-8?q?=E8=87=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch05-02-example-structs.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch05-02-example-structs.md b/src/ch05-02-example-structs.md index 72e6def..76f13ca 100644 --- a/src/ch05-02-example-structs.md +++ b/src/ch05-02-example-structs.md @@ -189,6 +189,6 @@ rect1 is Rectangle { } ``` -Rust 为我们提供了很多可以通过 `derive` 注解来使用的 trait，他们可以为我们的自定义类型增加有益的行为。这些 trait 和行为在附录 C 中列出。第十章会涉及到如何通过自定义行为来实现这些 trait，同时还有如何创建你自己的 trait。 +Rust 为我们提供了很多可以通过 `derive` 注解来使用的 trait，他们可以为我们的自定义类型增加实用的行为。这些 trait 和行为在附录 C 中列出。第十章会涉及到如何通过自定义行为来实现这些 trait，同时还有如何创建你自己的 trait。 我们的 `area` 函数是非常特化的————它只是计算了长方形的面积。如果这个行为与 `Rectangle` 结构体再结合得更紧密一些就更好了，因为它不能用于其他类型。现在让我们看看如何继续重构这些代码，来将 `area` 函数协调进 `Rectangle` 类型定义的`area` **方法** 中。 From 2456b4ad9afce7b0bae401967c49134036742f5d Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 31 Oct 2017 13:49:44 +0800 Subject: [PATCH 029/150] =?UTF-8?q?=E8=B0=83=E6=95=B4=E4=B8=80=E4=B8=8B?= =?UTF-8?q?=E8=AF=AD=E5=BA=8F=EF=BC=8C=E4=B9=8B=E5=89=8D=E7=9A=84=E4=B8=8D?= =?UTF-8?q?=E9=80=9A=E9=A1=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch05-03-method-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch05-03-method-syntax.md b/src/ch05-03-method-syntax.md index 112d4b7..701ea8d 100644 --- a/src/ch05-03-method-syntax.md +++ b/src/ch05-03-method-syntax.md @@ -41,7 +41,7 @@ fn main() { 在 `area` 的签名中，开始使用 `&self` 来替代 `rectangle: &Rectangle`，因为该方法位于 `impl Rectangle` 上下文中所以 Rust 知道 `self` 的类型是 `Rectangle`。注意仍然需要在 `self` 前面加上 `&`，就像 `&Rectangle` 一样。方法可以选择获取 `self` 的所有权，像我们这里一样不可变的借用 `self`，或者可变的借用 `self`，就跟其他别的参数一样。 -这里选择 `&self` 跟在函数版本中使用 `&Rectangle` 出于同样的理由：我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入。如果想要能够在方法中改变调用方法的实例的话，需要将第一个参数改为 `&mut self`。通过仅仅使用 `self` 作为第一个参数来使方法获取实例的所有权，不过这是很少见的；这种技术通常用在当方法将 `self` 转换成别的实例的时候，这时我们想要防止调用者在转换之后使用原始的实例。 +这里选择 `&self` 跟在函数版本中使用 `&Rectangle` 出于同样的理由：我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入。如果想要能够在方法中改变调用方法的实例的话，需要将第一个参数改为 `&mut self`。很少见到通过仅仅使用 `self` 作为第一个参数来使方法获取实例的所有权；这种技术通常用在当方法将 `self` 转换成别的实例的时候，这时我们想要防止调用者在转换之后使用原始的实例。 使用方法而不是函数，除了使用了方法语法和不需要在每个函数签名中重复` self` 类型之外，其主要好处在于组织性。我将某个类型实例能做的所有事情都一起放入 `impl` 块中，而不是让将来的用户在我们的代码中到处寻找 `Rectangle` 的功能。 From 0b9e6faf1c3e443e4075f38adfe559af23356154 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Wed, 1 Nov 2017 15:27:49 +0800 Subject: [PATCH 030/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E9=94=99=E5=88=AB?= =?UTF-8?q?=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch05-03-method-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch05-03-method-syntax.md b/src/ch05-03-method-syntax.md index 701ea8d..08b705f 100644 --- a/src/ch05-03-method-syntax.md +++ b/src/ch05-03-method-syntax.md @@ -182,4 +182,4 @@ impl Rectangle { 结构体让我们可以在自己的范围内创建有意义的自定义类型。通过结构体，我们可以将相关联的数据片段联系起来并命名他们来使得代码更清晰。方法允许为结构体实例指定行为，而关联函数将特定功能置于结构体的命名空间中并且无需一个实例。 -结构体并不是创建自定义类型的唯一方法；让我们转向 Rust 的枚举功能并为自己的工具箱再填一个工具。 +结构体并不是创建自定义类型的唯一方法；让我们转向 Rust 的枚举功能并为自己的工具箱再添一个工具。 From da155b230aced087eb24a0264a180a064421264f Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Wed, 1 Nov 2017 15:33:24 +0800 Subject: [PATCH 031/150] =?UTF-8?q?=E7=BA=A0=E6=AD=A3=E7=BF=BB=E8=AF=91?= =?UTF-8?q?=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch06-01-defining-an-enum.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index c32bde0..28c98e2 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -让我们通过一用代码来表现的场景，来看看为什么这里枚举是有用的而且比结构体更合适。比如我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序只可能会遇到两种 IP 地址：所以可以 **枚举** 出所有可能的值，这也正是它名字的由来。 +让我们通过一用代码来表现的场景，来看看为什么这里枚举是有用的而且比结构体更合适。比如我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的 IP 地址的所有可能性：所以可以 **枚举** 出所有可能的值，这也正是它名字的由来。 任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的而不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理申请任何类型的 IP 地址的场景时应该把他们当作相同的类型。 From 522a82dceadff1ff1d7392b4b9fb220d93f85ceb Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Wed, 1 Nov 2017 20:42:15 +0800 Subject: [PATCH 032/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E9=94=99=E5=88=AB?= =?UTF-8?q?=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch06-01-defining-an-enum.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index 28c98e2..78de502 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -212,7 +212,7 @@ m.call(); > crashes, which have probably caused a billion dollars of pain and damage in > the last forty years. > -> 我称之为我万亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的应有都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数以万计美元的苦痛和伤害。 +> 我称之为我万亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的使用都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数以万计美元的苦痛和伤害。 空值的问题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性是无处不在的，非常容易出现这类错误。 From d7d9d17834652a4eb38f6259dd52b058dcfc4332 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Wed, 1 Nov 2017 20:53:30 +0800 Subject: [PATCH 033/150] =?UTF-8?q?=E6=BA=90=E2=80=9C=E6=88=90=E5=91=98?= =?UTF-8?q?=E2=80=9D=E5=BC=95=E5=85=A5=E4=B8=80=E4=B8=AA=E6=96=B0=E7=9A=84?= =?UTF-8?q?=E6=A6=82=E5=BF=B5=EF=BC=8C=E4=B8=8D=E6=98=8E=E7=A1=AE=EF=BC=8C?= =?UTF-8?q?=E4=B8=8D=E5=A6=82=E7=9B=B4=E8=AF=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch06-01-defining-an-enum.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index 78de502..4ae4315 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -240,7 +240,7 @@ let some_string = Some("a string"); let absent_number: Option = None; ``` -如果使用 `None` 而不是 `Some`，需要告诉 Rust `Option` 是什么类型的，因为编译器只通过 `None` 值无法推断出 `Some` 成员的类型。 +如果使用 `None` 而不是 `Some`，需要告诉 Rust `Option` 是什么类型的，因为编译器只通过 `None` 值无法推断出 `Some` 变量保留的值的类型。 当有一个 `Some` 值时，我们就知道存在一个值，而这个值保存在 `Some` 中。当有个`None` 值时，在某种意义上它跟空值是相同的意义：并没有一个有效的值。那么，`Option` 为什么就比空值要好呢？ From ad4e4bdf4cba369f7c99fa900d8aeb4ab8c4841e Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Wed, 1 Nov 2017 20:57:11 +0800 Subject: [PATCH 034/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=AC=94=E8=AF=AF?= =?UTF-8?q?=EF=BC=9A=E5=BA=94=E8=AF=A5=E6=98=AF=E2=80=9C=E7=9B=B8=E5=8A=A0?= =?UTF-8?q?=E2=80=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch06-01-defining-an-enum.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index 4ae4315..b00be46 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -245,7 +245,7 @@ let absent_number: Option = None; 当有一个 `Some` 值时，我们就知道存在一个值，而这个值保存在 `Some` 中。当有个`None` 值时，在某种意义上它跟空值是相同的意义：并没有一个有效的值。那么，`Option` 为什么就比空值要好呢？ -简而言之，因为 `Option` 和 `T`（这里 `T` 可以是任何类型）是不同的类型，编译器不允许像一个被定义的有效的类型那样使用 `Option`。例如，这些代码不能编译，因为它尝试将 `Option` 与 `i8` 相比： +简而言之，因为 `Option` 和 `T`（这里 `T` 可以是任何类型）是不同的类型，编译器不允许像一个被定义的有效的类型那样使用 `Option`。例如，这些代码不能编译，因为它尝试将 `Option` 与 `i8` 相加： ```rust,ignore let x: i8 = 5; From 27ce77c7f49e99d2ca5ee374868a8c6c3aa2a71a Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Wed, 1 Nov 2017 22:47:26 +0800 Subject: [PATCH 035/150] =?UTF-8?q?=E5=B0=91=E4=BA=86=E4=B8=80=E5=8D=8A*?= =?UTF-8?q?=EF=BC=8C=E6=96=9C=E4=BD=93=E6=97=A0=E6=95=88?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch06-02-match.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch06-02-match.md b/src/ch06-02-match.md index 8829f45..f394cba 100644 --- a/src/ch06-02-match.md +++ b/src/ch06-02-match.md @@ -192,7 +192,7 @@ error[E0004]: non-exhaustive patterns: `None` not covered ``` -Rust 知道我们没有覆盖所有可能的情况甚至知道那些模式被忘记了！Rust 中的匹配是 **穷尽的**（*exhaustive）：必须穷举到最后的可能性来使代码有效。特别的在这个 `Option` 的例子中，Rust 防止我们忘记明确的处理 `None` 的情况，这使我们免于假设拥有一个实际上为空的值，这造成了之前提到过的价值亿万的错误。 +Rust 知道我们没有覆盖所有可能的情况甚至知道那些模式被忘记了！Rust 中的匹配是 **穷尽的**（*exhaustive*）：必须穷举到最后的可能性来使代码有效。特别的在这个 `Option` 的例子中，Rust 防止我们忘记明确的处理 `None` 的情况，这使我们免于假设拥有一个实际上为空的值，这造成了之前提到过的价值亿万的错误。 ### `_` 通配符 From 8fcba7c27f646733eae78f06c3fc10a49800298b Mon Sep 17 00:00:00 2001 From: Quanyi Ma Date: Thu, 2 Nov 2017 22:24:00 +0800 Subject: [PATCH 036/150] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E6=96=87=E5=AD=97?= =?UTF-8?q?=E9=94=99=E8=AF=AF=20=E2=80=9C=E8=AE=A1=E6=95=B0=E2=80=9D=20->?= =?UTF-8?q?=20"=E6=8A=80=E6=9C=AF"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-00-functional-features.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch13-00-functional-features.md b/src/ch13-00-functional-features.md index ef032ee..1689ff2 100644 --- a/src/ch13-00-functional-features.md +++ b/src/ch13-00-functional-features.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -Rust 的设计灵感来源于很多现存的语言和计数。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。这里我们将不会辩论函数式编程到底是什么或不是什么，而是突出展示 Rust 中那些类似很多经常被认为是函数式的语言中功能的功能。 +Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。这里我们将不会辩论函数式编程到底是什么或不是什么，而是突出展示 Rust 中那些类似很多经常被认为是函数式的语言中功能的功能。 更具体的，我们将要涉及： @@ -13,4 +13,4 @@ Rust 的设计灵感来源于很多现存的语言和计数。其中一个显著 * 如何使用这些功能来改进第十二章的 I/O 项目 * 这些功能的性能。**剧透高能：** 他们的速度超乎你的想象！ -还有其他受函数式风格影响的 Rust 功能，比如模式匹配和枚举，这些已经在其他章节中讲到过了。掌握闭包和迭代器则是编写符合语言风格的高性能 Rust 代码的重要一环，所以我们将专门用一整章来讲解他们。 \ No newline at end of file +还有其他受函数式风格影响的 Rust 功能，比如模式匹配和枚举，这些已经在其他章节中讲到过了。掌握闭包和迭代器则是编写符合语言风格的高性能 Rust 代码的重要一环，所以我们将专门用一整章来讲解他们。 From fbd5c4ec822f550f8a86fd2b4b8bfa4811d309c7 Mon Sep 17 00:00:00 2001 From: Cyperwu <429187074@qq.com> Date: Thu, 2 Nov 2017 22:43:49 -0500 Subject: [PATCH 037/150] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=BA=86=E4=B8=80?= =?UTF-8?q?=E5=A4=84=E5=AE=B9=E6=98=93=E4=BA=A7=E7=94=9F=E6=AD=A7=E4=B9=89?= =?UTF-8?q?=E7=9A=84=E5=9C=B0=E6=96=B9=EF=BC=8C=E8=80=8C=E4=B8=94=E8=A1=A5?= =?UTF-8?q?=E4=B8=8A=E4=BA=86=E7=BC=BA=E5=A4=B1=E7=9A=84=E9=83=A8=E5=88=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit and _ as a visual separator, such as 1_000. 这一句没翻译全 --- src/ch03-02-data-types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch03-02-data-types.md b/src/ch03-02-data-types.md index 516b800..b12283c 100644 --- a/src/ch03-02-data-types.md +++ b/src/ch03-02-data-types.md @@ -50,7 +50,7 @@ error[E0282]: unable to infer enough type information about `_` 另外，`isize` 和 `usize` 类型依赖运行程序的计算机架构：64 位架构上他们是 64 位的， 32 位架构上他们是 32 位的。 -可以使用表格 3-2 中的任何一种形式编写数字字面值。注意除字节以外的其它字面值允许使用类型后缀，例如 `57u8`，允许使用 `_` 做为分隔符以方便读数。 +可以使用表格 3-2 中的任何一种形式编写数字字面值。注意除字节以外的其它字面值允许使用类型后缀，例如 `57u8`，同时也允许使用 `_` 做为分隔符以方便读数，例如`1_000`。 表格 3-2: Rust 中的整型字面值 From bf8e3f92902d8df09950c78517f033de1fc88dd0 Mon Sep 17 00:00:00 2001 From: Cyperwu <429187074@qq.com> Date: Mon, 6 Nov 2017 00:13:54 -0600 Subject: [PATCH 038/150] =?UTF-8?q?=E6=A0=B9=E6=8D=AE=E5=8E=9F=E6=96=87?= =?UTF-8?q?=E6=84=8F=E6=80=9D=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 原文意应为“服务员”而非“服务器”，此处作修改 --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index d8e9a7a..8eef42e 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -26,7 +26,7 @@ Rust 的核心功能（之一）是 **所有权**（*ownership*）。虽然这 > > 想象一下去餐馆就坐吃饭。当进入时，你说明有几个人，餐馆员工会找到一个够大的空桌子并领你们过去。如果有人来迟了，他们也可以通过询问来找到你们坐在哪。 > -> 访问堆上的数据要比访问栈上的数据要慢因为必须通过指针来访问。现代的处理器在内存中跳转越少就越快（缓存）。继续类比，假设有一台服务器来处理来自多个桌子的订单。它在处理完一个桌子的所有订单后再移动到下一个桌子是最有效率的。从桌子 A 获取一个订单，接着再从桌子 B 获取一个订单，然后再从桌子 A，然后再从桌子 B 这样的流程会更加缓慢。出于同样原因，处理器在处理的数据之间彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）能更好的工作。在堆上分配大量的空间也可能消耗时间。 +> 访问堆上的数据要比访问栈上的数据要慢因为必须通过指针来访问。现代的处理器在内存中跳转越少就越快（缓存）。继续类比，假设有一个服务员在餐厅里处理多个桌子的点菜。在一个桌子点完所有菜后再移动到下一个桌子是最有效率的。从桌子 A 点一个菜，接着桌子 B 点一个菜，然后再桌子 A，然后再桌子 B 这样的流程会更加缓慢。出于同样原因，处理器在处理的数据之间彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）能更好的工作。在堆上分配大量的空间也可能消耗时间。 > > 当调用一个函数，传递给函数的值（包括可能指向堆上数据的指针）和函数的局部变量被压入栈中。当函数结束时，这些值被移出栈。 > From e7e8f80307814da153f9228816249e9b59eed4ad Mon Sep 17 00:00:00 2001 From: Cyperwu <429187074@qq.com> Date: Mon, 6 Nov 2017 00:19:12 -0600 Subject: [PATCH 039/150] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=BE=97=E9=80=9A?= =?UTF-8?q?=E9=A1=BA=E4=B8=80=E7=82=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 8eef42e..707a061 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -26,7 +26,7 @@ Rust 的核心功能（之一）是 **所有权**（*ownership*）。虽然这 > > 想象一下去餐馆就坐吃饭。当进入时，你说明有几个人，餐馆员工会找到一个够大的空桌子并领你们过去。如果有人来迟了，他们也可以通过询问来找到你们坐在哪。 > -> 访问堆上的数据要比访问栈上的数据要慢因为必须通过指针来访问。现代的处理器在内存中跳转越少就越快（缓存）。继续类比，假设有一个服务员在餐厅里处理多个桌子的点菜。在一个桌子点完所有菜后再移动到下一个桌子是最有效率的。从桌子 A 点一个菜，接着桌子 B 点一个菜，然后再桌子 A，然后再桌子 B 这样的流程会更加缓慢。出于同样原因，处理器在处理的数据之间彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）能更好的工作。在堆上分配大量的空间也可能消耗时间。 +> 访问堆上的数据要比访问栈上的数据要慢因为必须通过指针来访问。现代的处理器在内存中跳转越少就越快（缓存）。继续类比，假设有一个服务员在餐厅里处理多个桌子的点菜。在一个桌子报完所有菜后再移动到下一个桌子是最有效率的。从桌子 A 听一个菜，接着桌子 B 听一个菜，然后再桌子 A，然后再桌子 B 这样的流程会更加缓慢。出于同样原因，处理器在处理的数据之间彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）能更好的工作。在堆上分配大量的空间也可能消耗时间。 > > 当调用一个函数，传递给函数的值（包括可能指向堆上数据的指针）和函数的局部变量被压入栈中。当函数结束时，这些值被移出栈。 > From 7a0df0a866b8edcb0bfe499055a2ae38803f3039 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Tue, 7 Nov 2017 22:25:54 +0800 Subject: [PATCH 040/150] =?UTF-8?q?=E5=8E=9F=E6=96=87=E2=80=9C=E7=BB=87?= =?UTF-8?q?=E2=80=9D=E4=BC=BC=E4=B9=8E=E7=AC=94=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch07-01-mod-and-the-filesystem.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch07-01-mod-and-the-filesystem.md b/src/ch07-01-mod-and-the-filesystem.md index a77364a..8712573 100644 --- a/src/ch07-01-mod-and-the-filesystem.md +++ b/src/ch07-01-mod-and-the-filesystem.md @@ -30,7 +30,7 @@ Cargo 创建了一个空的测试来帮助我们开始库项目，不像使用 ` 因为没有 *src/main.rs* 文件，所以没有可供 Cargo 的 `cargo run` 执行的东西。因此，我们将使用 `cargo build` 命令只是编译库 crate 的代码。 -我们将学习根据编写代码的意图来选择不同的织库项目代码组织来适应多种场景。 +我们将学习根据编写代码的意图来以不同方法组织库项目代码以适应多种情况。 ### 模块定义 From 2ef71531e3c566e5ad3de80069a8633a75e12726 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 11 Nov 2017 13:04:53 +0800 Subject: [PATCH 041/150] =?UTF-8?q?=E5=8A=A0=E5=85=A5=E9=80=97=E5=8F=B7?= =?UTF-8?q?=E6=96=AD=E5=8F=A5=E6=9B=B4=E5=AE=B9=E6=98=93=E7=90=86=E8=A7=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch08-01-vectors.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch08-01-vectors.md b/src/ch08-01-vectors.md index 503a786..8c3f504 100644 --- a/src/ch08-01-vectors.md +++ b/src/ch08-01-vectors.md @@ -52,7 +52,7 @@ v.push(8); } // <- v goes out of scope and is freed here ``` -当 vector 被丢弃时，所有其内容也会被丢弃，这意味着这里它包含的整数将被清理。这可能看起来非常直观，不过一旦开始使用 vector 元素的引用情况就变得有些复杂了。下面让我们处理这种情况！ +当 vector 被丢弃时，所有其内容也会被丢弃，这意味着这里它包含的整数将被清理。这可能看起来非常直观，不过一旦开始使用 vector 元素的引用，情况就变得有些复杂了。下面让我们处理这种情况！ ### 读取 vector 的元素 From b7d818e134deeb5b042fdaea48dcbc61037ad0df Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 11 Nov 2017 13:05:14 +0800 Subject: [PATCH 042/150] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch08-01-vectors.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch08-01-vectors.md b/src/ch08-01-vectors.md index 8c3f504..488c0eb 100644 --- a/src/ch08-01-vectors.md +++ b/src/ch08-01-vectors.md @@ -109,7 +109,7 @@ immutable | - immutable borrow ends here ``` -这些代码看起来应该能够运行：为什么第一个元素的引用会关心 vector 结尾的变化？不能这么做的原因是由于 vector 的工作方式。在 vector 的结尾增加新元素是，在没有足够空间将所有所有元素依次相邻存放的情况下，可能会要求分配新内存并将老的元素拷贝到新的空间中。这时，第一个元素的引用就指向了被释放的内存。借用规则阻止程序陷入这种状况。 +这些代码看起来应该能够运行：为什么第一个元素的引用会关心 vector 结尾的变化？不能这么做的原因是由于 vector 的工作方式。在 vector 的结尾增加新元素时，在没有足够空间将所有所有元素依次相邻存放的情况下，可能会要求分配新内存并将老的元素拷贝到新的空间中。这时，第一个元素的引用就指向了被释放的内存。借用规则阻止程序陷入这种状况。 > 注意：关于更多内容，查看 Nomicon *https://doc.rust-lang.org/stable/nomicon/vec.html* From 1ea816f83dd5a1dfd0b0b2618c336e6541e21338 Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Sat, 11 Nov 2017 18:02:02 +0800 Subject: [PATCH 043/150] =?UTF-8?q?=E5=8E=9F=E8=AF=91=E6=96=87=E4=B8=8D?= =?UTF-8?q?=E5=A4=9F=E9=80=9A=E9=A1=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch08-02-strings.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch08-02-strings.md b/src/ch08-02-strings.md index cd2e99a..9de5b41 100644 --- a/src/ch08-02-strings.md +++ b/src/ch08-02-strings.md @@ -76,7 +76,7 @@ let mut s = String::from("foo"); s.push_str("bar"); ``` -执行这两行代码之后 `s` 将会包含 “foobar”。`push_str` 方法获取字符串 slice，因为并不需要获取参数的所有权。例如，如果将 `s2` 的内容附加到 `s1` 中后自身不能被使用就糟糕了： +执行这两行代码之后 `s` 将会包含 “foobar”。`push_str` 方法获取字符串 slice，因为我们并不需要获取参数的所有权。例如，如果将 `s2` 的内容附加到 `s1` 中后自身不能被使用就糟糕了： ```rust let mut s1 = String::from("foo"); From a8ad774f7b1a810ff77e36768f2e66e76860f2ec Mon Sep 17 00:00:00 2001 From: Cyperwu <429187074@qq.com> Date: Mon, 13 Nov 2017 00:52:29 -0600 Subject: [PATCH 044/150] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E5=B0=8F=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch10-02-traits.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ch10-02-traits.md b/src/ch10-02-traits.md index 60b7760..4a623db 100644 --- a/src/ch10-02-traits.md +++ b/src/ch10-02-traits.md @@ -115,7 +115,7 @@ impl Summarizable for WeatherForecast { 另外这段代码假设 `Summarizable` 是一个公有 trait，这是因为示例 10-12 中 `trait` 之前使用了 `pub` 关键字。 -trait 实现的一个需要注意的限制是：只能在 trait 或对应类型位于我们 crate 本地的时候为其实现 trait。换句话说，不允许对外部类型实现外部 trait。例如，不能在 `Vec` 上实现 `Display` trait，因为 `Display` 和 `Vec` 都定义于标准库中。允许在像 `Tweet` 这样作为我们 `aggregator`crate 部分功能的自定义类型上实现标准库中的 trait `Display`。也允许在 `aggregator`crate 中为 `Vec` 实现 `Summarizable`，因为 `Summarizable` 定义与此。这个限制是我们称为 **孤儿规则**（*orphan rule*）的一部分，如果你感兴趣的可以在类型理论中找到它。简单来说，它被称为 orphan rule 是因为其父类型不存在。没有这条规则的话，两个 crate 可以分别对相同类型是实现相同的 trait，因而这两个实现会相互冲突：Rust 将无从得知应该使用哪一个。因为 Rust 强制执行 orphan rule，其他人编写的代码不会破坏你代码，反之亦是如此。 +trait 实现的一个需要注意的限制是：只能在 trait 或对应类型位于我们 crate 本地的时候为其实现 trait。换句话说，不允许对外部类型实现外部 trait。例如，不能在 `Vec` 上实现 `Display` trait，因为 `Display` 和 `Vec` 都定义于标准库中。允许在像 `Tweet` 这样作为我们 `aggregator`crate 部分功能的自定义类型上实现标准库中的 trait `Display`。也允许在 `aggregator`crate 中为 `Vec` 实现 `Summarizable`，因为 `Summarizable` 定义于此。这个限制是我们称为 **孤儿规则**（*orphan rule*）的一部分，如果你感兴趣的可以在类型理论中找到它。简单来说，它被称为 orphan rule 是因为其父类型不存在。没有这条规则的话，两个 crate 可以分别对相同类型是实现相同的 trait，因而这两个实现会相互冲突：Rust 将无从得知应该使用哪一个。因为 Rust 强制执行 orphan rule，其他人编写的代码不会破坏你代码，反之亦是如此。 ### 默认实现 @@ -311,7 +311,7 @@ fn main() { ### 使用 trait bound 有条件的实现方法 -通过使用带有 trati bound 的泛型 `impl` 块，可以有条件的只为实现了特定 trait 的类型实现方法。例如，示例 10-17 中的类型 `Pair` 总是实现了 `new` 方法，不过只有 `Pair` 内部的 `T` 实现了 `PartialOrd` trait 来允许比较和 `Display` trait 来启用打印，才会实现 `cmp_display`： +通过使用带有 trait bound 的泛型 `impl` 块，可以有条件的只为实现了特定 trait 的类型实现方法。例如，示例 10-17 中的类型 `Pair` 总是实现了 `new` 方法，不过只有 `Pair` 内部的 `T` 实现了 `PartialOrd` trait 来允许比较和 `Display` trait 来启用打印，才会实现 `cmp_display`： ```rust use std::fmt::Display; @@ -361,4 +361,4 @@ blanket implementation 会出现在 trait 文档的 “Implementers” 部分。 trait 和 trait bound 让我们使用泛型类型参数来减少重复，并仍然能够向编译器明确指定泛型类型需要拥有哪些行为。因为我们向编译器提供了 trait bound 信息，它就可以检查代码中所用到的具体类型是否提供了正确的行为。在动态类型语言中，如果我们尝试调用一个类型并没有实现的方法，会在运行时出现错误。Rust 将这些错误移动到了编译时，甚至在代码能够运行之前就强迫我们修复错误。另外，我们也无需编写运行时检查行为的代码，因为在编译时就已经检查过了，这样相比其他那些不愿放弃泛型灵活性的语言有更好的性能。 -这里还有一种泛型，我们一直在使用它甚至都没有察觉它的存在，这就是 **生命周期**（*lifetimes*）。不同于其他泛型帮助我们确保类型拥有期望的行为，生命周期则有助于确保引用在我们需要他们的时候一直有效。让我们学习生命周期是如何做到这些的。 \ No newline at end of file +这里还有一种泛型，我们一直在使用它甚至都没有察觉它的存在，这就是 **生命周期**（*lifetimes*）。不同于其他泛型帮助我们确保类型拥有期望的行为，生命周期则有助于确保引用在我们需要他们的时候一直有效。让我们学习生命周期是如何做到这些的。 From 43594be4dfa1c7ef7b28b2a60588462584b33399 Mon Sep 17 00:00:00 2001 From: Cyperwu <429187074@qq.com> Date: Mon, 13 Nov 2017 02:39:50 -0600 Subject: [PATCH 045/150] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E7=BF=BB=E8=AF=91=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch10-03-lifetime-syntax.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/ch10-03-lifetime-syntax.md b/src/ch10-03-lifetime-syntax.md index bb9545a..d2b7497 100644 --- a/src/ch10-03-lifetime-syntax.md +++ b/src/ch10-03-lifetime-syntax.md @@ -176,7 +176,7 @@ error[E0106]: missing lifetime specifier 生命周期注解有着一个不太常见的语法：生命周期参数名称必须以撇号（`'`）开头。生命周期参数的名称通常全是小写，而且类似于泛型类型，其名称通常非常短。`'a` 是大多数人默认使用的名称。生命周期参数注解位于引用的 `&` 之后，并有一个空格来将引用类型与生命周期注解分隔开。 -这里有一些例子：我们有一个没有生命周期参数的 `i32` 的引用，一个有叫做 `'a` 的生命周期参数的 `i32` 的引用，和一个也有的生命周期参数 `'a` 的 `i32` 的可变引用： +这里有一些例子：我们有一个没有生命周期参数的 `i32` 的引用，一个有叫做 `'a` 的生命周期参数的 `i32` 的引用，和一个生命周期也是 `'a` 的 `i32` 的可变引用： ```rust,ignore &i32 // a reference @@ -184,7 +184,7 @@ error[E0106]: missing lifetime specifier &'a mut i32 // a mutable reference with an explicit lifetime ``` -生命周期注解本身没有多少意义：生命周期注解告诉 Rust 多个引用的泛型生命周期参数如何相互联系。如果函数有一个生命周期 `'a` 的 `i32` 的引用的参数 `first`，还有另一个同样是生命周期 `'a` 的 `i32` 的引用的参数 `second`，这两个生命周期注解有相同的名称意味着 `first` 和 `second` 必须与这相同的泛型生命周期存在得一样久。 +单个的生命周期注解本身没有多少意义：生命周期注解告诉 Rust 多个引用的泛型生命周期参数如何相互联系。如果函数有一个生命周期 `'a` 的 `i32` 的引用的参数 `first`，还有另一个同样是生命周期 `'a` 的 `i32` 的引用的参数 `second`，这两个生命周期注解有相同的名称意味着 `first` 和 `second` 必须与这相同的泛型生命周期存在得一样久。 ### 函数签名中的生命周期注解 @@ -208,7 +208,7 @@ fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { 现在函数签名表明对于某些生命周期 `'a`，函数会获取两个参数，他们都是与生命周期 `'a` 存在的一样长的字符串 slice。函数会返回一个同样也与生命周期 `'a` 存在的一样长的字符串 slice。这就是我们告诉 Rust 需要其保证的协议。 -通过在函数签名中指定生命周期参数，不会改变任何参数或返回值的生命周期，不过我们说过任何不坚持这个协议的类型都将被借用检查器拒绝。这个函数并不知道（或需要知道）`x` 和 `y` 具体会存在多久，不过只需要知道一些可以使用 `'a` 替代的作用域将会满足这个签名。 +我们并不会通过“在函数签名中指定生命周期参数”这种方式来改变任何参数或返回值的生命周期，而是指出任何不遵守这个协议的传入值都将被借用检查器拒绝。这个函数并不知道（或需要知道）`x` 和 `y` 具体会存在多久，而只需要知道有某个可以被 `'a` 替代的作用域将会满足这个签名。 当在函数中使用生命周期注解时，这些注解出现在函数签名中，而不存在于函数体中的任何代码中。这是因为 Rust 能够分析函数中代码而不需要任何协助，不过当函数引用或被函数之外的代码引用时，参数或返回值的生命周期可能在每次函数被调用时都不同。这可能会产生惊人的消耗并且对于 Rust 来说通常是不可能分析的。在这种情况下，我们需要自己标注生命周期。 @@ -240,7 +240,7 @@ fn main() { 示例 10-24：通过拥有不同的具体生命周期的 `String` 值调用 `longest` 函数 -接下来，让我们尝试一个 `result` 的引用的生命周期必须比两个参数的要短的例子。将 `result` 变量的声明从内部作用域中移动出来，不过将 `result` 和 `string2` 变量的赋值语句一同放在内部作用域里。接下来，我们将使用 `result` 的 `println!` 移动到内部作用域之外，就在其结束之后。注意示例 10-25 中的代码不能编译： +接下来，让我们尝试一个 `result` 的引用的生命周期肯定比两个参数的要短的例子。将 `result` 变量的声明从内部作用域中移动出来，但是将 `result` 和 `string2` 变量的赋值语句一同放在内部作用域里。接下来，我们将使用 `result` 的 `println!` 移动到内部作用域之外，就在其结束之后。注意示例 10-25 中的代码不能编译： 文件名: src/main.rs @@ -521,4 +521,4 @@ fn longest_with_an_announcement<'a, T>(x: &'a str, y: &'a str, ann: T) -> &'a st 这一章介绍了很多的内容！现在你知道了泛型类型参数、trait 和 trait bounds 以及泛型生命周期类型，你已经准备好编写既不重复又能适用于多种场景的代码了。泛型类型参数意味着代码可以适用于不同的类型。trait 和 trait bounds 保证了即使类型是泛型的，这些类型也会拥有所需要的行为。由生命周期注解所指定的引用生命周期之间的关系保证了这些灵活多变的代码不会出现悬垂引用。而所有的这一切发生在编译时所以不会影响运行时效率！ -你可能不会相信，这个领域还有更多需要学习的内容：第十七章会讨论 trait 对象，这是另一种使用 trait 的方式。第十九章会涉及到生命周期注解更复杂的场景。第二十章讲解一些高级的类型系统功能。不过接下来，让我们聊聊如何在 Rust 中编写测试，来确保代码的所有功能能像我们希望的那样工作！ \ No newline at end of file +你可能不会相信，这个领域还有更多需要学习的内容：第十七章会讨论 trait 对象，这是另一种使用 trait 的方式。第十九章会涉及到生命周期注解更复杂的场景。第二十章讲解一些高级的类型系统功能。不过接下来，让我们聊聊如何在 Rust 中编写测试，来确保代码的所有功能能像我们希望的那样工作！ From 36cd6ff06ef27628629f2bbb934e5e416e53311f Mon Sep 17 00:00:00 2001 From: bioinformatist Date: Thu, 16 Nov 2017 20:07:26 +0800 Subject: [PATCH 046/150] =?UTF-8?q?=E6=9B=B4=E6=AD=A3=E7=BF=BB=E8=AF=91?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch09-00-error-handling.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch09-00-error-handling.md b/src/ch09-00-error-handling.md index ad93fad..609d6ee 100644 --- a/src/ch09-00-error-handling.md +++ b/src/ch09-00-error-handling.md @@ -4,7 +4,7 @@ >
> commit 4f2dc564851dc04b271a2260c834643dfd86c724 -Rust 对可靠性的执着也扩展到了错误处理。错误对于软件来说是不可避免的，所以 Rust 有很多功能来处理当现错误的情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 +Rust 对可靠性的执着也扩展到了错误处理。错误对于软件来说是不可避免的，所以当出现错误时， Rust 有很多特性来处理当前情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 Rust 将错误组合成两个主要类别：**可恢复错误**（*recoverable*）和 **不可恢复错误**（*unrecoverable*）。可恢复错误通常代表向用户报告错误和重试操作是合理的情况，比如未找到文件。不可恢复错误通常是 bug 的同义词，比如尝试访问超过数组结尾的位置。 From ac77c3b1215bd2f4cbe5663777fa5c7df0d9f8e2 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Mon, 20 Nov 2017 14:22:26 +0800 Subject: [PATCH 047/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "尝直接试" to "尝试直接", "对任何应" to "任何对应". --- src/ch09-01-unrecoverable-errors-with-panic.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch09-01-unrecoverable-errors-with-panic.md b/src/ch09-01-unrecoverable-errors-with-panic.md index 3f8b96c..8d316c2 100644 --- a/src/ch09-01-unrecoverable-errors-with-panic.md +++ b/src/ch09-01-unrecoverable-errors-with-panic.md @@ -57,7 +57,7 @@ fn main() { 这里尝试访问 vector 的第一百个元素，不过它只有三个元素。这种情况下 Rust 会 panic。`[]` 应当返回一个元素，不过如果传递了一个无效索引，就没有可供 Rust 返回的正确的元素。 -这种情况下其他像 C 这样语言会尝直接试提供所要求的值，即便这可能不是你期望的：你会得到对任何应 vector 中这个元素的内存位置的值，甚至是这些内存并不属于 vector 的情况。这被称为 **缓冲区溢出**（*buffer overread*），并可能会导致安全漏洞，比如攻击者可以像这样操作索引来读取储存在数组后面不被允许的数据。 +这种情况下其他像 C 这样语言会尝试直接提供所要求的值，即便这可能不是你期望的：你会得到任何对应 vector 中这个元素的内存位置的值，甚至是这些内存并不属于 vector 的情况。这被称为 **缓冲区溢出**（*buffer overread*），并可能会导致安全漏洞，比如攻击者可以像这样操作索引来读取储存在数组后面不被允许的数据。 为了使程序远离这类漏洞，如果尝试读取一个索引不存在的元素，Rust 会停止执行并拒绝继续。尝试运行上面的程序会出现如下： @@ -122,4 +122,4 @@ stack backtrace: 如果你不希望我们的程序 panic，第一个提到我们编写的代码行的位置是你应该开始调查的，以便查明是什么值如何在这个地方引起了 panic。在上面的例子中，我们故意编写会 panic 的代码来演示如何使用 backtrace，修复这个 panic 的方法就是不要尝试在一个只包含三个项的 vector 中请求索引是 100 的元素。当将来你的代码出现了 panic，你需要搞清楚在这特定的场景下代码中执行了什么操作和什么值导致了 panic，以及应当如何处理才能避免这个问题。 -本章的后面会再次回到 `panic!` 并讲到何时应该何时不应该使用这个方式。接下来，我们来看看如何使用 `Result` 来从错误中恢复。 \ No newline at end of file +本章的后面会再次回到 `panic!` 并讲到何时应该何时不应该使用这个方式。接下来，我们来看看如何使用 `Result` 来从错误中恢复。 From f53a1822eaf3b98ede903457d67cde7d97c6bf6c Mon Sep 17 00:00:00 2001 From: Spartucus Date: Wed, 22 Nov 2017 21:16:00 +0800 Subject: [PATCH 048/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "泛型泛型" to "泛型". --- src/ch10-01-syntax.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch10-01-syntax.md b/src/ch10-01-syntax.md index cd2bcbc..cf63029 100644 --- a/src/ch10-01-syntax.md +++ b/src/ch10-01-syntax.md @@ -309,7 +309,7 @@ fn main() { ### 泛型代码的性能 -在阅读本部分的内容的同时你可能会好奇使用泛型类型参数是否会有运行时消耗。好消息是：Rust 实现泛型泛型的方式意味着你的代码使用泛型类型参数相比指定具体类型并没有任何速度上的损失。 +在阅读本部分的内容的同时你可能会好奇使用泛型类型参数是否会有运行时消耗。好消息是：Rust 实现泛型的方式意味着你的代码使用泛型类型参数相比指定具体类型并没有任何速度上的损失。 Rust 通过在编译时进行泛型代码的 **单态化**（*monomorphization*）来保证效率。单态化是一个将泛型代码转变为实际放入的具体类型的特定代码的过程。 @@ -345,4 +345,4 @@ fn main() { } ``` -我们可以使用泛型来编写不重复的代码，而 Rust 将会为每一个实例编译其特定类型的代码。这意味着在使用泛型时没有运行时开销；当代码运行，它的执行效率就跟好像手写每个具体定义的重复代码一样。这个单态化过程正是 Rust 泛型在运行时极其高效的原因。 \ No newline at end of file +我们可以使用泛型来编写不重复的代码，而 Rust 将会为每一个实例编译其特定类型的代码。这意味着在使用泛型时没有运行时开销；当代码运行，它的执行效率就跟好像手写每个具体定义的重复代码一样。这个单态化过程正是 Rust 泛型在运行时极其高效的原因。 From 031d4f0acf21c680f3d3e00874d041d34f536143 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Wed, 22 Nov 2017 21:40:28 +0800 Subject: [PATCH 049/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "与" to "于" --- src/ch10-02-traits.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch10-02-traits.md b/src/ch10-02-traits.md index 4a623db..e89ed7e 100644 --- a/src/ch10-02-traits.md +++ b/src/ch10-02-traits.md @@ -70,7 +70,7 @@ impl Summarizable for Tweet { 示例 10-13：在 `NewsArticle` 和 `Tweet` 类型上实现 `Summarizable` trait -在类型上实现 trait 类似与实现与 trait 无关的方法。区别在于 `impl` 关键字之后，我们提供需要实现 trait 的名称，接着是 `for` 和需要实现 trait 的类型的名称。在 `impl` 块中，使用 trait 定义中的方法签名，不过不再后跟分号，而是需要在大括号中编写函数体来为特定类型实现 trait 方法所拥有的行为。 +在类型上实现 trait 类似于实现与 trait 无关的方法。区别在于 `impl` 关键字之后，我们提供需要实现 trait 的名称，接着是 `for` 和需要实现 trait 的类型的名称。在 `impl` 块中，使用 trait 定义中的方法签名，不过不再后跟分号，而是需要在大括号中编写函数体来为特定类型实现 trait 方法所拥有的行为。 一旦实现了 trait，我们就可以用与 `NewsArticle` 和 `Tweet` 实例的非 trait 方法一样的方式调用 trait 方法了： From f773d3b73c57e386c6df03fd4d0740e1a2eaeb63 Mon Sep 17 00:00:00 2001 From: qhsong Date: Thu, 23 Nov 2017 04:03:33 -0600 Subject: [PATCH 050/150] Update ch04-01-what-is-ownership.md fix some typo --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 707a061..294bbd9 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -321,7 +321,7 @@ fn takes_and_gives_back(a_string: String) -> String { // a_string comes into 变量的所有权总是遵循相同的模式：将值赋值给另一个变量时移动它。当持有堆中数据值的变量离开作用域时，其值将通过 `drop` 被清理掉，除非数据被移动为另一个变量所有。 -在每一个函数中都获取并接着返回所有权可能有些冗余。如果我们想要函数使用一个值但不获取所有权改怎么办呢？如果我们还要接着使用它的话，每次都传递出去再传回来就有点烦人了，另外我们也可能想要返回函数体产生的任何（不止一个）数据。 +在每一个函数中都获取并接着返回所有权可能有些冗余。如果我们想要函数使用一个值但不获取所有权该怎么办呢？如果我们还要接着使用它的话，每次都传递出去再传回来就有点烦人了，另外我们也可能想要返回函数体产生的任何（不止一个）数据。 可以使用元组来返回多个值，像这样： From 6e9ce3c1a56df6dd4a2d357aa49188e0a7b53778 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 25 Nov 2017 15:34:11 +0800 Subject: [PATCH 051/150] Refactor some translation --- src/ch10-03-lifetime-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch10-03-lifetime-syntax.md b/src/ch10-03-lifetime-syntax.md index d2b7497..9a1ea1d 100644 --- a/src/ch10-03-lifetime-syntax.md +++ b/src/ch10-03-lifetime-syntax.md @@ -214,7 +214,7 @@ fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { 当具体的引用被传递给 `longest` 时，被 `'a` 所替代的具体生命周期是 `x` 的作用域与 `y` 的作用域相重叠的那一部分。因为作用域总是嵌套的，所以换一种说法就是泛型生命周期 `'a` 的具体生命周期等同于 `x` 和 `y` 的生命周期中较小的那一个。因为我们用相同的生命周期参数标注了返回的引用值，所以返回的引用值就能保证在 `x` 和 `y` 中较短的那个生命周期结束之前保持有效。 -让我们如何通过传递拥有不同具体生命周期的引用来观察他们是如何限制 `longest` 函数的使用的。示例 10-24 是一个应该在任何编程语言中都很直观的例子：`string1` 直到外部作用域结束都是有效的，`string2` 则在内部作用域中是有效的，而 `result` 则引用了一些直到内部作用域结束都是有效的值。借用检查器认可这些代码；它能够编译和运行，并打印出 `The longest string is long string is long`： +让我们看看如何通过传递拥有不同具体生命周期的引用来限制 `longest` 函数的使用。示例 10-24 是一个应该在任何编程语言中都很直观的例子：`string1` 直到外部作用域结束都是有效的，`string2` 则在内部作用域中是有效的，而 `result` 则引用了一些直到内部作用域结束都是有效的值。借用检查器认可这些代码；它能够编译和运行，并打印出 `The longest string is long string is long`： 文件名: src/main.rs From 23eec62026fe63dc2f5f2eec490e2184f508428a Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 25 Nov 2017 16:04:41 +0800 Subject: [PATCH 052/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "适用" to "使用". --- src/ch10-03-lifetime-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch10-03-lifetime-syntax.md b/src/ch10-03-lifetime-syntax.md index d2b7497..dae7d6d 100644 --- a/src/ch10-03-lifetime-syntax.md +++ b/src/ch10-03-lifetime-syntax.md @@ -428,7 +428,7 @@ fn longest(x: &str, y: &str) -> &str { fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str { ``` -再来应用第二条规则，它并不适用因为存在多于一个输入生命周期。再来看第三条规则，它同样也不适用因为没有 `self` 参数。然后我们就没有更多规则了，不过还没有计算出返回值的类型的生命周期。这就是为什么在编译示例 10-22 的代码时会出现错误的原因：编译器适用所有已知的生命周期省略规则，不过仍然不能计算出签名中所有引用的生命周期。 +再来应用第二条规则，它并不适用因为存在多于一个输入生命周期。再来看第三条规则，它同样也不适用因为没有 `self` 参数。然后我们就没有更多规则了，不过还没有计算出返回值的类型的生命周期。这就是为什么在编译示例 10-22 的代码时会出现错误的原因：编译器使用所有已知的生命周期省略规则，不过仍然不能计算出签名中所有引用的生命周期。 因为第三条规则真正能够适用的就只有方法签名，现在就让我们看看那种情况中的生命周期，并看看为什么这条规则意味着我们经常不需要在方法签名中标注生命周期。 From fb9415ba174dd572ac910eecbe1ea547e4f72f56 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 25 Nov 2017 16:10:45 +0800 Subject: [PATCH 053/150] Fix typo --- src/ch10-03-lifetime-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch10-03-lifetime-syntax.md b/src/ch10-03-lifetime-syntax.md index d2b7497..4fcabb4 100644 --- a/src/ch10-03-lifetime-syntax.md +++ b/src/ch10-03-lifetime-syntax.md @@ -442,7 +442,7 @@ parameters need to be declared and used since the lifetime parameters could go with the struct's fields or with references passed into or returned from methods. /Carol --> -当为带有生命周期的结构体实现方法时，其语法依然类似示例 10-11 中展示的泛型类型参数的语法：声明和使用生命周期参数的位置依赖于生命周期参数是否同结构体字段或方法参数和返回值相关 +当为带有生命周期的结构体实现方法时，其语法依然类似示例 10-11 中展示的泛型类型参数的语法：声明和使用生命周期参数的位置依赖于生命周期参数是否同结构体字段或方法参数和返回值相关。 （实现方法时）结构体字段的生命周期必须总是在 `impl` 关键字之后声明并在结构体名称之后被使用，因为这些生命周期是结构体类型的一部分。 From 62d8c44779bf9bea510675b685e48786adf39832 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 25 Nov 2017 21:58:24 +0800 Subject: [PATCH 054/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "其他代外部码" to "其他外部代码". --- src/ch11-03-test-organization.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch11-03-test-organization.md b/src/ch11-03-test-organization.md index d50ca22..2d325c4 100644 --- a/src/ch11-03-test-organization.md +++ b/src/ch11-03-test-organization.md @@ -208,6 +208,6 @@ fn it_adds_two() { ## 总结 -Rust 的测试功能提供了一个如何确保即使函数做出改变也能继续以指定方式运行的途径。单元测试独立的验证库的不同部分并能够测试私有实现细节。集成测试则涉及多个部分结合起来工作时的用例，并像其他代外部码那样测试库的公有 API。即使 Rust 的类型系统和所有权规则可以帮助避免一些 bug，不过测试对于减少代码是否符合期望相关的逻辑 bug 仍然是很重要的。 +Rust 的测试功能提供了一个如何确保即使函数做出改变也能继续以指定方式运行的途径。单元测试独立的验证库的不同部分并能够测试私有实现细节。集成测试则涉及多个部分结合起来工作时的用例，并像其他外部代码那样测试库的公有 API。即使 Rust 的类型系统和所有权规则可以帮助避免一些 bug，不过测试对于减少代码是否符合期望相关的逻辑 bug 仍然是很重要的。 -接下来让我们结合本章所学和其他之前章节的知识，在下一章一起编写一个项目！ \ No newline at end of file +接下来让我们结合本章所学和其他之前章节的知识，在下一章一起编写一个项目！ From f01a80679cf87f417f4dc07a3d079aa8aae809ac Mon Sep 17 00:00:00 2001 From: lcofjp Date: Sun, 26 Nov 2017 14:31:52 +0800 Subject: [PATCH 055/150] =?UTF-8?q?=E5=B0=86=E2=80=9C=E7=BB=99=E2=80=9D?= =?UTF-8?q?=E6=94=B9=E4=B8=BA=E2=80=9C=E4=B8=AA=E2=80=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 译者原意可能是“个”字 --- src/ch01-02-hello-world.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index e4de0e7..408e36e 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -85,7 +85,7 @@ fn main() { 这行代码完成这个小程序的所有工作：在屏幕上打印文本。这里有很多细节需要注意。首先 Rust 使用 4 个空格的缩进风格，而不是 1 个制表符（tab）。 -第二个重要的部分是 `println!()`。这给称为 Rust **宏**，Rust 元编程（metaprogramming）的关键所在。如果是调用函数，则应看起来像这样：`println`（没有`!`）。我们将在附录 E 中更加详细的讨论宏，现在你只需记住，当看到符号 `!` 的时候，调用的是宏而不是普通函数。 +第二个重要的部分是 `println!()`。这个称为 Rust **宏**，Rust 元编程（metaprogramming）的关键所在。如果是调用函数，则应看起来像这样：`println`（没有`!`）。我们将在附录 E 中更加详细的讨论宏，现在你只需记住，当看到符号 `!` 的时候，调用的是宏而不是普通函数。 接下来，`"Hello, world!"` 是一个 **字符串**。我们把这个字符串作为一个参数传递给 `println!`，它负责在屏幕上打印这个字符串。轻松加愉快！(⊙o⊙) From 354dddd7a25f8cf85cc2faad169fec13151afad7 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Mon, 27 Nov 2017 20:55:49 +0800 Subject: [PATCH 056/150] Fix typo --- src/ch01-00-introduction.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch01-00-introduction.md b/src/ch01-00-introduction.md index c9fc202..ac57af3 100644 --- a/src/ch01-00-introduction.md +++ b/src/ch01-00-introduction.md @@ -6,7 +6,7 @@ 欢迎阅读 “Rust 程序设计语言”，一本介绍 Rust 的书。Rust 是一门着眼于安全、速度和并发的编程语言。其程序设计兼顾底层语言的性能与控制，并不失高级语言强大的抽象能力。其特性适合那些有类 C 语言经验，正在寻找更安全的替代品的开发者；同样适合有着类 Python 语言背景，寻求在不牺牲表现力的前提下，编写更高性能代码的开发者。 -Rust 编译时执行绝大部分的安全检查和内存管理决策，对运行时性能的影响微不足道。这使其在其他语言不擅长的应用场景中得以大显身手：可预测时间和空间需求的程序，嵌入到其他语言中，以及编写如设备驱动和操作系统这样的底层代码，。Rust 也很擅长 web 程序：它驱动着 Rust 包登记网站（package +Rust 编译时执行绝大部分的安全检查和内存管理决策，对运行时性能的影响微不足道。这使其在其他语言不擅长的应用场景中得以大显身手：可预测时间和空间需求的程序，嵌入到其他语言中，以及编写如设备驱动和操作系统这样的底层代码。Rust 也很擅长 web 程序：它驱动着 Rust 包登记网站（package registry site），[crates.io]！我们由衷期待**你**使用 Rust 进行创作。 [crates.io]: https://crates.io/ @@ -22,4 +22,4 @@ registry site），[crates.io]！我们由衷期待**你**使用 Rust 进行创 > 译者注：译本的 [GitHub 仓库][trpl-zh-cn]，同样欢迎 Issue 和 PR :) -[trpl-zh-cn]: https://github.com/KaiserY/trpl-zh-cn \ No newline at end of file +[trpl-zh-cn]: https://github.com/KaiserY/trpl-zh-cn From dc8ab02731bf356c89396ea0444373af65224b30 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Mon, 27 Nov 2017 21:12:09 +0800 Subject: [PATCH 057/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "打印出出" to "打印出". --- src/ch12-01-accepting-command-line-arguments.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch12-01-accepting-command-line-arguments.md b/src/ch12-01-accepting-command-line-arguments.md index ac94255..bec5e7a 100644 --- a/src/ch12-01-accepting-command-line-arguments.md +++ b/src/ch12-01-accepting-command-line-arguments.md @@ -84,7 +84,7 @@ fn main() { 正如之前打印出 vector 时所所看到的，程序的名称占据了 vector 的第一个值 `args[0]`，所以我们从索引 `1` 开始。`minigrep` 获取的第一个参数是需要搜索的字符串，所以将其将第一个参数的引用存放在变量 `query` 中。第二个参数将是文件名，所以将第二个参数的引用放入变量 `filename` 中。 -我们将临时打印出出这些变量的值，再一次证明代码如我们期望的那样工作。让我们使用参数 `test` 和 `sample.txt` 再次运行这个程序： +我们将临时打印出这些变量的值，再一次证明代码如我们期望的那样工作。让我们使用参数 `test` 和 `sample.txt` 再次运行这个程序： ```text $ cargo run test sample.txt From 67061947eb627a366d6e07c2ac4b00d7b328bf98 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Mon, 27 Nov 2017 21:52:01 +0800 Subject: [PATCH 058/150] Refactor some translation --- src/ch12-03-improving-error-handling-and-modularity.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch12-03-improving-error-handling-and-modularity.md b/src/ch12-03-improving-error-handling-and-modularity.md index 26e3de0..3bd7722 100644 --- a/src/ch12-03-improving-error-handling-and-modularity.md +++ b/src/ch12-03-improving-error-handling-and-modularity.md @@ -202,7 +202,7 @@ thread 'main' panicked at 'not enough arguments', src/main.rs:29 note: Run with `RUST_BACKTRACE=1` for a backtrace. ``` -这个输出就好多了，现在有了一个合理的错误信息。然而，我们还有一堆额外的信息不希望提供给用户。所以在这里使用示例 9-8 中的技术可能不是最好的；无论如何 `panic!` 调用更适合程序上的问题而不是使用上的问题，正如第九章所讲到的。相反我们可以使用那一章学习的另一个技术：返回一个可以表明成功或错误的 `Result`。 +这个输出就好多了，现在有了一个合理的错误信息。然而，我们还有一堆额外的信息不希望提供给用户。所以在这里使用示例 9-8 中的技术可能不是最好的；正如第九章所讲到的一样，`panic!` 的调用更趋向于程序上的问题而不是使用上的问题。相反我们可以使用那一章学习的另一个技术：返回一个可以表明成功或错误的 `Result`。 #### 从 `new` 中返回 `Result` 而不是调用 `panic!` @@ -442,4 +442,4 @@ fn main() { 哇哦！这可有很多的工作，不过我们为将来成功打下了基础。现在处理错误将更容易，同时代码也更加模块化。从现在开始几乎所有的工作都将在 *src/lib.rs* 中进行。 -让我们利用这些新创建的模块的优势来进行一些在旧代码中难以展开的工作，他们在新代码中却很简单：编写测试！ \ No newline at end of file +让我们利用这些新创建的模块的优势来进行一些在旧代码中难以展开的工作，他们在新代码中却很简单：编写测试！ From afd10613c345907dee78d3659c91a6fe418e0a29 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Tue, 28 Nov 2017 08:53:43 +0800 Subject: [PATCH 059/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 用 => 有 --- src/ch03-01-variables-and-mutability.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch03-01-variables-and-mutability.md b/src/ch03-01-variables-and-mutability.md index d190639..6d7200b 100644 --- a/src/ch03-01-variables-and-mutability.md +++ b/src/ch03-01-variables-and-mutability.md @@ -89,7 +89,7 @@ const MAX_POINTS: u32 = 100_000; 常量在整个程序生命周期中都有效，位于它声明的作用域之中。这使得常量可以作为多处代码使用的全局范围的值，例如一个游戏中所有玩家可以获取的最高分或者光速。 -将用于整个程序的硬编码的值声明为常量对后来的维护者了解值的意义很用帮助。它也能将硬编码的值汇总一处，为将来可能的修改提供方便。 +将用于整个程序的硬编码的值声明为常量对后来的维护者了解值的意义很有帮助。它也能将硬编码的值汇总一处，为将来可能的修改提供方便。 ### 隐藏（Shadowing） From c8f35640be0f87f2c9b7413665191f2880afc0c4 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Tue, 28 Nov 2017 09:00:49 +0800 Subject: [PATCH 060/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 删除“在”字 --- src/ch03-02-data-types.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch03-02-data-types.md b/src/ch03-02-data-types.md index b12283c..bc91f28 100644 --- a/src/ch03-02-data-types.md +++ b/src/ch03-02-data-types.md @@ -207,7 +207,7 @@ fn main() { } ``` -数组在需要在栈（stack）而不是在堆（heap）上为数据分配空间时（第四章将讨论栈与堆的更多内容），或者是想要确保总是有固定数量的元素时十分有用。虽然它并不如 vector 类型那么灵活。vector 类型是标准库提供的一个 **允许** 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，你可能应该使用 vector：第八章会详细讨论 vector。 +数组需要在栈（stack）而不是在堆（heap）上为数据分配空间时（第四章将讨论栈与堆的更多内容），或者是想要确保总是有固定数量的元素时十分有用。虽然它并不如 vector 类型那么灵活。vector 类型是标准库提供的一个 **允许** 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，你可能应该使用 vector：第八章会详细讨论 vector。 一个你可能想要使用数组而不是 vector 的例子是当程序需要知道一年中月份的名字时。程序不大可能会去增加或减少月份，这时你可以使用数组因为我们知道它总是含有 12 个元素： From 2b591ea224de323e3e481a9ae606600967d1019c Mon Sep 17 00:00:00 2001 From: lcofjp Date: Tue, 28 Nov 2017 23:27:43 +0800 Subject: [PATCH 061/150] Fix typo modified: src/ch03-03-how-functions-work.md modified: src/ch03-05-control-flow.md --- src/ch03-03-how-functions-work.md | 6 +++--- src/ch03-05-control-flow.md | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/ch03-03-how-functions-work.md b/src/ch03-03-how-functions-work.md index 75ee424..8e71833 100644 --- a/src/ch03-03-how-functions-work.md +++ b/src/ch03-03-how-functions-work.md @@ -96,7 +96,7 @@ The value of x is: 5 The value of y is: 6 ``` -因为我们使用 `5` 作为 `x` 的值和 `6` 作为 `y` 的值来调用函数，这两个字符串和他们的值并被打印出来。 +因为我们使用 `5` 作为 `x` 的值和 `6` 作为 `y` 的值来调用函数，这两个字符串和他们的值被相应打印出来。 ### 函数体 @@ -104,7 +104,7 @@ The value of y is: 6 ### 语句与表达式 -我们已经用过语句与表达式了。**语句**（*Statements*）是执行一些操作但不返回值的指令。表达式（*Expressions*）计算并产生一个值。让我们看看一些例子： +我们已经用过语句与表达式了。**语句**（*Statements*）是执行一些操作但不返回值的指令。表达式（*Expressions*）计算并产生一个值。让我们看一些例子： 使用 `let` 关键字创建变量并绑定一个值是一个语句。在列表 3-3 中，`let y = 6;` 是一个语句： @@ -146,7 +146,7 @@ error: expected expression, found statement (`let`) `let y = 6` 语句并不返回值，所以并没有 `x` 可以绑定的值。这与其他语言不同，例如 C 和 Ruby，他们的赋值语句返回所赋的值。在这些语言中，可以这么写 `x = y = 6` 这样 `x` 和 `y` 的值都是 `6`；这在 Rust 中可不行。 -表达式计算出一些值，而且他们组成了其余大部分你将会编写的 Rust 代码。考虑一个简单的数学运算，比如 `5 + 6`，这是一个表达式并计算出值 `11`。表达式可以是语句的一部分：在列表 3-3 中有这个语句 `let y = 6;`，`6` 是一个表达式它计算出的值是 `6`。函数调用是一个表达式。宏调用是一个表达式。我们用来创新建作用域的大括号（代码块），`{}`，也是一个表达式，例如： +表达式计算出一些值，而且他们组成了其余大部分你将会编写的 Rust 代码。考虑一个简单的数学运算，比如 `5 + 6`，这是一个表达式并计算出值 `11`。表达式可以是语句的一部分：在列表 3-3 中有这个语句 `let y = 6;`，`6` 是一个表达式它计算出的值是 `6`。函数调用是一个表达式。宏调用是一个表达式。我们用来创建新作用域的大括号（代码块），`{}`，也是一个表达式，例如： 文件名: src/main.rs diff --git a/src/ch03-05-control-flow.md b/src/ch03-05-control-flow.md index 1bebb39..ea77e2e 100644 --- a/src/ch03-05-control-flow.md +++ b/src/ch03-05-control-flow.md @@ -54,7 +54,7 @@ $ cargo run condition was false ``` -另外值得注意的是代码中的条件 **必须** 是 `bool`。如果像看看条件不是 `bool` 值时会发生什么，尝试运行如下代码： +另外值得注意的是代码中的条件 **必须** 是 `bool`。如果想看看条件不是 `bool` 值时会发生什么，尝试运行如下代码： 文件名: src/main.rs @@ -202,7 +202,7 @@ error[E0308]: if and else have incompatible types ### 使用循环重复执行 -多次执行同一段代码是很常用的。为了这个功能，Rust 提供了多种 **循环**（*loops*）。一个循环执行循环体中的代码直到结尾并紧接着从回到开头继续执行。为了实验一下循环，让我们创建一个叫做 *loops* 的新项目。 +多次执行同一段代码是很常用的。为了这个功能，Rust 提供了多种 **循环**（*loops*）。一个循环执行循环体中的代码直到结尾并紧接着回到开头继续执行。为了实验一下循环，让我们创建一个叫做 *loops* 的新项目。 Rust 有三种循环类型：`loop`、`while` 和 `for`。让我们每一个都试试。 From 9c8976ec0ea0cceb74d6b7a3e6629ca917c93c85 Mon Sep 17 00:00:00 2001 From: Cyperwu <429187074@qq.com> Date: Tue, 28 Nov 2017 20:26:41 -0600 Subject: [PATCH 062/150] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E7=BF=BB=E8=AF=91=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-01-closures.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 37eb2fe..0e267bb 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -97,7 +97,7 @@ fn generate_workout(intensity: i32, random_number: i32) { 如果用户需要高强度锻炼，这里有一些额外的逻辑：如果 app 生成的随机数刚好是 3，app 相反会建议用户稍做休息并补充水分。如果不是，则用户会从复杂算法中得到数分钟跑步的高强度锻炼计划。 -数据科学部门的同学告知我们必须对调用算法的方式做出一些改变。为了简化做出这些改变的更新，我们将重构代码来只调用 `simulated_expensive_calculation` 一次。同时还希望去掉目前多余的连续两次函数调用，并不希望在计算过程中增加任何其他此函数的调用。也就是说，我们不希望在完全无需其结果的情况调用函数，不过最终仍然需要调用函数一次。 +数据科学部门的同学告知我们将来会对调用算法的方式做出一些改变。为了在要做这些改动的时候简化更新步骤，我们将重构代码来让它只调用 `simulated_expensive_calculation` 一次。同时还希望去掉目前多余的连续两次函数调用，并不希望在计算过程中增加任何其他此函数的调用。也就是说，我们不希望在完全无需其结果的情况调用函数，不过最终仍然需要调用函数一次。 有多种方法可以重构此程序。我们首先尝试的是将重复的慢计算函数调用提取到一个变量中，如示例 13-4 所示： @@ -210,7 +210,7 @@ fn generate_workout(intensity: i32, random_number: i32) { 示例 13-6：调用定义的 `expensive_closure` -现在我们达成了将满计算统一到一个地方的目标，并只会在需要结果的时候执行改代码。然而，我们又重新引入了示例 13-3 中的问题：仍然在第一个 `if` 块中调用了闭包两次，这会调用慢计算两次并使用户多等待一倍的时间。可以通过在 `if` 块中创建一个本地变量存放闭包调用的结果来解决这个问题，不过正因为使用了闭包还有另一个解决方案。稍后会回到这个方案上；首先讨论一下为何闭包定义中和所涉及的 trait 中没有类型注解。 +现在我们达成了将慢计算统一到一个地方的目标，并只会在需要结果的时候执行改代码。然而，我们又重新引入了示例 13-3 中的问题：仍然在第一个 `if` 块中调用了闭包两次，这会调用慢计算两次并使用户多等待一倍的时间。可以通过在 `if` 块中创建一个本地变量存放闭包调用的结果来解决这个问题，不过正因为使用了闭包还有另一个解决方案。稍后会回到这个方案上；首先讨论一下为何闭包定义中和所涉及的 trait 中没有类型注解。 ### 闭包类型推断和注解 @@ -553,4 +553,4 @@ error[E0382]: use of moved value: `x` 大部分需要指定一个 `Fn` trait bound 的时候，可以从 `Fn` 开始，编译器会根据闭包体中的情况告诉你是否需要 `FnMut` 或 `FnOnce`。 -为了展示闭包作为函数参数时捕获其环境的作用，让我们移动到下一个主题：迭代器。 \ No newline at end of file +为了展示闭包作为函数参数时捕获其环境的作用，让我们移动到下一个主题：迭代器。 From 55205dcc9262b0f096c3562905199248b4af53c8 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Wed, 29 Nov 2017 22:57:14 +0800 Subject: [PATCH 063/150] Fix typo --- src/ch04-01-what-is-ownership.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 294bbd9..331a577 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -171,7 +171,7 @@ let s2 = s1; 之前，我们提到过当变量离开作用域后 Rust 自动调用 `drop` 函数并清理变量的堆内存。不过图 4-4 展示了两个数据指针指向了同一位置。这就有了一个问题：当 `s2` 和 `s1` 离开作用域，他们都会尝试释放相同的内存。这是一个叫做 *double free* 的错误，也是之前提到过的内存安全性 bug 之一。两次释放（相同）内存会导致内存污染，它可能会导致潜在的安全漏洞。 -为了确保内存安全，这种场景下 Rust 的处理有另一个细节值得注意。与其尝试拷贝被分配的内存，Rust 则认为 `s1` 不再有效，因此 Rust 不需要在 `s1` 离开作用域后清理任何东西。看看在 `s2` 被创建之后尝试使用 `s1` 会发生生么： +为了确保内存安全，这种场景下 Rust 的处理有另一个细节值得注意。与其尝试拷贝被分配的内存，Rust 则认为 `s1` 不再有效，因此 Rust 不需要在 `s1` 离开作用域后清理任何东西。看看在 `s2` 被创建之后尝试使用 `s1` 会发生什么： ```rust,ignore let s1 = String::from("hello"); @@ -195,7 +195,7 @@ error[E0382]: use of moved value: `s1` which does not implement the `Copy` trait ``` -如果你在其他语言中听说过术语 “浅拷贝”（“shallow copy”）和 “深拷贝”（“deep copy”），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量无效化了，这个操作被称为 **移动**（*move*），而不是浅拷贝。上面的例子可以解读为 `s1` 被 **移动** 到了 `s2` 中。那么具体发生了什么如图 4-6 所示。 +如果你在其他语言中听说过术语 “浅拷贝”（“shallow copy”）和 “深拷贝”（“deep copy”），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量无效化了，这个操作被称为 **移动**（*move*），而不是浅拷贝。上面的例子可以解读为 `s1` 被 **移动** 到了 `s2` 中。那么具体发生了什么，如图 4-6 所示。 s1 moved to s2 From b273c23d0681da78a7b07c01cd867790d56f965e Mon Sep 17 00:00:00 2001 From: lcofjp Date: Wed, 29 Nov 2017 23:16:41 +0800 Subject: [PATCH 064/150] Fix typo --- src/ch05-01-defining-structs.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ch05-01-defining-structs.md b/src/ch05-01-defining-structs.md index 8b299f9..27e4c5b 100644 --- a/src/ch05-01-defining-structs.md +++ b/src/ch05-01-defining-structs.md @@ -4,9 +4,9 @@ >
> commit 56352c28cf3fe0402fa5a7cba73890e314d720eb -我们在第三章讨论过，结构体与元组类似。就像元组，结构体的每一部分可以是不同类型。不同于元组，需要命名各部分数据以便能清楚的表明其值的意义。由于有了这些名字使得结构体比元组更灵活：不需要依赖顺序来指定或访问实例中的值。 +我们在第三章讨论过，结构体与元组类似。就像元组，结构体的每一部分可以是不同类型。不同于元组，结构体需要命名各部分数据以便能清楚的表明其值的意义。由于有了这些名字使得结构体比元组更灵活：不需要依赖顺序来指定或访问实例中的值。 -为了定义结构体，通过 `struct` 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字，他们被称作 **字段**（*field*），并定义字段类型。例如，示例 5-1 展示了一个储存用户账号信息的结构体： +定义结构体，需要使用 `struct` 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字，他们被称作 **字段**（*field*），并定义字段类型。例如，示例 5-1 展示了一个储存用户账号信息的结构体： ```rust struct User { @@ -178,7 +178,7 @@ let black = Color(0, 0, 0); let origin = Point(0, 0, 0); ``` -注意 `black` 和 `origin` 变量有不同的类型，因为他们是不同的元组结构体的实例。我们定义的每一个结构体有着自己的类型，即使结构体中的字段有相同的类型。在其他方面，元组结构体类似我们在第三章提到的元组。 +注意 `black` 和 `origin` 变量是不同的类型，因为他们是不同的元组结构体的实例。我们定义的每一个结构体有着自己的类型，即使结构体中的字段有相同的类型。在其他方面，元组结构体类似我们在第三章提到的元组。 ### 没有任何字段的类单元结构体 From e345cd61f9aba544e61c08343f9e251bf603f8f9 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Wed, 29 Nov 2017 23:24:38 +0800 Subject: [PATCH 065/150] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E4=B8=80=E4=BA=9B?= =?UTF-8?q?=E4=B8=8D=E9=80=9A=E9=A1=BA=E7=9A=84=E8=AF=AD=E5=8F=A5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch05-02-example-structs.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch05-02-example-structs.md b/src/ch05-02-example-structs.md index 76f13ca..51f52de 100644 --- a/src/ch05-02-example-structs.md +++ b/src/ch05-02-example-structs.md @@ -71,7 +71,7 @@ fn area(dimensions: (u32, u32)) -> u32 { ### 使用结构体重构：增加更多意义 -现在引入结构体的时候了。我们可以将元组转换为一个有整体名称而且每个部分也有对应名字的数据类型，如示例 5-10 所示： +现在是引入结构体的时候了。我们可以将元组转换为一个有整体名称而且每个部分也有对应名字的数据类型，如示例 5-10 所示： 文件名: src/main.rs @@ -174,7 +174,7 @@ fn main() { 示例 5-12：增加注解来导出 `Debug` trait -此时此刻运行程序，运行这个程序，不会有任何错误并会出现如下输出： +现在我们再运行这个程序时，不会有任何错误并会出现如下输出： ```text rect1 is Rectangle { length: 50, width: 30 } From 4c09c94c6c87cb85c53bf20c208cdb28a74b7ddd Mon Sep 17 00:00:00 2001 From: Jeff <200006506@qq.com> Date: Thu, 30 Nov 2017 13:16:24 +0800 Subject: [PATCH 066/150] Fix typo --- src/ch08-03-hash-maps.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch08-03-hash-maps.md b/src/ch08-03-hash-maps.md index 40bcc7c..c850c43 100644 --- a/src/ch08-03-hash-maps.md +++ b/src/ch08-03-hash-maps.md @@ -170,7 +170,7 @@ println!("{:?}", map); vector、字符串和哈希 map 会在你的程序需要储存、访问和修改数据时帮助你。这里有一些你应该能够解决的练习问题： * 给定一系列数字，使用 vector 并返回这个列表的平均数（mean, average）、中位数（排列数组后位于中间的值）和众数（mode，出现次数最多的值；这里哈希函数会很有帮助）。 -* 将字符串转换为 Pig Latin，也就是每一个单词的第一个辅音字母被移动到单词的结尾并增加 “ay”，所以 “first” 会变成 “first-fay”。元音字母开头的单词则在结尾增加 “hay”（“apple” 会变成 “apple-hay”）。牢记 UTF-8 编码！ +* 将字符串转换为 Pig Latin，也就是每一个单词的第一个辅音字母被移动到单词的结尾并增加 “ay”，所以 “first” 会变成 “irst-fay”。元音字母开头的单词则在结尾增加 “hay”（“apple” 会变成 “apple-hay”）。牢记 UTF-8 编码！ * 使用哈希 map 和 vector，创建一个文本接口来允许用户向公司的部门中增加员工的名字。例如，“Add Sally to Engineering” 或 “Add Amir to Sales”。接着让用户获取一个部门的所有员工的列表，或者公司每个部门的所有员工按照字母顺排序的列表。 标准库 API 文档中描述的这些类型的方法将有助于你进行这些练习！ From a496a7c0512b049ae85d0d65f150f8d350202685 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 2 Dec 2017 16:24:28 +0800 Subject: [PATCH 067/150] Refactor some translations --- src/ch13-00-functional-features.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/ch13-00-functional-features.md b/src/ch13-00-functional-features.md index 1689ff2..f902586 100644 --- a/src/ch13-00-functional-features.md +++ b/src/ch13-00-functional-features.md @@ -4,13 +4,13 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。这里我们将不会辩论函数式编程到底是什么或不是什么，而是突出展示 Rust 中那些类似很多经常被认为是函数式的语言中功能的功能。 +Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。我们不会在这里讨论函数式编程是或不是什么的问题，而是展示Rust的一些特性，这些特性与许多语言中被称为功能的特性类似。 更具体的，我们将要涉及： -* **闭包**（*Closures*），一个可以储存在变量里的类似函数的结构 +* **闭包**（*Closures*），一个可以储存在变量里的类似函数的结构。 * **迭代器**（*Iterators*），一种处理元素序列的方式。。 -* 如何使用这些功能来改进第十二章的 I/O 项目 +* 如何使用这些功能来改进第十二章的 I/O 项目。 * 这些功能的性能。**剧透高能：** 他们的速度超乎你的想象！ -还有其他受函数式风格影响的 Rust 功能，比如模式匹配和枚举，这些已经在其他章节中讲到过了。掌握闭包和迭代器则是编写符合语言风格的高性能 Rust 代码的重要一环，所以我们将专门用一整章来讲解他们。 +还有其它受函数式风格影响的 Rust 功能，比如模式匹配和枚举，这些已经在其他章节中讲到过了。掌握闭包和迭代器则是编写符合语言风格的高性能 Rust 代码的重要一环，所以我们将专门用一整章来讲解他们。 From f2c4cdd57bca1811293e4fea2c99695d6106276a Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 2 Dec 2017 16:46:04 +0800 Subject: [PATCH 068/150] Fix typo Add missing ";". --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 0e267bb..4769882 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -83,7 +83,7 @@ fn generate_workout(intensity: i32, random_number: i32) { println!( "Today, run for {} minutes!", simulated_expensive_calculation(intensity) - ) + ); } } } From 3169179cba94b8f40c1c7962827d634cecbf5359 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 2 Dec 2017 16:50:10 +0800 Subject: [PATCH 069/150] Refactor some translations --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 0e267bb..cad8c3b 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -93,7 +93,7 @@ fn generate_workout(intensity: i32, random_number: i32) { 示例 13-3 中的代码有多处慢计算函数的调用。第一个 `if` 块调用了 `simulated_expensive_calculation` 两次，外部 `else` 中的 `if` 完全没有调用它，`else` 中的 `else` 调用了它一次。 -`generate_workout` 函数的合意的行为是首先检查用户需要低强度（由小于 25 的系数代表）锻炼还是高强度（25 或以上）锻炼。低强度锻炼计划会根据由 `simulated_expensive_calculation` 函数所模拟的复杂算法建议一定数量的俯卧撑和仰卧起坐，此函数需要强度系数作为输入。 +`generate_workout` 函数的期望行为是首先检查用户需要低强度（由小于 25 的系数表示）锻炼还是高强度（25 或以上）锻炼。低强度锻炼计划会根据由 `simulated_expensive_calculation` 函数所模拟的复杂算法建议一定数量的俯卧撑和仰卧起坐，此函数需要强度系数作为输入。 如果用户需要高强度锻炼，这里有一些额外的逻辑：如果 app 生成的随机数刚好是 3，app 相反会建议用户稍做休息并补充水分。如果不是，则用户会从复杂算法中得到数分钟跑步的高强度锻炼计划。 From e7bc850dccbf8c21ecbbb71b5d5e564542743bb4 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 2 Dec 2017 17:10:17 +0800 Subject: [PATCH 070/150] Fix typo --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 505e369..18166f3 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -214,7 +214,7 @@ fn generate_workout(intensity: i32, random_number: i32) { ### 闭包类型推断和注解 -闭包与由 `fn` 函数定义的函数有一些区别。第一是不要求像 `fn` 函数那样在参数和返回值上注明类型。 +闭包与由 `fn` 关键字定义的函数有一些区别。第一是不要求像 `fn` 函数那样在参数和返回值上注明类型。 函数中需要类型注解是因为他们是暴露给用户的显式接口的一部分。严格的定义这些接口对于保证所有人都认同函数使用和返回值的类型来说是很重要的。但是闭包并不用于这样暴露在外的接口：他们储存在变量中并被使用，不用命名他们或暴露给库的用户调用。 From 1afd665e3889acad38e1e9bc37b35c2586f269ab Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 2 Dec 2017 17:16:40 +0800 Subject: [PATCH 071/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "对其" to "对齐". --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 505e369..20c9483 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -237,7 +237,7 @@ let expensive_closure = |num: i32| -> i32 { 示例 13-7：为闭包的参数和返回值增加可选的类型注解 -有了类型注解闭包的语法就更类似函数了。如下是一个对其参数加一的函数的定义与拥有相同行为闭包语法的纵向对比。这里增加了一些空格来对其相应部分。这展示了闭包语法如何类似于函数语法，除了使用竖线而不是括号以及几个可选的语法： +有了类型注解闭包的语法就更类似函数了。如下是一个对其参数加一的函数的定义与拥有相同行为闭包语法的纵向对比。这里增加了一些空格来对齐相应部分。这展示了闭包语法如何类似于函数语法，除了使用竖线而不是括号以及几个可选的语法： ```rust,ignore fn add_one_v1 (x: i32) -> i32 { x + 1 } From 7a078153873acf14909daab1409666ac5ba01b89 Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 2 Dec 2017 17:26:54 +0800 Subject: [PATCH 072/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "结果提" to "结构体". --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 505e369..9274d34 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -304,7 +304,7 @@ struct Cacher 示例 13-9：定义一个 `Cacher` 结构体来在 `calculation` 中存放闭包并在 `value` 中存放 Option 值 -结果提 `Cacher` 有一个泛型 `T` 的字段 `calculation`。`T` 的 trait bound 指定了 `T` 是一个使用 `Fn` 的闭包。任何我们希望储存到 `Cacher` 实例的 `calculation` 字段的闭包必须有一个 `i32` 参数（由 `Fn` 之后的括号的内容指定）并必须返回一个 `i32`（由 `->` 之后的内容）。 +结构体 `Cacher` 有一个泛型  `T` 的字段 `calculation`。`T` 的 trait bound 指定了 `T` 是一个使用 `Fn` 的闭包。任何我们希望储存到 `Cacher` 实例的 `calculation` 字段的闭包必须有一个 `i32` 参数（由 `Fn` 之后的括号的内容指定）并必须返回一个 `i32`（由 `->` 之后的内容）。 `value` 是 `Option` 类型的。在执行闭包之前，`value` 将是 `None`。如果使用 `Cacher` 的代码请求闭包的结果，这时会执行闭包并将结果储存在 `value` 字段的 `Some` 成员中。接着如果代码再次请求闭包的结果，这时不再执行闭包，而是会返回存放在 `Some` 成员中的结果。 From 09acd3f1cf34871086a8d9eed9127a5af9e1830b Mon Sep 17 00:00:00 2001 From: Spartucus Date: Sat, 2 Dec 2017 17:30:28 +0800 Subject: [PATCH 073/150] Fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit change from "油管" to "有关". --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 505e369..b45ca0d 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -308,7 +308,7 @@ struct Cacher `value` 是 `Option` 类型的。在执行闭包之前，`value` 将是 `None`。如果使用 `Cacher` 的代码请求闭包的结果，这时会执行闭包并将结果储存在 `value` 字段的 `Some` 成员中。接着如果代码再次请求闭包的结果，这时不再执行闭包，而是会返回存放在 `Some` 成员中的结果。 -刚才讨论的油管 `value` 字段逻辑定义于示例 13-10： +刚才讨论的有关 `value` 字段逻辑定义于示例 13-10： 文件名: src/main.rs From 51e5b7f6b428db1156c99a9cfe12c610fa422128 Mon Sep 17 00:00:00 2001 From: Yu Sun Date: Sun, 3 Dec 2017 12:57:14 +0800 Subject: [PATCH 074/150] =?UTF-8?q?=E6=8C=89=E7=85=A7=E4=B9=8B=E5=89=8D?= =?UTF-8?q?=E7=9A=84=E8=A7=84=E8=8C=83=EF=BC=8C=E6=AD=A4=E5=A4=84=E5=B0=91?= =?UTF-8?q?=E4=B8=80=E4=B8=AA=E7=A9=BA=E6=A0=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch11-01-writing-tests.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch11-01-writing-tests.md b/src/ch11-01-writing-tests.md index a2d3b65..7aaf8fa 100644 --- a/src/ch11-01-writing-tests.md +++ b/src/ch11-01-writing-tests.md @@ -340,7 +340,7 @@ test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured 注意在一些语言和测试框架中，断言两个值相等的函数的参数叫做 `expected` 和 `actual`，而且指定参数的顺序是需要注意的。然而在 Rust 中，他们则叫做 `left` 和 `right`，同时指定期望的值和被测试代码产生的值的顺序并不重要。这个测试中的断言也可以写成 `assert_eq!(add_two(2), 4)`，这时错误信息会变成 `` assertion failed: `(left == right)` (left: `5`, right: `4`) ``。 -`assert_ne!` 宏在传递给它的两个值不相等时通过而在相等时失败。这个宏在代码按照我们期望运行时不确定值 **会** 是什么，不过知道他们绝对 **不会**是什么的时候最有用处。例如，如果一个函数确定会以某种方式改变其输出，不过这种方式由运行测试是星期几来决定，这时最好的断言可能就是函数的输出不等于其输入。 +`assert_ne!` 宏在传递给它的两个值不相等时通过而在相等时失败。这个宏在代码按照我们期望运行时不确定值 **会** 是什么，不过知道他们绝对 **不会** 是什么的时候最有用处。例如，如果一个函数确定会以某种方式改变其输出，不过这种方式由运行测试是星期几来决定，这时最好的断言可能就是函数的输出不等于其输入。 `assert_eq!` 和 `assert_ne!` 宏在底层分别使用了 `==` 和 `!=`。当断言失败时，这些宏会使用调试格式打印出其参数，这意味着被比较的值必需实现了 `PartialEq` 和 `Debug` trait。所有的基本类型和大部分标准库类型都实现了这些 trait。对于自定义的结构体和枚举，需要实现 `PartialEq` 才能断言他们的值是否相等。需要实现 `Debug` 才能在断言失败时打印他们的值。因为这两个 trait 都是可推导 trait，如第五章所提到的，通常可以直接在结构体或枚举上添加 `#[derive(PartialEq, Debug)]` 注解。附录 C 中有更多关于这些和其他可推导 trait 的详细信息。 From d00f5bb0c711cb7602e0cf0bdb387c30cdf13af3 Mon Sep 17 00:00:00 2001 From: Alex Chen Date: Mon, 4 Dec 2017 11:56:01 +0800 Subject: [PATCH 075/150] Improve readability --- src/ch01-02-hello-world.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index 408e36e..d33197f 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -188,9 +188,9 @@ authors = ["Your Name "] 第一行，`[package]`，是一个段落标题，表明下面的语句用来配置一个包。随着我们在这个文件增加更多的信息，还将增加其他段落。 -接下来的三行设置了三个 Cargo 所需的配置，他们告诉 Cargo 需要编译这个项目：名称、版本和作者。Cargo 从环境中获取你的名称和 email 信息。如果不正确，请修改并保存此文件。 +接下来的三行设置了三个 Cargo 所需的配置，项目的名称、版本和作者，它们告诉 Cargo 需要编译这个项目。Cargo 从环境中获取你的名称和 email 信息。如果不正确，请修改并保存此文件。 -最后一行，`[dependencies]`，是项目依赖的 *crates* 列表（我们这样称呼 Rust 代码包）段落的开始，这样 Cargo 就知道下载和编译它们了。这个项目并不需要任何其他的 crate，不过在下一章猜猜看教程会用得上。 +最后一行，`[dependencies]`，是项目依赖的 *crates* 列表（我们称呼 Rust 代码包为 crate）段落的开始，这样 Cargo 就知道应该下载和编译它们了。这个项目并不需要任何其他的 crate，不过在下一章猜猜看教程会用得上。 现在看看 *src/main.rs*： @@ -213,21 +213,21 @@ Cargo 期望源文件位于 *src* 目录，将项目根目录留给 README、lic ### 构建并运行 Cargo 项目 -现在让我们看看通过 Cargo 构建和运行 Hello World 程序有什么不同。为此，输入如下命令： +现在让我们看看通过 Cargo 构建和运行 Hello World 程序有什么不同。为此输入下面的命令： ```text $ cargo build Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo) ``` -这应该会创建 *target/debug/hello_cargo*（或者在 Windows 上是 *target\debug\hello_cargo.exe*）可执行文件，可以通过这个命令运行： +这应该会创建 *target/debug/hello_cargo*可执行文件（或者在 Windows 上是 *target\debug\hello_cargo.exe*），可以通过这个命令运行： ```text $ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows Hello, world! ``` -好的！如果一切顺利，`Hello, world!`应该再次打印在终端上。 +很好！如果一切顺利，`Hello, world!`应该再次打印在终端上。 首次运行 `cargo build` 的时候，Cargo 会在项目根目录创建一个新文件，*Cargo.lock*，它看起来像这样： From a5682848ab001ae7dee041d2bc299acc86884781 Mon Sep 17 00:00:00 2001 From: Alex Chen Date: Mon, 4 Dec 2017 22:33:03 +0800 Subject: [PATCH 076/150] Modify bit and pieces --- .gitignore | 2 +- src/ch01-00-introduction.md | 2 +- src/ch01-01-installation.md | 4 +-- src/ch01-02-hello-world.md | 8 +++--- src/ch02-00-guessing-game-tutorial.md | 8 +++--- src/ch03-00-common-programming-concepts.md | 6 ++--- src/ch03-01-variables-and-mutability.md | 18 +++++++------ src/ch03-02-data-types.md | 30 +++++++++++----------- src/ch03-03-how-functions-work.md | 30 +++++++++++----------- src/ch03-04-comments.md | 6 ++--- src/ch03-05-control-flow.md | 14 +++++----- 11 files changed, 65 insertions(+), 63 deletions(-) diff --git a/.gitignore b/.gitignore index c1393b1..146ccaf 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,2 @@ _book/ -mdbook/ \ No newline at end of file +mdbook/ diff --git a/src/ch01-00-introduction.md b/src/ch01-00-introduction.md index ac57af3..6679d8c 100644 --- a/src/ch01-00-introduction.md +++ b/src/ch01-00-introduction.md @@ -11,7 +11,7 @@ registry site），[crates.io]！我们由衷期待**你**使用 Rust 进行创 [crates.io]: https://crates.io/ -本书的目标读者至少应了解一门其它编程语言。阅读本书之后，你应该能自如的编写 Rust 程序。我们将通过短小精干、前后呼应的例子来学习 Rust，并展示其多样功能的使用方法，同时了解他们幕后如何运行。 +本书的目标读者至少应了解一门其它编程语言。阅读本书之后，你应该能自如的编写 Rust 程序。我们将通过短小精干、前后呼应的例子来学习 Rust，并展示其多样功能的使用方法，同时了解它们幕后如何运行。 ## 为本书做出贡献 diff --git a/src/ch01-01-installation.md b/src/ch01-01-installation.md index 263617c..6c99cd5 100644 --- a/src/ch01-01-installation.md +++ b/src/ch01-01-installation.md @@ -6,7 +6,7 @@ 使用 Rust 的第一步是安装。你需要网络连接来执行本章的命令，因为将要从网上下载 Rust。 -这里将会展示很多使用终端的命令，这些命令均以 `$` 开头。不需要真的输入`$`，在这里他们代表每行命令的起始。网上有很多教程和例子遵循这种惯例：`$` 代表以常规用户身份运行命令，`#` 代表需要用管理员身份运行命令。没有以 `$`（或 `#`）起始的行通常是之前命令的输出。 +这里将会展示很多使用终端的命令，这些命令均以 `$` 开头。不需要真的输入`$`，在这里它们代表每行命令的起始。网上有很多教程和例子遵循这种惯例：`$` 代表以常规用户身份运行命令，`#` 代表需要用管理员身份运行命令。没有以 `$`（或 `#`）起始的行通常是之前命令的输出。 ### 在 Linux 或 Mac 上安装 @@ -94,4 +94,4 @@ rustc x.y.z (abcabcabc yyyy-mm-dd) 安装程序也自带一份文档的本地拷贝，可以离线阅读。运行 `rustup doc` 在浏览器中查看本地文档。 -任何时候，如果你拿不准标准库中的类型或函数如何工作，请查看 API 文档！ \ No newline at end of file +任何时候，如果你拿不准标准库中的类型或函数如何工作，请查看 API 文档！ diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index d33197f..c0311b1 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -73,7 +73,7 @@ fn main() { } ``` -这几行定义了一个 Rust **函数**。`main` 函数是特殊的：它是每个可执行的 Rust 程序首先执行的。第一行代码表示 “我声明了一个叫做 `main` 的函数，它没有参数也没有返回值。” 如果有参数的话，他们的名称应该出现在括号中，`(`和`)`之间。 +这几行定义了一个 Rust **函数**。`main` 函数是特殊的：它是每个可执行的 Rust 程序首先执行的。第一行代码表示 “我声明了一个叫做 `main` 的函数，它没有参数也没有返回值。” 如果有参数的话，它们的名称应该出现在括号中，`(`和`)`之间。 还须注意函数体被包裹在花括号中，`{`和`}` 之间。Rust 要求所有函数体都要用花括号包裹起来（译者注：有些语言，当函数体只有一行时可以省略花括号，但在 Rust 中是不行的）。一般来说，将左花括号与函数声明置于同一行并以空格分隔，是良好的代码风格。 @@ -124,13 +124,13 @@ $ ./main # or .\main.exe on Windows 如果 *main.rs* 是上文所述的 “Hello, world!” 程序，它将会在终端上打印 `Hello, world!`。 -来自 Ruby、Python 或 JavaScript 这样的动态类型语言背景的同学，可能不太习惯将编译和执行分为两个单独的步骤。Rust 是一种 **预编译静态类型语言**（*ahead-of-time compiled language*），这意味着你可以编译程序并将其交与他人，他们不需要安装 Rust 即可运行。相反如果你给他们一个 `.rb`、`.py` 或 `.js` 文件，他们需要先分别安装 Ruby，Python，JavaScript 实现（运行时环境，VM），不过你只需要一句命令就可以编译和执行程序。这一切都是语言设计上的权衡取舍。 +来自 Ruby、Python 或 JavaScript 这样的动态类型语言背景的同学，可能不太习惯将编译和执行分为两个单独的步骤。Rust 是一种 **预编译静态类型语言**（*ahead-of-time compiled language*），这意味着你可以编译程序并将其交与他人，它们不需要安装 Rust 即可运行。相反如果你给他们一个 `.rb`、`.py` 或 `.js` 文件，他们需要先分别安装 Ruby，Python，JavaScript 实现（运行时环境，VM），不过你只需要一句命令就可以编译和执行程序。这一切都是语言设计上的权衡取舍。 使用 `rustc` 编译简单程序是没问题的，不过随着项目的增长，你可能需要控制你项目的方方面面，并且更容易地将代码分享给其它人或项目。接下来，我们要介绍一个叫做 Cargo 的工具，它会帮助你编写真实世界中的 Rust 程序。 ## Hello, Cargo! -Cargo 是 Rust 的构建系统和包管理工具，同时 Rustacean 们使用 Cargo 来管理他们的 Rust 项目，它使得很多任务变得更轻松。例如，Cargo 负责构建代码、下载依赖库并编译他们。我们把代码需要的库叫做 **依赖**（*dependencies*）。 +Cargo 是 Rust 的构建系统和包管理工具，同时 Rustacean 们使用 Cargo 来管理他们的 Rust 项目，它使得很多任务变得更轻松。例如，Cargo 负责构建代码、下载依赖库并编译它们。我们把代码需要的库叫做 **依赖**（*dependencies*）。 最简单的 Rust 程序，比如我们刚刚编写的，并没有任何依赖，所以我们只使用了 Cargo 构建代码的功能。随着编写的程序更加复杂，你会想要添加依赖，如果你使用 Cargo 开始的话，这将会变得简单许多。 @@ -267,7 +267,7 @@ Cargo 的另一个优点是，不管你使用什么操作系统其命令都是 ### 发布（release）构建 -当项目最终准备好发布了，可以使用 `cargo build --release` 来优化编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。这也就是为什么会有两种不同的配置：一种为了开发，你需要经常快速重新构建；另一种为了构建给用户最终程序，他们不会重新构建，并且希望程序运行得越快越好。如果你在测试代码的运行时间，请确保运行 `cargo build --release` 并使用 *target/release* 下的可执行文件进行测试。 +当项目最终准备好发布了，可以使用 `cargo build --release` 来优化编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。这也就是为什么会有两种不同的配置：一种为了开发，你需要经常快速重新构建；另一种为了构建给用户最终程序，它们不会重新构建，并且希望程序运行得越快越好。如果你在测试代码的运行时间，请确保运行 `cargo build --release` 并使用 *target/release* 下的可执行文件进行测试。 ### 把 Cargo 当作习惯 diff --git a/src/ch02-00-guessing-game-tutorial.md b/src/ch02-00-guessing-game-tutorial.md index 692295e..e56a24a 100644 --- a/src/ch02-00-guessing-game-tutorial.md +++ b/src/ch02-00-guessing-game-tutorial.md @@ -4,7 +4,7 @@ >
> commit 2e269ff82193fd65df8a87c06561d74b51ac02f7 -让我们一起动手完成一个项目，来快速上手 Rust！本章将介绍 Rust 中常用的一些概念，并通过真实的程序来展示如何运用他们。你将会学到更多诸如 `let`、`match`、方法、关联函数、外部 crate 等很多的知识！后继章节会深入探索这些概念的细节。在这一章，我们将练习基础。 +让我们一起动手完成一个项目，来快速上手 Rust！本章将介绍 Rust 中常用的一些概念，并通过真实的程序来展示如何运用它们。你将会学到更多诸如 `let`、`match`、方法、关联函数、外部 crate 等很多的知识！后继章节会深入探索这些概念的细节。在这一章，我们将练习基础。 我们会实现一个经典的新手编程问题：猜猜看游戏。它是这么工作的：程序将会随机生成一个 1 到 100 之间的随机整数。接着它会请玩家猜一个数并输入，然后提示猜测是大了还是小了。如果猜对了，它会打印祝贺信息并退出。 @@ -396,11 +396,11 @@ Please input your guess. You guessed: 5 ``` -你应该能得到不同的随机数，同时他们应该都是在 1 和 100 之间的。干得漂亮！ +你应该能得到不同的随机数，同时它们应该都是在 1 和 100 之间的。干得漂亮！ ## 比较猜测与秘密数字 -现在有了用户输入和一个随机数，我们可以比较他们。这个步骤如示例 2-4 所示： +现在有了用户输入和一个随机数，我们可以比较它们。这个步骤如示例 2-4 所示： 文件名: src/main.rs @@ -762,4 +762,4 @@ fn main() { 此时此刻，你顺利完成了猜猜看游戏！恭喜！ -这是一个通过动手实践学习 Rust 新概念的项目：`let`、`match`、方法、关联函数、使用外部 crate 等等，接下来的几章，我们将会继续深入。第三章涉及到大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用他们。第四章探索所有权（ownership），这是一个 Rust 同其他语言大不相同的功能。第五章讨论结构体和方法的语法，而第六章侧重解释枚举。 +这是一个通过动手实践学习 Rust 新概念的项目：`let`、`match`、方法、关联函数、使用外部 crate 等等，接下来的几章，我们将会继续深入。第三章涉及到大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用它们。第四章探索所有权（ownership），这是一个 Rust 同其他语言大不相同的功能。第五章讨论结构体和方法的语法，而第六章侧重解释枚举。 diff --git a/src/ch03-00-common-programming-concepts.md b/src/ch03-00-common-programming-concepts.md index 95daa4d..562b11b 100644 --- a/src/ch03-00-common-programming-concepts.md +++ b/src/ch03-00-common-programming-concepts.md @@ -4,10 +4,10 @@ >
> commit 04aa3a45eb72855b34213703718f50a12a3eeec8 -本章涉及一些几乎所有编程语言都有的概念，以及他们在 Rust 中是如何工作的。很多编程语言的核心概念都是共通的，本章中展示的概念都不是 Rust 特有的，不过我们会在 Rust 环境中讨论他们，解释他们的使用习惯。 +本章涉及一些几乎所有编程语言都有的概念，以及它们在 Rust 中是如何工作的。很多编程语言的核心概念都是共通的，本章中展示的概念都不是 Rust 特有的，不过我们会在 Rust 环境中讨论它们，解释它们的使用习惯。 -具体的，我们将会学习变量，基本类型，函数，注释和控制流。这些基础知识将会出现在每一个 Rust 程序中，提早学习这些概念会使你拥有坚实的起步基础。 +具体地，我们将会学习变量，基本类型，函数，注释和控制流。这些基础知识将会出现在每一个 Rust 程序中，提早学习这些概念会为你奠定坚实的起步基础。 > ### 关键字 > -> Rust 语言有一系列保留的 **关键字**（*keywords*），只能由语言本身使用，像大部分语言一样。你不能使用这些关键字作为变量或函数的名称，大部分关键字有特殊的意义，并被用来完成 Rust 程序中的各种任务；一些关键字目前没有相应的功能，是为将来可能添加的功能保留的。可以在附录 A 中找到关键字的列表。 +> Rust 语言有一系列保留的 **关键字**（*keywords*），就像大部分语言一样，它们只能由语言本身使用，你不能使用这些关键字作为变量或函数的名称。大部分关键字有特殊的意义，并被用来完成 Rust 程序中的各种任务；一些关键字目前没有相应的功能，是为将来可能添加的功能保留的。可以在附录 A 中找到关键字的列表。 diff --git a/src/ch03-01-variables-and-mutability.md b/src/ch03-01-variables-and-mutability.md index 6d7200b..2caf8ae 100644 --- a/src/ch03-01-variables-and-mutability.md +++ b/src/ch03-01-variables-and-mutability.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -第二章中提到过，变量默认是 **不可变**（*immutable*）的。这是利用 Rust 安全和简单并发的优势编写代码一大助力。不过，变量仍然有可变的选项。让我们探讨一下 Rust 拥抱不可变性的原因及方法，以及何时你不想使用不可变性。 +第二章中提到过，变量默认是 **不可变**（*immutable*）的。这是利用 Rust 安全和简单并发的优势编写代码一大助力。不过，你仍然可以使用可变变量。让我们探讨一下 Rust 拥抱不可变性的原因及方法，以及何时你不想使用不可变性。 当变量不可变时，意味着一旦值被绑定上一个名称，你就不能改变这个值。作为说明，通过 `cargo new --bin variables` 在 *projects* 目录生成一个叫做 *variables* 的新项目。 @@ -34,13 +34,15 @@ error[E0384]: re-assignment of immutable variable `x` | ^^^^^ re-assignment of immutable variable ``` -这个例子展示了编译器如何帮助你找出程序中的错误。虽然编译错误令人沮丧，那也不过是说程序不能安全的完成你想让它完成的工作；而 **不能** 说明你是不是一个好程序员！有经验的 Rustacean 们一样会遇到编译错误。这些错误给出的原因是 `对不可变变量重新赋值`（`re-assignment of immutable variable`），因为我们尝试对不可变变量 `x` 赋第二个值。 +这个例子展示了编译器如何帮助你找出程序中的错误。虽然编译错误令人沮丧，那也不过是说程序不能安全的完成你想让它完成的工作；而 **不能** 说明你是不是一个好程序员！有经验的 Rustacean 们一样会遇到编译错误。 -尝试去改变预设为不可变的值，产生编译错误是很重要的，因为这种情况可能导致 bug：如果代码的一部分假设一个值永远也不会改变，而另一部分代码改变了它，第一部分代码就有可能以不可预料的方式运行。不得不承认这种 bug 难以跟踪，尤其是第二部分代码只是 **有时** 改变其值。 +这些错误给出的原因是 `对不可变变量重新赋值`（`re-assignment of immutable variable`），因为我们尝试对不可变变量 `x` 赋第二个值。 + +在尝试改变预设为不可变的值的时候产生编译错误是很重要的，因为这种情况可能导致 bug：如果代码的一部分假设一个值永远也不会改变，而另一部分代码改变了它，第一部分代码就有可能以不可预料的方式运行。不得不承认这种 bug 难以跟踪，尤其是第二部分代码只是 **有时** 改变其值。 Rust 编译器保证，如果声明一个值不会变，它就真的不会变。这意味着当阅读和编写代码时，不需要记住如何以及哪里可能会被改变，从而使得代码易于推导。 -不过可变性也是非常有用的。变量只是默认不可变；可以通过在变量名之前加 `mut` 来使其可变。除了使值可以改变之外，它向读者表明了其他代码将会改变这个变量的意图。 +不过可变性也是非常有用的。变量只是默认不可变，可以通过在变量名之前加 `mut` 来使其可变。除了使值可以改变之外，它向读者表明了其他代码将会改变这个变量的意图。 例如，改变 *src/main.rs* 并替换其代码为如下： @@ -65,9 +67,9 @@ The value of x is: 5 The value of x is: 6 ``` -通过 `mut`，允许把绑定到 `x` 的值从 `5` 改成 `6`。在一些情况下，你会想要一个变量可变，因为相对只有不可变的风格更容易编写。 +通过 `mut`，允许把绑定到 `x` 的值从 `5` 改成 `6`。在一些情况下，你会想用可变变量，因为这样的代码比起只用不可变变量的更容易编写。 -除了避免 bug 外，还有多处需要权衡取舍。例如，使用大型数据结构时，适当地使变量可变，可能比复制和返回新分配的实例更快。对于较小的数据结构，总是创建新实例，采用更偏向函数式的风格编程，可能会使代码更易理解，为可读性而遭受性能惩罚或许值得。 +除了避免 bug 外，还有很多地方需要权衡取舍。例如，使用大型数据结构时，适当地使用可变变量，可能比复制和返回新分配的实例更快。对于较小的数据结构，总是创建新实例，采用更偏向函数式的风格编程，可能会使代码更易理解，为可读性而遭受性能惩罚或许值得。 ### 变量和常量的区别 @@ -87,7 +89,7 @@ The value of x is: 6 const MAX_POINTS: u32 = 100_000; ``` -常量在整个程序生命周期中都有效，位于它声明的作用域之中。这使得常量可以作为多处代码使用的全局范围的值，例如一个游戏中所有玩家可以获取的最高分或者光速。 +在声明它的作用域之中，常量在整个程序生命周期中都有效，这使得常量可以作为多处代码使用的全局范围的值，例如一个游戏中所有玩家可以获取的最高分或者光速。 将用于整个程序的硬编码的值声明为常量对后来的维护者了解值的意义很有帮助。它也能将硬编码的值汇总一处，为将来可能的修改提供方便。 @@ -147,4 +149,4 @@ error[E0308]: mismatched types found type `usize` ``` -现在我们探索了变量如何工作，让我们看看更多的数据类型。 \ No newline at end of file +现在我们已经了解了变量如何工作，让我们再看看更多的数据类型。 diff --git a/src/ch03-02-data-types.md b/src/ch03-02-data-types.md index bc91f28..8bc72c0 100644 --- a/src/ch03-02-data-types.md +++ b/src/ch03-02-data-types.md @@ -4,9 +4,9 @@ >
> commit f4bce88a0f4c09aaf0c996021729c6d42907bc2a -在 Rust 中，任何值都属于一种明确的 **类型**（*type*），这告诉了 Rust 它被指定了何种数据，以便明确其处理方式。我们将分两部分探讨一些内建类型：标量（scalar）和复合（compound）。 +在 Rust 中，任何值都属于一种明确的 **类型**（*type*），这告诉了 Rust 它被指定为何种数据，以便明确其处理方式。我们将分两部分探讨一些内建类型：标量（scalar）和复合（compound）。 -Rust 是 **静态类型**（*statically typed*）语言，也就是说在编译时就必须知道所有变量的类型，这一认知将贯穿整个章节，请在头脑中明确。通过值的形式及其使用方式，编译器通常可以推断出我们想要用的类型。多种类型均有可能时，比如第二章中使用 `parse` 将 `String` 转换为数字时，必须增加类型注解，像这样： +Rust 是 **静态类型**（*statically typed*）语言，也就是说在编译时就必须知道所有变量的类型，这一点将贯穿整个章节。通过值的形式及其使用方式，编译器通常可以推断出我们想要用的类型。多种类型均有可能时，比如第二章中使用 `parse` 将 `String` 转换为数字时，必须增加类型注解，像这样： ```rust let guess: u32 = "42".parse().expect("Not a number!"); @@ -28,7 +28,7 @@ error[E0282]: unable to infer enough type information about `_` ### 标量类型 -**标量**（*scalar*）类型代表一个单独的值。Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。你可能在其他语言中见过他们，不过让我们深入了解他们在 Rust 中时如何工作的。 +**标量**（*scalar*）类型代表一个单独的值。Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。你可能在其他语言中见过它们，不过让我们深入了解它们在 Rust 中时如何工作的。 #### 整型 @@ -48,9 +48,9 @@ error[E0282]: unable to infer enough type information about `_` 每一个有符号的变体可以储存包含从 -(2n - 1) 到 2n - 1 - 1 在内的数字，这里 `n` 是变体使用的位数。所以 `i8` 可以储存从 -(27) 到 27 - 1 在内的数字，也就是从 -128 到 127。无符号的变体可以储存从 0 到 2n - 1 的数字，所以 `u8` 可以储存从 0 到 28 - 1 的数字，也就是从 0 到 255。 -另外，`isize` 和 `usize` 类型依赖运行程序的计算机架构：64 位架构上他们是 64 位的， 32 位架构上他们是 32 位的。 +另外，`isize` 和 `usize` 类型依赖运行程序的计算机架构：64 位架构上它们是 64 位的， 32 位架构上它们是 32 位的。 -可以使用表格 3-2 中的任何一种形式编写数字字面值。注意除字节以外的其它字面值允许使用类型后缀，例如 `57u8`，同时也允许使用 `_` 做为分隔符以方便读数，例如`1_000`。 +可以使用表格 3-2 中的任何一种形式编写数字字面值。注意除 byte 以外的其它字面值允许使用类型后缀，例如 `57u8`，同时也允许使用 `_` 做为分隔符以方便读数，例如`1_000`。 表格 3-2: Rust 中的整型字面值 @@ -84,7 +84,7 @@ fn main() { #### 数字运算符 -Rust 支持所有数字类型常见的基本数学运算操作：加法、减法、乘法、除法以及余数。如下代码展示了如何使用一个 `let` 语句来使用他们： +Rust 支持所有数字类型常见的基本数学运算操作：加法、减法、乘法、除法以及取余。下面的代码展示了如何在一个 `let` 语句中使用它们： 文件名: src/main.rs @@ -107,7 +107,7 @@ fn main() { } ``` -这些语句中的每个表达式使用了一个数学运算符并计算出了一个值，他们绑定到了一个变量。附录 B 包含了一个 Rust 提供的所有运算符的列表。 +这些语句中的每个表达式使用了一个数学运算符并计算出了一个值，它们绑定到了一个变量。附录 B 包含了一个 Rust 提供的所有运算符的列表。 #### 布尔型 @@ -123,7 +123,7 @@ fn main() { } ``` -使用布尔值的主要场景是条件表达式，例如 `if` 表达式。在 “控制流”（“Control Flow”）部分将讲到`if`表达式在 Rust 中如何工作。 +使用布尔值的主要场景是条件表达式，例如 `if` 表达式。在 “控制流”（“Control Flow”）部分将讲到 `if` 表达式在 Rust 中如何工作。 #### 字符类型 @@ -139,7 +139,7 @@ fn main() { } ``` -Rust 的 `char` 类型代表了一个 Unicode 标量值（Unicode Scalar Value），这意味着它可以比 ASCII 表示更多内容。拼音字母（Accented letters），中文/日文/汉语等象形文字，emoji（絵文字）以及零长度的空白字符对于 Rust `char`类型都是有效的。Unicode 标量值包含从 `U+0000` 到 `U+D7FF` 和 `U+E000` 到 `U+10FFFF` 之间的值。不过，“字符” 并不是一个 Unicode 中的概念，所以人直觉上的 “字符” 可能与 Rust 中的 `char` 并不符合。第八章的 “字符串” 部分将详细讨论这个主题。 +Rust 的 `char` 类型代表了一个 Unicode 标量值（Unicode Scalar Value），这意味着它可以比 ASCII 表示更多内容。拼音字母（Accented letters），中文/日文/韩文等象形文字，emoji（絵文字）以及零长度的空白字符对于 Rust `char` 类型都是有效的。Unicode 标量值包含从 `U+0000` 到 `U+D7FF` 和 `U+E000` 到 `U+10FFFF` 之间的值。不过，“字符” 并不是一个 Unicode 中的概念，所以人直觉上的 “字符” 可能与 Rust 中的 `char` 并不符合。第八章的 “字符串” 部分将详细讨论这个主题。 ### 复合类型 @@ -173,9 +173,9 @@ fn main() { } ``` -程序首先创建了一个元组并绑定到 `tup` 变量上。接着使用了 `let` 和一个模式将 `tup` 分成了三个不同的变量，`x`、`y` 和 `z`。这叫做 *解构*（*destructuring*），因为它将一个元组拆成了三个部分。最后，程序打印出了 `y` 的值，也就是 `6.4`。 +程序首先创建了一个元组并绑定到 `tup` 变量上。接着使用了 `let` 和一个模式将 `tup` 分成了三个不同的变量，`x`、`y` 和 `z`。这叫做 **解构**（*destructuring*），因为它将一个元组拆成了三个部分。最后，程序打印出了 `y` 的值，也就是 `6.4`。 -除了使用模式匹配解构之外，也可以使用点号（`.`）后跟值的索引来直接访问他们。例如： +除了使用模式匹配解构之外，也可以使用点号（`.`）后跟值的索引来直接访问它们。例如： 文件名: src/main.rs @@ -195,7 +195,7 @@ fn main() { #### 数组 -另一个获取一个多个值集合的方式是 **数组**（*array*）。与元组不同，数组中的每个元素的类型必须相同。Rust 中的数组与一些其他语言中的数组不同，因为 Rust 中的数组是固定长度的：一旦声明，他们的长度不能增长或缩小。 +另一个获取一个多个值集合的方式是 **数组**（*array*）。与元组不同，数组中的每个元素的类型必须相同。Rust 中的数组与一些其他语言中的数组不同，因为 Rust 中的数组是固定长度的：一旦声明，它们的长度不能增长或缩小。 Rust 中数组的值位于中括号中的逗号分隔的列表中： @@ -207,9 +207,9 @@ fn main() { } ``` -数组需要在栈（stack）而不是在堆（heap）上为数据分配空间时（第四章将讨论栈与堆的更多内容），或者是想要确保总是有固定数量的元素时十分有用。虽然它并不如 vector 类型那么灵活。vector 类型是标准库提供的一个 **允许** 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，你可能应该使用 vector：第八章会详细讨论 vector。 +当你想要在栈（stack）而不是在堆（heap）上为数据分配空间（第四章将讨论栈与堆的更多内容），或者是想要确保总是有固定数量的元素时，数组非常有用，虽然它并不如 vector 类型那么灵活。vector 类型是标准库提供的一个 **允许** 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，你可能应该使用 vector。第八章会详细讨论 vector。 -一个你可能想要使用数组而不是 vector 的例子是当程序需要知道一年中月份的名字时。程序不大可能会去增加或减少月份，这时你可以使用数组因为我们知道它总是含有 12 个元素： +一个你可能想要使用数组而不是 vector 的例子是，当程序需要知道一年中月份的名字时，程序不大可能会去增加或减少月份。这时你可以使用数组，因为我们知道它总是含有 12 个元素： ```rust let months = ["January", "February", "March", "April", "May", "June", "July", @@ -235,7 +235,7 @@ fn main() { ##### 无效的数组元素访问 -如果我们访问数组结尾之后的元素会发生什么呢？比如我们将上面的例子改为如下： +如果我们访问数组结尾之后的元素会发生什么呢？比如我们将上面的例子改成下面这样： 文件名: src/main.rs diff --git a/src/ch03-03-how-functions-work.md b/src/ch03-03-how-functions-work.md index 8e71833..5cc0cad 100644 --- a/src/ch03-03-how-functions-work.md +++ b/src/ch03-03-how-functions-work.md @@ -24,7 +24,7 @@ fn another_function() { Rust 中的函数定义以 `fn` 开始并在函数名后跟一对括号。大括号告诉编译器哪里是函数体的开始和结尾。 -可以使用定义过的函数名后跟括号来调用任意函数。因为 `another_function` 已经在程序中定义过了，它可以在 `main` 函数中被调用。注意，源码中 `another_function` 在 `main` 函数 **之后** 被定义；也可以在其之前定义。Rust 不关心函数定义于何处，只要他们被定义了。 +可以使用定义过的函数名后跟括号来调用任意函数。因为 `another_function` 已经在程序中定义过了，它可以在 `main` 函数中被调用。注意，源码中 `another_function` 在 `main` 函数 **之后** 被定义；也可以在其之前定义。Rust 不关心函数定义于何处，只要它们被定义了。 让我们开始一个叫做 *functions* 的新二进制项目来进一步探索函数。将上面的 `another_function` 例子写入 *src/main.rs* 中并运行。你应该会看到如下输出： @@ -36,11 +36,11 @@ Hello, world! Another function. ``` -代码在 `main` 函数中按照他们出现的顺序被执行。首先，打印 “Hello, world!” 信息，接着 `another_function` 被调用并打印它的信息。 +代码在 `main` 函数中按照它们出现的顺序被执行。首先，打印 “Hello, world!” 信息，接着 `another_function` 被调用并打印它的信息。 ### 函数参数 -函数也可以被定义为拥有 **参数**（*parameters*），他们是作为函数签名一部分的特殊变量。当函数拥有参数时，可以为这些参数提供具体的值。技术上讲，这些具体值被称为参数（ *arguments*），不过通常的习惯是倾向于在函数定义中的变量和调用函数时传递的具体值都可以用 “parameter” 和 “argument” 而不加区别。 +函数也可以被定义为拥有 **参数**（*parameters*），它们是作为函数签名一部分的特殊变量。当函数拥有参数时，可以为这些参数提供具体的值。技术上讲，这些具体值被称为参数（*arguments*），不过通常的习惯是倾向于在函数定义中的变量和调用函数时传递的具体值都可以用 “parameter” 和 “argument” 而不加区别。 如下被重写的 `another_function` 版本展示了 Rust 中参数是什么样的： @@ -67,9 +67,9 @@ The value of x is: 5 `another_function` 的声明有一个叫做 `x` 的参数。`x` 的类型被指定为 `i32`。当 `5` 被传递给 `another_function` 时，`println!` 宏将 `5` 放入格式化字符串中大括号的位置。 -在函数签名中，**必须** 声明每个参数的类型。这是 Rust 设计中一个经过慎重考虑的决定：要求在函数定义中提供类型注解意味着编译器再也不需要在别的地方要求你注明类型就能知道你的意图。 +在函数签名中 **必须** 声明每个参数的类型。这是 Rust 设计中一个经过慎重考虑的决定：要求在函数定义中提供类型注解意味着编译器不需要在别的地方要求你注明类型就能知道你的意图。 -当一个函数有多个参数时，使用逗号隔开他们，像这样： +当一个函数有多个参数时，使用逗号隔开它们，像这样： 文件名: src/main.rs @@ -84,9 +84,9 @@ fn another_function(x: i32, y: i32) { } ``` -这个例子创建了一个有两个参数的函数，都是 `i32` 类型的。函数打印出了这两个参数的值。注意函数参数并不一定都是相同类型的，这个例子中他们只是碰巧相同罢了。 +这个例子创建了一个有两个参数的函数，都是 `i32` 类型的。函数打印出了这两个参数的值。注意函数参数并不一定都是相同类型的，这个例子中它们只是碰巧相同罢了。 -尝试运行代码。使用上面的例子替换当前 *function* 项目的 *src/main.rs* 文件，并 `cargo run` 运行它： +尝试运行代码。使用上面的例子替换当前 *function* 项目的 *src/main.rs* 文件，并用 `cargo run` 运行它： ```text $ cargo run @@ -96,11 +96,11 @@ The value of x is: 5 The value of y is: 6 ``` -因为我们使用 `5` 作为 `x` 的值和 `6` 作为 `y` 的值来调用函数，这两个字符串和他们的值被相应打印出来。 +因为我们使用 `5` 作为 `x` 的值， `6` 作为 `y` 的值来调用函数，这两个字符串和它们的值被相应打印出来。 ### 函数体 -函数体由一系列的语句和一个可选的表达式构成。目前为止，我们只涉及到了没有结尾表达式的函数，不过我们见过表达式作为了语句的一部分。因为 Rust 是一个基于表达式（expression-based）的语言，这是一个需要理解的（不同于其他语言）重要区别。其他语言并没有这样的区别，所以让我们看看语句与表达式有什么区别以及他们是如何影响函数体的。 +函数体由一系列的语句和一个可选的表达式构成。目前为止，我们只涉及到了没有结尾表达式的函数，不过我们见过表达式作为了语句的一部分。因为 Rust 是一个基于表达式（expression-based）的语言，这是一个需要理解的（不同于其他语言）重要区别。其他语言并没有这样的区别，所以让我们看看语句与表达式有什么区别以及它们是如何影响函数体的。 ### 语句与表达式 @@ -118,7 +118,7 @@ fn main() { 列表 3-3：包含一个语句的 `main` 函数定义 -函数定义也是语句；上面整个例子本身就是一个语句。 +函数定义也是语句，上面整个例子本身就是一个语句。 语句并不返回值。因此，不能把`let`语句赋值给另一个变量，比如下面的例子尝试做的： @@ -144,9 +144,9 @@ error: expected expression, found statement (`let`) = note: variable declaration using `let` is a statement ``` -`let y = 6` 语句并不返回值，所以并没有 `x` 可以绑定的值。这与其他语言不同，例如 C 和 Ruby，他们的赋值语句返回所赋的值。在这些语言中，可以这么写 `x = y = 6` 这样 `x` 和 `y` 的值都是 `6`；这在 Rust 中可不行。 +`let y = 6` 语句并不返回值，所以并没有 `x` 可以绑定的值。这与其他语言不同，例如 C 和 Ruby，它们的赋值语句返回所赋的值。在这些语言中，可以这么写 `x = y = 6` 这样 `x` 和 `y` 的值都是 `6`；这在 Rust 中可不行。 -表达式计算出一些值，而且他们组成了其余大部分你将会编写的 Rust 代码。考虑一个简单的数学运算，比如 `5 + 6`，这是一个表达式并计算出值 `11`。表达式可以是语句的一部分：在列表 3-3 中有这个语句 `let y = 6;`，`6` 是一个表达式它计算出的值是 `6`。函数调用是一个表达式。宏调用是一个表达式。我们用来创建新作用域的大括号（代码块），`{}`，也是一个表达式，例如： +表达式计算出一些值，而且它们组成了其余大部分你将会编写的 Rust 代码。考虑一个简单的数学运算，比如 `5 + 6`，这是一个表达式并计算出值 `11`。表达式可以是语句的一部分：在列表 3-3 中有这个语句 `let y = 6;`，`6` 是一个表达式，它计算出的值是 `6`。函数调用是一个表达式。宏调用是一个表达式。我们用来创建新作用域的大括号（代码块），`{}`，也是一个表达式，例如： 文件名: src/main.rs @@ -172,11 +172,11 @@ fn main() { } ``` -这个代码块的值是 `4`。这个值作为 `let` 语句的一部分被绑定到 `y` 上。注意结尾没有分号的那一行，与大部分我们见过的代码行不同。表达式并不包含结尾的分号。如果在表达式的结尾加上分号，他就变成了语句，这也就使其不返回一个值。在接下来的探索中记住函数和表达式都返回值就行了。 +是一个代码块，它的值是 `4`。这个值作为 `let` 语句的一部分被绑定到 `y` 上。注意结尾没有分号的那一行，与大部分我们见过的代码行不同。表达式并不包含结尾的分号。如果在表达式的结尾加上分号，他就变成了语句，这也就使其不返回一个值。在接下来的探索中记住函数和表达式都返回值就行了。 ### 函数的返回值 -可以向调用它的代码返回值。并不对返回值命名，不过会在一个箭头（`->`）后声明它的类型。在 Rust 中，函数的返回值等同于函数体最后一个表达式的值。这是一个有返回值的函数的例子： +函数可以向调用它的代码返回值。我们并不对返回值命名，不过会在一个箭头（`->`）后声明它的类型。在 Rust 中，函数的返回值等同于函数体最后一个表达式的值。这是一个有返回值的函数的例子： 文件名: src/main.rs @@ -260,4 +260,4 @@ help: consider removing this semicolon: | ^ ``` -主要的错误信息，“mismatched types,”（类型不匹配），揭示了代码的核心问题。函数`plus_one` 的定义说明它要返回一个 `i32`，不过语句并不返回一个值，这由那个空元组 `()` 表明。因此，这个函数返回了空元组 `()`，这与函数定义相矛盾并导致一个错误。在输出中，Rust 提供了一个可能会对修正问题有帮助的信息：它建议去掉分号，这会修复这个错误。 \ No newline at end of file +主要的错误信息，“mismatched types”（类型不匹配），揭示了代码的核心问题。函数 `plus_one` 的定义说明它要返回一个 `i32`，不过语句并不返回一个值，这由那个空元组 `()` 表明。因此，这个函数返回了空元组 `()`，这与函数定义相矛盾并导致一个错误。在输出中，Rust 提供了一个可能会对修正问题有帮助的信息：它建议去掉分号，这会修复这个错误。 diff --git a/src/ch03-04-comments.md b/src/ch03-04-comments.md index 929a9c6..49516d6 100644 --- a/src/ch03-04-comments.md +++ b/src/ch03-04-comments.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -所有编程语言都力求使他们的代码易于理解，不过有时需要提供额外的解释。在这种情况下，程序员在源码中留下记录，或者 **注释**（*comments*），编译器会忽略他们不过其他阅读代码的人可能会用得上。 +所有编程语言都力求使它们的代码易于理解，不过有时需要提供额外的解释。在这种情况下，程序员在源码中留下记录，或者 **注释**（*comments*），编译器会忽略它们不过其他阅读代码的人可能会用得上。 这是一个注释的例子： @@ -30,7 +30,7 @@ fn main() { } ``` -不过你会经常看到他们被以这种格式使用，也就是位于它所解释的代码行的上面一行： +不过你会经常看到它们被以这种格式使用，也就是位于它所解释的代码行的上面一行： 文件名: src/main.rs @@ -41,4 +41,4 @@ fn main() { } ``` -这就是注释的全部。并没有什么特别复杂的。 \ No newline at end of file +Rust 还有另一种注释，称为文档注释，我们将在 14 章讨论它。 diff --git a/src/ch03-05-control-flow.md b/src/ch03-05-control-flow.md index ea77e2e..192a46b 100644 --- a/src/ch03-05-control-flow.md +++ b/src/ch03-05-control-flow.md @@ -28,7 +28,7 @@ fn main() { -所有 `if` 表达式以 `if` 关键字开头，它后跟一个条件。在这个例子中，条件检查 `number` 是否有一个小于 5 的值。在条件为真时希望执行的代码块位于紧跟条件之后的大括号中。`if` 表达式中与条件关联的代码块有时被叫做 *arms*，就像第二章 “比较猜测与秘密数字” 部分中讨论到的 `match` 表达式中分支一样。也可以包含一个可选的 `else` 表达式，这里我们就这么做了，来提供一个在条件为假时应当执行的代码块。如果不提供 `else` 表达式并且条件为假时，程序会直接忽略 `if` 代码块并继续执行下面的代码。 +所有 `if` 表达式以 `if` 关键字开头，它后跟一个条件。在这个例子中，条件检查 `number` 是否有一个小于 5 的值。在条件为真时希望执行的代码块位于紧跟条件之后的大括号中。`if` 表达式中与条件关联的代码块有时被叫做 *arms*，就像第二章 “比较猜测与秘密数字” 部分中讨论到的 `match` 表达式中分支一样。也可以包含一个可选的 `else` 表达式来提供一个在条件为假时应当执行的代码块，这里我们就这么做了。如果不提供 `else` 表达式并且条件为假时，程序会直接忽略 `if` 代码块并继续执行下面的代码。 尝试运行代码，应该能看到如下输出： @@ -81,7 +81,7 @@ error[E0308]: mismatched types found type `{integer}` ``` -这个错误表明 Rust 期望一个 `bool` 不过却得到了一个整型。Rust 并不会尝试自动地将非布尔值转换为布尔值，不像例如 Ruby 和 JavaScript 这样的语言。必须总是显式地使用 `boolean` 作为 `if` 的条件。例如如果想 要`if` 代码块只在一个数字不等于 `0` 时执行，可以把 `if` 表达式修改为如下： +这个错误表明 Rust 期望一个 `bool` 不过却得到了一个整型。不像 Ruby 或 JavaScript 这样的语言，Rust 并不会尝试自动地将非布尔值转换为布尔值。必须总是显式地使用布尔值作为 `if` 的条件。例如，如果想要 `if` 代码块只在一个数字不等于 `0` 时执行，可以把 `if` 表达式修改成下面这样： 文件名: src/main.rs @@ -202,13 +202,13 @@ error[E0308]: if and else have incompatible types ### 使用循环重复执行 -多次执行同一段代码是很常用的。为了这个功能，Rust 提供了多种 **循环**（*loops*）。一个循环执行循环体中的代码直到结尾并紧接着回到开头继续执行。为了实验一下循环，让我们创建一个叫做 *loops* 的新项目。 +多次执行同一段代码是很常用的，Rust 为此提供了多种 **循环**（*loops*）。一个循环执行循环体中的代码直到结尾并紧接着回到开头继续执行。为了实验一下循环，让我们创建一个叫做 *loops* 的新项目。 Rust 有三种循环类型：`loop`、`while` 和 `for`。让我们每一个都试试。 #### 使用 `loop` 重复执行代码 -`loop` 关键字告诉 Rust 一遍又一遍的执行一段代码直到你明确要求停止。 +`loop` 关键字告诉 Rust 一遍又一遍地执行一段代码直到你明确要求停止。 作为一个例子，将 *loops* 目录中的 *src/main.rs* 文件修改为如下： @@ -321,7 +321,7 @@ fn main() { 例如，在示例 3-5 的代码中，如果从数组 `a` 中移除一个元素但忘记更新条件为 `while index < 4`，代码将会 panic。使用`for`循环的话，就不需要惦记着在更新数组元素数量时修改其他的代码了。 -`for` 循环的安全性和简洁性使得它在成为 Rust 中使用最多的循环结构。即使是在想要循环执行代码特定次数时，例如示例 3-5 中使用 `while` 循环的倒计时例子，大部分 Rustacean 也会使用 `for` 循环。这么做的方式是使用 `Range`，它是标准库提供的用来生成从一个数字开始到另一个数字结束的所有数字序列的类型。 +`for` 循环的安全性和简洁性使得它在成为 Rust 中使用最多的循环结构。即使是在想要循环执行代码特定次数时，例如示例 3-5 中使用 `while` 循环的倒计时例子，大部分 Rustacean 也会使用 `for` 循环。这么做的方式是使用 `Range`，它是标准库提供的用来生成从一个数字开始到另一个数字之前结束的所有数字序列的类型。 下面是一个使用 `for` 循环来倒计时的例子，它还使用了一个我们还未讲到的方法，`rev`，用来反转 range： @@ -340,10 +340,10 @@ fn main() { ## 总结 -你做到了！这是一个相当可观的章节：你学习了变量，标量和 `if` 表达式，还有循环！如果你想要实践本章讨论的概念，尝试构建如下的程序： +你做到了！这是一个大章节：你学习了变量，标量和 `if` 表达式，还有循环！如果你想要实践本章讨论的概念，尝试构建如下的程序： * 相互转换摄氏与华氏温度 * 生成 n 阶斐波那契数列 * 打印圣诞颂歌 “The Twelve Days of Christmas” 的歌词，并利用歌曲中的重复部分（编写循环） -当你准备好继续的时候，让我们讨论一个其他语言中 *并不* 常见的概念：所有权（ownership）。 \ No newline at end of file +当你准备好继续的时候，让我们讨论一个其他语言中 *并不* 常见的概念：所有权（ownership）。 From 3cd394f3052ceee17dbbd8bec5bbaeb480391cfc Mon Sep 17 00:00:00 2001 From: lcofjp Date: Tue, 5 Dec 2017 12:30:08 +0800 Subject: [PATCH 077/150] Fix typo --- src/ch05-03-method-syntax.md | 2 +- src/ch06-01-defining-an-enum.md | 2 +- src/ch07-01-mod-and-the-filesystem.md | 2 +- src/ch09-00-error-handling.md | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/ch05-03-method-syntax.md b/src/ch05-03-method-syntax.md index 08b705f..85a4d86 100644 --- a/src/ch05-03-method-syntax.md +++ b/src/ch05-03-method-syntax.md @@ -4,7 +4,7 @@ >
> commit 44bf3afd93519f8b0f900f21a5f2344d36e13448 -**方法** 与函数类似：他们使用 `fn` 关键和名字声明，可以拥有参数和返回值，同时包含一些代码会在某处被调用时执行。不过方法与函数是不同的，因为他们在结构体（或者枚举或者 trait 对象，将分别在第六章和第十七章讲解）的上下文中被定义，并且他们第一个参数总是` self`，它代表方法被调用的结构体的实例。 +**方法** 与函数类似：他们使用 `fn` 关键字和名字声明，可以拥有参数和返回值，同时包含一些代码会在某处被调用时执行。不过方法与函数是不同的，因为他们在结构体（或者枚举或者 trait 对象，将分别在第六章和第十七章讲解）的上下文中被定义，并且他们第一个参数总是` self`，它代表方法被调用的结构体的实例。 ### 定义方法 diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index b00be46..a8d5572 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -让我们通过一用代码来表现的场景，来看看为什么这里枚举是有用的而且比结构体更合适。比如我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的 IP 地址的所有可能性：所以可以 **枚举** 出所有可能的值，这也正是它名字的由来。 +让我们通过用代码来表现的场景，来看看为什么这里枚举是有用的而且比结构体更合适。比如我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的 IP 地址的所有可能性：所以可以 **枚举** 出所有可能的值，这也正是它名字的由来。 任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的而不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理申请任何类型的 IP 地址的场景时应该把他们当作相同的类型。 diff --git a/src/ch07-01-mod-and-the-filesystem.md b/src/ch07-01-mod-and-the-filesystem.md index a77364a..0332450 100644 --- a/src/ch07-01-mod-and-the-filesystem.md +++ b/src/ch07-01-mod-and-the-filesystem.md @@ -30,7 +30,7 @@ Cargo 创建了一个空的测试来帮助我们开始库项目，不像使用 ` 因为没有 *src/main.rs* 文件，所以没有可供 Cargo 的 `cargo run` 执行的东西。因此，我们将使用 `cargo build` 命令只是编译库 crate 的代码。 -我们将学习根据编写代码的意图来选择不同的织库项目代码组织来适应多种场景。 +我们将学习根据编写代码的意图来选择不同的库项目代码组织来适应多种场景。 ### 模块定义 diff --git a/src/ch09-00-error-handling.md b/src/ch09-00-error-handling.md index ad93fad..4762b16 100644 --- a/src/ch09-00-error-handling.md +++ b/src/ch09-00-error-handling.md @@ -4,7 +4,7 @@ >
> commit 4f2dc564851dc04b271a2260c834643dfd86c724 -Rust 对可靠性的执着也扩展到了错误处理。错误对于软件来说是不可避免的，所以 Rust 有很多功能来处理当现错误的情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 +Rust 对可靠性的执着也扩展到了错误处理。错误对于软件来说是不可避免的，所以 Rust 有很多功能来处理出现错误的情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 Rust 将错误组合成两个主要类别：**可恢复错误**（*recoverable*）和 **不可恢复错误**（*unrecoverable*）。可恢复错误通常代表向用户报告错误和重试操作是合理的情况，比如未找到文件。不可恢复错误通常是 bug 的同义词，比如尝试访问超过数组结尾的位置。 From 02fdcfd00d1d79d60104a3478a9c789c8cca40ce Mon Sep 17 00:00:00 2001 From: Alex Chen Date: Tue, 5 Dec 2017 14:28:02 +0800 Subject: [PATCH 078/150] Fix #91 --- src/ch15-05-interior-mutability.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index eb82b57..63b6bae 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -19,7 +19,7 @@ 对于引用和`Box`，借用规则的不可变性作用于编译时。对于`RefCell`，这些不可变性作用于**运行时**。对于引用，如果违反这些规则，会得到一个编译错误。而对于`RefCell`，违反这些规则会`panic!`。 -Rust 编译器执行的静态分析天生是保守的。代码的一些属性则不可能通过分析代码发现：其中最著名的就是停机问题（停机问题），这超出了本书的范畴，不过如果你感兴趣的话这是一个值得研究的有趣主题。 +Rust 编译器执行的静态分析天生是保守的。代码的一些属性则不可能通过分析代码发现：其中最著名的就是停机问题（Halting Problem），这超出了本书的范畴，不过如果你感兴趣的话这是一个值得研究的有趣主题。 因为一些分析是不可能的，Rust 编译器在其不确定的时候甚至都不尝试猜测，所以说它是保守的而且有时会拒绝事实上不会违反 Rust 保证的正确的程序。换句话说，如果 Rust 接受不正确的程序，那么人们也就不会相信 Rust 所做的保证了。如果 Rust 拒绝正确的程序，会给程序员带来不便，但不会带来灾难。`RefCell`正是用于当你知道代码遵守借用规则，而编译器不能理解的时候。 @@ -169,4 +169,4 @@ c after = Cons(RefCell { value: 10 }, Cons(RefCell { value: 15 }, Nil)) 这是非常巧妙的！通过使用`RefCell`，我们可以拥有一个表面上不可变的`List`，不过可以使用`RefCell`中提供内部可变性的方法来在需要时修改数据。`RefCell`的运行时借用规则检查也确实保护我们免于出现数据竞争，而且我们也决定牺牲一些速度来换取数据结构的灵活性。 -`RefCell`并不是标准库中唯一提供内部可变性的类型。`Cell`有点类似，不过不同于`RefCell`那样提供内部值的引用，其值被拷贝进和拷贝出`Cell`。`Mutex`提供线程间安全的内部可变性，下一章并发会讨论它的应用。请查看标准库来获取更多细节和不同类型的区别。 \ No newline at end of file +`RefCell`并不是标准库中唯一提供内部可变性的类型。`Cell`有点类似，不过不同于`RefCell`那样提供内部值的引用，其值被拷贝进和拷贝出`Cell`。`Mutex`提供线程间安全的内部可变性，下一章并发会讨论它的应用。请查看标准库来获取更多细节和不同类型的区别。 From cb231d4f738ae8b16fd22d252f1ea60f4d81e0b4 Mon Sep 17 00:00:00 2001 From: Alex Chen Date: Tue, 5 Dec 2017 17:31:45 +0800 Subject: [PATCH 079/150] Modify bits on ch05-ch06 --- src/ch04-01-what-is-ownership.md | 2 +- src/ch05-01-defining-structs.md | 10 +++++----- src/ch05-02-example-structs.md | 2 +- src/ch05-03-method-syntax.md | 22 +++++++++++----------- src/ch06-00-enums.md | 4 ++-- src/ch06-01-defining-an-enum.md | 18 +++++++++--------- src/ch06-02-match.md | 10 +++++----- src/ch06-03-if-let.md | 2 +- 8 files changed, 35 insertions(+), 35 deletions(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 331a577..510b373 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -237,7 +237,7 @@ println!("x = {}, y = {}", x, y); 原因是像整型这样的在编译时已知大小的类型被整个储存在栈上，所以拷贝其实际的值是快速的。这意味着没有理由在创建变量 `y` 后使 `x` 无效。换句话说，这里没有深浅拷贝的区别，所以这里调用 `clone` 并不会与通常的浅拷贝有什么不同，我们可以不用管它。 -Rust 有一个叫做 `Copy` trait 的特殊注解，可以用在类似整型这样的储存在栈上的类型（第十章详细讲解 trait）。如果一个类型拥有 `Copy` trait，一个旧的变量在将其赋值给其他变量后仍然可用。Rust 不允许自身或其任何部分实现了 `Drop` trait 的类型使用`Copy` trait。如果我们对其值离开作用域时需要特殊处理的类型使用 `Copy` 注解，将会出现一个编译时错误。关于如何为你的类型增加 `Copy` 注解，请阅读附录 C 中的可导出 trait。 +Rust 有一个叫做 `Copy` trait 的特殊注解，可以用在类似整型这样的储存在栈上的类型（第十章详细讲解 trait）。如果一个类型拥有 `Copy` trait，一个旧的变量在将其赋值给其他变量后仍然可用。Rust 不允许自身或其任何部分实现了 `Drop` trait 的类型使用 `Copy` trait。如果我们对其值离开作用域时需要特殊处理的类型使用 `Copy` 注解，将会出现一个编译时错误。关于如何为你的类型增加 `Copy` 注解，请阅读附录 C 中的可导出 trait。 那么什么类型是 `Copy` 的呢？可以查看给定类型的文档来确认，不过作为一个通用的规则，任何简单标量值的组合可以是 `Copy` 的，任何需要分配内存，或者本身就是某种形式资源的类型不会是 `Copy` 的。如下是一些 `Copy` 的类型： diff --git a/src/ch05-01-defining-structs.md b/src/ch05-01-defining-structs.md index 27e4c5b..d3c56e9 100644 --- a/src/ch05-01-defining-structs.md +++ b/src/ch05-01-defining-structs.md @@ -6,7 +6,7 @@ 我们在第三章讨论过，结构体与元组类似。就像元组，结构体的每一部分可以是不同类型。不同于元组，结构体需要命名各部分数据以便能清楚的表明其值的意义。由于有了这些名字使得结构体比元组更灵活：不需要依赖顺序来指定或访问实例中的值。 -定义结构体，需要使用 `struct` 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字，他们被称作 **字段**（*field*），并定义字段类型。例如，示例 5-1 展示了一个储存用户账号信息的结构体： +定义结构体，需要使用 `struct` 关键字并为整个结构体提供一个名字。结构体的名字需要描述它所组合的数据的意义。接着，在大括号中，定义每一部分数据的名字，它们被称作 **字段**（*field*），并定义字段类型。例如，示例 5-1 展示了一个储存用户账号信息的结构体： ```rust struct User { @@ -19,7 +19,7 @@ struct User { 示例 5-1：`User` 结构体定义 -一旦定义了结构体后为了使用它，通过为每个字段指定具体值来创建这个结构体的 **实例**。创建一个实例需要以结构体的名字开头，接着在大括号中使用 `key: value` 对的形式提供字段，其中 key 是字段的名字而 value 是需要储存在字段中的数据值。这时字段的顺序并不必要与在结构体中声明他们的顺序一致。换句话说，结构体的定义就像一个这个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。例如，可以像示例 5-2 这样来声明一个特定的用户： +一旦定义了结构体后为了使用它，通过为每个字段指定具体值来创建这个结构体的 **实例**。创建一个实例需要以结构体的名字开头，接着在大括号中使用 `key: value` 对的形式提供字段，其中 key 是字段的名字，value 是需要储存在字段中的数据值。实例中具体说明字段的顺序不需要和它们在结构体中声明的顺序一致。换句话说，结构体的定义就像一个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。例如，可以像示例 5-2 这样来声明一个特定的用户： ```rust # struct User { @@ -83,7 +83,7 @@ fn build_user(email: String, username: String) -> User { 示例 5-4：`build_user` 函数获取 email 和用户名并返回 `User` 实例 -不过，重复 `email` 字段与 `email` 变量的名字，同样的对于`username`，感觉有一点无趣。将函数参数起与结构体字段相同的名字是可以理解的，但是如果结构体有更多字段，重复他们是十分烦人的。幸运的是，这里有一个方便的语法！ +不过，重复 `email` 字段与 `email` 变量的名字，同样的对于`username`，感觉有一点无趣。将函数参数起与结构体字段相同的名字是可以理解的，但是如果结构体有更多字段，重复它们是十分烦人的。幸运的是，这里有一个方便的语法！ ### 变量与字段同名时的字段初始化语法 @@ -178,11 +178,11 @@ let black = Color(0, 0, 0); let origin = Point(0, 0, 0); ``` -注意 `black` 和 `origin` 变量是不同的类型，因为他们是不同的元组结构体的实例。我们定义的每一个结构体有着自己的类型，即使结构体中的字段有相同的类型。在其他方面，元组结构体类似我们在第三章提到的元组。 +注意 `black` 和 `origin` 变量是不同的类型，因为它们是不同的元组结构体的实例。我们定义的每一个结构体有着自己的类型，即使结构体中的字段有相同的类型。在其他方面，元组结构体类似我们在第三章提到的元组。 ### 没有任何字段的类单元结构体 -我们也可以定义一个没有任何字段的结构体！他们被称为 **类单元结构体**（*unit-like structs*）因为他们类似于 `()`，即 unit 类型。类单元结构体常常在你想要在某个类型上实现 trait 但不需要在类型内存储数据的时候发挥作用。我们将在第十章介绍 trait。 +我们也可以定义一个没有任何字段的结构体！它们被称为 **类单元结构体**（*unit-like structs*）因为它们类似于 `()`，即 unit 类型。类单元结构体常常在你想要在某个类型上实现 trait 但不需要在类型内存储数据的时候发挥作用。我们将在第十章介绍 trait。 > ## 结构体数据的所有权 > diff --git a/src/ch05-02-example-structs.md b/src/ch05-02-example-structs.md index 51f52de..a577c93 100644 --- a/src/ch05-02-example-structs.md +++ b/src/ch05-02-example-structs.md @@ -191,4 +191,4 @@ rect1 is Rectangle { Rust 为我们提供了很多可以通过 `derive` 注解来使用的 trait，他们可以为我们的自定义类型增加实用的行为。这些 trait 和行为在附录 C 中列出。第十章会涉及到如何通过自定义行为来实现这些 trait，同时还有如何创建你自己的 trait。 -我们的 `area` 函数是非常特化的————它只是计算了长方形的面积。如果这个行为与 `Rectangle` 结构体再结合得更紧密一些就更好了，因为它不能用于其他类型。现在让我们看看如何继续重构这些代码，来将 `area` 函数协调进 `Rectangle` 类型定义的`area` **方法** 中。 +我们的 `area` 函数是非常特化的，它只是计算了长方形的面积。如果这个行为与 `Rectangle` 结构体再结合得更紧密一些就更好了，因为它不能用于其他类型。现在让我们看看如何继续重构这些代码，来将 `area` 函数协调进 `Rectangle` 类型定义的`area` **方法** 中。 diff --git a/src/ch05-03-method-syntax.md b/src/ch05-03-method-syntax.md index 85a4d86..116f5fe 100644 --- a/src/ch05-03-method-syntax.md +++ b/src/ch05-03-method-syntax.md @@ -4,11 +4,11 @@ >
> commit 44bf3afd93519f8b0f900f21a5f2344d36e13448 -**方法** 与函数类似：他们使用 `fn` 关键字和名字声明，可以拥有参数和返回值，同时包含一些代码会在某处被调用时执行。不过方法与函数是不同的，因为他们在结构体（或者枚举或者 trait 对象，将分别在第六章和第十七章讲解）的上下文中被定义，并且他们第一个参数总是` self`，它代表方法被调用的结构体的实例。 +**方法** 与函数类似：它们使用 `fn` 关键字和名字声明，可以拥有参数和返回值，同时包含一段该方法在某处被调用时会执行的代码。不过方法与函数是不同的，因为它们在结构体的上下文中被定义（或者是枚举或 trait 对象的上下文，将分别在第六章和第十七章讲解），并且它们第一个参数总是 `self`，它代表调用该方法的结构体实例。 ### 定义方法 -让我们将获取一个 `Rectangle` 实例作为参数的 `area` 函数改写成一个定义于 `Rectangle` 结构体上的 `area` 方法，如示例 5-13 所示： +让我们把前面实现的获取一个 `Rectangle` 实例作为参数的 `area` 函数，改写成一个定义于 `Rectangle` 结构体上的 `area` 方法，如示例 5-13 所示： 文件名: src/main.rs @@ -37,13 +37,13 @@ fn main() { 示例 5-13：在 `Rectangle` 结构体上定义 `area` 方法 -为了使函数定义于 `Rectangle` 的上下文中，我们开始了一个 `impl` 块（`impl` 是 *implementation* 的缩写）。接着将函数移动到 `impl` 大括号中，并将签名中的第一个（在这里也是唯一一个）参数和函数体中其他地方的对应参数改成 `self`。然后在`main` 中将我们调用 `area` 方法并传递 `rect1` 作为参数的地方，改成使用 **方法语法**（*method syntax*）在 `Rectangle` 实例上调用 `area` 方法。方法语法获取一个实例并加上一个点号后跟方法名、括号以及任何参数。 +为了使函数定义于 `Rectangle` 的上下文中，我们开始了一个 `impl` 块（`impl` 是 *implementation* 的缩写）。接着将函数移动到 `impl` 大括号中，并将签名中的第一个（在这里也是唯一一个）参数和函数体中其他地方的对应参数改成 `self`。然后在 `main` 中将我们先前调用 `area` 方法并传递 `rect1` 作为参数的地方，改成使用 **方法语法**（*method syntax*）在 `Rectangle` 实例上调用 `area` 方法。方法语法获取一个实例并加上一个点号，后跟方法名、括号以及任何参数。 -在 `area` 的签名中，开始使用 `&self` 来替代 `rectangle: &Rectangle`，因为该方法位于 `impl Rectangle` 上下文中所以 Rust 知道 `self` 的类型是 `Rectangle`。注意仍然需要在 `self` 前面加上 `&`，就像 `&Rectangle` 一样。方法可以选择获取 `self` 的所有权，像我们这里一样不可变的借用 `self`，或者可变的借用 `self`，就跟其他别的参数一样。 +在 `area` 的签名中，开始使用 `&self` 来替代 `rectangle: &Rectangle`，因为该方法位于 `impl Rectangle` 上下文中所以 Rust 知道 `self` 的类型是 `Rectangle`。注意仍然需要在 `self` 前面加上 `&`，就像 `&Rectangle` 一样。方法可以选择获取 `self` 的所有权，或者像我们这里一样不可变地借用 `self`，或者可变地借用 `self`，就跟其他别的参数一样。 -这里选择 `&self` 跟在函数版本中使用 `&Rectangle` 出于同样的理由：我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入。如果想要能够在方法中改变调用方法的实例的话，需要将第一个参数改为 `&mut self`。很少见到通过仅仅使用 `self` 作为第一个参数来使方法获取实例的所有权；这种技术通常用在当方法将 `self` 转换成别的实例的时候，这时我们想要防止调用者在转换之后使用原始的实例。 +这里选择 `&self` 跟在函数版本中使用 `&Rectangle` 出于同样的理由：我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入。如果想要在方法中改变调用方法的实例，需要将第一个参数改为 `&mut self`。很少见到通过仅仅使用 `self` 作为第一个参数来使方法获取实例的所有权；这种技术通常用在当方法将 `self` 转换成别的实例的时候，这时我们想要防止调用者在转换之后使用原始的实例。 -使用方法而不是函数，除了使用了方法语法和不需要在每个函数签名中重复` self` 类型之外，其主要好处在于组织性。我将某个类型实例能做的所有事情都一起放入 `impl` 块中，而不是让将来的用户在我们的代码中到处寻找 `Rectangle` 的功能。 +尽量使用方法替代函数，除了使用了方法语法和不需要在每个函数签名中重复 `self` 类型之外，其主要好处在于组织性。我们将某个类型实例能做的所有事情都一起放入 `impl` 块中，而不是让将来的用户在我们的代码中到处寻找 `Rectangle` 的功能。 > ### `->`运算符到哪去了？ > @@ -74,11 +74,11 @@ fn main() { > (&p1).distance(&p2); > ``` > -> 第一行看起来简洁的多。这种自动解引用的行为之所以能行得通是因为方法有一个明确的接收者————`self` 类型。在给出接收者和方法名的前提下，Rust 可以明确的计算出方法是仅仅读取（`&self`），做出修改（`&mut self`）或者是获取所有权（`self`）。Rust 这种使得借用对方法接收者来说是隐式的做法是其所有权系统程序员友好性实践的一大部分。 +> 第一行看起来简洁的多。这种自动解引用的行为之所以能行得通是因为方法有一个明确的接收者————`self` 类型。在给出接收者和方法名的前提下，Rust 可以明确地计算出方法是仅仅读取（`&self`），做出修改（`&mut self`）或者是获取所有权（`self`）。Rust 这种使得借用对方法接收者来说是隐式的做法是其所有权系统程序员友好性实践的一大部分。 ### 带有更多参数的方法 -让我们更多的实践一下方法，通过为 `Rectangle` 结构体实现第二个方法。这回，我们让一个 `Rectangle` 的实例获取另一个 `Rectangle` 实例并返回 `self` 能否完全包含第二个长方形，如果能返回 `true` 若不能则返回 `false`。一旦定义了 `can_hold` 方法，就可以运行示例 5-14 中的代码了： +让我们更多的实践一下方法，通过为 `Rectangle` 结构体实现第二个方法。这回，我们让一个 `Rectangle` 的实例获取另一个 `Rectangle` 实例并返回 `self` 能否完全包含第二个长方形，如果能则返回 `true` ，如果不能则返回 `false`。一旦定义了 `can_hold` 方法，就可以运行示例 5-14 中的代码了： 文件名: src/main.rs @@ -130,7 +130,7 @@ impl Rectangle { ### 关联函数 -`impl` 块的另一个有用的功能是：允许在 `impl` 块中定义 **不** 以 `self` 作为参数的函数。这被称为 **关联函数**（*associated functions*），因为他们与结构体相关联。即便如此他们仍是函数而不是方法，因为他们并不作用于一个结构体的实例。你已经使用过一个关联函数了：`String::from`。 +`impl` 块的另一个有用的功能是：允许在 `impl` 块中定义 **不** 以 `self` 作为参数的函数。这被称为 **关联函数**（*associated functions*），因为它们与结构体相关联。即便如此它们仍是函数而不是方法，因为它们并不作用于一个结构体的实例。你已经使用过一个关联函数了：`String::from`。 关联函数经常被用作返回一个结构体新实例的构造函数。例如我们可以提供一个关联函数，它接受一个维度参数并且同时用来作为长和宽，这样可以更轻松的创建一个正方形 `Rectangle` 而不必指定两次同样的值： @@ -150,7 +150,7 @@ impl Rectangle { } ``` -使用结构体名和 `::` 语法来调用这个关联函数：比如 `let sq = Rectangle::square(3);`。这个方法位于结构体的命名空间中：`::` 语法用于关联函数和模块创建的命名空间，第七章会讲到后者。 +使用结构体名和 `::` 语法来调用这个关联函数：比如 `let sq = Rectangle::square(3);`。这个方法位于结构体的命名空间中：`::` 语法用于关联函数和模块创建的命名空间，第七章会讲到模块。 ### 多个 `impl` 块 @@ -180,6 +180,6 @@ impl Rectangle { ## 总结 -结构体让我们可以在自己的范围内创建有意义的自定义类型。通过结构体，我们可以将相关联的数据片段联系起来并命名他们来使得代码更清晰。方法允许为结构体实例指定行为，而关联函数将特定功能置于结构体的命名空间中并且无需一个实例。 +结构体让我们可以在自己的范围内创建有意义的自定义类型。通过结构体，我们可以将相关联的数据片段联系起来并命名它们，这样可以使得代码更加清晰。方法允许为结构体实例指定行为，而关联函数将特定功能置于结构体的命名空间中并且无需一个实例。 结构体并不是创建自定义类型的唯一方法；让我们转向 Rust 的枚举功能并为自己的工具箱再添一个工具。 diff --git a/src/ch06-00-enums.md b/src/ch06-00-enums.md index fee6254..9b34e78 100644 --- a/src/ch06-00-enums.md +++ b/src/ch06-00-enums.md @@ -4,6 +4,6 @@ >
> commit 4f2dc564851dc04b271a2260c834643dfd86c724 -本章介绍 **枚举**（*enumerations*），也被称作 *enums*。枚举允许你通过列举可能的值来定义一个类型。首先，我们会定义并使用一个枚举来展示它是如何连同数据一起编码信息的。接下来，我们会探索一个特别有用的枚举，叫做 `Option`，它代表一个值要么是一些值要么什么都不是。然后会讲到 `match` 表达式中的模式匹配如何使对枚举不同的值运行不同的代码变得容易。最后会涉及到 `if let`，另一个简洁方便处理代码中枚举的结构。 +本章介绍 **枚举**（*enumerations*），也被称作 *enums*。枚举允许你通过列举可能的值来定义一个类型。首先，我们会定义并使用一个枚举来展示它是如何连同数据一起编码信息的。接下来，我们会探索一个特别有用的枚举，叫做 `Option`，它代表一个值要么是某个值要么什么都不是。然后会讲到在 `match` 表达式中用模式匹配，针对不同的枚举值编写相应要执行的代码。最后会涉及到 `if let`，另一个简洁方便处理代码中枚举的结构。 -枚举是一个很多语言都有的功能，不过不同语言中的功能各不相同。Rust 的枚举与像 F#、OCaml 和 Haskell 这样的函数式编程语言中的 **代数数据类型**（*algebraic data types*）最为相似。 \ No newline at end of file +枚举是一个很多语言都有的功能，不过不同语言中的功能各不相同。Rust 的枚举与 F#、OCaml 和 Haskell 这样的函数式编程语言中的 **代数数据类型**（*algebraic data types*）最为相似。 diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index a8d5572..182f2df 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -4,9 +4,9 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -让我们通过用代码来表现的场景，来看看为什么这里枚举是有用的而且比结构体更合适。比如我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的 IP 地址的所有可能性：所以可以 **枚举** 出所有可能的值，这也正是它名字的由来。 +让我们在一个实际场景中看看在这个特定场景下，使用枚举比使用结构体更合适。假设我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的所有可能的 IP 地址类型：所以可以 **枚举** 出所有可能的值，这也正是它名字的由来。 -任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的而不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理申请任何类型的 IP 地址的场景时应该把他们当作相同的类型。 +任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理申请任何类型的 IP 地址的场景时应该把它们当作相同的类型。 可以通过在代码中定义一个 `IpAddrKind` 枚举来表现这个概念并列出可能的 IP 地址类型，`V4` 和 `V6`。这被称为枚举的 **成员**（*variants*）： @@ -33,7 +33,7 @@ let four = IpAddrKind::V4; let six = IpAddrKind::V6; ``` -注意枚举的成员位于其标识符的命名空间中，并使用两个冒号分开。这么设计的益处是现在 `IpAddrKind::V4` 和 `IpAddrKind::V6` 是相同类型的：`IpAddrKind`。例如，接着可以定义一个函数来获取任何 `IpAddrKind`： +注意枚举的成员位于其标识符的命名空间中，并使用两个冒号分开。这么设计的益处是现在 `IpAddrKind::V4` 和 `IpAddrKind::V6` 都是 `IpAddrKind` 类型的。例如，接着可以定义一个函数来获取任何 `IpAddrKind`： ```rust # enum IpAddrKind { @@ -101,7 +101,7 @@ let loopback = IpAddr::V6(String::from("::1")); 我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。 -使用枚举而不是结构体还有另外一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将 `V4` 地址储存为四个 `u8` 值而 `V6` 地址仍然表现为一个 `String`，这就不能使用结构体了。枚举可以轻易处理的这个情况： +用枚举替代结构体还有另一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将 `V4` 地址储存为四个 `u8` 值而 `V6` 地址仍然表现为一个 `String`，这就不能使用结构体了。枚举可以轻易处理的这个情况： ```rust enum IpAddr { @@ -114,7 +114,7 @@ let home = IpAddr::V4(127, 0, 0, 1); let loopback = IpAddr::V6(String::from("::1")); ``` -这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了[以致标准库提供了一个可供使用的定义！][IpAddr]让我们看看标准库如何定义 `IpAddr` 的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，他们对不同的成员的定义是不同的： +这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了[以致标准库提供了一个可供使用的定义！][IpAddr]让我们看看标准库如何定义 `IpAddr` 的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，它们对不同的成员的定义是不同的： [IpAddr]: https://doc.rust-lang.org/std/net/enum.IpAddr.html @@ -169,7 +169,7 @@ struct WriteMessage(String); // tuple struct struct ChangeColorMessage(i32, i32, i32); // tuple struct ``` -不过如果我们使用不同的结构体，他们都有不同的类型，将不能轻易的定义一个获取任何这些信息类型的函数，正如可以使用示例 6-2 中定义的 `Message` 枚举那样，因为他们是一个类型的。 +不过如果我们使用不同的结构体，它们都有不同的类型，将不能轻易的定义一个获取任何这些信息类型的函数，正如可以使用示例 6-2 中定义的 `Message` 枚举那样，因为它们是一个类型的。 结构体和枚举还有另一个相似点：就像可以使用 `impl` 来为结构体定义方法那样，也可以在枚举上定义方法。这是一个定义于我们 `Message` 枚举上的叫做 `call` 的方法： @@ -197,7 +197,7 @@ m.call(); ### `Option` 枚举和其相对于空值的优势 -在之前的部分，我们看到了 `IpAddr` 枚举如何利用 Rust 的类型系统编码更多信息而不单单是程序中的数据。这一部分探索一个 `Option` 的案例分析，它是另一个标准库定义的枚举。`Option` 类型应用广泛因为它编码了一个非常普遍的场景，就是一个值可能是某个值或者什么都不是。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。 +在之前的部分，我们看到了 `IpAddr` 枚举如何利用 Rust 的类型系统编码更多信息而不单单是程序中的数据。接下来我们分析一个 `Option` 的案例，`Option` 是标准库定义的另一个枚举。`Option` 类型应用广泛因为它编码了一个非常普遍的场景，即一个值要么是某个值要么什么都不是。从类型系统的角度来表达这个概念就意味着编译器需要检查是否处理了所有应该处理的情况，这样就可以避免在其他编程语言中非常常见的 bug。 编程语言的设计经常从其包含功能的角度考虑问题，但是从其所排除在外的功能的角度思考也很重要。Rust 并没有很多其他语言中有的空值功能。**空值**（*Null* ）是一个值，它代表没有值。在有空值的语言中，变量总是这两种状态之一：空值和非空值。 @@ -212,7 +212,7 @@ m.call(); > crashes, which have probably caused a billion dollars of pain and damage in > the last forty years. > -> 我称之为我万亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的使用都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数以万计美元的苦痛和伤害。 +> 我称之为我十亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的使用都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数十亿美元的苦痛和伤害。 空值的问题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性是无处不在的，非常容易出现这类错误。 @@ -229,7 +229,7 @@ enum Option { } ``` -`Option` 是如此有用以至于它甚至被包含在了 prelude 之中：不需要显式导入它。另外，它的成员也是如此：可以不需要 `Option::` 前缀来直接使用 `Some` 和 `None`。即便如此 `Option` 也仍是常规的枚举，`Some(T)` 和 `None` 仍是 `Option` 的成员。 +`Option` 是如此有用以至于它甚至被包含在了 prelude 之中，这意味着我们不需要显式导入它。另外，它的成员也是如此，可以不需要 `Option::` 前缀来直接使用 `Some` 和 `None`。即便如此 `Option` 也仍是常规的枚举，`Some(T)` 和 `None` 仍是 `Option` 的成员。 `` 语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是 `` 意味着 `Option` 枚举的 `Some` 成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型 `Option` 值的例子： diff --git a/src/ch06-02-match.md b/src/ch06-02-match.md index 8829f45..ab0c714 100644 --- a/src/ch06-02-match.md +++ b/src/ch06-02-match.md @@ -4,11 +4,11 @@ >
> commit 01dd4248621c2f510947592e47d16bdab9b14cf0 -Rust 有一个叫做 `match` 的极为强大的控制流运算符，它允许我们将一个值与一系列的模式相比较并根据匹配的模式执行相应代码。模式可由字面值、变量、通配符和许多其他内容构成；第十八章会涉及到所有不同种类的模式以及他们的作用。`match` 的力量来源于模式的表现力以及编译器检查，它确保了所有可能的情况都得到处理。 +Rust 有一个叫做 `match` 的极为强大的控制流运算符，它允许我们将一个值与一系列的模式相比较并根据匹配的模式执行相应代码。模式可由字面值、变量、通配符和许多其他内容构成；第十八章会涉及到所有不同种类的模式以及它们的作用。`match` 的力量来源于模式的表现力以及编译器检查，它确保了所有可能的情况都得到处理。 可以把 `match` 表达式想象成某种硬币分类器：硬币滑入有着不同大小孔洞的轨道，每一个硬币都会掉入符合它大小的孔洞。同样地，值也会检查 `match` 的每一个模式，并且在遇到第一个 “符合” 的模式时，值会进入相关联的代码块并在执行中被使用。 -因为刚刚提到了硬币，让我们用他们来作为一个使用 `match` 的例子！我们可以编写一个函数来获取一个未知的（美帝）硬币，并以一种类似验钞机的方式，确定它是何种硬币并返回它的美分值，如示例 6-3 中所示： +因为刚刚提到了硬币，让我们用它们来作为一个使用 `match` 的例子！我们可以编写一个函数来获取一个未知的（美帝）硬币，并以一种类似验钞机的方式，确定它是何种硬币并返回它的美分值，如示例 6-3 中所示： ```rust enum Coin { @@ -155,7 +155,7 @@ None => None, Some(i) => Some(i + 1), ``` -`Some(5)` 与 `Some(i)` 匹配吗？为什么不呢！他们是相同的成员。`i` 绑定了 `Some` 中包含的值，所以 `i` 的值是 `5`。接着匹配分支的代码被执行，所以我们将 `i` 的值加一并返回一个含有值 `6` 的新 `Some`。 +`Some(5)` 与 `Some(i)` 匹配吗？为什么不呢！它们是相同的成员。`i` 绑定了 `Some` 中包含的值，所以 `i` 的值是 `5`。接着匹配分支的代码被执行，所以我们将 `i` 的值加一并返回一个含有值 `6` 的新 `Some`。 #### 匹配 `None` @@ -192,7 +192,7 @@ error[E0004]: non-exhaustive patterns: `None` not covered ``` -Rust 知道我们没有覆盖所有可能的情况甚至知道那些模式被忘记了！Rust 中的匹配是 **穷尽的**（*exhaustive）：必须穷举到最后的可能性来使代码有效。特别的在这个 `Option` 的例子中，Rust 防止我们忘记明确的处理 `None` 的情况，这使我们免于假设拥有一个实际上为空的值，这造成了之前提到过的价值亿万的错误。 +Rust 知道我们没有覆盖所有可能的情况甚至知道那些模式被忘记了！Rust 中的匹配是 **穷尽的**（*exhaustive*）：必须穷举到最后的可能性来使代码有效。特别的在这个 `Option` 的例子中，Rust 防止我们忘记明确的处理 `None` 的情况，这使我们免于假设拥有一个实际上为空的值，这造成了之前提到过的价值亿万的错误。 ### `_` 通配符 @@ -211,4 +211,4 @@ match some_u8_value { `_` 模式会匹配所有的值。通过将其放置于其他分支之后，`_` 将会匹配所有之前没有指定的可能的值。`()` 就是 unit 值，所以 `_` 的情况什么也不会发生。因此，可以说我们想要对 `_` 通配符之前没有列出的所有可能的值不做任何处理。 -然而，`match` 在只关心 **一个** 情况的场景中可能就有点啰嗦了。为此 Rust 提供了`if let`。 \ No newline at end of file +然而，`match` 在只关心 **一个** 情况的场景中可能就有点啰嗦了。为此 Rust 提供了`if let`。 diff --git a/src/ch06-03-if-let.md b/src/ch06-03-if-let.md index 83f1e02..2df595e 100644 --- a/src/ch06-03-if-let.md +++ b/src/ch06-03-if-let.md @@ -88,4 +88,4 @@ if let Coin::Quarter(state) = coin { 你的 Rust 程序现在能够使用结构体和枚举在自己的作用域内表现其内容了。在你的 API 中使用自定义类型保证了类型安全：编译器会确保你的函数只会得到它期望的类型的值。 -为了向你的用户提供一个组织良好的 API，它使用起来很直观并且只向用户暴露他们确实需要的部分，那么现在就让我们转向 Rust 的模块系统吧。 \ No newline at end of file +为了向你的用户提供一个组织良好的 API，它使用起来很直观并且只向用户暴露他们确实需要的部分，那么现在就让我们转向 Rust 的模块系统吧。 From 07d0b3146df594f9eefcd049480428919d1edd4f Mon Sep 17 00:00:00 2001 From: Alex Chen Date: Tue, 5 Dec 2017 21:57:25 +0800 Subject: [PATCH 080/150] Modify ch07-ch08 --- src/ch07-00-modules.md | 8 ++++---- src/ch07-01-mod-and-the-filesystem.md | 17 +++++++++-------- src/ch07-02-controlling-visibility-with-pub.md | 18 +++++++++--------- src/ch07-03-importing-names-with-use.md | 11 ++++++----- src/ch08-00-common-collections.md | 2 +- src/ch08-01-vectors.md | 14 +++++++------- src/ch08-02-strings.md | 16 ++++++++-------- src/ch08-03-hash-maps.md | 8 ++++---- 8 files changed, 48 insertions(+), 46 deletions(-) diff --git a/src/ch07-00-modules.md b/src/ch07-00-modules.md index 9f2e041..1230dae 100644 --- a/src/ch07-00-modules.md +++ b/src/ch07-00-modules.md @@ -4,12 +4,12 @@ >
> commit b707dc664960f0ffc495c373900d6b13e434927d -在你刚开始编写 Rust 程序时，代码可能仅仅位于 `main` 函数里。随着代码数量的增长，最终你会将功能移动到其他函数中，为了复用也为了更好的组织。通过将代码分隔成更小的块，每一个块代码自身就更易于理解。不过当你发现自己有太多的函数了该怎么办呢？Rust 有一个模块系统可以有组织的复用代码。 +在你刚开始编写 Rust 程序时，代码可能仅仅位于 `main` 函数里。随着代码数量的增长，为了复用和更好地组织代码，最终你会将功能移动到其他函数中。通过将代码分隔成更小的块，每一个块代码自身就更易于理解。不过当你发现自己有太多的函数了该怎么办呢？Rust 有一个模块系统可以有组织地复用代码。 -就跟你将代码行提取到一个函数中一样，也可以将函数（和其他类似结构体和枚举的代码）提取到不同模块中。**模块**（*module*）是一个包含函数或类型定义的命名空间，你可以选择这些定义是能（公有）还是不能（私有）在其模块外可见。这是一个模块如何工作的概括： +就跟你将代码行提取到一个函数中一样，也可以将函数（和其他类似结构体和枚举的代码）提取到不同模块中。**模块**（*module*）是一个包含函数或类型定义的命名空间，你可以选择这些定义能（公有）或不能（私有）在其模块外可见。下面是一个模块如何工作的梗概： * 使用 `mod` 关键字声明新模块。此模块的代码要么直接位于声明之后的大括号中，要么位于另一个文件。 * 函数、类型、常量和模块默认都是私有的。可以使用 `pub` 关键字将其变成公有并在命名空间之外可见。 -* `use` 关键字引入模块、或模块中的定义到作用域中以便于引用他们。 +* `use` 关键字将模块或模块中的定义引入到作用域中以便于引用它们。 -我们会逐一了解这每一部分并学习如何将他们结合在一起。 \ No newline at end of file +我们会逐一了解这每一部分并学习如何将它们结合在一起。 diff --git a/src/ch07-01-mod-and-the-filesystem.md b/src/ch07-01-mod-and-the-filesystem.md index 0332450..6ce5de4 100644 --- a/src/ch07-01-mod-and-the-filesystem.md +++ b/src/ch07-01-mod-and-the-filesystem.md @@ -4,7 +4,7 @@ >
> commit c6a9e77a1b1ed367e0a6d5dcd222589ad392a8ac -我们将通过使用 Cargo 创建一个新项目来开始我们的模块之旅，不过不再创建一个二进制 crate，而是创建一个库 crate：一个其他人可以作为依赖导入的项目。第二章猜猜看游戏中作为依赖使用的 `rand` 就是这样的 crate。 +我们将通过使用 Cargo 创建一个新项目来开始我们的模块之旅，不过这次不再创建一个二进制 crate，而是创建一个库 crate：一个其他人可以作为依赖导入的项目。第二章猜猜看游戏中作为依赖使用的 `rand` 就是这样的 crate。 我们将创建一个提供一些通用网络功能的项目的骨架结构；我们将专注于模块和函数的组织，而不担心函数体中的具体代码。这个项目叫做 `communicator`。Cargo 默认会创建一个库 crate 除非指定其他项目类型，所以如果不像一直以来那样加入 `--bin` 参数则项目将会是一个库： @@ -22,11 +22,12 @@ $ cd communicator mod tests { #[test] fn it_works() { + assert_eq!(2 + 2, 4); } } ``` -Cargo 创建了一个空的测试来帮助我们开始库项目，不像使用 `--bin` 参数那样创建一个 “Hello, world!” 二进制项目。在本章之后的 “使用 `super` 访问父模块” 部分会介绍 `#[]` 和 `mod tests` 语法，目前只需确保他们位于 *src/lib.rs* 底部即可。 +Cargo 创建了一个空的测试来帮助我们开始库项目，不像使用 `--bin` 参数那样创建一个 “Hello, world!” 二进制项目。在本章之后的 “使用 `super` 访问父模块” 部分会介绍 `#[]` 和 `mod tests` 语法，目前只需确保它们位于 *src/lib.rs* 底部即可。 因为没有 *src/main.rs* 文件，所以没有可供 Cargo 的 `cargo run` 执行的东西。因此，我们将使用 `cargo build` 命令只是编译库 crate 的代码。 @@ -65,7 +66,7 @@ mod client { 示例 7-1：`network` 模块和 `client` 一同定义于 *src/lib.rs* -现在我们有了 `network::connect` 函数和 `client::connect` 函数。他们可能有着完全不同的功能，同时他们也不会彼此冲突，因为他们位于不同的模块。 +现在我们有了 `network::connect` 函数和 `client::connect` 函数。它们可能有着完全不同的功能，同时它们也不会彼此冲突，因为它们位于不同的模块。 在这个例子中，因为我们构建的是一个库，作为库入口点的文件是 *src/lib.rs*。然而，对于创建模块来说，*src/lib.rs* 并没有什么特殊意义。也可以在二进制 crate 的 *src/main.rs* 中创建模块，正如在库 crate 的 *src/lib.rs* 创建模块一样。事实上，也可以将模块放入其他模块中。这有助于随着模块的增长，将相关的功能组织在一起并又保持各自独立。如何选择组织代码依赖于如何考虑代码不同部分之间的关系。例如，对于库的用户来说，`client` 模块和它的函数 `connect` 可能放在 `network` 命名空间里显得更有道理，如示例 7-2 所示： @@ -85,7 +86,7 @@ mod network { 示例 7-2：将 `client` 模块移动到 `network` 模块中 -在 *src/lib.rs* 文件中，将现有的 `mod network` 和 `mod client` 的定义替换为示例 7-2 中的定义，这里将 `client` 模块作为 `network` 的一个内部模块。现在我们有了 `network::connect` 和 `network::client::connect` 函数：同样的，这两个 `connect` 函数也不相冲突，因为他们在不同的命名空间中。 +在 *src/lib.rs* 文件中，将现有的 `mod network` 和 `mod client` 的定义替换为示例 7-2 中的定义，这里将 `client` 模块作为 `network` 的一个内部模块。现在我们有了 `network::connect` 和 `network::client::connect` 函数：同样的，这两个 `connect` 函数也不相冲突，因为它们在不同的命名空间中。 这样，模块之间形成了一个层次结构。*src/lib.rs* 的内容位于最顶层，而其子模块位于较低的层次。如下是示例 7-1 中的例子以层次的方式考虑的结构： @@ -103,7 +104,7 @@ communicator └── client ``` -可以看到示例 7-2 中，`client` 是 `network` 的子模块，而不是它的同级模块。更为复杂的项目可以有很多的模块，所以他们需要符合逻辑地组合在一起以便记录他们。在项目中 “符合逻辑” 的意义全凭你的理解和库的用户对你项目领域的认识。利用我们这里讲到的技术来创建同级模块和嵌套的模块，总有一个会是你会喜欢的结构。 +可以看到示例 7-2 中，`client` 是 `network` 的子模块，而不是它的同级模块。更为复杂的项目可以有很多的模块，所以它们需要符合逻辑地组合在一起以便记录它们。在项目中 “符合逻辑” 的意义全凭你的理解和库的用户对你项目领域的认识。利用我们这里讲到的技术来创建同级模块和嵌套的模块，总有一个会是你会喜欢的结构。 ### 将模块移动到其他文件 @@ -128,7 +129,7 @@ mod network { } ``` -示例 7-3：三个模块，`client`、`network` 和 `network::server`，他们都定义于 *src/lib.rs* +示例 7-3：三个模块，`client`、`network` 和 `network::server`，它们都定义于 *src/lib.rs* *src/lib.rs* 文件有如下层次结构： @@ -139,7 +140,7 @@ communicator └── server ``` -如果这些模块有很多函数，而这些函数又很长，将难以在文件中寻找我们需要的代码。因为这些函数被嵌套进一个或多个模块中，同时函数中的代码也会开始变长。这就有充分的理由将`client`、`network` 和 `server`每一个模块从 *src/lib.rs* 抽出并放入他们自己的文件中。 +如果这些模块有很多函数，而这些函数又很长，将难以在文件中寻找我们需要的代码。因为这些函数被嵌套进一个或多个模块中，同时函数中的代码也会开始变长。这就有充分的理由将`client`、`network` 和 `server`每一个模块从 *src/lib.rs* 抽出并放入它们自己的文件中。 首先，将 `client` 模块的代码替换为只有 `client` 模块声明，这样 *src/lib.rs* 看起来应该像这样： @@ -205,7 +206,7 @@ warning: function is never used: `connect`, #[warn(dead_code)] on by default | ^ ``` -这些警告提醒我们有从未被使用的函数。目前不用担心这些警告；在本章后面的 “使用 `pub` 控制可见性” 部分会解决他们。好消息是，他们仅仅是警告；我们的项目能够被成功编译。 +这些警告提醒我们有从未被使用的函数。目前不用担心这些警告，在本章后面的 “使用 `pub` 控制可见性” 部分会解决它们。好消息是，它们仅仅是警告，我们的项目能够被成功编译。 下面使用相同的模式将 `network` 模块提取到自己的文件中。删除 *src/lib.rs* 中 `network` 模块的内容并在声明后加上一个分号，像这样： diff --git a/src/ch07-02-controlling-visibility-with-pub.md b/src/ch07-02-controlling-visibility-with-pub.md index 864179e..94381a8 100644 --- a/src/ch07-02-controlling-visibility-with-pub.md +++ b/src/ch07-02-controlling-visibility-with-pub.md @@ -26,9 +26,9 @@ warning: function is never used: `connect`, #[warn(dead_code)] on by default | ^ ``` -那么为什么会出现这些错误信息呢？我们构建的是一个库，它的函数的目的是被 **用户** 使用，而不一定要被项目自身使用，所以不应该担心这些 `connect` 函数是未使用的。创建他们的意义就在于被另一个项目而不是被我们自己使用。 +那么为什么会出现这些错误信息呢？我们构建的是一个库，它的函数的目的是被 **用户** 使用，而不一定要被项目自身使用，所以不应该担心这些 `connect` 函数是未使用的。创建它们的意义就在于被另一个项目而不是被我们自己使用。 -为了理解为什么这个程序出现了这些警告，尝试作为另一个项目来使用这个 `connect` 库，从外部调用他们。为此，通过创建一个包含这些代码的 *src/main.rs* 文件，在与库 crate 相同的目录创建一个二进制 crate： +为了理解为什么这个程序出现了这些警告，尝试作为另一个项目来使用这个 `connect` 库，从外部调用它们。为此，通过创建一个包含这些代码的 *src/main.rs* 文件，在与库 crate 相同的目录创建一个二进制 crate： 文件名: src/main.rs @@ -82,7 +82,7 @@ error: function `connect` is private | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` -非常好！另一个不同的错误！好的，不同的错误信息也是值得庆祝的（可能是程序员被黑的最惨的一次）。新错误表明 “函数 `connect` 是私有的”，那么让我们修改 *src/client.rs* 将 `client::connect` 也设为公有： +非常好！另一个不同的错误！好的，不同的错误信息也是值得庆祝的（可能是程序员被黑的最惨的一次）。新错误表明“函数 `connect` 是私有的”，那么让我们修改 *src/client.rs* 将 `client::connect` 也设为公有： 文件名: src/client.rs @@ -109,7 +109,7 @@ warning: function is never used: `connect`, #[warn(dead_code)] on by default 编译通过了，关于 `client::connect` 未被使用的警告消失了！ -未被使用的代码并不总是意味着他们需要被设为公有的：如果你 **不** 希望这些函数成为公有 API 的一部分，未被使用的代码警告可能是在警告你这些代码不再需要并可以安全的删除他们。这也可能是警告你出 bug 了，如果你刚刚不小心删除了库中所有这个函数的调用。 +未被使用的代码并不总是意味着它们需要被设为公有的：如果你 **不** 希望这些函数成为公有 API 的一部分，未被使用的代码警告可能是在警告你这些代码不再需要并可以安全的删除它们。这也可能是警告你出 bug 了，如果你刚刚不小心删除了库中所有这个函数的调用。 当然我们的情况是，**确实** 希望另外两个函数也作为 crate 公有 API 的一部分，所以让我们也将其标记为 `pub` 并去掉剩余的警告。修改 *src/network/mod.rs* 为： @@ -138,7 +138,7 @@ warning: function is never used: `connect`, #[warn(dead_code)] on by default | ^ ``` -恩，虽然将 `network::connect` 设为 `pub` 了我们仍然得到了一个未被使用函数的警告。这是因为模块中的函数是公有的，不过函数所在的 `network` 模块却不是公有的。这回我们是自内向外修改库文件的，而 `client::connect` 的时候是自外向内修改的。我们需要修改 *src/lib.rs* 让 `network` 也是公有的： +虽然将 `network::connect` 设为 `pub` 了我们仍然得到了一个未被使用函数的警告。这是因为模块中的函数是公有的，不过函数所在的 `network` 模块却不是公有的。这回我们是自内向外修改库文件的，而 `client::connect` 的时候是自外向内修改的。我们需要修改 *src/lib.rs* 让 `network` 也是公有的： 文件名: src/lib.rs @@ -200,7 +200,7 @@ fn try_me() { #### 检查错误 -`try_me` 函数位于项目的根模块。叫做 `outermost` 的模块是私有的，不过第二条私有性规则说明` try_me` 函数允许访问 `outermost` 模块，因为 `outermost` 位于当前（根）模块，`try_me` 也是。 +`try_me` 函数位于项目的根模块。叫做 `outermost` 的模块是私有的，不过第二条私有性规则说明 `try_me` 函数允许访问 `outermost` 模块，因为 `outermost` 位于当前（根）模块，`try_me` 也是。 `outermost::middle_function` 的调用是正确的。因为 `middle_function` 是公有的，而 `try_me` 通过其父模块 `outermost` 访问 `middle_function`。根据上一段的规则我们可以确定这个模块是可访问的。 @@ -210,12 +210,12 @@ fn try_me() { #### 修改错误 -这里有一些尝试修复错误的代码修改意见。在你尝试他们之前，猜测一下他们哪个能修复错误，接着编译查看你是否猜对了，并结合私有性规则理解为什么。 +这里有一些尝试修复错误的代码修改意见。在你尝试它们之前，猜测一下它们哪个能修复错误，接着编译查看你是否猜对了，并结合私有性规则理解为什么。 * 如果 `inside` 模块是公有的？ * 如果 `outermost` 是公有的而 `inside` 是私有的？ * 如果在 `inner_function` 函数体中调用 `::outermost::middle_secret_function()`？（开头的两个冒号意味着从根模块开始引用模块。） -请随意设计更多的实验并尝试理解他们！ +请随意设计更多的实验并尝试理解它们！ -接下来，让我们讨论一下使用 `use` 关键字将模块项目引入作用域。 \ No newline at end of file +接下来，让我们讨论一下使用 `use` 关键字将模块项目引入作用域。 diff --git a/src/ch07-03-importing-names-with-use.md b/src/ch07-03-importing-names-with-use.md index 852ce2a..c691eae 100644 --- a/src/ch07-03-importing-names-with-use.md +++ b/src/ch07-03-importing-names-with-use.md @@ -72,7 +72,7 @@ fn main() { 这使得我们可以忽略所有的模块并直接引用函数。 -因为枚举也像模块一样组成了某种命名空间，也可以使用 `use` 来导入枚举的成员。对于任何类型的 `use` 语句，如果从一个命名空间导入多个项，可以使用大括号和逗号来列举他们，像这样： +因为枚举也像模块一样组成了某种命名空间，也可以使用 `use` 来导入枚举的成员。对于任何类型的 `use` 语句，如果从一个命名空间导入多个项，可以使用大括号和逗号来列举它们，像这样： ```rust enum TrafficLight { @@ -110,7 +110,7 @@ fn main() { } ``` -`*` 被称为 **全局导入**（*glob*），它会导入命名空间中所有可见的项。全局导入应该保守的使用：他们是方便的，但是也可能会引入多于你预期的内容从而导致命名冲突。 +`*` 被称为 **全局导入**（*glob*），它会导入命名空间中所有可见的项。全局导入应该保守的使用：它们是方便的，但是也可能会引入多于你预期的内容从而导致命名冲突。 ### 使用 `super` 访问父模块 @@ -127,6 +127,7 @@ pub mod network; mod tests { #[test] fn it_works() { + assert_eq!(2 + 2, 4); } } ``` @@ -167,7 +168,7 @@ error[E0433]: failed to resolve. Use of undeclared type or module `client` | ^^^^^^^^^^^^^^^ Use of undeclared type or module `client` ``` -编译失败了，不过为什么呢？并不需要像 *src/main.rs* 那样将 `communicator::` 置于函数前，因为这里肯定是在 `communicator` 库 crate 之内的。之所以失败的原因是路径是相对于当前模块的，在这里就是 `tests`。唯一的例外就是 `use` 语句，它默认是相对于 crate 根模块的。我们的 `tests` 模块需要 `client` 模块位于其作用域中！ +编译失败了，不过为什么呢？并不需要像 *src/main.rs* 那样将 `communicator::` 置于函数前，因为这里肯定是在 `communicator` 库 crate 之内的。失败的原因是路径是相对于当前模块的，在这里就是 `tests`。唯一的例外就是 `use` 语句，它默认是相对于 crate 根模块的。我们的 `tests` 模块需要 `client` 模块位于其作用域中！ 那么如何在模块层次结构中回退一级模块，以便在 `tests` 模块中能够调用 `client::connect`函数呢？在 `tests` 模块中，要么可以在开头使用双冒号来让 Rust 知道我们想要从根模块开始并列出整个路径： @@ -216,6 +217,6 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured ## 总结 -现在你掌握了组织代码的核心科技！利用他们将相关的代码组合在一起、防止代码文件过长并将一个整洁的公有 API 展现给库的用户。 +现在你掌握了组织代码的核心科技！利用它们将相关的代码组合在一起、防止代码文件过长并将一个整洁的公有 API 展现给库的用户。 -接下来，让我们看看一些标准库提供的集合数据类型，你可以利用他们编写出漂亮整洁的代码。 \ No newline at end of file +接下来，让我们看看一些标准库提供的集合数据类型，你可以利用它们编写出漂亮整洁的代码。 diff --git a/src/ch08-00-common-collections.md b/src/ch08-00-common-collections.md index d3f99eb..f62c5a7 100644 --- a/src/ch08-00-common-collections.md +++ b/src/ch08-00-common-collections.md @@ -14,4 +14,4 @@ Rust 标准库中包含一系列被称为 **集合**（*collections*）的非常 [collections]: https://doc.rust-lang.org/std/collections -我们将讨论如何创建和更新 vector、字符串和哈希 map，以及他们有什么不同。 \ No newline at end of file +我们将讨论如何创建和更新 vector、字符串和哈希 map，以及它们有什么不同。 diff --git a/src/ch08-01-vectors.md b/src/ch08-01-vectors.md index 503a786..a6f924a 100644 --- a/src/ch08-01-vectors.md +++ b/src/ch08-01-vectors.md @@ -4,17 +4,17 @@ >
> commit 6c24544ba718bce0755bdaf03423af86280051d5 -我们要讲到的第一个类型是`Vec`，也被称为 *vector*。vector 允许我们在一个单独的数据结构中储存多于一个值，它在内存中彼此相邻的排列所有的值。vector 只能储存相同类型的值。他们在拥有一系列项的场景下非常实用，例如文件中的文本行或是购物车中商品的价格。 +我们要讲到的第一个类型是`Vec`，也被称为 *vector*。vector 允许我们在一个单独的数据结构中储存多于一个值，它在内存中彼此相邻地排列所有的值。vector 只能储存相同类型的值。它们在拥有一系列项的场景下非常实用，例如文件中的文本行或是购物车中商品的价格。 ### 新建 vector -为了创建一个新的，空的 vector，可以调用 `Vec::new` 函数： +为了创建一个新的空 vector，可以调用 `Vec::new` 函数： ```rust let v: Vec = Vec::new(); ``` -注意这里我们增加了一个类型注解。因为没有向这个 vector 中插入任何值，Rust 并不知道我们想要储存什么类型的元素。这是一个非常重要的点。vector 是同质的（homogeneous）：他们可以储存很多值，不过这些值必须都是相同类型的。vector 是用泛型实现的，第十章会涉及到如何对你自己的类型使用他们。现在，所有你需要知道的就是 `Vec` 是一个由标准库提供的类型，它可以存放任何类型，而当 `Vec` 存放某个特定类型时，那个类型位于尖括号中。这里我们告诉 Rust `v` 这个 `Vec` 将存放 `i32` 类型的元素。 +注意这里我们增加了一个类型注解。因为没有向这个 vector 中插入任何值，Rust 并不知道我们想要储存什么类型的元素。这是一个非常重要的点。vector 是同质的（homogeneous）：它们可以储存很多值，不过这些值必须都是相同类型的。vector 是用泛型实现的，第十章会涉及到如何对你自己的类型使用它们。现在，所有你需要知道的就是 `Vec` 是一个由标准库提供的类型，它可以存放任何类型，而当 `Vec` 存放某个特定类型时，那个类型位于尖括号中。这里我们告诉 Rust `v` 这个 `Vec` 将存放 `i32` 类型的元素。 在实际的代码中，一旦插入值 Rust 就可以推断出想要存放的类型，所以你很少会需要这些类型注解。更常见的做法是使用初始值来创建一个 `Vec`，而且为了方便 Rust 提供了 `vec!` 宏。这个宏会根据我们提供的值来创建一个新的 `Vec`。如下代码会新建一个拥有值 `1`、`2` 和 `3` 的 `Vec`： @@ -56,7 +56,7 @@ v.push(8); ### 读取 vector 的元素 -现在你知道如何创建、更新和销毁 vector 了，接下来的一步最好了解一下如何读取他们的内容。有两种方法引用 vector 中储存的值。为了更加清楚的说明这个例子，我们标注这些函数返回的值的类型。 +现在你知道如何创建、更新和销毁 vector 了，接下来的一步最好了解一下如何读取它们的内容。有两种方法引用 vector 中储存的值。为了更加清楚的说明这个例子，我们标注这些函数返回的值的类型。 这个例子展示了访问 vector 中一个值的两种方式，索引语法或者 `get` 方法： @@ -80,7 +80,7 @@ let does_not_exist = v.get(100); 当运行这段代码，你会发现对于第一个 `[]` 方法，当引用一个不存在的元素时 Rust 会造成 `panic!`。这个方法更适合当程序认为尝试访问超过 vector 结尾的元素是一个严重错误的情况，这时应该使程序崩溃。 -当 `get` 方法被传递了一个数组外的索引时，它不会 panic 而是返回 `None`。当偶尔出现超过 vector 范围的访问属于正常情况的时候可以考虑使用它。接着你的代码可以有处理 `Some(&element)` 或 `None` 的逻辑，如第六章讨论的那样。例如，索引可能来源于用户输入的数字。如果他们不慎输入了一个过大的数字那么程序就会得到 `None` 值，你可以告诉用户 `Vec` 当前元素的数量并再请求他们输入一个有效的值。这就比因为输入错误而使程序崩溃要友好的多！ +当 `get` 方法被传递了一个数组外的索引时，它不会 panic 而是返回 `None`。当偶尔出现超过 vector 范围的访问属于正常情况的时候可以考虑使用它。接着你的代码可以有处理 `Some(&element)` 或 `None` 的逻辑，如第六章讨论的那样。例如，索引可能来源于用户输入的数字。如果它们不慎输入了一个过大的数字那么程序就会得到 `None` 值，你可以告诉用户 `Vec` 当前元素的数量并再请求它们输入一个有效的值。这就比因为输入错误而使程序崩溃要友好的多！ #### 无效引用 @@ -137,6 +137,6 @@ let row = vec![ Rust 在编译时就必须准确的知道 vector 中类型的原因在于它需要知道储存每个元素到底需要多少内存。第二个好处是可以准确的知道这个 vector 中允许什么类型。如果 Rust 允许 vector 存放任意类型，那么当对 vector 元素执行操作时一个或多个类型的值就有可能会造成错误。使用枚举外加 `match` 意味着 Rust 能在编译时就保证总是会处理所有可能的情况，正如第六章讲到的那样。 -如果在编写程序时不能确切无遗的知道运行时会储存进 vector 的所有类型，枚举技术就行不通了。相反，你可以使用 trait 对象，第十七章会讲到它。 +如果在编写程序时不能确切无遗地知道运行时会储存进 vector 的所有类型，枚举技术就行不通了。相反，你可以使用 trait 对象，第十七章会讲到它。 -现在我们了解了一些使用 vector 的最常见的方式，请一定去看看标准库中 `Vec` 定义的很多其他实用方法的 API 文档。例如，除了 `push` 之外还有一个 `pop` 方法，它会移除并返回 vector 的最后一个元素。让我们继续下一个集合类型：`String`！ \ No newline at end of file +现在我们了解了一些使用 vector 的最常见的方式，请一定去看看标准库中 `Vec` 定义的很多其他实用方法的 API 文档。例如，除了 `push` 之外还有一个 `pop` 方法，它会移除并返回 vector 的最后一个元素。让我们继续下一个集合类型：`String`！ diff --git a/src/ch08-02-strings.md b/src/ch08-02-strings.md index cd2e99a..5e0c086 100644 --- a/src/ch08-02-strings.md +++ b/src/ch08-02-strings.md @@ -10,11 +10,11 @@ ### 什么是字符串？ -在开始深入这些方面之前，我们需要讨论一下术语 **字符串** 的具体意义。Rust 的核心语言中事实上就只有一种字符串类型：`str`，字符串 slice，它通常以被借用的形式出现，`&str`。第四章讲到了 **字符串 slice**：他们是一些储存在别处的 UTF-8 编码字符串数据的引用。比如字符串字面值被储存在程序的二进制输出中，字符串 slice 也是如此。 +在开始深入这些方面之前，我们需要讨论一下术语 **字符串** 的具体意义。Rust 的核心语言中事实上就只有一种字符串类型：`str`，字符串 slice，它通常以被借用的形式出现，`&str`。第四章讲到了 **字符串 slice**：它们是一些储存在别处的 UTF-8 编码字符串数据的引用。比如字符串字面值被储存在程序的二进制输出中，字符串 slice 也是如此。 -称作 `String` 的类型是由标准库提供的，而没有写进核心语言部分，它是可增长的、可变的、有所有权的、UTF-8 编码的字符串类型。当 Rustacean 们谈到 Rust 的 “字符串”时，他们通常指的是 `String` 和字符串 slice `&str`类型，而不是其中一个。这一部分大部分是关于 `String` 的，不过这些类型在 Rust 标准库中都被广泛使用。`String` 和字符串 slice 都是 UTF-8 编码的。 +称作 `String` 的类型是由标准库提供的，而没有写进核心语言部分，它是可增长的、可变的、有所有权的、UTF-8 编码的字符串类型。当 Rustacean 们谈到 Rust 的 “字符串”时，它们通常指的是 `String` 和字符串 slice `&str`类型，而不是其中一个。这一部分大部分是关于 `String` 的，不过这些类型在 Rust 标准库中都被广泛使用。`String` 和字符串 slice 都是 UTF-8 编码的。 -Rust 标准库中还包含一系列其他字符串类型，比如 `OsString`、`OsStr`、`CString` 和 `CStr`。相关库 crate 甚至会提供更多储存字符串数据的选择。与 `*String`/`*Str` 的命名类似，他们通常也提供有所有权和可借用的变体，就比如说 `String`/`&str`。这些字符串类型在储存的编码或内存表现形式上可能有所不同。本章将不会讨论其他这些字符串类型；查看 API 文档来更多的了解如何使用他们以及各自适合的场景。 +Rust 标准库中还包含一系列其他字符串类型，比如 `OsString`、`OsStr`、`CString` 和 `CStr`。相关库 crate 甚至会提供更多储存字符串数据的选择。与 `*String`/`*Str` 的命名类似，它们通常也提供有所有权和可借用的变体，就比如说 `String`/`&str`。这些字符串类型在储存的编码或内存表现形式上可能有所不同。本章将不会讨论其他这些字符串类型；查看 API 文档来更多的了解如何使用它们以及各自适合的场景。 ### 新建字符串 @@ -26,7 +26,7 @@ let mut s = String::new(); 这新建了一个叫做 `s` 的空的字符串，接着我们可以向其中装载数据。 -通常字符串会有初始数据因为我们希望一开始就有这个字符串。为此，使用 `to_string` 方法，它能用于任何实现了 `Display` trait 的类型，对于字符串字面值是这样： +通常字符串会有初始数据，因为我们希望一开始就有这个字符串。为此，使用 `to_string` 方法，它能用于任何实现了 `Display` trait 的类型，对于字符串字面值是这样： ```rust let data = "initial contents"; @@ -39,13 +39,13 @@ let s = "initial contents".to_string(); 这会创建一个包含 `initial contents` 的字符串。 -也可以使用 `String::from` 函数来从字符串字面值创建 `String`。如下等同于使用 `to_string`： +也可以使用 `String::from` 函数来从字符串字面值创建 `String`。下面代码等同于使用 `to_string`： ```rust let s = String::from("initial contents"); ``` -因为字符串使用广泛，这里有很多不同的用于字符串的通用 API 可供选择。他们有些可能显得有些多余，不过都有其用武之地！在这个例子中，`String::from` 和 `.to_string` 最终做了完全相同的工作，所以如何选择就是风格问题了。 +因为字符串使用广泛，这里有很多不同的用于字符串的通用 API 可供选择。它们有些可能显得有些多余，不过都有其用武之地！在这个例子中，`String::from` 和 `.to_string` 最终做了完全相同的工作，所以如何选择就是风格问题了。 记住字符串是 UTF-8 编码的，所以可以包含任何可以正确编码的数据： @@ -195,13 +195,13 @@ let answer = &hello[0]; 224, 165, 135] ``` -这里有 18 个字节，也就是计算机最终会储存的数据。如果从 Unicode 标量值的角度理解他们，也就像 Rust 的 `char` 类型那样，这些字节看起来像这样： +这里有 18 个字节，也就是计算机最终会储存的数据。如果从 Unicode 标量值的角度理解它们，也就像 Rust 的 `char` 类型那样，这些字节看起来像这样： ```text ['न', 'म', 'स', '्', 'त', 'े'] ``` -这里有六个 `char`，不过第四个和第六个都不是字母，他们是发音符号本身并没有任何意义。最后，如果以字形簇的角度理解，就会得到人们所说的构成这个单词的四个字母： +这里有六个 `char`，不过第四个和第六个都不是字母，它们是发音符号本身并没有任何意义。最后，如果以字形簇的角度理解，就会得到人们所说的构成这个单词的四个字母： ```text ["न", "म", "स्", "ते"] diff --git a/src/ch08-03-hash-maps.md b/src/ch08-03-hash-maps.md index c850c43..d93aa11 100644 --- a/src/ch08-03-hash-maps.md +++ b/src/ch08-03-hash-maps.md @@ -6,7 +6,7 @@ 最后介绍的常用集合类型是 **哈希 map**（*hash map*）。`HashMap` 类型储存了一个键类型 `K` 对应一个值类型 `V` 的映射。它通过一个 **哈希函数**（*hashing function*）来实现映射，决定如何将键和值放入内存中。很多编程语言支持这种数据结构，不过通常有不同的名字：哈希、map、对象、哈希表或者关联数组，仅举几例。 -哈希 map 可以用于需要任何类型作为键来寻找数据的情况，而不是像 vector 那样通过索引。例如，在一个游戏中，你可以将每个团队的分数记录到哈希 map 中，其中键是队伍的名字而值是每个队伍的分数。给出一个队名，就能得到他们的得分。 +哈希 map 可以用于需要任何类型作为键来寻找数据的情况，而不是像 vector 那样通过索引。例如，在一个游戏中，你可以将每个团队的分数记录到哈希 map 中，其中键是队伍的名字而值是每个队伍的分数。给出一个队名，就能得到它们的得分。 本章我们会介绍哈希 map 的基本 API，不过还有更多吸引人的功能隐藏于标准库中 `HashMap` 定义的函数中。请一如既往地查看标准库文档来了解更多信息。 @@ -24,7 +24,7 @@ scores.insert(String::from("Yellow"), 50); ``` 注意必须首先 `use` 标准库中集合部分的 `HashMap`。在这三个常用集合中，`HashMap` 是最不常用的，所以并没有被 prelude 自动引用。标准库中对 `HashMap` 的支持也相对较少，例如，并没有内建的构建宏。 -像 vector 一样，哈希 map 将他们的数据储存在堆上，这个 `HashMap` 的键类型是 `String` 而值类型是 `i32`。同样类似于 vector，哈希 map 是同质的：所有的键必须是相同类型，值也必须都是相同类型。 +像 vector 一样，哈希 map 将它们的数据储存在堆上，这个 `HashMap` 的键类型是 `String` 而值类型是 `i32`。同样类似于 vector，哈希 map 是同质的：所有的键必须是相同类型，值也必须都是相同类型。 另一个构建哈希 map 的方法是使用一个元组的 vector 的 `collect` 方法，其中每个元组包含一个键值对。`collect` 方法可以将数据收集进一系列的集合类型，包括 `HashMap`。例如，如果队伍的名字和初始分数分别在两个 vector 中，可以使用 `zip` 方法来创建一个元组的 vector，其中 “Blue” 与 10 是一对，依此类推。接着就可以使用 `collect` 方法将这个元组 vector 转换成一个 `HashMap`： @@ -163,7 +163,7 @@ println!("{:?}", map); ### 哈希函数 -`HashMap` 默认使用一种密码学安全的哈希函数，它可以抵抗拒绝服务（Denial of Service, DoS）攻击。然而并不是最快的，不过为了更高的安全性值得付出一些性能的代价。如果性能监测显示此哈希函数非常慢，以致于你无法接受，你可以指定一个不同的 *hasher* 来切换为其它函数。hasher 是一个实现了 `BuildHasher` trait 的类型。第十章会讨论 trait 和如何实现他们。你并不需要从头开始实现你自己的 hasher；crates.io 有其他人分享的实现了许多常用哈希算法的 hasher 的库。 +`HashMap` 默认使用一种密码学安全的哈希函数，它可以抵抗拒绝服务（Denial of Service, DoS）攻击。然而并不是最快的，不过为了更高的安全性值得付出一些性能的代价。如果性能监测显示此哈希函数非常慢，以致于你无法接受，你可以指定一个不同的 *hasher* 来切换为其它函数。hasher 是一个实现了 `BuildHasher` trait 的类型。第十章会讨论 trait 和如何实现它们。你并不需要从头开始实现你自己的 hasher；crates.io 有其他人分享的实现了许多常用哈希算法的 hasher 的库。 ## 总结 @@ -175,4 +175,4 @@ vector、字符串和哈希 map 会在你的程序需要储存、访问和修改 标准库 API 文档中描述的这些类型的方法将有助于你进行这些练习！ -我们已经开始接触可能会有失败操作的复杂程序了，这也意味着接下来是一个了解错误处理的绝佳时机！ \ No newline at end of file +我们已经开始接触可能会有失败操作的复杂程序了，这也意味着接下来是一个了解错误处理的绝佳时机！ From 46e3393e75faed6716128f25f496c2df88857241 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Wed, 6 Dec 2017 09:26:01 +0800 Subject: [PATCH 081/150] fix typo --- src/ch09-02-recoverable-errors-with-result.md | 6 +++--- src/ch09-03-to-panic-or-not-to-panic.md | 2 +- src/ch10-00-generics.md | 2 +- src/ch10-01-syntax.md | 2 +- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/ch09-02-recoverable-errors-with-result.md b/src/ch09-02-recoverable-errors-with-result.md index 9ef6fd5..0a137cf 100644 --- a/src/ch09-02-recoverable-errors-with-result.md +++ b/src/ch09-02-recoverable-errors-with-result.md @@ -205,11 +205,11 @@ fn read_username_from_file() -> Result { 首先让我们看看函数的返回值：`Result`。这意味着函数返回一个 `Result` 类型的值，其中泛型参数 `T` 的具体类型是 `String`，而 `E` 的具体类型是 `io::Error`。如果这个函数没有出任何错误成功返回，函数的调用者会收到一个包含 `String` 的 `Ok` 值————函数从文件中读取到的用户名。如果函数遇到任何错误，函数的调用者会收到一个 `Err` 值，它储存了一个包含更多这个问题相关信息的 `io::Error` 实例。这里选择 `io::Error` 作为函数的返回值是因为它正好是函数体中那两个可能会失败的操作的错误返回值：`File::open` 函数和 `read_to_string` 方法。 -函数体以 `File::open` 函数开头。接着使用 `match` 处理返回值 `Result`，类似于示例 9-3 中的 `match`，唯一的区别是不再当 `Err` 时调用 `panic!`，而是提早返回并将 `File::open` 返回的错误值作为函数的错误返回值传递给调用者。如果 `File::open` 成功了，我们将文件句柄储存在变量 `f` 中并继续。 +函数体以 `File::open` 函数开头。接着使用 `match` 处理返回值 `Result`，类似于示例 9-3 中的 `match`，唯一的区别是当 `Err` 时不再调用 `panic!`，而是提早返回并将 `File::open` 返回的错误值作为函数的错误返回值传递给调用者。如果 `File::open` 成功了，我们将文件句柄储存在变量 `f` 中并继续。 接着我们在变量 `s` 中创建了一个新 `String` 并调用文件句柄 `f` 的 `read_to_string` 方法来将文件的内容读取到 `s` 中。`read_to_string` 方法也返回一个 `Result` 因为它也可能会失败：哪怕是 `File::open` 已经成功了。所以我们需要另一个 `match` 来处理这个 `Result`：如果 `read_to_string` 成功了，那么这个函数就成功了，并返回文件中的用户名，它现在位于被封装进 `Ok` 的 `s` 中。如果`read_to_string` 失败了，则像之前处理 `File::open` 的返回值的 `match` 那样返回错误值。并不需要显式的调用 `return`，因为这是函数的最后一个表达式。 -调用这个函数的代码最终会得到一个包含用户名的 `Ok` 值，或者一个包含 `io::Error` 的 `Err` 值。我们无从得知调用者会如何处理这些值。例如，如果他们得到了一个 `Err` 值，他们可能会选择 `panic!` 并使程序崩溃、使用一个默认的用户名或者从文件之外的地方寻找用户名。我们没有足够的信息知晓调用者具体会如何尝试，所以将所有的成功或失败信息向上传播，让他们选择合适处理方法。 +调用这个函数的代码最终会得到一个包含用户名的 `Ok` 值，或者一个包含 `io::Error` 的 `Err` 值。我们无从得知调用者会如何处理这些值。例如，如果他们得到了一个 `Err` 值，他们可能会选择 `panic!` 并使程序崩溃、使用一个默认的用户名或者从文件之外的地方寻找用户名。我们没有足够的信息知晓调用者具体会如何尝试，所以将所有的成功或失败信息向上传播，让他们选择合适的处理方法。 这种传播错误的模式在 Rust 是如此的常见，以至于有一个更简便的专用语法：`?`。 @@ -234,7 +234,7 @@ fn read_username_from_file() -> Result { `Result` 值之后的 `?` 被定义为与示例 9-5 中定义的处理 `Result` 值的 `match` 表达式有着完全相同的工作方式。如果 `Result` 的值是 `Ok`，这个表达式将会返回 `Ok` 中的值而程序将继续执行。如果值是 `Err`，`Err` 中的值将作为整个函数的返回值，就好像使用了 `return` 关键字一样，这样错误值就被传播给了调用者。 -在示例 9-6 的上下文中，`File::open` 调用结尾的 `?` 将会把 `Ok` 中的值返回给变量 `f`。如果出现了错误，`?` 会提早返回整个函数并将任何 `Err` 值传播给调用者。同理也适用于 `read_to_string` 调用结尾的 `?`。 +在示例 9-6 的上下文中，`File::open` 调用结尾的 `?` 将会把 `Ok` 中的值返回给变量 `f`。如果出现了错误，`?` 会提早返回整个函数并将一些 `Err` 值传播给调用者。同理也适用于 `read_to_string` 调用结尾的 `?`。 `?` 消除了大量样板代码并使得函数的实现更简单。我们甚至可以在 `?` 之后直接使用链式方法调用来进一步缩短代码： diff --git a/src/ch09-03-to-panic-or-not-to-panic.md b/src/ch09-03-to-panic-or-not-to-panic.md index 7c2d50a..280f5c6 100644 --- a/src/ch09-03-to-panic-or-not-to-panic.md +++ b/src/ch09-03-to-panic-or-not-to-panic.md @@ -40,7 +40,7 @@ let home = "127.0.0.1".parse::().unwrap(); 无论代码编写的多么好，当有害状态是预期会出现时，返回 `Result` 仍要比调用 `panic!` 更为合适。这样的例子包括解析器接收到错误数据，或者 HTTP 请求返回一个表明触发了限流的状态。在这些例子中，应该通过返回 `Result` 来表明失败预期是可能的，这样将有害状态向上传播，这样调用者就可以决定该如何处理这个问题。使用 `panic!` 来处理这些情况就不是最好的选择。 -当代码对值进行操作时，应该首先验证值是有效的，并在其无效时 `panic!`。这主要是出于安全的原因：尝试操作无效数据会暴露代码漏洞，这就是标准库在尝试越界访问数组时会 `panic!` 的主要原因：尝试访问不属于当前数据结构的内存是一个常见的安全隐患。函数通常都遵循 **契约**（*contracts*）：他们的行为只有在输入满足特定条件时才能得到保证。当违反契约时 panic 是有道理的，因为这这通常代表调用方的 bug，而且这也不是那种你希望调用方必须处理的错误。事实上也没有合理的方式来恢复调用方的代码：调用方的 **程序员** 需要修复他的代码。函数的契约，尤其是当违反它会造成 panic 的契约，应该在函数的 API 文档中得到解释。 +当代码对值进行操作时，应该首先验证值是有效的，并在其无效时 `panic!`。这主要是出于安全的原因：尝试操作无效数据会暴露代码漏洞，这就是标准库在尝试越界访问数组时会 `panic!` 的主要原因：尝试访问不属于当前数据结构的内存是一个常见的安全隐患。函数通常都遵循 **契约**（*contracts*）：他们的行为只有在输入满足特定条件时才能得到保证。当违反契约时 panic 是有道理的，因为这通常代表调用方的 bug，而且这也不是那种你希望调用方必须处理的错误。事实上也没有合理的方式来恢复调用方的代码：调用方的 **程序员** 需要修复他的代码。函数的契约，尤其是当违反它会造成 panic 的契约，应该在函数的 API 文档中得到解释。 虽然在所有函数中都拥有许多错误检查是冗长而烦人的。幸运的是，可以利用 Rust 的类型系统（以及编译器的类型检查）为你进行很多检查。如果函数有一个特定类型的参数，可以在知晓编译器已经确保其拥有一个有效值的前提下进行你的代码逻辑。例如，如果你使用了一个不同于 `Option` 的类型，而且程序期望它是 **有值** 的并且不是 **空值**。你的代码无需处理 `Some` 和 `None` 这两种情况，它只会有一种情况就是绝对会有一个值。尝试向函数传递空值的代码甚至根本不能编译，所以你的函数在运行时没有必要判空。另外一个例子是使用像 `u32` 这样的无符号整型，也会确保它永远不为负。 diff --git a/src/ch10-00-generics.md b/src/ch10-00-generics.md index 4b65740..04410fa 100644 --- a/src/ch10-00-generics.md +++ b/src/ch10-00-generics.md @@ -6,7 +6,7 @@ 每一个编程语言都有高效的处理重复概念的工具；在 Rust 中工具之一就是 **泛型**（*generics*）。泛型是具体类型或其他属性的抽象替代。我们可以表达泛型的属性，比如他们的行为或如何与其他泛型相关联，而不需要在编写和编译代码时知道他们在这里实际上代表什么。 -同理为了编写一份可以用于多种具体值的代码，函数并不知道其参数为何值，这时就可以让函数获取泛型而不是像 `i32` 或 `String` 这样的具体值。我们已经使用过第六章的 `Option`，第八章的 `Vec` 和 `HashMap`，以及第九章的 `Result` 这些泛型了。本章会探索如何使用泛型定义我们自己自己的类型、函数和方法！ +同理为了编写一份可以用于多种具体值的代码，函数并不知道其参数为何值，这时就可以让函数获取泛型而不是像 `i32` 或 `String` 这样的具体值。我们已经使用过第六章的 `Option`，第八章的 `Vec` 和 `HashMap`，以及第九章的 `Result` 这些泛型了。本章会探索如何使用泛型定义我们自己的类型、函数和方法！ 首先，我们将回顾一下提取函数以减少代码重复的机制。接着使用一个只在参数类型上不同的泛型函数来实现相同的功能。我们也会讲到结构体和枚举定义中的泛型。 diff --git a/src/ch10-01-syntax.md b/src/ch10-01-syntax.md index cf63029..650b6a5 100644 --- a/src/ch10-01-syntax.md +++ b/src/ch10-01-syntax.md @@ -253,7 +253,7 @@ fn main() { 示例 10-9：在 `Point` 结构体上实现方法 `x`，它返回 `T` 类型的字段 `x` 的引用 -注意必须在 `impl` 后面声明 `T`，这样就可以在 `Point` 上实现的方法中使用它了。在 `impl` 之后声明泛型 `T` ，这样 Rust 就知道 `Point` 的加括号中的类型是泛型而不是具体类型。例如，可以选择为 `Point` 实例实现方法，而不是为泛型 `Point` 实例。示例 10-10 展示了一个没有在 `impl` 之后（的尖括号）声明泛型的例子，这里使用了一个具体类型，`f32`： +注意必须在 `impl` 后面声明 `T`，这样就可以在 `Point` 上实现的方法中使用它了。在 `impl` 之后声明泛型 `T` ，这样 Rust 就知道 `Point` 的尖括号中的类型是泛型而不是具体类型。例如，可以选择为 `Point` 实例实现方法，而不是为泛型 `Point` 实例。示例 10-10 展示了一个没有在 `impl` 之后（的尖括号）声明泛型的例子，这里使用了一个具体类型，`f32`： ```rust # struct Point { From d3b2feabeee8b98a8418425946ca8e4b642eda2d Mon Sep 17 00:00:00 2001 From: Spartucus Date: Wed, 6 Dec 2017 16:07:05 +0800 Subject: [PATCH 082/150] Refactor translation --- src/ch13-02-iterators.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch13-02-iterators.md b/src/ch13-02-iterators.md index 8fe2156..5711296 100644 --- a/src/ch13-02-iterators.md +++ b/src/ch13-02-iterators.md @@ -99,7 +99,7 @@ fn iterator_sum() { ### `Iterator` trait 中产生其他迭代器的方法 -`Iterator` trait 中定义的另一类方法会产生其他的迭代器。这些方法被称为 **迭代器适配器**（*iterator adaptors*），他们允许我们将当前迭代器变为不同类型的迭代器。可以链式调用多个迭代器适配器。不过因为所有的迭代器都是惰性的，必须调用一个消费适配器方法以便获取迭代器适配器调用的结果。示例 13-17 展示了一个调用迭代器适配器方法 `map` 的例子，它会获取一个 `map` 会在每一个项上调用的闭包来产生一个新迭代器，它的每一项为 vector 中每一项加一。不过这些代码会产生一个警告： +`Iterator` trait 中定义的另一类方法会产生其他的迭代器。这些方法被称为 **迭代器适配器**（*iterator adaptors*），他们允许我们将当前迭代器变为不同类型的迭代器。可以链式调用多个迭代器适配器。不过因为所有的迭代器都是惰性的，必须调用一个消费适配器方法以便获取迭代器适配器调用的结果。示例 13-17 展示了一个调用迭代器适配器方法 `map` 的例子，该 `map` 方法使用闭包来调用每个元素以生成新的迭代器。 这里的闭包创建了一个新的迭代器，其中 `vector` 中的每个元素都被加1。不过这些代码会产生一个警告： 文件名: src/main.rs @@ -334,4 +334,4 @@ fn using_other_iterator_trait_methods() { 注意 `zip` 只产生4对值；理论上第五对值 `(5, None)` 从未被产生，因为 `zip` 在任一输入迭代器返回 `None` 时也返回 `None`。 -所有这些方法调用都是可能的，因为我们通过指定 `next` 如何工作来实现 `Iterator` trait 而标准库则提供其他调用 `next` 的默认方法实现。 \ No newline at end of file +所有这些方法调用都是可能的，因为我们通过指定 `next` 如何工作来实现 `Iterator` trait 而标准库则提供其他调用 `next` 的默认方法实现。 From 2a7fe8d4483645e46b756649a5ca769f1629809b Mon Sep 17 00:00:00 2001 From: lcofjp Date: Thu, 7 Dec 2017 09:14:30 +0800 Subject: [PATCH 083/150] fix typo --- src/ch10-02-traits.md | 2 +- src/ch10-03-lifetime-syntax.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch10-02-traits.md b/src/ch10-02-traits.md index e89ed7e..2f6eebb 100644 --- a/src/ch10-02-traits.md +++ b/src/ch10-02-traits.md @@ -115,7 +115,7 @@ impl Summarizable for WeatherForecast { 另外这段代码假设 `Summarizable` 是一个公有 trait，这是因为示例 10-12 中 `trait` 之前使用了 `pub` 关键字。 -trait 实现的一个需要注意的限制是：只能在 trait 或对应类型位于我们 crate 本地的时候为其实现 trait。换句话说，不允许对外部类型实现外部 trait。例如，不能在 `Vec` 上实现 `Display` trait，因为 `Display` 和 `Vec` 都定义于标准库中。允许在像 `Tweet` 这样作为我们 `aggregator`crate 部分功能的自定义类型上实现标准库中的 trait `Display`。也允许在 `aggregator`crate 中为 `Vec` 实现 `Summarizable`，因为 `Summarizable` 定义于此。这个限制是我们称为 **孤儿规则**（*orphan rule*）的一部分，如果你感兴趣的可以在类型理论中找到它。简单来说，它被称为 orphan rule 是因为其父类型不存在。没有这条规则的话，两个 crate 可以分别对相同类型是实现相同的 trait，因而这两个实现会相互冲突：Rust 将无从得知应该使用哪一个。因为 Rust 强制执行 orphan rule，其他人编写的代码不会破坏你代码，反之亦是如此。 +trait 实现的一个需要注意的限制是：只能在 trait 或对应类型位于我们 crate 本地的时候为其实现 trait。换句话说，不允许对外部类型实现外部 trait。例如，不能在 `Vec` 上实现 `Display` trait，因为 `Display` 和 `Vec` 都定义于标准库中。允许在像 `Tweet` 这样作为我们 `aggregator`crate 部分功能的自定义类型上实现标准库中的 trait `Display`。也允许在 `aggregator`crate 中为 `Vec` 实现 `Summarizable`，因为 `Summarizable` 定义于此。这个限制是我们称为 **孤儿规则**（*orphan rule*）的一部分，如果你感兴趣的可以在类型理论中找到它。简单来说，它被称为 orphan rule 是因为其父类型不存在。没有这条规则的话，两个 crate 可以分别对相同类型实现相同的 trait，因而这两个实现会相互冲突：Rust 将无从得知应该使用哪一个。因为 Rust 强制执行 orphan rule，其他人编写的代码不会破坏你代码，反之亦是如此。 ### 默认实现 diff --git a/src/ch10-03-lifetime-syntax.md b/src/ch10-03-lifetime-syntax.md index e3f73e9..c045c02 100644 --- a/src/ch10-03-lifetime-syntax.md +++ b/src/ch10-03-lifetime-syntax.md @@ -97,7 +97,7 @@ looking arrows and labels? /Carol --> 这里 `x` 拥有生命周期 `'b`，比 `'a` 要大。这就意味着 `r` 可以引用 `x`：Rust 知道 `r` 中的引用在 `x` 有效的时候也总是有效的。 -现在我们已经在一个具体的例子中展示了引用的声明周期位于何处，并讨论了 Rust 如何分析生命周期来保证引用总是有效的，接下来让我们聊聊在函数的上下文中参数和返回值的泛型生命周期。 +现在我们已经在一个具体的例子中展示了引用的生命周期位于何处，并讨论了 Rust 如何分析生命周期来保证引用总是有效的，接下来让我们聊聊在函数的上下文中参数和返回值的泛型生命周期。 ### 函数中的泛型生命周期 From 804bb929cdb285207047a3b2c1e477617c8e6024 Mon Sep 17 00:00:00 2001 From: Yu Sun Date: Thu, 7 Dec 2017 19:45:50 +0800 Subject: [PATCH 084/150] =?UTF-8?q?=E4=B9=8B=E5=89=8D=E7=9A=84greprs?= =?UTF-8?q?=E5=B7=B2=E7=BB=8F=E6=9B=B4=E6=96=B0=E4=B8=BAminigrep=EF=BC=8C?= =?UTF-8?q?=E6=AD=A4=E4=B8=A4=E5=A4=84=E6=9C=AA=E6=9B=B4=E6=96=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch12-03-improving-error-handling-and-modularity.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch12-03-improving-error-handling-and-modularity.md b/src/ch12-03-improving-error-handling-and-modularity.md index 3bd7722..28f8b94 100644 --- a/src/ch12-03-improving-error-handling-and-modularity.md +++ b/src/ch12-03-improving-error-handling-and-modularity.md @@ -416,7 +416,7 @@ pub fn run(config: Config) -> Result<(), Box> { 这里使用了公有的 `pub`：在 `Config`、其字段和其 `new`方法，以及 `run` 函数上。现在我们有了一个拥有可以测试的公有 API 的库 crate 了。 -现在需要在 *src/main.rs* 中使用 `extern crate greprs` 将移动到 *src/lib.rs* 的代码引入二进制 crate 的作用域。接着我们将增加一个 `use greprs::Config` 行将 `Config` 类型引入作用域，并使用库 crate 的名称作为 `run` 函数的前缀，如示例 12-14 所示： +现在需要在 *src/main.rs* 中使用 `extern crate minigrep` 将移动到 *src/lib.rs* 的代码引入二进制 crate 的作用域。接着我们将增加一个 `use minigrep::Config` 行将 `Config` 类型引入作用域，并使用库 crate 的名称作为 `run` 函数的前缀，如示例 12-14 所示： Filename: src/main.rs From d16de7601e7b86308bfc6e7be66610eca6634153 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Thu, 7 Dec 2017 22:27:26 +0800 Subject: [PATCH 085/150] fix typo --- src/ch11-00-testing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch11-00-testing.md b/src/ch11-00-testing.md index faf3413..0190454 100644 --- a/src/ch11-00-testing.md +++ b/src/ch11-00-testing.md @@ -14,7 +14,7 @@ 程序的正确性意味着代码如我们期望的那样运行。Rust 是一个非常注重正确性的编程语言，不过正确性是一个难以证明的复杂主题。Rust 的类型系统在此问题上下了很大的功夫，不过它不可能捕获所有种类的错误。为此，Rust 也在语言本身包含了编写软件测试的支持。 -例如，我们可以编写一个叫做 `add_two` 的将传递给它的值加二的函数。它的签名有一个整型参数并返回一个整型值。当实现和编译这个函数时，Rust 会进行所有目前我们已经见过的的类型检查和借用检查，例如，这些检查会确保我们不会传递 `String` 或无效的引用给这个函数。Rust 所 **不能** 检查的是这个函数是否会准确的完成我们期望的工作：返回参数加二后的值，而不是比如说参数加 10 或减 50 的值！这也就是测试出场的地方。 +例如，我们可以编写一个叫做 `add_two` 的将传递给它的值加二的函数。它的签名有一个整型参数并返回一个整型值。当实现和编译这个函数时，Rust 会进行所有目前我们已经见过的类型检查和借用检查，例如，这些检查会确保我们不会传递 `String` 或无效的引用给这个函数。Rust 所 **不能** 检查的是这个函数是否会准确的完成我们期望的工作：返回参数加二后的值，而不是比如说参数加 10 或减 50 的值！这也就是测试出场的地方。 我们可以编写测试断言，比如说，当传递 `3` 给 `add_two` 函数时，应该得到 `5`。当对代码进行修改时可以运行测试来确保任何现存的正确行为没有被改变。 From a8c9824c7bbfa4971927cbeac770fd25c539c069 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Thu, 7 Dec 2017 22:29:37 +0800 Subject: [PATCH 086/150] fix typo --- src/ch07-01-mod-and-the-filesystem.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch07-01-mod-and-the-filesystem.md b/src/ch07-01-mod-and-the-filesystem.md index 6ce5de4..37f6ab2 100644 --- a/src/ch07-01-mod-and-the-filesystem.md +++ b/src/ch07-01-mod-and-the-filesystem.md @@ -96,7 +96,7 @@ communicator └── client ``` -而这是示例 7-2 中例子的的层次结构： +而这是示例 7-2 中例子的层次结构： ```text communicator From 6395e96ee60aa8de622479ede22713ee97c00021 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Fri, 8 Dec 2017 08:53:47 +0800 Subject: [PATCH 087/150] fix typo --- src/ch11-01-writing-tests.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch11-01-writing-tests.md b/src/ch11-01-writing-tests.md index a2d3b65..f21e692 100644 --- a/src/ch11-01-writing-tests.md +++ b/src/ch11-01-writing-tests.md @@ -135,7 +135,7 @@ error: test failed 示例 11-4：一个测试通过和一个测试失败的测试结果 -`test tests::another` 这一行是 `FAILED` 而不是 `ok` 了。在单独测试结果和总结之间多了两个新的部分：第一个部分显示了测试失败的详细原因。在这个例子中，`another` 因为 `panicked at 'Make this test fail'` 而失败，这位于 *src/lib.rs* 的第 9 行。下一部分仅仅列出了所有失败的测试，这在很有多测试和很多失败测试的详细输出时很有帮助。可以使用失败测试的名称来只运行这个测试，这样比较方便调试；下一部分会讲到更多运行测试的方法。 +`test tests::another` 这一行是 `FAILED` 而不是 `ok` 了。在单独测试结果和总结之间多了两个新的部分：第一个部分显示了测试失败的详细原因。在这个例子中，`another` 因为 `panicked at 'Make this test fail'` 而失败，这位于 *src/lib.rs* 的第 9 行。下一部分仅仅列出了所有失败的测试，这在有很多测试和很多失败测试的详细输出时很有帮助。可以使用失败测试的名称来只运行这个测试，这样比较方便调试；下一部分会讲到更多运行测试的方法。 最后是总结行：总体上讲，一个测试结果是 `FAILED` 的。有一个测试通过和一个测试失败。 @@ -462,7 +462,7 @@ mod tests { 示例 11-8：测试会造成 `panic!` 的条件 -`#[should_panic]` 属性位于 `#[test]` 之后和对应的测试函数之前。让我们看看测试通过时它时什么样子： +`#[should_panic]` 属性位于 `#[test]` 之后和对应的测试函数之前。让我们看看测试通过时它是什么样子： ```text running 1 test From 1146cdc205faabddab438e21daefb4173e86c9f1 Mon Sep 17 00:00:00 2001 From: Shing Tak Lam Date: Fri, 8 Dec 2017 19:39:31 +0800 Subject: [PATCH 088/150] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=BA=86=209-2=20?= =?UTF-8?q?=E4=B8=AD=E7=9A=84=E5=AE=9E=E4=BE=8B=E6=A0=87=E5=8F=B7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch09-02-recoverable-errors-with-result.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch09-02-recoverable-errors-with-result.md b/src/ch09-02-recoverable-errors-with-result.md index 0a137cf..c477999 100644 --- a/src/ch09-02-recoverable-errors-with-result.md +++ b/src/ch09-02-recoverable-errors-with-result.md @@ -252,7 +252,7 @@ fn read_username_from_file() -> Result { } ``` -在 `s` 中创建新的 `String` 被放到了函数开头；这没有什么变化。我们对 `File::open("hello.txt")?` 的结果直接链式调用了 `read_to_string`，而不再创建变量 `f`。仍然需要 `read_to_string` 调用结尾的 `?`，而且当 `File::open` 和 `read_to_string` 都成功没有失败时返回包含用户名 `s` 的 `Ok` 值。其功能再一次与示例 9-5 和示例 9-5 保持一致，不过这是一个与众不同且更符合工程学的写法。 +在 `s` 中创建新的 `String` 被放到了函数开头；这没有什么变化。我们对 `File::open("hello.txt")?` 的结果直接链式调用了 `read_to_string`，而不再创建变量 `f`。仍然需要 `read_to_string` 调用结尾的 `?`，而且当 `File::open` 和 `read_to_string` 都成功没有失败时返回包含用户名 `s` 的 `Ok` 值。其功能再一次与示例 9-5 和示例 9-6 保持一致，不过这是一个与众不同且更符合工程学的写法。 ### `?` 只能被用于返回 `Result` 的函数 From a026189698b98f3d39d91ccbd93ee26ea8dc9704 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Sat, 9 Dec 2017 09:44:57 +0800 Subject: [PATCH 089/150] fix typo --- src/ch12-01-accepting-command-line-arguments.md | 2 +- src/ch12-03-improving-error-handling-and-modularity.md | 4 ++-- src/ch13-01-closures.md | 2 +- src/ch17-03-oo-design-patterns.md | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/ch12-01-accepting-command-line-arguments.md b/src/ch12-01-accepting-command-line-arguments.md index bec5e7a..ad78888 100644 --- a/src/ch12-01-accepting-command-line-arguments.md +++ b/src/ch12-01-accepting-command-line-arguments.md @@ -45,7 +45,7 @@ fn main() { > > 注意 `std::env::args` 在其任何参数包含无效 Unicode 字符时会 panic。如果你需要接受包含无效 Unicode 字符的参数，使用 `std::env::args_os` 代替。这个函数返回 `OsString` 值而不是 `String` 值。这里出于简单考虑使用了 `std::env::args`，因为 `OsString` 值每个平台都不一样而且比 `String` 值处理起来更复杂。 -在 `main` 函数的第一行，我们调用了 `env::args`，并立即使用 `collect` 来创建了一个包含迭代器所有值的 vector。`collect` 可以被用来创建很多类型的集合，所以这里显式注明的 `args` 类型来指定我们需要一个字符串 vector。虽然在 Rust 中我们很少会需要注明类型，`collect` 就是一个经常需要注明类型的函数，因为 Rust 不能推断出你想要什么类型的集合。 +在 `main` 函数的第一行，我们调用了 `env::args`，并立即使用 `collect` 来创建了一个包含迭代器所有值的 vector。`collect` 可以被用来创建很多类型的集合，所以这里显式注明 `args` 的类型来指定我们需要一个字符串 vector。虽然在 Rust 中我们很少会需要注明类型，`collect` 就是一个经常需要注明类型的函数，因为 Rust 不能推断出你想要什么类型的集合。 最后，我们使用调试格式 `:?` 打印出 vector。让我们尝试不用参数运行代码，接着用两个参数： diff --git a/src/ch12-03-improving-error-handling-and-modularity.md b/src/ch12-03-improving-error-handling-and-modularity.md index 3bd7722..eb455ce 100644 --- a/src/ch12-03-improving-error-handling-and-modularity.md +++ b/src/ch12-03-improving-error-handling-and-modularity.md @@ -8,7 +8,7 @@ 第一，`main` 现在进行了两个任务：它解析了参数并打开了文件。对于一个这样的小函数，这并不是一个大问题。然而如果 `main` 中的功能持续增加，`main` 函数处理的独立的任务也会增加。当函数承担了更多责任，它就更难以推导，更难以测试，并且更难以在不破坏其他部分的情况下做出修改。最好能分离出功能以便每个函数就负责一个任务。 -这同时也关系到第二个问题：`search` 和 `filename` 是程序中的配置变量，而像 `f` 和 `contents` 则用来执行程序逻辑。随着 `main` 函数的增长，就需要引入更多的变量到作用域中，而当作用域中有更多的变量时，将更难以追踪每个变量的目的。最好能将将配置变量组织进一个结构这样就能使他们的目的更明确了。 +这同时也关系到第二个问题：`search` 和 `filename` 是程序中的配置变量，而像 `f` 和 `contents` 则用来执行程序逻辑。随着 `main` 函数的增长，就需要引入更多的变量到作用域中，而当作用域中有更多的变量时，将更难以追踪每个变量的目的。最好能将配置变量组织进一个结构这样就能使他们的目的更明确了。 第三个问题是如果打开文件失败我们使用 `expect` 来打印出错误信息，不过这个错误信息只是说 `file not found`。除了缺少文件之外还有很多打开文件可能失败的方式：例如，文件可能存在，不过可能没有打开它的权限。如果我们现在就出于这种情况，打印出的 `file not found` 错误信息就给了用户错误的建议！ @@ -416,7 +416,7 @@ pub fn run(config: Config) -> Result<(), Box> { 这里使用了公有的 `pub`：在 `Config`、其字段和其 `new`方法，以及 `run` 函数上。现在我们有了一个拥有可以测试的公有 API 的库 crate 了。 -现在需要在 *src/main.rs* 中使用 `extern crate greprs` 将移动到 *src/lib.rs* 的代码引入二进制 crate 的作用域。接着我们将增加一个 `use greprs::Config` 行将 `Config` 类型引入作用域，并使用库 crate 的名称作为 `run` 函数的前缀，如示例 12-14 所示： +现在需要在 *src/main.rs* 中使用 `extern crate minigrep` 将移动到 *src/lib.rs* 的代码引入二进制 crate 的作用域。接着我们将增加一个 `use minigrep::Config` 行将 `Config` 类型引入作用域，并使用库 crate 的名称作为 `run` 函数的前缀，如示例 12-14 所示： Filename: src/main.rs diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index c679934..8cea7cc 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -279,7 +279,7 @@ error[E0308]: mismatched types ### 使用带有泛型和 `Fn` trait 的闭包 -回到我们的健身计划生成 app ，在示例 13-6 中的代码仍然调用了多于需要的慢计算闭包。在全部代码中的每一个需要多个慢计算闭包结果的地方，可以将将结果保存进变量以供复用，这样就可以使用变量而不是再次调用闭包。但是这样就会有很多重复的保存结果变量的地方。 +回到我们的健身计划生成 app ，在示例 13-6 中的代码仍然调用了多于需要的慢计算闭包。在全部代码中的每一个需要多个慢计算闭包结果的地方，可以将结果保存进变量以供复用，这样就可以使用变量而不是再次调用闭包。但是这样就会有很多重复的保存结果变量的地方。 然而，因为拥有一个慢计算的闭包，我们还可以采取另一个解决方案。可以创建一个存放闭包和调用闭包结果的结构体。该结构体只会在需要结果时执行闭包，并会缓存结果值，这样余下的代码就不必再负责保存结果并可以复用该值。你可能见过这种模式被称 *memoization* 或 *lazy evaluation*。 diff --git a/src/ch17-03-oo-design-patterns.md b/src/ch17-03-oo-design-patterns.md index 4e66c1a..1f6eb35 100644 --- a/src/ch17-03-oo-design-patterns.md +++ b/src/ch17-03-oo-design-patterns.md @@ -323,7 +323,7 @@ impl State for Published { #### 将状态和行为编码为类型 -我们将展示如何稍微反思状态模式来进行一系列不同的权衡取舍。不同于完全封装状态和状态转移使得外部代码对其毫不知情，我们将将状态编码进不同的类型。当状态是类型时，Rust 的类型检查就会使任何在只能使用发布的博文的地方使用草案博文的尝试变为编译时错误。 +我们将展示如何稍微反思状态模式来进行一系列不同的权衡取舍。不同于完全封装状态和状态转移使得外部代码对其毫不知情，我们将状态编码进不同的类型。当状态是类型时，Rust 的类型检查就会使任何在只能使用发布的博文的地方使用草案博文的尝试变为编译时错误。 让我们考虑一下列表 17-11 中 `main` 的第一部分： From 82e630c8235db5c5408076988ab0b214bedd67d4 Mon Sep 17 00:00:00 2001 From: Yu Sun Date: Sat, 9 Dec 2017 20:44:01 +0800 Subject: [PATCH 090/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=BF=BB=E8=AF=91?= =?UTF-8?q?=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-00-functional-features.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-00-functional-features.md b/src/ch13-00-functional-features.md index f902586..e7b91b3 100644 --- a/src/ch13-00-functional-features.md +++ b/src/ch13-00-functional-features.md @@ -4,7 +4,7 @@ >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。我们不会在这里讨论函数式编程是或不是什么的问题，而是展示Rust的一些特性，这些特性与许多语言中被称为功能的特性类似。 +Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。我们不会在这里讨论函数式编程是或不是什么的问题，而是展示Rust的一些在功能上与其他语言类似的特性。 更具体的，我们将要涉及： From 386fbfe281538c30ea8d77d01892cc9c4282de7e Mon Sep 17 00:00:00 2001 From: lcofjp Date: Sun, 10 Dec 2017 14:33:06 +0800 Subject: [PATCH 091/150] fix typo --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 8cea7cc..a8ecd6d 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -248,7 +248,7 @@ let add_one_v4 = |x| x + 1 ; 第一行展示了一个函数定义，而第二行展示了一个完整标注的闭包定义。第三行闭包定义中省略了类型注解，而第四行去掉了可选的大括号，因为闭包体只有一行。 -闭包定义会为每个参数和返回值推断一个具体类型。例如，示例 13-8 中展示了仅仅将参数作为返回值的简短的闭包定义。除了作为示例的目的这个闭包并不是很实用。注意其定义并没有增加任何类型注解：如果尝试调用闭包两次，第一次使用 `String` 类型作为参数而第一次使用 `i32`，则会得到一个错误： +闭包定义会为每个参数和返回值推断一个具体类型。例如，示例 13-8 中展示了仅仅将参数作为返回值的简短的闭包定义。除了作为示例的目的这个闭包并不是很实用。注意其定义并没有增加任何类型注解：如果尝试调用闭包两次，第一次使用 `String` 类型作为参数而第二次使用 `i32`，则会得到一个错误： 文件名: src/main.rs From 008c38b6000ca136614bc631ee1f92705da2d3d5 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Mon, 11 Dec 2017 08:46:11 +0800 Subject: [PATCH 092/150] fix typo --- src/ch14-02-publishing-to-crates-io.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch14-02-publishing-to-crates-io.md b/src/ch14-02-publishing-to-crates-io.md index 1f1d5db..2527c04 100644 --- a/src/ch14-02-publishing-to-crates-io.md +++ b/src/ch14-02-publishing-to-crates-io.md @@ -102,7 +102,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured 第七章介绍了如何使用 `mod` 关键字来将代码组织进模块中，如何使用 `pub` 关键字将项变为公有，和如何使用 `use` 关键字将项引入作用域。然而对你开发来说很有道理的结果可能对用户来说就不太方便了。你可能希望将结构组织进有多个层次的层级中，不过想要使用被定义在很深层级中的类型的人可能很难发现这些类型是否存在。他们也可能会厌烦 `use my_crate::some_module::another_module::UsefulType;` 而不是 `use my_crate::UsefulType;` 来使用类型。 -公有 API 的结构是你发布 crate 时主要需要考虑的。crate 用户没有你那么熟悉其结构，并且如何模块层级过大他们可能会难以找到所需的部分。 +公有 API 的结构是你发布 crate 时主要需要考虑的。crate 用户没有你那么熟悉其结构，并且如果模块层级过大他们可能会难以找到所需的部分。 好消息是，如果结果对于用户来说 **不是** 很方便，你也无需重新安排内部组织：你可以选择使用 `pub use` 重导出（re-export）项来使公有结构不同于私有结构。重导出获取位于一个位置的公有项并将其公开到另一个位置，好像它就定义在这个新位置一样。 @@ -309,7 +309,7 @@ Uploading guessing_game v0.1.0 (file:///projects/guessing_game) ### 发布现存 crate 的新版本 -当你修改了 crate 并准备好发布新版本时，改变 *Cargo.toml* 中 `version` 所指定的值。请使用 [语义化版本规则][semver] 来根据修改的类型决定下一个版本呢号。接着运行 `cargo publish` 来上传新版本。 +当你修改了 crate 并准备好发布新版本时，改变 *Cargo.toml* 中 `version` 所指定的值。请使用 [语义化版本规则][semver] 来根据修改的类型决定下一个版本号。接着运行 `cargo publish` 来上传新版本。 [semver]: http://semver.org/ From bffafd193cf103ee9b597b8213929a23b614c4f1 Mon Sep 17 00:00:00 2001 From: Yu Sun Date: Mon, 11 Dec 2017 23:23:48 +0800 Subject: [PATCH 093/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E7=BF=BB=E8=AF=91?= =?UTF-8?q?=E9=94=99=E8=AF=AF?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 505e369..446da6b 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -141,7 +141,7 @@ fn generate_workout(intensity: i32, random_number: i32) { 示例 13-4：将 `simulated_expensive_calculation` 调用提取到一个位置，位于 `if` 块之前并将结果储存在变量 `expensive_result` 中 -这个修改统一了 `simulated_expensive_calculation` 调用并解决了第一个 `if` 块中不必要的两次调用函数的问题。不幸的是，现在所有的情况下都需要调用函数并等待结果，而内部 `if` 块完全不需要其结果。 +这个修改统一了 `simulated_expensive_calculation` 调用并解决了第一个 `if` 块中不必要的两次调用函数的问题。不幸的是，现在所有的情况下都需要调用函数并等待结果，包括那个完全不需要这一结果的内部 `if` 块。 我们希望能够在程序的一个位置指定某些代码，并只在程序的某处实际需要结果的时候执行这些代码。这正是闭包的用武之地！ From 580af26ad9837c145d1958d9d12bab6ef01de838 Mon Sep 17 00:00:00 2001 From: Yu Sun Date: Tue, 12 Dec 2017 01:03:14 +0800 Subject: [PATCH 094/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E9=94=99=E5=88=AB?= =?UTF-8?q?=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 446da6b..73c3661 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -304,7 +304,7 @@ struct Cacher 示例 13-9：定义一个 `Cacher` 结构体来在 `calculation` 中存放闭包并在 `value` 中存放 Option 值 -结果提 `Cacher` 有一个泛型 `T` 的字段 `calculation`。`T` 的 trait bound 指定了 `T` 是一个使用 `Fn` 的闭包。任何我们希望储存到 `Cacher` 实例的 `calculation` 字段的闭包必须有一个 `i32` 参数（由 `Fn` 之后的括号的内容指定）并必须返回一个 `i32`（由 `->` 之后的内容）。 +结构体 `Cacher` 有一个泛型 `T` 的字段 `calculation`。`T` 的 trait bound 指定了 `T` 是一个使用 `Fn` 的闭包。任何我们希望储存到 `Cacher` 实例的 `calculation` 字段的闭包必须有一个 `i32` 参数（由 `Fn` 之后的括号的内容指定）并必须返回一个 `i32`（由 `->` 之后的内容）。 `value` 是 `Option` 类型的。在执行闭包之前，`value` 将是 `None`。如果使用 `Cacher` 的代码请求闭包的结果，这时会执行闭包并将结果储存在 `value` 字段的 `Some` 成员中。接着如果代码再次请求闭包的结果，这时不再执行闭包，而是会返回存放在 `Some` 成员中的结果。 From a30686067092397c2f2a06e83fef393f90e85958 Mon Sep 17 00:00:00 2001 From: Yu Sun Date: Tue, 12 Dec 2017 01:08:15 +0800 Subject: [PATCH 095/150] =?UTF-8?q?=E4=BF=AE=E6=AD=A3=E9=94=99=E5=88=AB?= =?UTF-8?q?=E5=AD=97?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/ch13-01-closures.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 73c3661..c9812f1 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -308,7 +308,7 @@ struct Cacher `value` 是 `Option` 类型的。在执行闭包之前，`value` 将是 `None`。如果使用 `Cacher` 的代码请求闭包的结果，这时会执行闭包并将结果储存在 `value` 字段的 `Some` 成员中。接着如果代码再次请求闭包的结果，这时不再执行闭包，而是会返回存放在 `Some` 成员中的结果。 -刚才讨论的油管 `value` 字段逻辑定义于示例 13-10： +刚才讨论的有关 `value` 字段逻辑定义于示例 13-10： 文件名: src/main.rs From 45badfb39db93ba8f67b1616570df2e0752736f0 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Tue, 12 Dec 2017 08:55:49 +0800 Subject: [PATCH 096/150] fix typo --- src/ch15-01-box.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch15-01-box.md b/src/ch15-01-box.md index 9d83515..e7ecd8d 100644 --- a/src/ch15-01-box.md +++ b/src/ch15-01-box.md @@ -51,7 +51,7 @@ cons list 是一个每一项都包含两个部分的列表：当前项的值和 > > cons list 通过递归调用 `cons` 函数产生。代表递归的终止条件（base case）的规范名称是 `Nil`，它宣布列表的终止。注意这不同于第六章中的 “null” 或 “nil” 的概念，他们代表无效或缺失的值。 -注意虽然函数式编程语言经常使用 cons list，但是它并不是一个 Rust 中常见的类型。大部分在 Rust 中需要列表的时候，`Vec` 是一个更好的选择。其他更为复杂的递归数据类型 **确实** 在 Rust 的很多场景中很使用，不过通过以 cons list 作为开始，我们可以探索如何使用 box 毫不费力的定义一个递归数据类型。 +注意虽然函数式编程语言经常使用 cons list，但是它并不是一个 Rust 中常见的类型。大部分在 Rust 中需要列表的时候，`Vec` 是一个更好的选择。其他更为复杂的递归数据类型 **确实** 在 Rust 的很多场景中很有用，不过通过以 cons list 作为开始，我们可以探索如何使用 box 毫不费力的定义一个递归数据类型。 示例 15-2 包含一个 cons list 的枚举定义。注意这还不能编译因为这个类型没有已知的大小，之后我们会展示： @@ -137,7 +137,7 @@ Rust 无法计算出要为定义为递归的类型分配多少空间，所以编 因为 `Box` 是一个指针，我们总是知道它需要多少空间：指针的大小并不会根据其指向的数据量而改变。 -所以可以将 `Box` 放入 `Cons` 成员中而不是直接存放另一个 `List` 值。`Box` 会指向另一个位于堆上的 `List` 值，而不是存放在 `Cons` 成员中。从概念上将，我们仍然有一个通过在其中 “存放” 其他列表创建的列表，不过现在实现这个概念的方式更像是一个项挨着另一项，而不是一项包含另一项。 +所以可以将 `Box` 放入 `Cons` 成员中而不是直接存放另一个 `List` 值。`Box` 会指向另一个位于堆上的 `List` 值，而不是存放在 `Cons` 成员中。从概念上讲，我们仍然有一个通过在其中 “存放” 其他列表创建的列表，不过现在实现这个概念的方式更像是一个项挨着另一项，而不是一项包含另一项。 我们可以修改示例 15-2 中 `List` 枚举的定义和示例 15-3 中对 `List` 的应用，如示例 15-6 所示，这是可以编译的： From 00339cadcf36b83e52e2ae247fd26fc85ab166db Mon Sep 17 00:00:00 2001 From: Yu Sun Date: Tue, 12 Dec 2017 23:56:50 +0800 Subject: [PATCH 097/150] fix mistakes --- src/ch07-01-mod-and-the-filesystem.md | 4 ---- src/ch09-00-error-handling.md | 4 ---- 2 files changed, 8 deletions(-) diff --git a/src/ch07-01-mod-and-the-filesystem.md b/src/ch07-01-mod-and-the-filesystem.md index 5194adf..902a74b 100644 --- a/src/ch07-01-mod-and-the-filesystem.md +++ b/src/ch07-01-mod-and-the-filesystem.md @@ -31,11 +31,7 @@ Cargo 创建了一个空的测试来帮助我们开始库项目，不像使用 ` 因为没有 *src/main.rs* 文件，所以没有可供 Cargo 的 `cargo run` 执行的东西。因此，我们将使用 `cargo build` 命令只是编译库 crate 的代码。 -<<<<<<< HEAD -我们将学习根据编写代码的意图来选择不同的库项目代码组织来适应多种场景。 -======= 我们将学习根据编写代码的意图来以不同方法组织库项目代码以适应多种情况。 ->>>>>>> 828c1412827d09b3a539566ec64e2560fd5fd22d ### 模块定义 diff --git a/src/ch09-00-error-handling.md b/src/ch09-00-error-handling.md index 0a590a3..609d6ee 100644 --- a/src/ch09-00-error-handling.md +++ b/src/ch09-00-error-handling.md @@ -4,11 +4,7 @@ >
> commit 4f2dc564851dc04b271a2260c834643dfd86c724 -<<<<<<< HEAD -Rust 对可靠性的执着也扩展到了错误处理。错误对于软件来说是不可避免的，所以 Rust 有很多功能来处理出现错误的情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 -======= Rust 对可靠性的执着也扩展到了错误处理。错误对于软件来说是不可避免的，所以当出现错误时， Rust 有很多特性来处理当前情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 ->>>>>>> 828c1412827d09b3a539566ec64e2560fd5fd22d Rust 将错误组合成两个主要类别：**可恢复错误**（*recoverable*）和 **不可恢复错误**（*unrecoverable*）。可恢复错误通常代表向用户报告错误和重试操作是合理的情况，比如未找到文件。不可恢复错误通常是 bug 的同义词，比如尝试访问超过数组结尾的位置。 From eedadc382ece6df02c44cd106bca2747b044bea6 Mon Sep 17 00:00:00 2001 From: lcofjp Date: Thu, 14 Dec 2017 13:20:02 +0800 Subject: [PATCH 098/150] fix typo --- src/ch16-01-threads.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch16-01-threads.md b/src/ch16-01-threads.md index fb7c653..2881279 100644 --- a/src/ch16-01-threads.md +++ b/src/ch16-01-threads.md @@ -147,7 +147,7 @@ hi number 3 from the main thread! hi number 4 from the main thread! ``` -稍微考虑一下将`join`放置与何处会影响线程是否同时运行。 +稍微考虑一下将`join`放置于何处会影响线程是否同时运行。 ### 线程和`move`闭包 From 59289f5e9597e183fc6f0a1580b311515b8dbb33 Mon Sep 17 00:00:00 2001 From: Jeff <200006506@qq.com> Date: Fri, 22 Dec 2017 16:14:23 +0800 Subject: [PATCH 099/150] Update ch15-05-interior-mutability.md --- src/ch15-05-interior-mutability.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index 63b6bae..55cb8bd 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -14,12 +14,12 @@ 1. 在任意给定时间，**只能**拥有如下中的一个： * 一个可变引用。 - * 任意属性的不可变引用。 + * 任意数量的不可变引用。 2. 引用必须总是有效的。 对于引用和`Box`，借用规则的不可变性作用于编译时。对于`RefCell`，这些不可变性作用于**运行时**。对于引用，如果违反这些规则，会得到一个编译错误。而对于`RefCell`，违反这些规则会`panic!`。 -Rust 编译器执行的静态分析天生是保守的。代码的一些属性则不可能通过分析代码发现：其中最著名的就是停机问题（Halting Problem），这超出了本书的范畴，不过如果你感兴趣的话这是一个值得研究的有趣主题。 +Rust 编译器执行的静态分析天生是保守的。代码的一些属性则不可能通过分析代码发现：其中最著名的就是[停机问题（Halting Problem）](https://zh.wikipedia.org/wiki/%E5%81%9C%E6%9C%BA%E9%97%AE%E9%A2%98)，这超出了本书的范畴，不过如果你感兴趣的话这是一个值得研究的有趣主题。 因为一些分析是不可能的，Rust 编译器在其不确定的时候甚至都不尝试猜测，所以说它是保守的而且有时会拒绝事实上不会违反 Rust 保证的正确的程序。换句话说，如果 Rust 接受不正确的程序，那么人们也就不会相信 Rust 所做的保证了。如果 Rust 拒绝正确的程序，会给程序员带来不便，但不会带来灾难。`RefCell`正是用于当你知道代码遵守借用规则，而编译器不能理解的时候。 From 48dc004b154c1ed2b0e28a61a0cc0f750e96b605 Mon Sep 17 00:00:00 2001 From: GreenPine Date: Mon, 25 Dec 2017 16:26:46 +0800 Subject: [PATCH 100/150] =?UTF-8?q?=E6=9B=B4=E6=94=B9=E9=94=99=E5=AD=97@?= =?UTF-8?q?=20ch20-01-single-threaded?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `恢复` -> `回复` --- src/ch20-01-single-threaded.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch20-01-single-threaded.md b/src/ch20-01-single-threaded.md index c16b4f1..6ba794a 100644 --- a/src/ch20-01-single-threaded.md +++ b/src/ch20-01-single-threaded.md @@ -57,7 +57,7 @@ Connection established! Connection established! ``` -对于一次浏览器请求会打印出多条信息；这些连接可能是浏览器请求页面和请求出现在浏览器 tab 页中的 `favicon.ico`，或者浏览器可能重试了连接。浏览器期望使用 HTTP 交互，不过我们并未恢复任何内容。当 `stream` 在循环的结尾离开作用域并被丢弃，其连接将被关闭，作为 `TcpStream` 的 `drop` 实现的一部分。浏览器有时通过重连来处理关闭的连接，因为这些问题可能是暂时的。现在重要的是我们成功的处理了 TCP 连接！ +对于一次浏览器请求会打印出多条信息；这些连接可能是浏览器请求页面和请求出现在浏览器 tab 页中的 `favicon.ico`，或者浏览器可能重试了连接。浏览器期望使用 HTTP 交互，不过我们并未回复任何内容。当 `stream` 在循环的结尾离开作用域并被丢弃，其连接将被关闭，作为 `TcpStream` 的 `drop` 实现的一部分。浏览器有时通过重连来处理关闭的连接，因为这些问题可能是暂时的。现在重要的是我们成功的处理了 TCP 连接！ 记得当运行完特定版本的代码后使用 ctrl-C 来停止程序，并在做出最新的代码修改之后执行 `cargo run` 重启服务。 @@ -390,4 +390,4 @@ fn handle_connection(mut stream: TcpStream) { 好极了！我们有了一个 40 行左右 Rust 代码的小而简单的 server，它对一个请求返回页面内容而对所有其他请求返回 `404` 响应。 -不过因为 server 运行于单线程中，它一次只能处理一个请求。让我们模拟一些慢请求来看看这如何会称为一个问题。 \ No newline at end of file +不过因为 server 运行于单线程中，它一次只能处理一个请求。让我们模拟一些慢请求来看看这如何会称为一个问题。 From 90b33ab7a91d3260d87308e70bb94ea2ea8e2d37 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Mon, 8 Jan 2018 08:49:35 +0800 Subject: [PATCH 101/150] fix ch04-01 typo --- src/ch04-01-what-is-ownership.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 510b373..1c8fc0b 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -163,7 +163,7 @@ let s2 = s1; 图 4-4：变量 `s2` 的内存表现，它有一份 `s1` 指针、长度和容量的拷贝 -这个表现形式看起来 **并不像** 图 4-5 中的那样，它是如果 Rust 也拷贝了堆上的数据后内存看起来是怎么样的。如果 Rust 这么做了，那么操作 `s2 = s1` 在堆上数据比较大的时候可能会对运行时性能造成非常大的影响。 +这个表现形式看起来 **并不像** 图 4-5 中的那样，但是如果 Rust 也拷贝了堆上的数据后内存看起来会是如何呢。如果 Rust 这么做了，那么操作 `s2 = s1` 在堆上数据比较大的时候可能会对运行时性能造成非常大的影响。 s1 and s2 to two places From b7d9aaaa0d9ec97bc71f12b068b0ec071aadf0c4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=90=95=E9=87=91=E9=BE=99?= Date: Wed, 10 Jan 2018 15:06:50 +0800 Subject: [PATCH 102/150] feature_fix_ch02-00_wrong_character --- src/ch02-00-guessing-game-tutorial.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch02-00-guessing-game-tutorial.md b/src/ch02-00-guessing-game-tutorial.md index e56a24a..43e4477 100644 --- a/src/ch02-00-guessing-game-tutorial.md +++ b/src/ch02-00-guessing-game-tutorial.md @@ -150,7 +150,7 @@ io::stdin().read_line(&mut guess) .expect("Failed to read line"); ``` -如果程序的开头没有 `use std::io` 这一行，可以把函数调用写成 `std::io::stdin`。`stdin` 函数返回一个 [`std::io::Stdin`][iostdin] 的实例，这代表终端标准输入句柄的类型。 +如果程序的开头没有 `use std::io` 这一行，可以把函数调用写成 `std::io::stdin`。`stdin` 函数返回一个 [`std::io::stdin`][iostdin] 的实例，这代表终端标准输入句柄的类型。 [iostdin]: https://doc.rust-lang.org/std/io/struct.Stdin.html From 5e2b246777b1e5d1dff3f189d356e3c6aef12a78 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Thu, 11 Jan 2018 10:27:53 +0800 Subject: [PATCH 103/150] init travis ci support --- .travis.yml | 21 +++++++++ src/SUMMARY.md | 67 ++++++++++++++--------------- src/appendix-03-derivable-traits.md | 1 + src/appendix-04-macros.md | 1 + src/appendix-05-translation.md | 1 + src/appendix-06-newest-features.md | 1 + theme/index.hbs | 41 ++++++++++++++---- 7 files changed, 90 insertions(+), 43 deletions(-) create mode 100644 .travis.yml create mode 100644 src/appendix-03-derivable-traits.md create mode 100644 src/appendix-04-macros.md create mode 100644 src/appendix-05-translation.md create mode 100644 src/appendix-06-newest-features.md diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..396291f --- /dev/null +++ b/.travis.yml @@ -0,0 +1,21 @@ +sudo: false +dist: trusty +language: rust +cache: cargo +rust: + - nightly +branches: + only: + - master +before_script: + - (cargo install mdbook --vers 0.0.26 --force || true) +script: + - mdbook build +deploy: + provider: pages + local-dir: mdbook + skip-cleanup: true + github-token: $GITHUB_TOKEN + keep-history: false + on: + branch: master \ No newline at end of file diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 79c7607..2803635 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -9,7 +9,7 @@ - [猜猜看教程](ch02-00-guessing-game-tutorial.md) - [通用编程概念](ch03-00-common-programming-concepts.md) - - [变量和可变性](ch03-01-variables-and-mutability.md) + - [变量与可变性](ch03-01-variables-and-mutability.md) - [数据类型](ch03-02-data-types.md) - [函数如何工作](ch03-03-how-functions-work.md) - [注释](ch03-04-comments.md) @@ -17,25 +17,25 @@ - [认识所有权](ch04-00-understanding-ownership.md) - [什么是所有权](ch04-01-what-is-ownership.md) - - [引用 & 借用](ch04-02-references-and-borrowing.md) + - [引用与借用](ch04-02-references-and-borrowing.md) - [Slices](ch04-03-slices.md) -- [使用结构体组织相关联的数据](ch05-00-structs.md) +- [使用结构体来组织相关联的数据](ch05-00-structs.md) - [定义并实例化结构体](ch05-01-defining-structs.md) - [一个使用结构体的示例程序](ch05-02-example-structs.md) - [方法语法](ch05-03-method-syntax.md) -- [枚举和模式匹配](ch06-00-enums.md) +- [枚举与模式匹配](ch06-00-enums.md) - [定义枚举](ch06-01-defining-an-enum.md) - [`match` 控制流运算符](ch06-02-match.md) - - [`if let` 简单控制流](ch06-03-if-let.md) + - [`if let` 简洁控制流](ch06-03-if-let.md) ## 基本 Rust 技能 - [模块](ch07-00-modules.md) - - [`mod`和文件系统](ch07-01-mod-and-the-filesystem.md) - - [使用`pub`控制可见性](ch07-02-controlling-visibility-with-pub.md) - - [使用`use`导入命名](ch07-03-importing-names-with-use.md) + - [`mod` 与文件系统](ch07-01-mod-and-the-filesystem.md) + - [使用 `pub` 控制可见性](ch07-02-controlling-visibility-with-pub.md) + - [在不同的模块中引用命名](ch07-03-importing-names-with-use.md) - [通用集合类型](ch08-00-common-collections.md) - [vector](ch08-01-vectors.md) @@ -43,11 +43,11 @@ - [哈希 map](ch08-03-hash-maps.md) - [错误处理](ch09-00-error-handling.md) - - [`panic!`与不可恢复的错误](ch09-01-unrecoverable-errors-with-panic.md) - - [`Result`与可恢复的错误](ch09-02-recoverable-errors-with-result.md) - - [`panic!`还是不`panic!`](ch09-03-to-panic-or-not-to-panic.md) + - [`panic!` 与不可恢复的错误](ch09-01-unrecoverable-errors-with-panic.md) + - [`Result` 与可恢复的错误](ch09-02-recoverable-errors-with-result.md) + - [`panic!` 还是不 `panic!`](ch09-03-to-panic-or-not-to-panic.md) -- [泛型、trait 和生命周期](ch10-00-generics.md) +- [泛型、trait 与生命周期](ch10-00-generics.md) - [泛型数据类型](ch10-01-syntax.md) - [trait：定义共享的行为](ch10-02-traits.md) - [生命周期与引用有效性](ch10-03-lifetime-syntax.md) @@ -57,35 +57,35 @@ - [运行测试](ch11-02-running-tests.md) - [测试的组织结构](ch11-03-test-organization.md) -- [一个 I/O 项目](ch12-00-an-io-project.md) +- [一个 I/O 项目：构建命令行程序](ch12-00-an-io-project.md) - [接受命令行参数](ch12-01-accepting-command-line-arguments.md) - [读取文件](ch12-02-reading-a-file.md) - - [增强错误处理和模块化](ch12-03-improving-error-handling-and-modularity.md) - - [测试库的功能](ch12-04-testing-the-librarys-functionality.md) + - [重构以改进模块化与错误处理](ch12-03-improving-error-handling-and-modularity.md) + - [采用测试驱动开发完善库的功能](ch12-04-testing-the-librarys-functionality.md) - [处理环境变量](ch12-05-working-with-environment-variables.md) - - [输出到`stderr`而不是`stdout`](ch12-06-writing-to-stderr-instead-of-stdout.md) + - [将错误信息输出到标准错误而不是标准输出](ch12-06-writing-to-stderr-instead-of-stdout.md) ## Rust 编程思想 -- [Rust 中的函数式语言功能](ch13-00-functional-features.md) - - [闭包](ch13-01-closures.md) - - [迭代器](ch13-02-iterators.md) - - [改进 I/O 项目](ch13-03-improving-our-io-project.md) - - [性能](ch13-04-performance.md) +- [Rust 中的函数式语言功能：迭代器与闭包](ch13-00-functional-features.md) + - [闭包：可以捕获其环境的匿名函数](ch13-01-closures.md) + - [使用迭代器处理元素序列](ch13-02-iterators.md) + - [改进之前的 I/O 项目](ch13-03-improving-our-io-project.md) + - [性能比较：循环对迭代器](ch13-04-performance.md) -- [更多关于 Cargo 和 Crates.io](ch14-00-more-about-cargo.md) - - [发布配置](ch14-01-release-profiles.md) +- [更多关于 Cargo 和 Crates.io 的内容](ch14-00-more-about-cargo.md) + - [采用发布配置自定义构建](ch14-01-release-profiles.md) - [将 crate 发布到 Crates.io](ch14-02-publishing-to-crates-io.md) - [Cargo 工作空间](ch14-03-cargo-workspaces.md) - - [使用`cargo install`从 Crates.io 安装文件](ch14-04-installing-binaries.md) + - [使用 `cargo install` 从 Crates.io 安装二进制文件](ch14-04-installing-binaries.md) - [Cargo 自定义扩展命令](ch14-05-extending-cargo.md) - [智能指针](ch15-00-smart-pointers.md) - - [`Box`Box在堆上存储数据，并且可确定大小](ch15-01-box.md) + - [`Box` 在堆上存储数据，并且可确定大小](ch15-01-box.md) - [`Deref` Trait 允许通过引用访问数据](ch15-02-deref.md) - [`Drop` Trait 运行清理代码](ch15-03-drop.md) - [`Rc` 引用计数智能指针](ch15-04-rc.md) - - [`RefCell`和内部可变性模式](ch15-05-interior-mutability.md) + - [`RefCell` 和内部可变性模式](ch15-05-interior-mutability.md) - [引用循环和内存泄漏是安全的](ch15-06-reference-cycles.md) - [无畏并发](ch16-00-concurrency.md) @@ -94,7 +94,7 @@ - [共享状态](ch16-03-shared-state.md) - [可扩展的并发：`Sync`和`Send`](ch16-04-extensible-concurrency-sync-and-send.md) -- [面向对象](ch17-00-oop.md) +- [Rust 是面向对象语言吗？](ch17-00-oop.md) - [什么是面向对象？](ch17-01-what-is-oo.md) - [为使用不同类型的值而设计的 trait 对象](ch17-02-trait-objects.md) - [面向对象设计模式的实现](ch17-03-oo-design-patterns.md) @@ -103,7 +103,7 @@ - [模式用来匹配值的结构](ch18-00-patterns.md) - [所有可能会用到模式的位置](ch18-01-all-the-places-for-patterns.md) - - [refutable：何时模式可能会匹配失败](ch18-02-refutability.md) + - [Refutability：何时模式可能会匹配失败](ch18-02-refutability.md) - [模式的全部语法](ch18-03-pattern-syntax.md) - [高级特征](ch19-00-advanced-features.md) @@ -123,9 +123,8 @@ - [附录](appendix-00.md) - [A - 关键字](appendix-01-keywords.md) - - [B - 运算符](appendix-02-operators.md) - - [C - 可导出的 trait]() - - [D - Rust 开发版]() - - [E - 宏]() - - [F - 本书翻译]() - - [G - 最新功能](appendix-07-newest-features.md) + - [B - 运算符与符号](appendix-02-operators.md) + - [C - 可导出的 trait](appendix-03-derivable-traits.md) + - [D - 宏](appendix-04-macros.md) + - [E - 本书翻译](appendix-05-translation.md) + - [F - 最新功能](appendix-06-newest-features.md) diff --git a/src/appendix-03-derivable-traits.md b/src/appendix-03-derivable-traits.md new file mode 100644 index 0000000..39ecf9f --- /dev/null +++ b/src/appendix-03-derivable-traits.md @@ -0,0 +1 @@ +# C - 可导出的 trait diff --git a/src/appendix-04-macros.md b/src/appendix-04-macros.md new file mode 100644 index 0000000..8129451 --- /dev/null +++ b/src/appendix-04-macros.md @@ -0,0 +1 @@ +# D - 宏 diff --git a/src/appendix-05-translation.md b/src/appendix-05-translation.md new file mode 100644 index 0000000..f59f546 --- /dev/null +++ b/src/appendix-05-translation.md @@ -0,0 +1 @@ +# E - 本书翻译 diff --git a/src/appendix-06-newest-features.md b/src/appendix-06-newest-features.md new file mode 100644 index 0000000..25f6b45 --- /dev/null +++ b/src/appendix-06-newest-features.md @@ -0,0 +1 @@ +# F - 最新功能 diff --git a/theme/index.hbs b/theme/index.hbs index 2127fbe..3572417 100644 --- a/theme/index.hbs +++ b/theme/index.hbs @@ -121,18 +121,19 @@ {{#each additional_js}} {{/each}} + @@ -143,35 +144,37 @@
-
+
{{!--

You are reading a draft of the next edition of TRPL. For more, go here.

--}} +
-
{{{ content }}}
{{#previous}} - {{/previous}} {{#next}} - {{/next}} @@ -203,6 +206,18 @@ {{{livereload}}} + {{#if google_analytics}} + + {{/if}} + {{#if playpens_editable}} @@ -211,6 +226,14 @@ {{/if}} + {{#if is_print}} + + {{/if}} + From 2767e943b2c61acca7efab4f37bd761217f56a34 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Thu, 11 Jan 2018 12:38:28 +0800 Subject: [PATCH 104/150] check to ch02-00 --- README.md | 6 +--- book.json | 2 +- book.toml | 2 +- src/PREFACE.md | 6 +--- src/appendix-07-newest-features.md | 1 - src/ch01-00-introduction.md | 2 +- src/ch01-01-installation.md | 4 +-- src/ch01-02-hello-world.md | 36 +++++++++++----------- src/ch02-00-guessing-game-tutorial.md | 44 +++++++++++++++------------ 9 files changed, 51 insertions(+), 52 deletions(-) delete mode 100644 src/appendix-07-newest-features.md diff --git a/README.md b/README.md index 16d2525..b0c566c 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,3 @@ # Rust 程序设计语言（第二版） 简体中文版 -还在施工中：目前翻译到第十六章，正在更新第十二章 - -目前官方进度：[第十七章](https://github.com/rust-lang/book/projects/1)（18~20 章还在编写当中） - -GitBook 代码排版已大体解决，已不影响阅读 \ No newline at end of file +还在施工中... \ No newline at end of file diff --git a/book.json b/book.json index 8a1a7cd..e82baa0 100644 --- a/book.json +++ b/book.json @@ -9,7 +9,7 @@ "description": "Rust 程序设计语言 简体中文版", - "author": "Steve Klabnik 和 Carol Nichols，以及来自 Rust 社区的贡献，KaiserY 译", + "author": "Steve Klabnik 和 Carol Nichols，以及来自 Rust 社区的贡献，KaiserY 以及 Rust 中文社区翻译", "language": "zh-hans", diff --git a/book.toml b/book.toml index e63fef4..66f8c14 100644 --- a/book.toml +++ b/book.toml @@ -1,5 +1,5 @@ title = "Rust 程序设计语言 简体中文版" -author = "Steve Klabnik 和 Carol Nichols，以及来自 Rust 社区的贡献，KaiserY 译" +author = "Steve Klabnik 和 Carol Nichols，以及来自 Rust 社区的贡献，KaiserY 以及 Rust 中文社区翻译" description = "Rust 程序设计语言 简体中文版" [output.html] diff --git a/src/PREFACE.md b/src/PREFACE.md index 16d2525..b0c566c 100644 --- a/src/PREFACE.md +++ b/src/PREFACE.md @@ -1,7 +1,3 @@ # Rust 程序设计语言（第二版） 简体中文版 -还在施工中：目前翻译到第十六章，正在更新第十二章 - -目前官方进度：[第十七章](https://github.com/rust-lang/book/projects/1)（18~20 章还在编写当中） - -GitBook 代码排版已大体解决，已不影响阅读 \ No newline at end of file +还在施工中... \ No newline at end of file diff --git a/src/appendix-07-newest-features.md b/src/appendix-07-newest-features.md deleted file mode 100644 index 04c9f4e..0000000 --- a/src/appendix-07-newest-features.md +++ /dev/null @@ -1 +0,0 @@ -# G - 最新功能 diff --git a/src/ch01-00-introduction.md b/src/ch01-00-introduction.md index 6679d8c..cb42f37 100644 --- a/src/ch01-00-introduction.md +++ b/src/ch01-00-introduction.md @@ -20,6 +20,6 @@ registry site），[crates.io]！我们由衷期待**你**使用 Rust 进行创 [on GitHub]: https://github.com/rust-lang/book [CONTRIBUTING.md]: https://github.com/rust-lang/book/blob/master/CONTRIBUTING.md -> 译者注：译本的 [GitHub 仓库][trpl-zh-cn]，同样欢迎 Issue 和 PR :) +> 译者注：本译本的 [GitHub 仓库][trpl-zh-cn]，同样欢迎 Issue 和 PR :) [trpl-zh-cn]: https://github.com/KaiserY/trpl-zh-cn diff --git a/src/ch01-01-installation.md b/src/ch01-01-installation.md index 6c99cd5..bd9615e 100644 --- a/src/ch01-01-installation.md +++ b/src/ch01-01-installation.md @@ -2,7 +2,7 @@ > [ch01-01-installation.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch01-01-installation.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit b6dcc87f2b811c88fc741c86cf6ed3976333acba 使用 Rust 的第一步是安装。你需要网络连接来执行本章的命令，因为将要从网上下载 Rust。 @@ -22,7 +22,7 @@ $ curl https://sh.rustup.rs -sSf | sh Rust is installed now. Great! ``` -当然，如果你对于 `curl | sh` 这样的模式心有疑虑，请随意下载、检查和运行这个脚本。 +当然，如果你不信任采用 `curl URL | sh` 来安装软禁啊，请随意下载、检查和运行这个脚本。 此安装脚本自动将 Rust 加入系统 PATH 环境变量中，再次登陆时生效。如果你希望立刻（不重新登陆）就开始使用 Rust，在 shell 中运行如下命令： diff --git a/src/ch01-02-hello-world.md b/src/ch01-02-hello-world.md index c0311b1..70375d2 100644 --- a/src/ch01-02-hello-world.md +++ b/src/ch01-02-hello-world.md @@ -2,15 +2,15 @@ > [ch01-02-hello-world.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch01-02-hello-world.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit c21a4e7b315d62583470482ab542587a26e1b2e8 -现在安装好了 Rust，让我们来编写第一个程序。当学习一门新语言的时候，使用该语言在屏幕上打印 “Hello, world!” 是一项传统，我们将遵循这个传统。 +现在安装好了 Rust，让我们来编写第一个程序。当学习一门新语言的时候，使用该语言在屏幕上打印 “Hello, world!” 是一项传统，这里我们将遵循这个传统。 > 注意：本书假设你熟悉基本的命令行操作。Rust 对于你的编辑器、工具，以及代码位于何处并没有特定的要求，如果相比命令行你更倾向于 IDE，请随意使用合意的 IDE。 ### 创建项目目录 -首先，创建一个存放 Rust 代码的目录。Rust 并不关心代码的位置，不过在本书中，我们建议你在 home 目录中创建一个 *projects* 目录，并把你的所有项目放在这。打开一个终端，输入如下命令为这个项目创建一个文件夹： +首先，创建一个存放 Rust 代码的目录。Rust 并不关心代码的位置，不过在本书中，我们建议你在 home 目录中创建一个 *projects* 目录，并将你的所有项目置于此处。打开终端并输入如下命令为此项目创建一个目录： Linux 和 Mac： @@ -61,11 +61,11 @@ $ ./main Hello, world! ``` -在 Windows 上，运行 `.\main.exe`，而不是`./main`。不管使用何种系统，应该在终端看到 `Hello, world!` 字样。如果你做到了，恭喜你！你已经正式编写了一个 Rust 程序。现在你成为了一名 Rust 程序员！欢迎！ +在 Windows 上，运行 `.\main.exe`，而不是`./main`。不管使用何种系统，都应该在终端看到 `Hello, world!` 字样。如果你做到了，恭喜你！你已经正式编写了一个 Rust 程序。现在你成为了一名 Rust 程序员！欢迎！ ### 分析 Rust 程序 -现在，让我们回过头来仔细看看 “Hello, world!” 程序到底发生了什么。这是拼图的第一片： +现在，让我们回过头来仔细看看 “Hello, world!” 程序中到底发生了什么。这是拼图的第一片： ```rust fn main() { @@ -73,7 +73,7 @@ fn main() { } ``` -这几行定义了一个 Rust **函数**。`main` 函数是特殊的：它是每个可执行的 Rust 程序首先执行的。第一行代码表示 “我声明了一个叫做 `main` 的函数，它没有参数也没有返回值。” 如果有参数的话，它们的名称应该出现在括号中，`(`和`)`之间。 +这几行定义了一个 Rust **函数**。`main` 函数是特殊的：它是每个可执行的 Rust 程序所首先执行的。第一行代码表示 “我声明了一个叫做 `main` 的函数，它没有参数也没有返回值。” 如果有参数的话，它们的名称应该出现在括号中，位于 `(` 和 `)` 之间。 还须注意函数体被包裹在花括号中，`{`和`}` 之间。Rust 要求所有函数体都要用花括号包裹起来（译者注：有些语言，当函数体只有一行时可以省略花括号，但在 Rust 中是不行的）。一般来说，将左花括号与函数声明置于同一行并以空格分隔，是良好的代码风格。 @@ -85,7 +85,7 @@ fn main() { 这行代码完成这个小程序的所有工作：在屏幕上打印文本。这里有很多细节需要注意。首先 Rust 使用 4 个空格的缩进风格，而不是 1 个制表符（tab）。 -第二个重要的部分是 `println!()`。这个称为 Rust **宏**，Rust 元编程（metaprogramming）的关键所在。如果是调用函数，则应看起来像这样：`println`（没有`!`）。我们将在附录 E 中更加详细的讨论宏，现在你只需记住，当看到符号 `!` 的时候，调用的是宏而不是普通函数。 +第二个重要的部分是 `println!()`。这称为 Rust **宏**，Rust 元编程（metaprogramming）的关键所在。如果是调用函数，则应看起来像这样：`println`（没有`!`）。我们将在附录 D 中更加详细的讨论宏，现在你只需记住，当看到符号 `!` 的时候，就意味着调用的是宏而不是普通函数。 接下来，`"Hello, world!"` 是一个 **字符串**。我们把这个字符串作为一个参数传递给 `println!`，它负责在屏幕上打印这个字符串。轻松加愉快！(⊙o⊙) @@ -95,7 +95,7 @@ fn main() { “编写并运行 Rust 程序” 部分中展示了如何运行新创建的程序。现在我们将拆分并检查每一步操作。 -在运行一个 Rust 程序之前必须先进行编译。可以通过 `rustc` 命令来使用 Rust 编译器，并传递源文件的名字给它，如下： +在运行 Rust 程序之前必须先进行编译。可以通过 `rustc` 命令并传递源文件名称来使用 Rust 编译器，如下： ```text $ rustc main.rs @@ -124,15 +124,15 @@ $ ./main # or .\main.exe on Windows 如果 *main.rs* 是上文所述的 “Hello, world!” 程序，它将会在终端上打印 `Hello, world!`。 -来自 Ruby、Python 或 JavaScript 这样的动态类型语言背景的同学，可能不太习惯将编译和执行分为两个单独的步骤。Rust 是一种 **预编译静态类型语言**（*ahead-of-time compiled language*），这意味着你可以编译程序并将其交与他人，它们不需要安装 Rust 即可运行。相反如果你给他们一个 `.rb`、`.py` 或 `.js` 文件，他们需要先分别安装 Ruby，Python，JavaScript 实现（运行时环境，VM），不过你只需要一句命令就可以编译和执行程序。这一切都是语言设计上的权衡取舍。 +来自 Ruby、Python 或 JavaScript 这样的动态类型语言背景的同学，可能不太习惯将编译和执行分为两个单独的步骤。Rust 是一种 **预编译静态类型**（*ahead-of-time compiled*）语言，这意味着你可以编译程序并将其交与他人，它们不需要安装 Rust 即可运行。相反如果你给他们一个 `.rb`、`.py` 或 `.js` 文件，他们需要先分别安装 Ruby，Python，JavaScript 实现（运行时环境，VM），不过你只需要一句命令就可以编译和执行程序。这一切都是语言设计上的权衡取舍。 使用 `rustc` 编译简单程序是没问题的，不过随着项目的增长，你可能需要控制你项目的方方面面，并且更容易地将代码分享给其它人或项目。接下来，我们要介绍一个叫做 Cargo 的工具，它会帮助你编写真实世界中的 Rust 程序。 ## Hello, Cargo! -Cargo 是 Rust 的构建系统和包管理工具，同时 Rustacean 们使用 Cargo 来管理他们的 Rust 项目，它使得很多任务变得更轻松。例如，Cargo 负责构建代码、下载依赖库并编译它们。我们把代码需要的库叫做 **依赖**（*dependencies*）。 +Cargo 是 Rust 的构建系统和包管理工具，同时 Rustacean 们使用 Cargo 来管理他们的 Rust 项目，因为它使得很多任务变得更轻松。例如，Cargo 负责构建代码、下载依赖库并编译它们。我们把代码所需要的库叫做 **依赖**（*dependencies*）。 -最简单的 Rust 程序，比如我们刚刚编写的，并没有任何依赖，所以我们只使用了 Cargo 构建代码的功能。随着编写的程序更加复杂，你会想要添加依赖，如果你使用 Cargo 开始的话，这将会变得简单许多。 +最简单的 Rust 程序，比如我们刚刚编写的，并没有任何依赖，所以目前我们只会用到 Cargo 构建代码那部分的功能。随着编写的程序更加复杂，你会想要添加依赖，如果你一开始就使用 Cargo 的话，事情会变得简单许多。 由于绝大部分 Rust 项目使用 Cargo，本书接下来的部分将假设你使用它。如果使用之前介绍的官方安装包的话，则自带了 Cargo。如果通过其他方式安装的话，可以在终端输入如下命令检查是否安装了 Cargo： @@ -167,7 +167,7 @@ $ cd hello_cargo 我们向 `cargo new` 传递了 `--bin`，因为我们的目标是生成一个可执行程序，而不是一个库。可执行程序是二进制可执行文件，通常就叫做 **二进制文件**（*binaries*）。项目的名称被定为 `hello_cargo`，同时 Cargo 在一个同名目录中创建它的文件，接着我们可以进入查看。 -如果列出 *hello_cargo* 目录中的文件，将会看到 Cargo 生成了一个文件和一个目录：一个 *Cargo.toml* 文件和一个 *src* 目录，*main.rs* 文件位于 *src* 目录中。它也在 *hello_cargo* 目录初始化了一个 git 仓库，以及一个 *.gitignore* 文件；你可以通过`--vcs`参数切换到其它版本控制系统（VCS），或者不使用 VCS。 +如果列出 *hello_cargo* 目录中的文件，将会看到 Cargo 生成了一个文件和一个目录：一个 *Cargo.toml* 文件和一个 *src* 目录，*main.rs* 文件位于 *src* 目录中。它也在 *hello_cargo* 目录初始化了一个 git 仓库，以及一个 *.gitignore* 文件；你可以通过 `--vcs` 参数切换到其它版本控制系统（VCS），或者不使用 VCS。 使用文本编辑器（工具请随意）打开 *Cargo.toml* 文件。它应该看起来像这样： @@ -186,11 +186,11 @@ authors = ["Your Name "] [toml]: https://github.com/toml-lang/toml -第一行，`[package]`，是一个段落标题，表明下面的语句用来配置一个包。随着我们在这个文件增加更多的信息，还将增加其他段落。 +第一行，`[package]`，是一个部分标题，表明下面的语句用来配置一个包。随着我们在这个文件增加更多的信息，还将增加其他部分。 接下来的三行设置了三个 Cargo 所需的配置，项目的名称、版本和作者，它们告诉 Cargo 需要编译这个项目。Cargo 从环境中获取你的名称和 email 信息。如果不正确，请修改并保存此文件。 -最后一行，`[dependencies]`，是项目依赖的 *crates* 列表（我们称呼 Rust 代码包为 crate）段落的开始，这样 Cargo 就知道应该下载和编译它们了。这个项目并不需要任何其他的 crate，不过在下一章猜猜看教程会用得上。 +最后一行，`[dependencies]`，是项目依赖的 *crates* 列表（我们称呼 Rust 代码包为 crate）部分的开始，这样 Cargo 就知道应该下载和编译它们了。这个项目并不需要任何其他的 crate，不过在下一章猜猜看教程会用得上。 现在看看 *src/main.rs*： @@ -218,16 +218,17 @@ Cargo 期望源文件位于 *src* 目录，将项目根目录留给 README、lic ```text $ cargo build Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo) + Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs ``` -这应该会创建 *target/debug/hello_cargo*可执行文件（或者在 Windows 上是 *target\debug\hello_cargo.exe*），可以通过这个命令运行： +这应该会创建 *target/debug/hello_cargo* 可执行文件（或者在 Windows 上是 *target\debug\hello_cargo.exe*），可以通过这个命令运行： ```text $ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows Hello, world! ``` -很好！如果一切顺利，`Hello, world!`应该再次打印在终端上。 +很好！如果一切顺利，`Hello, world!` 应该再次打印在终端上。 首次运行 `cargo build` 的时候，Cargo 会在项目根目录创建一个新文件，*Cargo.lock*，它看起来像这样： @@ -254,13 +255,14 @@ Hello, world! ```text $ cargo run Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo) + Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs Running `target/debug/hello_cargo` Hello, world! ``` 所以现在又出现更多的不同： -- 使用 `cargo build` 构建项目（或使用 `cargo run` 一步构建并运行），而不是使用`rustc` +- 使用 `cargo build` 构建项目（或使用 `cargo run` 一步构建并运行），而不是使用 `rustc` - 有别于将构建结果放在与源码相同的目录，Cargo 会将其放到 *target/debug* 目录。 Cargo 的另一个优点是，不管你使用什么操作系统其命令都是一样的，所以本书之后将不再为 Linux 和 Mac 以及 Windows 提供相应的命令。 diff --git a/src/ch02-00-guessing-game-tutorial.md b/src/ch02-00-guessing-game-tutorial.md index 43e4477..c1fe61d 100644 --- a/src/ch02-00-guessing-game-tutorial.md +++ b/src/ch02-00-guessing-game-tutorial.md @@ -2,7 +2,7 @@ > [ch02-00-guessing-game-tutorial.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch02-00-guessing-game-tutorial.md) >
-> commit 2e269ff82193fd65df8a87c06561d74b51ac02f7 +> commit 8a145ebea5c05f07fc240269bc9557340972188f 让我们一起动手完成一个项目，来快速上手 Rust！本章将介绍 Rust 中常用的一些概念，并通过真实的程序来展示如何运用它们。你将会学到更多诸如 `let`、`match`、方法、关联函数、外部 crate 等很多的知识！后继章节会深入探索这些概念的细节。在这一章，我们将练习基础。 @@ -53,9 +53,9 @@ $ cargo run Hello, world! ``` -`run` 命令适合用于需要快速迭代的项目，而这个游戏便是这样的项目：我们需要在下一步迭代之前快速测试。 +`run` 命令适合用于需要快速迭代的项目，而这个游戏便是这样的项目：我们需要在下一步迭代之前快速测试每一步。 -重新打开 *src/main.rs* 文件。我们将会在这个文件中编写全部代码。 +重新打开 *src/main.rs* 文件。我们将会在这个文件中编写全部的代码。 ## 处理一次猜测 @@ -88,7 +88,7 @@ fn main() { use std::io; ``` -Rust 默认只在每个程序的 [*prelude*][prelude] 中引入少量类型。如果需要的类型不在 prelude 中，你必须使用一个 `use` 语句显式的将其引入作用域。`std::io` 库提供很多 `io` 相关的功能，比如接受用户输入。 +Rust 默认只在每个程序的 [*prelude*][prelude] 中引入少量类型。如果需要的类型不在 prelude 中，你必须使用一个 `use` 语句显式的将其引入作用域。`std::io` 库提供很多 `io` 相关的功能，比如接受用户输入的功能。 [prelude]: https://doc.rust-lang.org/std/prelude/index.html @@ -150,7 +150,7 @@ io::stdin().read_line(&mut guess) .expect("Failed to read line"); ``` -如果程序的开头没有 `use std::io` 这一行，可以把函数调用写成 `std::io::stdin`。`stdin` 函数返回一个 [`std::io::stdin`][iostdin] 的实例，这代表终端标准输入句柄的类型。 +如果程序的开头没有 `use std::io` 这一行，可以把函数调用写成 `std::io::stdin`。`stdin` 函数返回一个 [`std::io::stdin`][iostdin] 的实例，这代表终端标准输入句柄的类型。 [iostdin]: https://doc.rust-lang.org/std/io/struct.Stdin.html @@ -162,13 +162,13 @@ io::stdin().read_line(&mut guess) `&` 表示这个参数是一个 **引用**（*reference*），它允许多处代码访问同一处数据，而无需在内存中多次拷贝。引用是一个复杂的特性，Rust 的一个主要优势就是安全而简单的操纵引用。完成当前程序并不需要了解如此多细节：第四章会更全面的解释引用。现在，我们只需知道它像变量一样，默认是不可变的，需要写成 `&mut guess` 而不是 `&guess` 来使其可变。 -我们还没有分析完这行代码。虽然这是单独一行代码，但它是一个逻辑行（虽然换行了但仍是一个语句）的第一部分。第二部分是这个方法： +我们还没有完全分析完这行代码。虽然这是单独一行代码，但它是一个逻辑行（虽然换行了但仍是一个语句）的第一部分。第二部分是这个方法： ```rust,ignore .expect("Failed to read line"); ``` -当使用 `.foo()` 语法调用方法时，通过换行并缩进来把长行拆开，是明智的。我们完全可以这样写： +当使用 `.foo()` 语法调用方法时，通过换行并缩进来把长行拆开是明智的。我们完全可以这样写： ```rust,ignore io::stdin().read_line(&mut guess).expect("Failed to read line"); @@ -187,24 +187,27 @@ io::stdin().read_line(&mut guess).expect("Failed to read line"); [enums]: ch06-00-enums.html -对于 `Result`，它的成员是 `Ok` 或 `Err`，`Ok` 表示操作成功，内部包含成功时产生的值。`Err` 意味着操作失败，包含失败的前因后果。 +对于 `Result`，它的成员是 `Ok` 或 `Err`，`Ok` 表示操作成功，内部包含成功时产生的值。`Err` 意味着操作失败，并且包含失败的前因后果。 这些 `Result` 类型的作用是编码错误处理信息。`Result` 类型的值，像其他类型一样，拥有定义于其上的方法。`io::Result` 的实例拥有 [`expect` 方法][expect]。如果 `io::Result` 实例的值是 `Err`，`expect` 会导致程序崩溃，并显示当做参数传递给 `expect` 的信息。如果 `read_line` 方法返回 `Err`，则可能是来源于底层操作系统错误的结果。如果 `io::Result` 实例的值是 `Ok`，`expect` 会获取 `Ok` 中的值并原样返回。在本例中，这个值是用户输入到标准输入中的字节的数量。 [expect]: https://doc.rust-lang.org/std/result/enum.Result.html#method.expect -如果不使用 `expect`，程序也能编译，不过会出现一个警告： +如果不调用 `expect`，程序也能编译，不过会出现一个警告： ```text $ cargo build Compiling guessing_game v0.1.0 (file:///projects/guessing_game) -src/main.rs:10:5: 10:39 warning: unused result which must be used, -#[warn(unused_must_use)] on by default -src/main.rs:10 io::stdin().read_line(&mut guess); - ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +warning: unused `std::result::Result` which must be used + --> src/main.rs:10:5 + | +10 | io::stdin().read_line(&mut guess); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + | + = note: #[warn(unused_must_use)] on by default ``` -Rust 警告我们没有使用 `read_line` 的返回值 `Result`，说明有一个可能的错误没有处理。想消除警告，就老实的写错误处理，不过我们就是希望程序在出现问题时立即崩溃，所以直接使用 `expect`。第九章会学习如何从错误中恢复。 +Rust 警告我们没有使用 `read_line` 的返回值 `Result`，说明有一个可能的错误没有处理。消除警告的正确做法是实际编写错误处理代码，不过我们就是希望程序在出现问题时立即崩溃，所以直接使用 `expect`。第九章会学习如何从错误中恢复。 ### 使用 `println!` 占位符打印值 @@ -232,6 +235,7 @@ println!("x = {} and y = {}", x, y); ```text $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) + Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs Running `target/debug/guessing_game` Guess the number! Please input your guess. @@ -249,9 +253,9 @@ You guessed: 6 ### 使用 crate 来增加更多功能 -记住 *crate* 是一个 Rust 代码的包。我们正在构建的项目是一个**二进制 crate**，它生成一个可执行文件。 `rand` crate 是一个 **库 crate**，库 crate 可以包含任意能被其他程序使用的代码。 +记住 *crate* 是一个 Rust 代码的包。我们正在构建的项目是一个 **二进制 crate**，它生成一个可执行文件。 `rand` crate 是一个 **库 crate**，库 crate 可以包含任意能被其他程序使用的代码。 -Cargo 对外部 crate 的运用是其亮点。在我们使用 `rand` 编写代码之前，需要编辑 *Cargo.toml* ，声明 `rand` 作为一个依赖。现在打开这个文件并在底部的 `[dependencies]` 段落标题之下添加： +Cargo 对外部 crate 的运用是其真正闪光的地方。在我们使用 `rand` 编写代码之前，需要编辑 *Cargo.toml* ，声明 `rand` 作为一个依赖。现在打开这个文件并在底部的 `[dependencies]` 部分标题之下添加： 文件名: Cargo.toml @@ -261,7 +265,7 @@ Cargo 对外部 crate 的运用是其亮点。在我们使用 `rand` 编写代 rand = "0.3.14" ``` -在 *Cargo.toml* 文件中，标题以及之后的内容属同一个段落，直到遇到下一个标题才开始新的段落。`[dependencies]` 段落告诉 Cargo 本项目依赖了哪些外部 crate 及其版本。本例中，我们使用语义化版本 `0.3.14` 来指定 `rand` crate。Cargo 理解[语义化版本（Semantic Versioning）][semver]（有时也称为 *SemVer*），这是一种定义版本号的标准。`0.3.14` 事实上是 `^0.3.14` 的简写，它表示 “任何与 0.3.14 版本公有 API 相兼容的版本”。 +在 *Cargo.toml* 文件中，标题以及之后的内容属同一个部分，直到遇到下一个标题才开始新的部分。`[dependencies]` 部分告诉 Cargo 本项目依赖了哪些外部 crate 及其版本。本例中，我们使用语义化版本 `0.3.14` 来指定 `rand` crate。Cargo 理解[语义化版本（Semantic Versioning）][semver]（有时也称为 *SemVer*），这是一种定义版本号的标准。`0.3.14` 事实上是 `^0.3.14` 的简写，它表示 “任何与 0.3.14 版本公有 API 相兼容的版本”。 [semver]: http://semver.org @@ -275,6 +279,7 @@ $ cargo build Compiling libc v0.2.14 Compiling rand v0.3.14 Compiling guessing_game v0.1.0 (file:///projects/guessing_game) + Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs ``` 示例 2-2: 增加 rand crate 作为依赖之后运行 `cargo build` 的输出 @@ -287,18 +292,19 @@ $ cargo build 在更新完 registry 后，Cargo 检查 `[dependencies]` 段落并下载缺失的部分。本例中，虽然只声明了 `rand` 一个依赖，然而 Cargo 还是额外获取了 `libc` 的拷贝，因为 `rand` 依赖 `libc` 来正常工作。下载完成后，Rust 编译依赖，然后使用这些依赖编译项目。 -如果不做任何修改，立刻再次运行 `cargo build`，则不会有任何输出。Cargo 知道它已经下载并编译了依赖，同时 *Cargo.toml* 文件也没有变动。Cargo 还知道代码也没有任何修改，所以它不会重新编译代码。因为无事可做，它简单的退出了。如果打开 *src/main.rs* 文件，做一些无关紧要的修改，保存并再次构建，只会出现一行输出： +如果不做任何修改，立刻再次运行 `cargo build`，则不会有任何输出。Cargo 知道它已经下载并编译了依赖，同时 *Cargo.toml* 文件也没有变动。Cargo 还知道代码也没有任何修改，所以它不会重新编译代码。因为无事可做，它简单的退出了。如果打开 *src/main.rs* 文件，做一些无关紧要的修改，保存并再次构建，只会出现两行输出： ```text $ cargo build Compiling guessing_game v0.1.0 (file:///projects/guessing_game) + Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs ``` 这一行表示 Cargo 只针对 *src/main.rs* 文件的微小修改而更新构建。依赖没有变化，所以 Cargo 知道它可以复用已经为此下载并编译的代码。它只是重新构建了部分（项目）代码。 #### *Cargo.lock* 文件确保构建是可重现的 -Cargo 有一个机制来确保任何人在任何时候重新构建代码，都会产生相同的结果：Cargo 只会使用你指定的依赖的版本，除非你又手动指定了别的。例如，如果下周 `rand` crate 的 `v0.3.15` 版本出来了，它修复了一个重要的 bug，同时也含有一个缺陷，会破坏代码的运行，这时会发生什么呢？ +Cargo 有一个机制来确保任何人在任何时候重新构建代码，都会产生相同的结果：Cargo 只会使用你指定的依赖的版本，除非你又手动指定了别的。例如，如果下周 `rand` crate 的 `v0.3.15` 版本出来了，它修复了一个重要的 bug，同时也含有一个会破坏代码运行的缺陷，这时会发生什么呢？ 这个问题的答案是 *Cargo.lock* 文件。它在第一次运行 `cargo build` 时创建，并放在 *guessing_game* 目录。当第一次构建项目时，Cargo 计算出所有符合要求的依赖版本并写入 *Cargo.lock* 文件。当将来构建项目时，Cargo 会发现 *Cargo.lock* 存在并使用其中指定的版本，而不是再次计算所有的版本。这使得你拥有了一个自动化的可重现的构建。换句话说，项目会持续使用 `0.3.14` 直到你显式升级，感谢 *Cargo.lock* 文件。 From fca0b2b4b9ea76d2062b23782c072d877427b2f1 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Thu, 11 Jan 2018 18:11:35 +0800 Subject: [PATCH 105/150] check to ch03-01 --- src/ch02-00-guessing-game-tutorial.md | 38 +++++++++++----------- src/ch03-00-common-programming-concepts.md | 2 +- src/ch03-01-variables-and-mutability.md | 24 +++++++------- 3 files changed, 33 insertions(+), 31 deletions(-) diff --git a/src/ch02-00-guessing-game-tutorial.md b/src/ch02-00-guessing-game-tutorial.md index c1fe61d..c577a01 100644 --- a/src/ch02-00-guessing-game-tutorial.md +++ b/src/ch02-00-guessing-game-tutorial.md @@ -374,11 +374,11 @@ fn main() { 这里在顶部增加一行 `extern crate rand;` 通知 Rust 我们要使用外部依赖。这也会调用相应的 `use rand`，所以现在可以使用 `rand::` 前缀来调用 `rand` crate 中的任何内容。 -接下来增加了另一行 `use`：`use rand::Rng`。`Rng` 是一个 trait，它定义了随机数生成器应实现的方法 ，想使用这些方法的话此 trait 必须在作用域中。第十章会详细介绍 trait。 +接下来增加了另一行 `use`：`use rand::Rng`。`Rng` 是一个 trait，它定义了随机数生成器应实现的方法，想使用这些方法的话此 trait 必须在作用域中。第十章会详细介绍 trait。 -另外，中间还新增加了两行。`rand::thread_rng` 函数提供实际使用的随机数生成器：它位于当前执行线程，并从操作系统获取 seed。接下来，调用随机数生成器的 `gen_range` 方法。这个方法由刚才引入到作用域的 `Rng` trait 定义。`gen_range` 方法获取两个数字作为参数，并生成一个范围在两者之间的随机数。它包含下限但不包含上限，所以需要指定 `1` 和 `101` 来请求一个 1 和 100 之间的数。 +另外，中间还新增加了两行。`rand::thread_rng` 函数提供实际使用的随机数生成器：它位于当前执行线程本地，并从操作系统获取 seed。接下来，调用随机数生成器的 `gen_range` 方法。这个方法由刚才引入到作用域的 `Rng` trait 定义。`gen_range` 方法获取两个数字作为参数，并生成一个范围在两者之间的随机数。它包含下限但不包含上限，所以需要指定 `1` 和 `101` 来请求一个 1 和 100 之间的数。 -知道 use 哪个 trait 和该从 crate 中调用哪个方法并不代表你 **知道** 如何使用。crate 的使用说明位于其文档中。Cargo 有一个很棒的功能是：运行 `cargo doc --open` 命令来构建所有本地依赖提供的文档，并在浏览器中打开。例如，假设你对 `rand` crate 中的其他功能感兴趣，`cargo doc --open` 并点击左侧导航栏中的 `rand`。 +知道 use 哪个 trait 和该从 crate 中调用哪个方法并不是是你唯一会 **知道** 的。crate 的使用说明位于其文档中。Cargo 有一个很棒的功能是：运行 `cargo doc --open` 命令来构建所有本地依赖提供的文档，并在浏览器中打开。例如，假设你对 `rand` crate 中的其他功能感兴趣，`cargo doc --open` 并点击左侧导航栏中的 `rand`。 新增加的第二行代码打印出了秘密数字。这在开发程序时很有用，因为可以测试它，不过在最终版本中会删掉它。游戏一开始就打印出结果就没什么可玩的了！ @@ -387,6 +387,7 @@ fn main() { ```text $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) + Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs Running `target/debug/guessing_game` Guess the number! The secret number is: 7 @@ -434,9 +435,9 @@ fn main() { println!("You guessed: {}", guess); match guess.cmp(&secret_number) { - Ordering::Less => println!("Too small!"), + Ordering::Less => println!("Too small!"), Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), + Ordering::Equal => println!("You win!"), } } ``` @@ -449,9 +450,9 @@ fn main() { ```rust,ignore match guess.cmp(&secret_number) { - Ordering::Less => println!("Too small!"), + Ordering::Less => println!("Too small!"), Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), + Ordering::Equal => println!("You win!"), } ``` @@ -459,7 +460,7 @@ match guess.cmp(&secret_number) { [match]: ch06-02-match.html -一个 `match` 表达式由 **分支（arms）** 构成。一个分支包含一个 **模式**（*pattern*）和表达式开头的值与分支模式相匹配时应该执行的代码。Rust 获取提供给 `match` 的值并挨个检查每个分支的模式。`match` 结构和模式是 Rust 中强大的功能，它体现了代码可能遇到的多种情形，并帮助你没有遗漏的处理。这些功能将分别在第六章和第十八章详细介绍。 +一个 `match` 表达式由 **分支（arms）** 构成。一个分支包含一个 **模式**（*pattern*）和表达式开头的值与分支模式相匹配时应该执行的代码。Rust 获取提供给 `match` 的值并挨个检查每个分支的模式。`match` 结构和模式是 Rust 中强大的功能，它体现了代码可能遇到的多种情形，并帮助你确保没有遗漏处理。这些功能将分别在第六章和第十八章详细介绍。 让我们看看使用 `match` 表达式的例子。假设用户猜了 50，这时随机生成的秘密数字是 38。比较 50 与 38 时，因为 50 比 38 要大，`cmp` 方法会返回 `Ordering::Greater`。`Ordering::Greater` 是 `match` 表达式得到的值。它检查第一个分支的模式，`Ordering::Less` 与 `Ordering::Greater`并不匹配，所以它忽略了这个分支的动作并来到下一个分支。下一个分支的模式是 `Ordering::Greater`，**正确** 匹配！这个分支关联的代码被执行，在屏幕打印出 `Too big!`。`match` 表达式就此终止，因为该场景下没有检查最后一个分支的必要。 @@ -485,7 +486,6 @@ Could not compile `guessing_game`. 所以我们必须把从输入中读取到的 `String` 转换为一个真正的数字类型，才好与秘密数字进行比较。这可以通过在 `main` 函数体中增加如下两行代码来实现： - 文件名: src/main.rs ```rust,ignore @@ -515,9 +515,9 @@ fn main() { println!("You guessed: {}", guess); match guess.cmp(&secret_number) { - Ordering::Less => println!("Too small!"), + Ordering::Less => println!("Too small!"), Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), + Ordering::Equal => println!("You win!"), } } ``` @@ -544,6 +544,7 @@ let guess: u32 = guess.trim().parse() ```text $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) + Finished dev [unoptimized + debuginfo] target(s) in 0.43 secs Running `target/guessing_game` Guess the number! The secret number is: 58 @@ -591,9 +592,9 @@ fn main() { println!("You guessed: {}", guess); match guess.cmp(&secret_number) { - Ordering::Less => println!("Too small!"), + Ordering::Less => println!("Too small!"), Ordering::Greater => println!("Too big!"), - Ordering::Equal => println!("You win!"), + Ordering::Equal => println!("You win!"), } } } @@ -634,7 +635,6 @@ error: Process didn't exit successfully: `target/debug/guess` (exit code: 101) 让我们增加一个 `break`，在用户猜对时退出游戏： - 文件名: src/main.rs ```rust,ignore @@ -665,9 +665,9 @@ fn main() { println!("You guessed: {}", guess); match guess.cmp(&secret_number) { - Ordering::Less => println!("Too small!"), + Ordering::Less => println!("Too small!"), Ordering::Greater => println!("Too big!"), - Ordering::Equal => { + Ordering::Equal => { println!("You win!"); break; } @@ -693,7 +693,7 @@ let guess: u32 = match guess.trim().parse() { 如果 `parse` 能够成功的将字符串转换为一个数字，它会返回一个包含结果数字的 `Ok`。这个 `Ok` 值与 `match` 第一个分支的模式相匹配，该分支对应的动作返回 `Ok` 值中的数字 `num`，最后如愿变成新创建的 `guess` 变量。 -如果 `parse` *不* 能将字符串转换为一个数字，它会返回一个包含更多错误信息的 `Err`。`Err` 值不能匹配第一个 `match` 分支的 `Ok(num)` 模式，但是会匹配第二个分支的 `Err(_)` 模式：`_` 是一个通配值，本例中用来匹配所有 `Err` 值，不管其中有何种信息。所以程序会执行第二个分支的动作，`continue` 意味着进入 `loop` 的下一次循环，请求另一个猜测。这样程序就有效的忽略了 `parse` 可能遇到的所有错误！ +如果 `parse` *不* 能将字符串转换为一个数字，它会返回一个包含更多错误信息的 `Err`。`Err` 值不能匹配第一个 `match` 分支的 `Ok(num)` 模式，但是会匹配第二个分支的 `Err(_)` 模式：`_` 是一个通配符值，本例中用来匹配所有 `Err` 值，不管其中有何种信息。所以程序会执行第二个分支的动作，`continue` 意味着进入 `loop` 的下一次循环，请求另一个猜测。这样程序就有效的忽略了 `parse` 可能遇到的所有错误！ 现在万事俱备，只需运行 `cargo run`： @@ -751,9 +751,9 @@ fn main() { println!("You guessed: {}", guess); match guess.cmp(&secret_number) { - Ordering::Less => println!("Too small!"), + Ordering::Less => println!("Too small!"), Ordering::Greater => println!("Too big!"), - Ordering::Equal => { + Ordering::Equal => { println!("You win!"); break; } diff --git a/src/ch03-00-common-programming-concepts.md b/src/ch03-00-common-programming-concepts.md index 562b11b..5b6cd65 100644 --- a/src/ch03-00-common-programming-concepts.md +++ b/src/ch03-00-common-programming-concepts.md @@ -4,7 +4,7 @@ >
> commit 04aa3a45eb72855b34213703718f50a12a3eeec8 -本章涉及一些几乎所有编程语言都有的概念，以及它们在 Rust 中是如何工作的。很多编程语言的核心概念都是共通的，本章中展示的概念都不是 Rust 特有的，不过我们会在 Rust 环境中讨论它们，解释它们的使用习惯。 +本章涉及一些几乎所有编程语言都有的概念，以及它们在 Rust 中是如何工作的。很多编程语言的核心概念都是共通的，本章中展示的概念都不是 Rust 所特有的，不过我们会在 Rust 环境中讨论它们，解释它们的使用习惯。 具体地，我们将会学习变量，基本类型，函数，注释和控制流。这些基础知识将会出现在每一个 Rust 程序中，提早学习这些概念会为你奠定坚实的起步基础。 diff --git a/src/ch03-01-variables-and-mutability.md b/src/ch03-01-variables-and-mutability.md index 2caf8ae..0c6990b 100644 --- a/src/ch03-01-variables-and-mutability.md +++ b/src/ch03-01-variables-and-mutability.md @@ -2,9 +2,9 @@ > [ch03-01-variables-and-mutability.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch03-01-variables-and-mutability.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 6aad5008b69078a2fc18e6dd7e00ef395170c749 -第二章中提到过，变量默认是 **不可变**（*immutable*）的。这是利用 Rust 安全和简单并发的优势编写代码一大助力。不过，你仍然可以使用可变变量。让我们探讨一下 Rust 拥抱不可变性的原因及方法，以及何时你不想使用不可变性。 +第二章中提到过，变量默认是 **不可变**（*immutable*）的。这是鼓励你利用 Rust 安全和简单并发的优势来编写代码的一大助力。不过，你仍然可以使用可变变量。让我们探讨一下 Rust 拥抱不可变性的原因及方法，以及何时你不想使用不可变性。 当变量不可变时，意味着一旦值被绑定上一个名称，你就不能改变这个值。作为说明，通过 `cargo new --bin variables` 在 *projects* 目录生成一个叫做 *variables* 的新项目。 @@ -24,23 +24,23 @@ fn main() { 保存并使用 `cargo run` 运行程序。应该会看到一个错误信息，如下输出所示： ```text -error[E0384]: re-assignment of immutable variable `x` +error[E0384]: cannot assign twice to immutable variable `x` --> src/main.rs:4:5 | 2 | let x = 5; | - first assignment to `x` 3 | println!("The value of x is: {}", x); 4 | x = 6; - | ^^^^^ re-assignment of immutable variable + | ^^^^^ cannot assign twice to immutable variable ``` 这个例子展示了编译器如何帮助你找出程序中的错误。虽然编译错误令人沮丧，那也不过是说程序不能安全的完成你想让它完成的工作；而 **不能** 说明你是不是一个好程序员！有经验的 Rustacean 们一样会遇到编译错误。 -这些错误给出的原因是 `对不可变变量重新赋值`（`re-assignment of immutable variable`），因为我们尝试对不可变变量 `x` 赋第二个值。 +这些错误给出的原因是 `不能对不可变变量二次赋值`（`cannot assign twice to immutable variable x`），因为我们尝试对不可变变量 `x` 赋第二个值。 -在尝试改变预设为不可变的值的时候产生编译错误是很重要的，因为这种情况可能导致 bug：如果代码的一部分假设一个值永远也不会改变，而另一部分代码改变了它，第一部分代码就有可能以不可预料的方式运行。不得不承认这种 bug 难以跟踪，尤其是第二部分代码只是 **有时** 改变其值。 +在尝试改变预设为不可变的值的时候产生编译错误是很重要的，因为这种情况可能导致 bug：如果代码的一部分假设一个值永远也不会改变，而另一部分代码改变了它，第一部分代码就有可能以不可预料的方式运行。不得不承认这种 bug 难以跟踪，尤其是第二部分代码只是 **有时** 改变其值的时候。 -Rust 编译器保证，如果声明一个值不会变，它就真的不会变。这意味着当阅读和编写代码时，不需要记住如何以及哪里可能会被改变，从而使得代码易于推导。 +Rust 编译器保证，如果声明一个值不会变，它就真的不会变。这意味着当阅读和编写代码时，不需要追踪一个值如何以及哪里可能会被改变，从而使得代码易于推导。 不过可变性也是非常有用的。变量只是默认不可变，可以通过在变量名之前加 `mut` 来使其可变。除了使值可以改变之外，它向读者表明了其他代码将会改变这个变量的意图。 @@ -62,12 +62,13 @@ fn main() { ```text $ cargo run Compiling variables v0.1.0 (file:///projects/variables) + Finished dev [unoptimized + debuginfo] target(s) in 0.30 secs Running `target/debug/variables` The value of x is: 5 The value of x is: 6 ``` -通过 `mut`，允许把绑定到 `x` 的值从 `5` 改成 `6`。在一些情况下，你会想用可变变量，因为这样的代码比起只用不可变变量的更容易编写。 +通过 `mut`，允许把绑定到 `x` 的值从 `5` 改成 `6`。在一些情况下，你会想用可变变量，因为这样的代码比起只用不可变变量的实现更容易编写。 除了避免 bug 外，还有很多地方需要权衡取舍。例如，使用大型数据结构时，适当地使用可变变量，可能比复制和返回新分配的实例更快。对于较小的数据结构，总是创建新实例，采用更偏向函数式的风格编程，可能会使代码更易理解，为可读性而遭受性能惩罚或许值得。 @@ -77,7 +78,7 @@ The value of x is: 6 首先，不允许对常量使用 `mut`：常量不光默认不能变，它总是不能变。 -声明常量使用 `const` 关键字而不是 `let`，而且 *必须* 注明值的类型。在下一部分，“数据类型”，涉及到类型和类型注解，现在无需关心这些细节，记住总是标注类型即可。 +声明常量使用 `const` 关键字而不是 `let`，并且 *必须* 注明值的类型。在下一部分，“数据类型” 中会涉及到类型和类型注解，现在无需关心这些细节，记住总是标注类型即可。 常量可以在任何作用域声明，包括全局作用域，这在一个值需要被很多部分的代码用到时很有用。 @@ -91,7 +92,7 @@ const MAX_POINTS: u32 = 100_000; 在声明它的作用域之中，常量在整个程序生命周期中都有效，这使得常量可以作为多处代码使用的全局范围的值，例如一个游戏中所有玩家可以获取的最高分或者光速。 -将用于整个程序的硬编码的值声明为常量对后来的维护者了解值的意义很有帮助。它也能将硬编码的值汇总一处，为将来可能的修改提供方便。 +将用于整个程序的硬编码的值声明为常量对后来的维护者了解值的意义很有帮助。同时将硬编码的值汇总于一处，也能为将来修改提供方便。 ### 隐藏（Shadowing） @@ -116,6 +117,7 @@ fn main() { ```text $ cargo run Compiling variables v0.1.0 (file:///projects/variables) + Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs Running `target/debug/variables` The value of x is: 12 ``` @@ -149,4 +151,4 @@ error[E0308]: mismatched types found type `usize` ``` -现在我们已经了解了变量如何工作，让我们再看看更多的数据类型。 +现在我们已经了解了变量如何工作，让我们再看看更多变量可以拥有的数据类型。 From ddccfa0c68328493e4004542d50c93310cff5179 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Thu, 11 Jan 2018 23:09:29 +0800 Subject: [PATCH 106/150] check to ch03-03 --- src/ch03-02-data-types.md | 32 ++++++++++++++++--------------- src/ch03-03-how-functions-work.md | 24 +++++++++++------------ 2 files changed, 29 insertions(+), 27 deletions(-) diff --git a/src/ch03-02-data-types.md b/src/ch03-02-data-types.md index 8bc72c0..1f9da0e 100644 --- a/src/ch03-02-data-types.md +++ b/src/ch03-02-data-types.md @@ -2,9 +2,9 @@ > [ch03-02-data-types.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch03-02-data-types.md) >
-> commit f4bce88a0f4c09aaf0c996021729c6d42907bc2a +> commit ec65990849230388e4ce4db5b7a0cb8a0f0d60e2 -在 Rust 中，任何值都属于一种明确的 **类型**（*type*），这告诉了 Rust 它被指定为何种数据，以便明确其处理方式。我们将分两部分探讨一些内建类型：标量（scalar）和复合（compound）。 +在 Rust 中，任何值都属于一种明确的 **类型**（*type*），这告诉了 Rust 它被指定为何种数据，以便明确其处理方式。本部分我们将看到一系列内建于语言中的类型。我们将其分为两类：标量（scalar）和复合（compound）。 Rust 是 **静态类型**（*statically typed*）语言，也就是说在编译时就必须知道所有变量的类型，这一点将贯穿整个章节。通过值的形式及其使用方式，编译器通常可以推断出我们想要用的类型。多种类型均有可能时，比如第二章中使用 `parse` 将 `String` 转换为数字时，必须增加类型注解，像这样： @@ -15,24 +15,25 @@ let guess: u32 = "42".parse().expect("Not a number!"); 这里如果不添加类型注解，Rust 会显示如下错误，这说明编译器需要更多信息，来了解我们想要的类型： ```text -error[E0282]: unable to infer enough type information about `_` +error[E0282]: type annotations needed --> src/main.rs:2:9 | 2 | let guess = "42".parse().expect("Not a number!"); - | ^^^^^ cannot infer type for `_` - | - = note: type annotations or generic parameter binding required + | ^^^^^ + | | + | cannot infer type for `_` + | consider giving `guess` a type ``` -在我们讨论各种数据类型时，你会看到多样的类型注解。 +在我们讨论各种数据类型时，你会看到不同的类型注解。 ### 标量类型 -**标量**（*scalar*）类型代表一个单独的值。Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。你可能在其他语言中见过它们，不过让我们深入了解它们在 Rust 中时如何工作的。 +**标量**（*scalar*）类型代表一个单独的值。Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。你可能在其他语言中见过它们，不过让我们深入了解它们在 Rust 中是如何工作的。 #### 整型 -**整数** 是一个没有小数部分的数字。我们在这一章的前面使用过 `u32` 类型。该类型声明指示，u32 关联的值应该是一个占据 32 比特位的无符号整数（有符号整型类型以 `i` 开头而不是 `u`）。表格 3-1 展示了 Rust 内建的整数类型。每一种变体的有符号和无符号列（例如，*i8*）可以用来声明对应的整数值。 +**整数** 是一个没有小数部分的数字。我们在这一章的前面使用过 `u32` 类型。该类型声明表明，u32 关联的值应该是一个占据 32 比特位的无符号整数（有符号整型类型以 `i` 开头而不是 `u`）。表格 3-1 展示了 Rust 内建的整数类型。每一种变体都有符号和无符号列（例如，*i8*）可以用来声明对应的整数值。 表格 3-1: Rust 中的整型 @@ -62,11 +63,11 @@ error[E0282]: unable to infer enough type information about `_` | Binary | `0b1111_0000` | | Byte (`u8` only) | `b'A'` | -那么该使用哪种类型的数字呢？如果拿不定主意，Rust 的默认类型通常就很好，数字类型默认是 `i32`：它通常是最快的，甚至在 64 位系统上也是。`isize` 或 `usize` 主要作为集合的索引。 +那么该使用哪种类型的数字呢？如果拿不定主意，Rust 的默认类型通常就很好，数字类型默认是 `i32`：它通常是最快的，甚至在 64 位系统上也是。`isize` 或 `usize` 主要作为某些集合的索引。 #### 浮点型 -Rust 同样有两个主要的 **浮点数**（*floating-point numbers*）类型，`f32` 和 `f64`，它们是带小数点的数字，分别占 32 位和 64 位比特。默认类型是 `f64`，因为它与 `f32` 速度差不多，然而精度更高。在 32 位系统上也能够使用 `f64`，不过比使用 `f32` 要慢。多数情况下，一开始以潜在的性能损耗换取更高的精度是合理的；如果觉得浮点数的大小是个麻烦，你应该以性能测试作为决策依据。 +Rust 同样有两个主要的 **浮点数**（*floating-point numbers*）类型，`f32` 和 `f64`，它们是带小数点的数字，分别占 32 位和 64 位比特。默认类型是 `f64`，因为在现代 CPU 中它与 `f32` 速度几乎一样，不过精度更高。 这是一个展示浮点数的实例： @@ -127,7 +128,7 @@ fn main() { #### 字符类型 -目前为止只使用到了数字，不过 Rust 也支持字符。Rust 的 `char` 类型是大部分语言中基本字母字符类型，如下代码展示了如何使用它： +目前为止只使用到了数字，不过 Rust 也支持字符。Rust 的 `char` 类型是大部分语言中基本字母字符类型，如下代码展示了如何使用它。注意 `char` 由单引号指定，不同于字符串使用双引号： 文件名: src/main.rs @@ -139,7 +140,7 @@ fn main() { } ``` -Rust 的 `char` 类型代表了一个 Unicode 标量值（Unicode Scalar Value），这意味着它可以比 ASCII 表示更多内容。拼音字母（Accented letters），中文/日文/韩文等象形文字，emoji（絵文字）以及零长度的空白字符对于 Rust `char` 类型都是有效的。Unicode 标量值包含从 `U+0000` 到 `U+D7FF` 和 `U+E000` 到 `U+10FFFF` 之间的值。不过，“字符” 并不是一个 Unicode 中的概念，所以人直觉上的 “字符” 可能与 Rust 中的 `char` 并不符合。第八章的 “字符串” 部分将详细讨论这个主题。 +Rust 的 `char` 类型代表了一个 Unicode 标量值（Unicode Scalar Value），这意味着它可以比 ASCII 表示更多内容。拼音字母（Accented letters），中文/日文/韩文等象形文字，emoji（絵文字）以及零长度的空白字符对于 Rust `char` 类型都是有效的。Unicode 标量值包含从 `U+0000` 到 `U+D7FF` 和 `U+E000` 到 `U+10FFFF` 在内的值。不过，“字符” 并不是一个 Unicode 中的概念，所以人直觉上的 “字符” 可能与 Rust 中的 `char` 并不符合。第八章的 “字符串” 部分将详细讨论这个主题。 ### 复合类型 @@ -231,11 +232,11 @@ fn main() { } ``` -在这个例子中，叫做 `first` 的变量的值是 `1`，因为它是数组索引 `[0]` 的值。`second` 将会是数组索引 `[1]` 的值 `2`。 +在这个例子中，叫做 `first` 的变量的值是 `1`，因为它是数组索引 `[0]` 的值。变量 `second` 将会是数组索引 `[1]` 的值 `2`。 ##### 无效的数组元素访问 -如果我们访问数组结尾之后的元素会发生什么呢？比如我们将上面的例子改成下面这样： +如果我们访问数组结尾之后的元素会发生什么呢？比如我们将上面的例子改成下面这样，这可以编译不过在运行时会因错误而退出： 文件名: src/main.rs @@ -255,6 +256,7 @@ fn main() { ```text $ cargo run Compiling arrays v0.1.0 (file:///projects/arrays) + Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs Running `target/debug/arrays` thread '
' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:6 diff --git a/src/ch03-03-how-functions-work.md b/src/ch03-03-how-functions-work.md index 5cc0cad..1f8c612 100644 --- a/src/ch03-03-how-functions-work.md +++ b/src/ch03-03-how-functions-work.md @@ -2,7 +2,7 @@ > [ch03-03-how-functions-work.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch03-03-how-functions-work.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 6aad5008b69078a2fc18e6dd7e00ef395170c749 函数在 Rust 代码中应用广泛。你已经见过一个语言中最重要的函数：`main` 函数，它是很多程序的入口点。你也见过了 `fn` 关键字，它用来声明新函数。 @@ -31,6 +31,7 @@ Rust 中的函数定义以 `fn` 开始并在函数名后跟一对括号。大括 ```text $ cargo run Compiling functions v0.1.0 (file:///projects/functions) + Finished dev [unoptimized + debuginfo] target(s) in 0.28 secs Running `target/debug/functions` Hello, world! Another function. @@ -61,6 +62,7 @@ fn another_function(x: i32) { ```text $ cargo run Compiling functions v0.1.0 (file:///projects/functions) + Finished dev [unoptimized + debuginfo] target(s) in 1.21 secs Running `target/debug/functions` The value of x is: 5 ``` @@ -86,17 +88,18 @@ fn another_function(x: i32, y: i32) { 这个例子创建了一个有两个参数的函数，都是 `i32` 类型的。函数打印出了这两个参数的值。注意函数参数并不一定都是相同类型的，这个例子中它们只是碰巧相同罢了。 -尝试运行代码。使用上面的例子替换当前 *function* 项目的 *src/main.rs* 文件，并用 `cargo run` 运行它： +尝试运行代码。使用上面的例子替换当前 *functions* 项目的 *src/main.rs* 文件，并用 `cargo run` 运行它： ```text $ cargo run Compiling functions v0.1.0 (file:///projects/functions) + Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs Running `target/debug/functions` The value of x is: 5 The value of y is: 6 ``` -因为我们使用 `5` 作为 `x` 的值， `6` 作为 `y` 的值来调用函数，这两个字符串和它们的值被相应打印出来。 +因为我们使用 `5` 作为 `x` 的值 `6` 作为 `y` 的值来调用函数，这两个字符串和它们的值被相应打印出来。 ### 函数体 @@ -106,7 +109,7 @@ The value of y is: 6 我们已经用过语句与表达式了。**语句**（*Statements*）是执行一些操作但不返回值的指令。表达式（*Expressions*）计算并产生一个值。让我们看一些例子： -使用 `let` 关键字创建变量并绑定一个值是一个语句。在列表 3-3 中，`let y = 6;` 是一个语句： +使用 `let` 关键字创建变量并绑定一个值是一个语句。在列表 3-1 中，`let y = 6;` 是一个语句： 文件名: src/main.rs @@ -116,13 +119,13 @@ fn main() { } ``` -列表 3-3：包含一个语句的 `main` 函数定义 +列表 3-1：包含一个语句的 `main` 函数定义 函数定义也是语句，上面整个例子本身就是一个语句。 -语句并不返回值。因此，不能把`let`语句赋值给另一个变量，比如下面的例子尝试做的： +语句并不返回值。因此，不能把 `let` 语句赋值给另一个变量，比如下面的例子尝试做的，这会产生一个错误： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore fn main() { @@ -197,6 +200,7 @@ fn main() { ```text $ cargo run Compiling functions v0.1.0 (file:///projects/functions) + Finished dev [unoptimized + debuginfo] target(s) in 0.30 secs Running `target/debug/functions` The value of x is: 5 ``` @@ -248,16 +252,12 @@ error[E0308]: mismatched types 7 | fn plus_one(x: i32) -> i32 { | ____________________________^ 8 | | x + 1; + | | - help: consider removing this semicolon 9 | | } | |_^ expected i32, found () | = note: expected type `i32` found type `()` -help: consider removing this semicolon: - --> src/main.rs:8:10 - | -8 | x + 1; - | ^ ``` 主要的错误信息，“mismatched types”（类型不匹配），揭示了代码的核心问题。函数 `plus_one` 的定义说明它要返回一个 `i32`，不过语句并不返回一个值，这由那个空元组 `()` 表明。因此，这个函数返回了空元组 `()`，这与函数定义相矛盾并导致一个错误。在输出中，Rust 提供了一个可能会对修正问题有帮助的信息：它建议去掉分号，这会修复这个错误。 From 23450ed8f8caae6f900f1c55d496f4ac898406f5 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Thu, 11 Jan 2018 23:12:20 +0800 Subject: [PATCH 107/150] update ci status & license --- LICENSE | 2 +- README.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index d5bbe58..2678cd5 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2017 KaiserY +Copyright (c) 2017-2018 KaiserY Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal diff --git a/README.md b/README.md index b0c566c..f9958b0 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,5 @@ # Rust 程序设计语言（第二版） 简体中文版 +[![Build Status](https://travis-ci.org/KaiserY/trpl-zh-cn.svg?branch=master)](https://travis-ci.org/KaiserY/trpl-zh-cn) + 还在施工中... \ No newline at end of file From 72b6ceabbc36e50716b83c3baa414f03b9057c50 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Sun, 14 Jan 2018 13:16:25 +0800 Subject: [PATCH 108/150] check to ch03-05 --- src/ch03-04-comments.md | 10 ++++----- src/ch03-05-control-flow.md | 42 +++++++++++++++++++++---------------- 2 files changed, 29 insertions(+), 23 deletions(-) diff --git a/src/ch03-04-comments.md b/src/ch03-04-comments.md index 49516d6..594a638 100644 --- a/src/ch03-04-comments.md +++ b/src/ch03-04-comments.md @@ -2,17 +2,17 @@ > [ch03-04-comments.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch03-04-comments.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit d4c77666f480edfb960cc9b11a31c42f4b90c745 -所有编程语言都力求使它们的代码易于理解，不过有时需要提供额外的解释。在这种情况下，程序员在源码中留下记录，或者 **注释**（*comments*），编译器会忽略它们不过其他阅读代码的人可能会用得上。 +所有编程语言都力求使其代码易于理解，不过有时需要提供额外的解释。在这种情况下，程序员在源码中留下记录，或者 **注释**（*comments*），编译器会忽略它们不过其他阅读代码的人可能会用得上。 -这是一个注释的例子： +这是一个简单的注释的例子： ```rust // Hello, world. ``` -在 Rust 中，注释必须以两道斜杠开始并持续到本行的结尾。对于超过一行的注释，需要在每一行都加上`//`，像这样： +在 Rust 中，注释必须以两道斜杠开始，并持续到本行的结尾。对于超过一行的注释，需要在每一行都加上 `//`，像这样： ```rust // So we’re doing something complicated here, long enough that we need @@ -30,7 +30,7 @@ fn main() { } ``` -不过你会经常看到它们被以这种格式使用，也就是位于它所解释的代码行的上面一行： +不过你会经常看到它们用于这种格式，也就是位于它所解释的代码行的上面一行： 文件名: src/main.rs diff --git a/src/ch03-05-control-flow.md b/src/ch03-05-control-flow.md index 192a46b..4fb8b4f 100644 --- a/src/ch03-05-control-flow.md +++ b/src/ch03-05-control-flow.md @@ -2,7 +2,7 @@ > [ch03-05-control-flow.md](https://github.com/rust-lang/book/blob/master/src/ch03-05-control-flow.md) >
-> commit 2e269ff82193fd65df8a87c06561d74b51ac02f7 +> commit ec65990849230388e4ce4db5b7a0cb8a0f0d60e2 通过条件是不是为真来决定是否执行某些代码，或者根据条件是否为真来重复运行一段代码是大部分编程语言的基本组成部分。Rust 代码中最常见的用来控制执行流的结构是 `if` 表达式和循环。 @@ -28,13 +28,14 @@ fn main() { -所有 `if` 表达式以 `if` 关键字开头，它后跟一个条件。在这个例子中，条件检查 `number` 是否有一个小于 5 的值。在条件为真时希望执行的代码块位于紧跟条件之后的大括号中。`if` 表达式中与条件关联的代码块有时被叫做 *arms*，就像第二章 “比较猜测与秘密数字” 部分中讨论到的 `match` 表达式中分支一样。也可以包含一个可选的 `else` 表达式来提供一个在条件为假时应当执行的代码块，这里我们就这么做了。如果不提供 `else` 表达式并且条件为假时，程序会直接忽略 `if` 代码块并继续执行下面的代码。 +所有的 `if` 表达式都以 `if` 关键字开头，其后跟一个条件。在这个例子中，条件检查变量 `number` 是否有一个小于 5 的值。在条件为真时希望执行的代码块位于紧跟条件之后的大括号中。`if` 表达式中与条件关联的代码块有时被叫做 *arms*，就像第二章 “比较猜测与秘密数字” 部分中讨论到的 `match` 表达式中分支一样。也可以包含一个可选的 `else` 表达式来提供一个在条件为假时应当执行的代码块，这里我们就这么做了。如果不提供 `else` 表达式并且条件为假时，程序会直接忽略 `if` 代码块并继续执行下面的代码。 尝试运行代码，应该能看到如下输出： ```text $ cargo run Compiling branches v0.1.0 (file:///projects/branches) + Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs Running `target/debug/branches` condition was true ``` @@ -50,11 +51,12 @@ let number = 7; ```text $ cargo run Compiling branches v0.1.0 (file:///projects/branches) + Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs Running `target/debug/branches` condition was false ``` -另外值得注意的是代码中的条件 **必须** 是 `bool`。如果想看看条件不是 `bool` 值时会发生什么，尝试运行如下代码： +另外值得注意的是代码中的条件 **必须** 是 `bool` 值。如果想看看条件不是 `bool` 值时会发生什么，尝试运行如下代码： 文件名: src/main.rs @@ -124,17 +126,18 @@ fn main() { ```text $ cargo run Compiling branches v0.1.0 (file:///projects/branches) + Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs Running `target/debug/branches` number is divisible by 3 ``` -当执行这个程序，它按顺序检查每个 `if` 表达式并执行第一个条件为真的代码块。注意即使 6 可以被 2 整除，也不会出现 `number is divisible by 2` 的输出，更不会出现 `else` 块中的 `number is not divisible by 4, 3, or 2`。原因是 Rust 只会执行第一个条件为真的代码块，并且它一旦找到一个以后，就不会检查剩下的条件了。 +当执行这个程序，它按顺序检查每个 `if` 表达式并执行第一个条件为真的代码块。注意即使 6 可以被 2 整除，也不会出现 `number is divisible by 2` 的输出，更不会出现 `else` 块中的 `number is not divisible by 4, 3, or 2`。原因是 Rust 只会执行第一个条件为真的代码块，并且一旦它找到一个以后，甚至就不会检查剩下的条件了。 使用过多的 `else if` 表达式会使代码显得杂乱无章，所以如果有多于一个 `else if`，最好重构代码。为此第六章会介绍 Rust 中一个叫做 `match` 的强大的分支结构（branching construct）。 #### 在 `let` 语句中使用 `if` -因为 `if` 是一个表达式，我们可以在 `let` 语句的右侧使用它，例如在示例 3-4 中： +因为 `if` 是一个表达式，我们可以在 `let` 语句的右侧使用它，例如在示例 3-2 中： 文件名: src/main.rs @@ -151,18 +154,19 @@ fn main() { } ``` -示例 3-4：将 `if` 的返回值赋值给一个变量 +示例 3-2：将 `if` 的返回值赋值给一个变量 `number` 变量将会绑定到基于 `if` 表达式结果的值。运行这段代码看看会出现什么： ```text $ cargo run Compiling branches v0.1.0 (file:///projects/branches) + Finished dev [unoptimized + debuginfo] target(s) in 0.30 secs Running `target/debug/branches` The value of number is: 5 ``` -还记得代码块的值是其最后一个表达式的值，以及数字本身也是一个表达式吗。在这个例子中，整个 `if` 表达式的值依赖哪个代码块被执行。这意味着 `if` 的每个分支的可能的返回值都必须是相同类型；在示例 3-4 中，`if` 分支和 `else` 分支的结果都是 `i32` 整型。不过如果像下面的例子那样这些类型并不匹配会怎么样呢？ +还记得代码块的值是其最后一个表达式的值，以及数字本身也是一个表达式吗。在这个例子中，整个 `if` 表达式的值依赖哪个代码块被执行。这意味着 `if` 的每个分支的可能的返回值都必须是相同类型；在示例 3-2 中，`if` 分支和 `else` 分支的结果都是 `i32` 整型。如果它们的类型不匹配，如下面这个例子，则会出现一个错误： 文件名: src/main.rs @@ -195,7 +199,7 @@ error[E0308]: if and else have incompatible types | |_____^ expected integral variable, found reference | = note: expected type `{integer}` - found type `&'static str` + found type `&str` ``` `if` 代码块的表达式返回一个整型，而 `else` 代码块返回一个字符串。这并不可行，因为变量必须只有一个类型。Rust 需要在编译时就确切的知道 `number` 变量的类型，这样它就可以在编译时证明其他使用 `number` 变量的地方它的类型是有效的。Rust 并不能够在 `number` 的类型只能在运行时确定的情况下工作；这样会使编译器变得更复杂而且只能为代码提供更少的保障，因为它不得不记录所有变量的多种可能的类型。 @@ -227,6 +231,7 @@ fn main() { ```text $ cargo run Compiling loops v0.1.0 (file:///projects/loops) + Finished dev [unoptimized + debuginfo] target(s) in 0.29 secs Running `target/debug/loops` again! again! @@ -235,13 +240,13 @@ again! ^Cagain! ``` -符号 `^C` 代表你在这按下了ctrl-C。在 `^C` 之后你可能看到 `again!` 也可能看不到，这依赖于在接收到终止信号时代码执行到了循环的何处。 +符号 `^C` 代表你在这按下了ctrl-C。在 `^C` 之后你可能看到也可能看不到 `again!` ，这依赖于在接收到终止信号时代码执行到了循环的何处。 -幸运的是，Rust 提供了另一个更可靠的方式来退出循环。可以使用 `break` 关键字来告诉程序何时停止执行循环。还记得我们在第二章猜猜看游戏的 “猜测正确后退出” 部分使用过它来在用户猜对数字赢得游戏后退出程序吗。 +幸运的是，Rust 提供了另一个更可靠的方式来退出循环。可以使用 `break` 关键字来告诉程序何时停止执行循环。回忆一下在第二章猜猜看游戏的 “猜测正确后退出” 部分使用过它来在用户猜对数字赢得游戏后退出程序。 #### `while` 条件循环 -在程序中计算循环的条件也很常见。当条件为真，执行循环。当条件不再为真，调用 `break`停止循环。这个循环类型可以通过组合 `loop`、`if`、`else` 和 `break`来实现；如果你喜欢的话，现在就可以在程序中试试。 +在程序中计算循环的条件也很常见。当条件为真，执行循环。当条件不再为真，调用 `break` 停止循环。这个循环类型可以通过组合 `loop`、`if`、`else` 和 `break` 来实现；如果你喜欢的话，现在就可以在程序中试试。 然而，这个模式太常见了以至于 Rust 为此提供了一个内建的语言结构，它被称为 `while` 循环。下面的例子使用了 `while`：程序循环三次，每次数字都减一。接着，在循环之后，打印出另一个信息并退出： @@ -265,7 +270,7 @@ fn main() { #### 使用 `for` 遍历集合 -可以使用 `while` 结构来遍历一个元素集合，比如数组。如下： +可以使用 `while` 结构来遍历一个元素集合，比如数组。例如，看看如下的示例 3-3： 文件名: src/main.rs @@ -282,13 +287,14 @@ fn main() { } ``` -示例 3-5：使用 `while` 循环遍历集合中的每一个元素 +示例 3-3：使用 `while` 循环遍历集合中的每一个元素 这里代码对数组中的元素进行计数。它从索引 `0` 开始，并接着循环直到遇到数组的最后一个索引（这时，`index < 5` 不再为真）。运行这段代码会打印出数组中的每一个元素： ```text $ cargo run Compiling loops v0.1.0 (file:///projects/loops) + Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs Running `target/debug/loops` the value is: 10 the value is: 20 @@ -301,7 +307,7 @@ the value is: 50 不过这个过程是容易出错的；如果索引长度不正确会导致程序 panic。这也使程序更慢，因为编译器增加了运行时代码来对每次循环的每个元素进行条件检查。 -可以使用 `for` 循环来对一个集合的每个元素执行一些代码，来作为一个更有效率的替代。`for` 循环看起来像这样： +可以使用 `for` 循环来对一个集合的每个元素执行一些代码，来作为一个更有效率的替代。`for` 循环看起来如示例 3-4 所示： 文件名: src/main.rs @@ -315,13 +321,13 @@ fn main() { } ``` -示例 3-6：使用 `for` 循环遍历集合中的每一个元素 +示例 3-4：使用 `for` 循环遍历集合中的每一个元素 -当运行这段代码，将看到与示例 3-5 一样的输出。更为重要的是，我们增强了代码安全性并消除了出现可能会导致超出数组的结尾或遍历长度不够而缺少一些元素这类 bug 的机会。 +当运行这段代码，将看到与示例 3-3 一样的输出。更为重要的是，我们增强了代码安全性并消除了出现可能会导致超出数组的结尾或遍历长度不够而缺少一些元素这类 bug 的机会。 -例如，在示例 3-5 的代码中，如果从数组 `a` 中移除一个元素但忘记更新条件为 `while index < 4`，代码将会 panic。使用`for`循环的话，就不需要惦记着在更新数组元素数量时修改其他的代码了。 +例如，在示例 3-3 的代码中，如果从数组 `a` 中移除一个元素但忘记更新条件为 `while index < 4`，代码将会 panic。使用`for`循环的话，就不需要惦记着在更新数组元素数量时修改其他的代码了。 -`for` 循环的安全性和简洁性使得它在成为 Rust 中使用最多的循环结构。即使是在想要循环执行代码特定次数时，例如示例 3-5 中使用 `while` 循环的倒计时例子，大部分 Rustacean 也会使用 `for` 循环。这么做的方式是使用 `Range`，它是标准库提供的用来生成从一个数字开始到另一个数字之前结束的所有数字序列的类型。 +`for` 循环的安全性和简洁性使得它在成为 Rust 中使用最多的循环结构。即使是在想要循环执行代码特定次数时，例如示例 3-3 中使用 `while` 循环的倒计时例子，大部分 Rustacean 也会使用 `for` 循环。这么做的方式是使用 `Range`，它是标准库提供的用来生成从一个数字开始到另一个数字之前结束的所有数字序列的类型。 下面是一个使用 `for` 循环来倒计时的例子，它还使用了一个我们还未讲到的方法，`rev`，用来反转 range： From dc88ac94d7b4340bffbd7a886c091808e1352642 Mon Sep 17 00:00:00 2001 From: yjh Date: Sun, 14 Jan 2018 23:12:50 +0800 Subject: [PATCH 109/150] Update ch01-01-installation.md fix a typo --- src/ch01-01-installation.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch01-01-installation.md b/src/ch01-01-installation.md index bd9615e..4cb7e2e 100644 --- a/src/ch01-01-installation.md +++ b/src/ch01-01-installation.md @@ -22,7 +22,7 @@ $ curl https://sh.rustup.rs -sSf | sh Rust is installed now. Great! ``` -当然，如果你不信任采用 `curl URL | sh` 来安装软禁啊，请随意下载、检查和运行这个脚本。 +当然，如果你不信任采用 `curl URL | sh` 来安装软件啊，请随意下载、检查和运行这个脚本。 此安装脚本自动将 Rust 加入系统 PATH 环境变量中，再次登陆时生效。如果你希望立刻（不重新登陆）就开始使用 Rust，在 shell 中运行如下命令： From 3e3083791d44430930692928f8d953992c46a070 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Mon, 15 Jan 2018 23:08:00 +0800 Subject: [PATCH 110/150] check to ch04-01 --- src/ch01-01-installation.md | 2 +- src/ch04-00-understanding-ownership.md | 2 +- src/ch04-01-what-is-ownership.md | 88 +++++++++++++------------- 3 files changed, 47 insertions(+), 45 deletions(-) diff --git a/src/ch01-01-installation.md b/src/ch01-01-installation.md index 4cb7e2e..c94a81b 100644 --- a/src/ch01-01-installation.md +++ b/src/ch01-01-installation.md @@ -22,7 +22,7 @@ $ curl https://sh.rustup.rs -sSf | sh Rust is installed now. Great! ``` -当然，如果你不信任采用 `curl URL | sh` 来安装软件啊，请随意下载、检查和运行这个脚本。 +当然，如果你不信任采用 `curl URL | sh` 来安装软件，请随意下载、检查和运行这个脚本。 此安装脚本自动将 Rust 加入系统 PATH 环境变量中，再次登陆时生效。如果你希望立刻（不重新登陆）就开始使用 Rust，在 shell 中运行如下命令： diff --git a/src/ch04-00-understanding-ownership.md b/src/ch04-00-understanding-ownership.md index 9e2f94a..eb57126 100644 --- a/src/ch04-00-understanding-ownership.md +++ b/src/ch04-00-understanding-ownership.md @@ -4,4 +4,4 @@ >
> commit 4f2dc564851dc04b271a2260c834643dfd86c724 -所有权（系统）是 Rust 最独特的功能，它使得 Rust 可以无需垃圾回收（garbage collector）就能保障内存安全。因此，理解 Rust 中所有权如何工作是十分重要的。本章我们将讲到所有权以及相关功能：借用、slice 以及 Rust 如何在内存中布局数据。 \ No newline at end of file +所有权（系统）是 Rust 最独特的功能，其令 Rust 无需垃圾回收（garbage collector）即可保障内存安全。因此，理解 Rust 中所有权如何工作是十分重要的。本章我们将讲到所有权以及相关功能：借用、slice 以及 Rust 如何在内存中布局数据。 \ No newline at end of file diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 1c8fc0b..95b7c24 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -2,13 +2,13 @@ > [ch04-01-what-is-ownership.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch04-01-what-is-ownership.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit ec65990849230388e4ce4db5b7a0cb8a0f0d60e2 -Rust 的核心功能（之一）是 **所有权**（*ownership*）。虽然这个功能理解起来很直观，不过它对语言的其余部分有着更深层的含义。 +Rust 的核心功能（之一）是 **所有权**（*ownership*）。虽然这个功能说明起来很直观，不过它对语言的其余部分有着更深层的含义。 -所有程序都必须管理他们运行时使用计算机内存的方式。一些语言中使用垃圾回收在程序运行过程中来时刻寻找不再被使用的内存；在另一些语言中，程序员必须亲自分配和释放内存。Rust 则选择了第三种方式：内存被一个所有权系统管理，它拥有一系列的规则使编译器在编译时进行检查。任何所有权系统的功能都不会导致运行时开销。 +所有程序都必须管理其运行时使用计算机内存的方式。一些语言中使用垃圾回收在程序运行过程中来时刻寻找不再被使用的内存；在另一些语言中，程序员必须亲自分配和释放内存。Rust 则选择了第三种方式：内存被一个所有权系统管理，它拥有一系列的规则使编译器在编译时进行检查。任何所有权系统的功能都不会导致运行时开销。 -因为所有权对很多程序员都是一个新概念，需要一些时间来适应。好消息是随着你对 Rust 和所有权系统的规则越来越有经验，你就越能自然地编写出安全和高效的代码。持之以恒！ +因为所有权对很多程序员来说都是一个新概念，需要一些时间来适应。好消息是随着你对 Rust 和所有权系统的规则越来越有经验，你就越能自然地编写出安全和高效的代码。持之以恒！ 当你理解了所有权系统，你就会对这个使 Rust 如此独特的功能有一个坚实的基础。在本章中，你将会通过一些例子来学习所有权，他们关注一个非常常见的数据结构：字符串。 @@ -18,19 +18,19 @@ Rust 的核心功能（之一）是 **所有权**（*ownership*）。虽然这 > > 在很多语言中并不经常需要考虑到栈与堆。不过在像 Rust 这样的系统编程语言中，值是位于栈上还是堆上在更大程度上影响了语言的行为以及为何必须做出这样的选择。我们会在本章的稍后部分描述所有权与堆与栈相关的部分，所以这里只是一个用来预热的简要解释。 > -> 栈和堆都是代码在运行时可供使用的部分内存，不过他们以不同的结构组成。栈以放入值的顺序存储并以相反顺序取出值。这也被称作 **后进先出**（*last in, first out*）。想象一下一叠盘子：当增加更多盘子时，把他们放在盘子堆的顶部，当需要盘子时，也从顶部拿走。不能从中间也不能从底部增加或拿走盘子！增加数据叫做 **进栈**（*pushing onto the stack*），而移出数据叫做 **出栈**（*popping off the stack*）。 +> 栈和堆都是代码在运行时可供使用的内存部分，不过他们以不同的结构组成。栈以放入值的顺序存储并以相反顺序取出值。这也被称作 **后进先出**（*last in, first out*）。想象一下一叠盘子：当增加更多盘子时，把他们放在盘子堆的顶部，当需要盘子时，也从顶部拿走。不能从中间也不能从底部增加或拿走盘子！增加数据叫做 **进栈**（*pushing onto the stack*），而移出数据叫做 **出栈**（*popping off the stack*）。 > -> 操作栈是非常快的，因为它访问数据的方式：永远也不需要寻找一个位置放入新数据或者取出数据因为这个位置总是在栈顶。另一个使得栈快速的性质是栈中的所有数据都必须是一个已知的固定的大小。 +> 操作栈是非常快的，因为它访问数据的方式：永远也不需要寻找一个位置放入新数据或者取出数据因为这个位置总是在栈顶。另一个使得栈快速的性质是栈中的所有数据都必须有一个已知且固定的大小。 > -> 相反对于在编译时未知大小或大小可能变化的数据，可以把他们储存在堆上。堆是缺乏组织的：当向堆放入数据时，我们请求一定大小的空间。操作系统在堆的某处找到一块足够大的空位，把它标记为已使用，并返回给我们一个它位置的指针。这个过程称作 **在堆上分配内存**（*allocating on the heap*），并且有时这个过程就简称为 “分配”（allocating）。向栈中放入数据并不被认为是分配。因为指针是已知的固定大小的，我们可以将指针储存在栈上，不过当需要实际数据时，必须访问指针。 +> 相反对于在编译时未知大小或大小可能变化的数据，可以把他们储存在堆上。堆是缺乏组织的：当向堆放入数据时，我们请求一定大小的空间。操作系统在堆的某处找到一块足够大的空位，把它标记为已使用，并返回给我们一个其位置的 **指针**（*pointer*）。这个过程称作 **在堆上分配内存**（*allocating on the heap*），并且有时这个过程就简称为 “分配”（allocating）。向栈中放入数据并不被认为是分配。因为指针是已知的固定大小的，我们可以将指针储存在栈上，不过当需要实际数据时，必须访问指针。 > > 想象一下去餐馆就坐吃饭。当进入时，你说明有几个人，餐馆员工会找到一个够大的空桌子并领你们过去。如果有人来迟了，他们也可以通过询问来找到你们坐在哪。 > -> 访问堆上的数据要比访问栈上的数据要慢因为必须通过指针来访问。现代的处理器在内存中跳转越少就越快（缓存）。继续类比，假设有一个服务员在餐厅里处理多个桌子的点菜。在一个桌子报完所有菜后再移动到下一个桌子是最有效率的。从桌子 A 听一个菜，接着桌子 B 听一个菜，然后再桌子 A，然后再桌子 B 这样的流程会更加缓慢。出于同样原因，处理器在处理的数据之间彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）能更好的工作。在堆上分配大量的空间也可能消耗时间。 +> 访问堆上的数据要比访问栈上的数据要慢因为必须通过指针来访问。现代处理器在内存中跳转越少就越快（缓存）。继续类比，假设有一个服务员在餐厅里处理多个桌子的点菜。在一个桌子报完所有菜后再移动到下一个桌子是最有效率的。从桌子 A 听一个菜，接着桌子 B 听一个菜，然后再桌子 A，然后再桌子 B 这样的流程会更加缓慢。出于同样原因，处理器在处理的数据之间彼此较近的时候（比如在栈上）比较远的时候（比如可能在堆上）能更好的工作。在堆上分配大量的空间也可能消耗时间。 > > 当调用一个函数，传递给函数的值（包括可能指向堆上数据的指针）和函数的局部变量被压入栈中。当函数结束时，这些值被移出栈。 > -> 记录何处的代码在使用堆上的什么数据，最小化堆上的冗余数据的数量以及清理堆上不再使用的数据以致不至于耗尽空间，这些所有的问题正是所有权系统要处理的。一旦理解了所有权，你就不需要经常考虑栈和堆了，不过理解如何管理堆内存可以帮助我们理解所有权为何存在以及为什么以这种方式工作。 +> 记录何处的代码在使用堆上的什么数据，最小化堆上的冗余数据的数量以及清理堆上不再使用的数据以致不至于耗尽空间，这些所有的问题正是所有权系统要处理的。一旦理解了所有权，你就不需要经常考虑栈和堆了，不过理解如何管理堆内存可以帮助我们理解所有权为何存在以及为什么要以这种方式工作。 @@ -38,21 +38,21 @@ Rust 的核心功能（之一）是 **所有权**（*ownership*）。虽然这 首先，让我们看一下所有权的规则。请记住它们，我们将讲解一些它们的例子： -> 1. 每一个值都被它的 **所有者**（*owner*）变量拥有。 -> 2. 值在任意时刻只能被一个所有者拥有。 -> 3. 当所有者离开作用域，这个值将被丢弃。 +> 1. Rust 中每一个值都有一个称之为其 **所有者**（*owner*）的变量。 +> 2. 值有且只能有一个所有者。 +> 3. 当所有者（变量）离开作用域，这个值将被丢弃。 ### 变量作用域 -我们已经在第二章完成过一个 Rust 程序的例子。现在我们已经掌握了基本语法，所以不会在之后的例子中包含 `fn main() {` 代码了，所以如果你是一路跟过来的，必须手动将之后例子的代码放入一个`main`函数中。为此，例子将显得更加具体，使我们可以关注具体细节而不是样板代码。 +我们已经在第二章完成过一个 Rust 程序的例子。现在我们已经掌握了基本语法，所以不会在之后的例子中包含 `fn main() {` 代码了，所以如果你是一路跟过来的，必须手动将之后例子的代码放入一个 `main` 函数中。为此，例子将显得更加简明，使我们可以关注具体细节而不是样板代码。 -作为所有权的第一个例子，我们看看一些变量的 **作用域**（*scope*）。作用域是一个项(原文:item) 在程序中有效的范围。假如有一个这样的变量： +作为所有权的第一个例子，我们看看一些变量的 **作用域**（*scope*）。作用域是一个项(原文：item) 在程序中有效的范围。假设有这样一个变量： ```rust let s = "hello"; ``` -变量`s`绑定到了一个字符串字面值，这个字符串值是硬编码进我们程序代码中的。这个变量从声明的点开始直到当前 **作用域** 结束时都是有效的。示例 4-1 的注释标明了变量`s`在哪里是有效的： +变量 `s` 绑定到了一个字符串字面值，这个字符串值是硬编码进程序代码中的。这个变量从声明的点开始直到当前 **作用域** 结束时都是有效的。示例 4-1 的注释标明了变量 `s` 在何处是有效的： ```rust { // s is not valid here, it’s not yet declared @@ -66,18 +66,18 @@ let s = "hello"; 换句话说，这里有两个重要的点： -1. 当`s` **进入作用域**，它就是有效的。 +1. 当 `s` **进入作用域** 时，它就是有效的。 2. 这一直持续到它 **离开作用域** 为止。 目前为止，变量是否有效与作用域的关系跟其他编程语言是类似的。现在我们在此基础上介绍 `String` 类型。 ### `String` 类型 -为了演示所有权的规则，我们需要一个比第三章讲到的任何一个都要复杂的数据类型。之前出现的数据类型都是储存在栈上的并且当离开作用域时被移出栈，不过我们需要寻找一个储存在堆上的数据来探索 Rust 如何知道该在何时清理数据的。 +为了演示所有权的规则，我们需要一个比第三章讲到的任何一个都要复杂的数据类型。“Data Types” 部分涉及到的数据类型都是储存在栈上的并且当离开作用域时被移出栈，不过我们需要寻找一个储存在堆上的数据来探索 Rust 是如何知道该在何时清理数据的。 这里使用 `String` 作为例子并专注于 `String` 与所有权相关的部分。这些方面也同样适用于其他标准库提供的或你自己创建的复杂数据类型。在第八章会更深入地讲解 `String`。 -我们已经见过字符串字面值了，它被硬编码进程序里。字符串字面值是很方便的，不过他们并不总是适合所有需要使用文本的场景。原因之一就是他们是不可变的。另一个原因是不是所有字符串的值都能在编写代码时就知道：例如，如果想要获取用户输入并储存该怎么办呢？为此，Rust 有第二个字符串类型，`String`。这个类型储存在堆上所以能够储存在编译时未知大小的文本。可以用 `from` 从字符串字面值来创建 `String`，如下： +我们已经见过字符串字面值了，它被硬编码进程序里。字符串字面值是很方便的，不过他们并不总是适合所有需要使用文本的场景。原因之一就是他们是不可变的。另一个原因是不是所有字符串的值都能在编写代码时就知道：例如，如果想要获取用户输入并储存该怎么办呢？为此，Rust 有第二个字符串类型，`String`。这个类型储存在堆上所以能够储存在编译时未知大小的文本。可以用 `from` 函数从字符串字面值来创建 `String`，如下： ```rust let s = String::from("hello"); @@ -85,7 +85,7 @@ let s = String::from("hello"); 这两个冒号（`::`）运算符允许将特定的 `from` 函数置于 `String` 类型的命名空间（namespace）下而不需要使用类似 `string_from` 这样的名字。在第五章的 “方法语法”（“Method Syntax”）部分会着重讲解这个语法而且在第七章会讲到模块的命名空间。 -这类字符串 *可以* 被修改： +这类字符串 **可以** 被修改： ```rust let mut s = String::from("hello"); @@ -99,14 +99,14 @@ println!("{}", s); // This will print `hello, world!` ### 内存与分配 -对于字符串字面值的情况，我们在编译时就知道内容所以它直接被硬编码进最终的可执行文件中，这使得字符串字面值快速和高效。不过这些属性都只来源于其不可变性。不幸的是，我们不能为了每一个在编译时未知大小的文本而将一块内存放入二进制文件中而它的大小还可能随着程序运行而改变。 +对于字符串字面值的情况，我们在编译时就知道其内容所以它直接被硬编码进最终的可执行文件中，这使得字符串字面值快速且高效。不过这些属性都只来源于其不可变性。不幸的是，我们不能为了每一个在编译时未知大小的文本而将一块内存放入二进制文件中而它的大小还可能随着程序运行而改变。 对于 `String` 类型，为了支持一个可变，可增长的文本片段，需要在堆上分配一块在编译时未知大小的内存来存放内容。这意味着： 1. 内存必须在运行时向操作系统请求。 2. 需要一个当我们处理完 `String` 时将内存返回给操作系统的方法。 -第一部分由我们完成：当调用 `String::from` 时，它的实现 (*implementation*) 请求它需要的内存。这在编程语言中是非常通用的。 +第一部分由我们完成：当调用 `String::from` 时，它的实现 (*implementation*) 请求其所需的内存。这在编程语言中是非常通用的。 然而，第二部分实现起来就各有区别了。在有 **垃圾回收**（*garbage collector*，*GC*）的语言中， GC 记录并清除不再使用的内存，而我们作为程序员，并不需要关心他们。没有 GC 的话，识别出不再使用的内存并调用代码显式释放就是我们程序员的责任了，正如请求内存的时候一样。从历史的角度上说正确处理内存回收曾经是一个困难的编程问题。如果忘记回收了会浪费内存。如果过早回收了，将会出现无效变量。如果重复回收，这也是个 bug。我们需要 `allocate` 和 `free` 一一对应。 @@ -125,11 +125,11 @@ Rust 采取了一个不同的策略：内存在拥有它的变量离开作用域 > 注意：在 C++ 中，这种 item 在生命周期结束时释放资源的方法有时被称作 **资源获取即初始化**（*Resource Acquisition Is Initialization (RAII)*）。如果你使用过 RAII 模式的话应该对 Rust 的 `drop` 函数并不陌生。 -这个模式对编写 Rust 代码的方式有着深远的影响。它现在看起来很简单，不过在更复杂的场景下代码的行为可能是不可预测的，比如当有多个变量使用在堆上分配的内存时。现在让我们探索一些这样的场景。 +这个模式对编写 Rust 代码的方式有着深远的影响。现在它看起来很简单，不过在更复杂的场景下代码的行为可能是不可预测的，比如当有多个变量使用在堆上分配的内存时。现在让我们探索一些这样的场景。 #### 变量与数据交互的方式（一）：移动 -Rust 中的多个变量以一种独特的方式与同一数据交互。让我们看看示例 4-2 中一个使用整型的例子： +Rust 中的多个变量可以采用一种独特的方式与同一数据交互。让我们看看示例 4-2 中一个使用整型的例子： ```rust let x = 5; @@ -138,7 +138,7 @@ let y = x; 示例 4-2：将变量 `x` 赋值给 `y` -根据其他语言的经验大致可以猜到这在干什么：“将 `5` 绑定到 `x`；接着生成一个值 `x` 的拷贝并绑定到 `y`”。现在有了两个变量，`x` 和 `y`，都等于 `5`。这也正是事实上发生了的，因为正数是有已知固定大小的简单值，所以这两个 `5` 被放入了栈中。 +根据其他语言的经验我们大致可以猜到这在干什么：“将 `5` 绑定到 `x`；接着生成一个值 `x` 的拷贝并绑定到 `y`”。现在有了两个变量，`x` 和 `y`，都等于 `5`。这也正是事实上发生了的，因为正数是有已知固定大小的简单值，所以这两个 `5` 被放入了栈中。 现在看看这个 `String` 版本： @@ -149,27 +149,27 @@ let s2 = s1; 这看起来与上面的代码非常类似，所以我们可能会假设他们的运行方式也是类似的：也就是说，第二行可能会生成一个 `s1` 的拷贝并绑定到 `s2` 上。不过，事实上并不完全是这样。 -为了更全面的解释这个问题，让我们看看图 4-3 中 `String` 真正是什么样。`String` 由三部分组成，如图左侧所示：一个指向存放字符串内容内存的指针，一个长度，和一个容量。这一组数据储存在栈上。右侧则是堆上存放内容的内存部分。 +为了更全面的解释这个问题，让我们看看图 4-1 中 `String` 真正是什么样的。`String` 由三部分组成，如图左侧所示：一个指向存放字符串内容内存的指针，一个长度，和一个容量。这一组数据储存在栈上。右侧则是堆上存放内容的内存部分。 String in memory -图 4-3：一个绑定到 `s1` 的拥有值 `"hello"` 的 `String` 的内存表现 +图 4-1：一个绑定到 `s1` 的拥有值 `"hello"` 的 `String` 的内存表现 长度代表当前 `String` 的内容使用了多少字节的内存。容量是 `String` 从操作系统总共获取了多少字节的内存。长度与容量的区别是很重要的，不过这在目前为止的场景中并不重要，所以可以暂时忽略容量。 -当我们把 `s1` 赋值给 `s2`，`String` 的数据被复制了，这意味着我们从栈上拷贝了它的指针、长度和容量。我们并没有复制堆上指针所指向的数据。换句话说，内存中数据的表现如图 4-4 所示。 +当我们把 `s1` 赋值给 `s2`，`String` 的数据被复制了，这意味着我们从栈上拷贝了它的指针、长度和容量。我们并没有复制堆上指针所指向的数据。换句话说，内存中数据的表现如图 4-2 所示。 s1 and s2 pointing to the same value -图 4-4：变量 `s2` 的内存表现，它有一份 `s1` 指针、长度和容量的拷贝 +图 4-2：变量 `s2` 的内存表现，它有一份 `s1` 指针、长度和容量的拷贝 -这个表现形式看起来 **并不像** 图 4-5 中的那样，但是如果 Rust 也拷贝了堆上的数据后内存看起来会是如何呢。如果 Rust 这么做了，那么操作 `s2 = s1` 在堆上数据比较大的时候可能会对运行时性能造成非常大的影响。 +这个表现形式看起来 **并不像** 图 4-3 中的那样，但是如果 Rust 也拷贝了堆上的数据后内存看起来会是如何呢。如果 Rust 这么做了，那么操作 `s2 = s1` 在堆上数据比较大的时候可能会对运行时性能造成非常大的影响。 s1 and s2 to two places -图 4-5：另一个 `s2 = s1` 时可能的内存表现，如果 Rust 同时也拷贝了堆上的数据的话 +图 4-3：另一个 `s2 = s1` 时可能的内存表现，如果 Rust 同时也拷贝了堆上的数据的话 -之前，我们提到过当变量离开作用域后 Rust 自动调用 `drop` 函数并清理变量的堆内存。不过图 4-4 展示了两个数据指针指向了同一位置。这就有了一个问题：当 `s2` 和 `s1` 离开作用域，他们都会尝试释放相同的内存。这是一个叫做 *double free* 的错误，也是之前提到过的内存安全性 bug 之一。两次释放（相同）内存会导致内存污染，它可能会导致潜在的安全漏洞。 +之前，我们提到过当变量离开作用域后 Rust 自动调用 `drop` 函数并清理变量的堆内存。不过图 4-4 展示了两个数据指针指向了同一位置。这就有了一个问题：当 `s2` 和 `s1` 离开作用域，他们都会尝试释放相同的内存。这是一个叫做 **二次释放**（*double free*）的错误，也是之前提到过的内存安全性 bug 之一。两次释放（相同）内存会导致内存污染，它可能会导致潜在的安全漏洞。 为了确保内存安全，这种场景下 Rust 的处理有另一个细节值得注意。与其尝试拷贝被分配的内存，Rust 则认为 `s1` 不再有效，因此 Rust 不需要在 `s1` 离开作用域后清理任何东西。看看在 `s2` 被创建之后尝试使用 `s1` 会发生什么： @@ -184,22 +184,23 @@ println!("{}, world!", s1); ```text error[E0382]: use of moved value: `s1` - --> src/main.rs:4:27 + --> src/main.rs:5:28 | 3 | let s2 = s1; | -- value moved here -4 | println!("{}, world!", s1); +4 | +5 | println!("{}, world!", s1); | ^^ value used here after move | - = note: move occurs because `s1` has type `std::string::String`, -which does not implement the `Copy` trait + = note: move occurs because `s1` has type `std::string::String`, which does + not implement the `Copy` trait ``` -如果你在其他语言中听说过术语 “浅拷贝”（“shallow copy”）和 “深拷贝”（“deep copy”），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量无效化了，这个操作被称为 **移动**（*move*），而不是浅拷贝。上面的例子可以解读为 `s1` 被 **移动** 到了 `s2` 中。那么具体发生了什么，如图 4-6 所示。 +如果你在其他语言中听说过术语 “浅拷贝”（“shallow copy”）和 “深拷贝”（“deep copy”），那么拷贝指针、长度和容量而不拷贝数据可能听起来像浅拷贝。不过因为 Rust 同时使第一个变量无效化了，这个操作被称为 **移动**（*move*），而不是浅拷贝。上面的例子可以解读为 `s1` 被 **移动** 到了 `s2` 中。那么具体发生了什么，如图 4-4 所示。 s1 moved to s2 -图 4-6：`s1` 无效化之后的内存表现 +图 4-4：`s1` 无效化之后的内存表现 这样就解决了我们的麻烦！因为只有 `s2` 是有效的，当其离开作用域，它就释放自己的内存，完毕。 @@ -218,7 +219,7 @@ let s2 = s1.clone(); println!("s1 = {}, s2 = {}", s1, s2); ``` -这段代码能正常运行，也是如何显式产生图 4-5 中行为的方式，这里堆上的数据 **确实** 被复制了。 +这段代码能正常运行，也是如何显式产生图 4-3 中行为的方式，这里堆上的数据 **确实** 被复制了。 当出现 `clone` 调用时，你知道一些特定的代码被执行而且这些代码可能相当消耗资源。你很容易察觉到一些不寻常的事情正在发生。 @@ -258,6 +259,7 @@ fn main() { takes_ownership(s); // s's value moves into the function... // ... and so is no longer valid here. + let x = 5; // x comes into scope. makes_copy(x); // x would move into the function, @@ -277,15 +279,15 @@ fn makes_copy(some_integer: i32) { // some_integer comes into scope. } // Here, some_integer goes out of scope. Nothing special happens. ``` -示例 4-7：带有所有权和作用域标注的函数 +示例 4-3：带有所有权和作用域标注的函数 -当尝试在调用 `takes_ownership` 后使用 `s` 时，Rust 会抛出一个编译时错误。这些静态检查使我们免于犯错。试试在 `main` 函数中添加使用 `s` 和 `x` 的代码来看看哪里能使用他们，以及哪里所有权规则会阻止我们这么做。 +当尝试在调用 `takes_ownership` 后使用 `s` 时，Rust 会抛出一个编译时错误。这些静态检查使我们免于犯错。试试在 `main` 函数中添加使用 `s` 和 `x` 的代码来看看哪里能使用他们，以及所有权规则会在哪里阻止我们这么做。 ### 返回值与作用域 -返回值也可以转移作用域。这里是一个有与示例 4-7 中类似标注的例子： +返回值也可以转移作用域。这里是一个拥有与示例 4-3 中类似标注的例子： -Filename: src/main.rs +文件名: src/main.rs ```rust fn main() { @@ -343,4 +345,4 @@ fn calculate_length(s: String) -> (String, usize) { } ``` -但是这不免有些形式主义，而且这种场景应该很常见。幸运的是，Rust 对此提供了一个功能，叫做 **引用**（*references*）。 +但是这未免有些形式主义，而且这种场景应该很常见。幸运的是，Rust 对此提供了一个功能，叫做 **引用**（*references*）。 From 8dfa8d7ed98602ad5385a23973f7d5cd2c7ca09f Mon Sep 17 00:00:00 2001 From: KaiserY Date: Wed, 17 Jan 2018 09:29:47 +0800 Subject: [PATCH 111/150] check to ch04-03 --- src/ch04-02-references-and-borrowing.md | 56 +++++++++++---------- src/ch04-03-slices.md | 67 ++++++++++++------------- 2 files changed, 62 insertions(+), 61 deletions(-) diff --git a/src/ch04-02-references-and-borrowing.md b/src/ch04-02-references-and-borrowing.md index c1d453d..4850b03 100644 --- a/src/ch04-02-references-and-borrowing.md +++ b/src/ch04-02-references-and-borrowing.md @@ -2,13 +2,13 @@ > [ch04-02-references-and-borrowing.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch04-02-references-and-borrowing.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit aa493fef8630e3eee865167892666569afbbc2aa -有这样一个问题：在上一部分的结尾处的使用元组的代码中，因为 `String` 先被移动到了 `calculate_length` 内，因此我们不得不将 `String` 作为返回值，这样在调用 `calculate_length` 后才仍然可以使用 `String`。 +上一部分结尾的元组代码有这样一个问题：我们不得不将 `String` 返回给调用函数，以便仍能在调用 `calculate_length` 后使用 `String`，因为 `String` 被移动到了 `calculate_length` 内。 下面是如何定义并使用一个（新的）`calculate_length` 函数，它以一个对象的 **引用** 作为参数而不是获取值的所有权： -Filename: src/main.rs +文件名: src/main.rs ```rust fn main() { @@ -26,12 +26,14 @@ fn calculate_length(s: &String) -> usize { 首先，注意变量声明和函数返回值中的所有元组代码都消失了。其次，注意我们传递 `&s1` 给 `calculate_length`，同时在函数定义中，我们获取 `&String` 而不是 `String`。 -这些 & 符号就是 **引用**，他们允许你使用值但不获取它的所有权。图 4-8 展示了一个图解。 +这些 & 符号就是 **引用**，他们允许你使用值但不获取其所有权。图 4-5 展示了一个图解。 &String s pointing at String s1 图 4-8：`&String s` 指向 `String s1` +> 注意：与使用 `&` 引用相对的操作是 **解引用**（*dereferencing*），它使用解引用运算符，`*`。我们将会在第八章遇到一些解引用运算符，并在第十五章详细讨论解引用。 + 仔细看看这个函数调用： ```rust @@ -43,7 +45,7 @@ let s1 = String::from("hello"); let len = calculate_length(&s1); ``` -`&s1` 语法允许我们创建一个 **参考** 值 `s1` 的引用，但是并不拥有它。因为并不拥有这个值，当引用离开作用域它指向的值也不会被丢弃。 +`&s1` 语法允许我们创建一个 **指向** 值 `s1` 的引用，但是并不拥有它。因为并不拥有这个值，当引用离开作用域时其指向的值也不会被丢弃。 同理，函数签名使用了 `&` 来表明参数 `s` 的类型是一个引用。让我们增加一些解释性的注解： @@ -54,11 +56,11 @@ fn calculate_length(s: &String) -> usize { // s is a reference to a String // it refers to, nothing happens. ``` -变量 `s` 有效的作用域与函数参数的作用域一样，不过当引用离开作用域后并不丢弃它指向的数据因为我们没有所有权。函数使用引用而不是实际值作为参数意味着无需返回值来交还所有权，因为就不曾拥有所有权。 +变量 `s` 有效的作用域与函数参数的作用域一样，不过当引用离开作用域后并不丢弃它指向的数据，因为我们没有所有权。函数使用引用而不是实际值作为参数意味着无需返回值来交还所有权，因为就不曾拥有所有权。 我们将获取引用作为函数参数称为 **借用**（*borrowing*）。正如现实生活中，如果一个人拥有某样东西，你可以从他那里借来。当你使用完毕，必须还回去。 -如果我们尝试修改借用的变量呢？尝试示例 4-9 中的代码。剧透：这行不通！ +如果我们尝试修改借用的变量呢？尝试示例 4-4 中的代码。剧透：这行不通！ 文件名: src/main.rs @@ -79,18 +81,20 @@ fn change(some_string: &String) { 这里是错误： ```text -error: cannot borrow immutable borrowed content `*some_string` as mutable +error[E0596]: cannot borrow immutable borrowed content `*some_string` as mutable --> error.rs:8:5 | +7 | fn change(some_string: &String) { + | ------- use `&mut String` here to make mutable 8 | some_string.push_str(", world"); - | ^^^^^^^^^^^ + | ^^^^^^^^^^^ cannot borrow as mutable ``` -正如变量默认是不可变的，引用也一样。不允许修改引用的值。 +正如变量默认是不可变的，引用也一样。（默认）不允许修改引用的值。 ### 可变引用 -可以通过一个小调整来修复在示例 4-9 代码中的错误，在示例 4-9 的代码中： +可以通过一个小调整来修复在示例 4-4 代码中的错误： 文件名: src/main.rs @@ -106,7 +110,7 @@ fn change(some_string: &mut String) { } ``` -首先，必须将 `s` 改为 `mut`。然后必须创建一个可变引用 `&mut s` 和接受一个可变引用 `some_string: &mut String`。 +首先，必须将 `s` 改为 `mut`。然后必须创建一个可变引用 `&mut s` 和接受一个可变引用，`some_string: &mut String`。 不过可变引用有一个很大的限制：在特定作用域中的特定数据有且只有一个可变引用。这些代码会失败： @@ -133,7 +137,7 @@ error[E0499]: cannot borrow `s` as mutable more than once at a time | - first borrow ends here ``` -这个限制允许可变性，不过是以一种受限制的方式。新 Rustacean 们经常与此作斗争，因为大部分语言任何时候变量都是可变的。这个限制的好处是 Rust 可以在编译时就避免数据竞争。 +这个限制允许可变性，不过是以一种受限制的方式允许。新 Rustacean 们经常与此作斗争，因为大部分语言中变量任何时候都是可变的。这个限制的好处是 Rust 可以在编译时就避免数据竞争。 **数据竞争**（*data race*）是一种特定类型的竞争状态，它可由这三个行为造成： @@ -141,7 +145,7 @@ error[E0499]: cannot borrow `s` as mutable more than once at a time 2. 至少有一个这样的指针被用来写入数据。 3. 不存在同步数据访问的机制。 -数据竞争会导致未定义行为，难以在运行时追踪，并且难以诊断和修复；Rust 避免了这种情况的发生，因为它直接拒绝编译存在数据竞争的代码！ +数据竞争会导致未定义行为，难以在运行时追踪，并且难以诊断和修复；Rust 避免了这种情况的发生，因为它甚至不会编译存在数据竞争的代码！ 一如既往，可以使用大括号来创建一个新的作用域来允许拥有多个可变引用，只是不能 **同时** 拥有： @@ -186,13 +190,13 @@ immutable 尽管这些错误有时使人沮丧，但请牢记这是 Rust 编译器在提早指出一个潜在的 bug（在编译时而不是运行时）并明确告诉你问题在哪，而不是任由你去追踪为何有时数据并不是你想象中的那样。 -### 悬垂引用 +### 悬垂引用（Dangling References） 在存在指针的语言中，容易通过释放内存时保留指向它的指针而错误地生成一个 **悬垂指针**（*dangling pointer*），所谓悬垂指针是其指向的内存可能已经被分配给其它持有者。相比之下，在 Rust 中编译器确保引用永远也不会变成悬垂状态：当我们拥有一些数据的引用，编译器确保数据不会在其引用之前离开作用域。 -让我们尝试创建一个悬垂引用： +让我们尝试创建一个悬垂引用，Rust 会通过一个编译时错误来避免： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore fn main() { @@ -213,13 +217,11 @@ error[E0106]: missing lifetime specifier --> dangle.rs:5:16 | 5 | fn dangle() -> &String { - | ^^^^^^^ + | ^ expected lifetime parameter | - = help: this function's return type contains a borrowed value, but there is no - value for it to be borrowed from + = help: this function's return type contains a borrowed value, but there is + no value for it to be borrowed from = help: consider giving it a 'static lifetime - -error: aborting due to previous error ``` 错误信息引用了一个我们还未涉及到的功能：**生命周期**（*lifetimes*）。第十章会详细介绍生命周期。不过，如果你不理会生命周期的部分，错误信息确实包含了为什么代码是有问题的关键： @@ -229,7 +231,7 @@ this function's return type contains a borrowed value, but there is no value for it to be borrowed from. ``` -让我们仔细看看我们的 `dangle` 代码的每一步到底放生了什么： +让我们仔细看看我们的 `dangle` 代码的每一步到底发生了什么： ```rust,ignore fn dangle() -> &String { // dangle returns a reference to a String @@ -241,7 +243,7 @@ fn dangle() -> &String { // dangle returns a reference to a String // Danger! ``` -因为 `s` 是在 `dangle` 创建的，当 `dangle` 的代码执行完毕后，`s` 将被释放。不过我们尝试返回一个它的引用。这意味着这个引用会指向一个无效的 `String`！这可不对。Rust 不会允许我们这么做的。 +因为 `s` 是在 `dangle` 函数内创建的，当 `dangle` 的代码执行完毕后，`s` 将被释放。不过我们尝试返回一个它的引用。这意味着这个引用会指向一个无效的 `String`！这可不对。Rust 不会允许我们这么做的。 这里的解决方法是直接返回 `String`： @@ -253,15 +255,15 @@ fn no_dangle() -> String { } ``` -这样就可以没有任何错误的运行了。所有权被移动出去，所以没有值被释放掉。 +这样就可以没有任何错误的运行了。所有权被移动出去，所以没有值被释放。 ### 引用的规则 -简要的概括一下对引用的讨论： +让我们简要的概括一下之前对引用的讨论： 1. 在任意给定时间，**只能** 拥有如下中的一个： * 一个可变引用。 * 任意数量的不可变引用。 2. 引用必须总是有效的。 -接下来，我们来看看一种不同类型的引用：slice。 +接下来，我们来看看另一种不同类型的引用：slice。 diff --git a/src/ch04-03-slices.md b/src/ch04-03-slices.md index 47096fb..d5ab5fd 100644 --- a/src/ch04-03-slices.md +++ b/src/ch04-03-slices.md @@ -2,21 +2,21 @@ > [ch04-03-slices.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch04-03-slices.md) >
-> commit df9e3b922335ec2c76b6c1c4ede31b7742103c48 +> commit 88a12e16d4c7fa669349c9b1ddb48093de92c5e6 另一个没有所有权的数据类型是 *slice*。slice 允许你引用集合中一段连续的元素序列，而不用引用整个集合。 -这里有一个小的编程问题：编写一个获取一个字符串并返回它在其中找到的第一个单词的函数。如果函数没有在字符串中找到一个空格，就意味着整个字符串是一个单词，所以整个字符串都应该返回。 +这里有一个小的编程问题：编写一个获取一个字符串并返回它在其中找到的第一个单词的函数。如果函数没有在字符串中找到一个空格，就意味着整个字符串是一个单词，所以整个字符串都应返回。 -让我们看看这个函数的签名： +让我们考虑一下这个函数的签名： ```rust,ignore fn first_word(s: &String) -> ? ``` -`first_word` 这个函数有一个参数 `&String`。因为我们不需要所有权，所以这没有问题。不过应该返回什么呢？我们并没有一个真正获取 **部分** 字符串的办法。不过，我们可以返回单词结尾的索引。让我们试试如示例 4-10 所示的代码： +`first_word` 函数有一个参数 `&String`。因为我们不需要所有权，所以这没有问题。不过应该返回什么呢？我们并没有一个真正获取 **部分** 字符串的办法。不过，我们可以返回单词结尾的索引。试试如示例 4-5 所示的代码： -Filename: src/main.rs +文件名: src/main.rs ```rust fn first_word(s: &String) -> usize { @@ -32,9 +32,9 @@ fn first_word(s: &String) -> usize { } ``` -示例 4-10：`first_word` 函数返回 `String` 参数的一个字节索引值 +示例 4-5：`first_word` 函数返回 `String` 参数的一个字节索引值 -让我们将代码分解成小块。因为需要一个元素一个元素的检查 `String` 中的值是否是空格，需要用 `as_bytes` 方法将 `String` 转化为字节数组： +让我们将代码分解成小块。因为需要一个元素一个元素的检查 `String` 中的值是否为空格，需要用 `as_bytes` 方法将 `String` 转化为字节数组： ```rust,ignore let bytes = s.as_bytes(); @@ -46,11 +46,11 @@ let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { ``` -第十三章将讨论迭代器的更多细节。现在，只需知道 `iter` 方法返回集合中的每一个元素，而 `enumerate` 包装 `iter` 的结果并返回一个元组，其中每一个元素是元组的一部分。返回元组的第一个元素是索引，第二个元素是集合中元素的引用。这比我们自己计算索引要方便一些。 +第十三章将会讨论迭代器的更多细节。现在，只需知道 `iter` 方法返回集合中的每一个元素，而 `enumerate` 包装 `iter` 的结果并返回一个元组，其中每一个元素是元组的一部分。返回元组的第一个元素是索引，第二个元素是集合中元素的引用。这比我们自己计算索引要方便一些。 -因为 `enumerate` 方法返回一个元组，我们可以使用模式来解构它，就像 Rust 中其他地方一样。所以在 `for` 循环中，我们指定了一个模式，其中 `i` 是元组中的索引而 `&item` 是单个字节。因为从 `.iter().enumerate()` 中获取了集合元素的引用，我们在模式中使用了`&`。 +因为 `enumerate` 方法返回一个元组，我们可以使用模式来解构，就像 Rust 中其他任何地方所做的一样。所以在 `for` 循环中，我们指定了一个模式，其中 `i` 是元组中的索引而 `&item` 则是单个字节。因为我们从 `.iter().enumerate()` 中获取了集合元素的引用，所以模式中使用了 `&`。 -我们通过字节的字面值来寻找代表空格的字节。如果找到了，返回它的位置。否则，使用 `s.len()` 返回字符串的长度： +我们通过字节的字面值语法来寻找代表空格的字节。如果找到了，返回它的位置。否则，使用 `s.len()` 返回字符串的长度： ```rust,ignore if item == b' ' { @@ -60,7 +60,7 @@ for (i, &item) in bytes.iter().enumerate() { s.len() ``` -现在有了一个找到字符串中第一个单词结尾索引的方法了，不过这有一个问题。我们返回了单独一个 `usize`，不过它只在 `&String` 的上下文中才是一个有意义的数字。换句话说，因为它是一个与 `String` 相分离的值，无法保证将来它仍然有效。考虑一下示例 4-11 中使用了示例 4-10 中 `first_word` 函数的程序： +现在有了一个找到字符串中第一个单词结尾索引的方法了，不过这有一个问题。我们返回了单独一个 `usize`，不过它只在 `&String` 的上下文中才是一个有意义的数字。换句话说，因为它是一个与 `String` 相分离的值，无法保证将来它仍然有效。考虑一下示例 4-6 中使用了示例 4-5 中 `first_word` 函数的程序： 文件名: src/main.rs @@ -89,9 +89,9 @@ fn main() { } ``` -示例 4-11：储存 `first_word` 函数调用的返回值并接着改变 `String` 的内容 +示例 4-6：储存 `first_word` 函数调用的返回值并接着改变 `String` 的内容 -这个程序编译时没有任何错误，而且在调用 `s.clear()` 之后使用 `word` 也不会出错。这时 `word` 与 `s` 状态就没有联系了，所以 `word `仍然包含值 `5`。可以尝试用值 `5` 来提取变量 `s` 的第一个单词，不过这是有 bug 的，因为在我们将 `5` 保存到 `word` 之后 `s` 的内容已经改变。 +这个程序编译时没有任何错误，而且在调用 `s.clear()` 之后使用 `word` 也不会出错。这时 `word` 与 `s` 状态就完全没有联系了，所以 `word `仍然包含值 `5`。可以尝试用值 `5` 来提取变量 `s` 的第一个单词，不过这是有 bug 的，因为在我们将 `5` 保存到 `word` 之后 `s` 的内容已经改变。 我们不得不时刻担心 `word` 的索引与 `s` 中的数据不再同步，这是冗余且容易出错的！如果编写这么一个 `second_word` 函数的话，管理索引这件事将更加容易出问题。它的签名看起来像这样： @@ -118,11 +118,11 @@ let world = &s[6..11]; 使用一个由中括号中的 `[starting_index..ending_index]` 指定的 range 创建一个 slice，其中 `starting_index` 是包含在 slice 的第一个位置，`ending_index` 则是 slice 最后一个位置的后一个值。在其内部，slice 的数据结构储存了开始位置和 slice 的长度，长度对应 `ending_index` 减去 `starting_index` 的值。所以对于 `let world = &s[6..11];` 的情况，`world` 将是一个包含指向 `s` 第 6 个字节的指针和长度值 5 的 slice。 -图 4-12 展示了一个图例。 +图 4-6 展示了一个图例。 world containing a pointer to the 6th byte of String s and a length 5 -图 4-12：引用了部分 `String` 的字符串 slice +图 4-6：引用了部分 `String` 的字符串 slice 对于 Rust 的 `..` range 语法，如果想要从第一个索引（0）开始，可以不写两个点号之前的值。换句话说，如下两个语句是相同的： @@ -155,6 +155,8 @@ let slice = &s[0..len]; let slice = &s[..]; ``` +> 注意：字符串 slice range 的索引必须位于有效的 UTF-8 字符边界内，如果尝试从一个多字节字符的中间位置创建字符串 slice，则程序将会因错误而退出。出于介绍字符串 slice 的目的，本部分假设只使用 ASCII 字符集；第八章的 “字符串” 部分会更加全面的讨论 UTF-8 处理问题。 + 在记住所有这些知识后，让我们重写 `first_word` 来返回一个 slice。“字符串 slice” 的类型签名写作 `&str`： 文件名: src/main.rs @@ -173,19 +175,19 @@ fn first_word(s: &String) -> &str { } ``` -我们使用跟示例 4-10 相同的方式获取单词结尾的索引，通过寻找第一个出现的空格。当我们找到一个空格，我们返回一个索引，它使用字符串的开始和空格的索引来作为开始和结束的索引。 +我们使用跟示例 4-5 相同的方式获取单词结尾的索引，通过寻找第一个出现的空格。当找到一个空格，我们返回一个索引，它使用字符串的开始和空格的索引来作为开始和结束的索引。 现在当调用 `first_word` 时，会返回一个单独的与底层数据相联系的值。这个值由一个 slice 开始位置的引用和 slice 中元素的数量组成。 -`second_word`函数也可以改为返回一个 slice： +`second_word` 函数也可以改为返回一个 slice： ```rust,ignore fn second_word(s: &String) -> &str { ``` -现在我们有了一个不易混杂的直观的 API 了，因为编译器会确保指向 `String` 的引用保持有效。还记得示例 4-11 程序中，那个当我们获取第一个单词结尾的索引不过接着就清除了字符串所以索引就无效了的 bug 吗？那些代码逻辑上是不正确的，不过却没有表现出任何直接的错误。问题会在之后尝试对空字符串使用第一个单词的索引时出现。slice 就不可能出现这种 bug 并让我们更早的知道出问题了。使用 slice 版本的 `first_word` 会抛出一个编译时错误： +现在我们有了一个不易混淆且直观的 API 了，因为编译器会确保指向 `String` 的引用持续有效。还记得示例 4-6 程序中，那个当我们获取第一个单词结尾的索引不过接着就清除了字符串所以索引就无效了的 bug 吗？那些代码逻辑上是不正确的，不过却没有表现出任何直接的错误。问题会在之后尝试对空字符串使用第一个单词的索引时出现。slice 就不可能出现这种 bug 并让我们更早的知道出问题了。使用 slice 版本的 `first_word` 会抛出一个编译时错误： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore fn main() { @@ -200,19 +202,16 @@ fn main() { 这里是编译错误： ```text -17:6 error: cannot borrow `s` as mutable because it is also borrowed as - immutable [E0502] - s.clear(); // Error! - ^ -15:29 note: previous borrow of `s` occurs here; the immutable borrow prevents - subsequent moves or mutable borrows of `s` until the borrow ends - let word = first_word(&s); - ^ -18:2 note: previous borrow ends here -fn main() { - -} -^ +error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable + --> src/main.rs:6:5 + | +4 | let word = first_word(&s); + | - immutable borrow occurs here +5 | +6 | s.clear(); // Error! + | ^ mutable borrow occurs here +7 | } + | - immutable borrow ends here ``` 回忆一下借用规则，当拥有某值的不可变引用时，就不能再获取一个可变引用。因为 `clear` 需要清空 `String`，它尝试获取一个可变引用，它失败了。Rust 不仅使得我们的 API 简单易用，也在编译时就消除了一整类的错误！ @@ -274,7 +273,7 @@ fn main() { } ``` -### 其他 slice +### 其他类型的 slice 字符串 slice，正如你想象的那样，是针对字符串的。不过也有更通用的 slice 类型。考虑一下这个数组： @@ -296,4 +295,4 @@ let slice = &a[1..3]; 所有权、借用和 slice 这些概念是 Rust 何以在编译时保障内存安全的关键所在。Rust 像其他系统编程语言那样给予你对内存使用的控制，但拥有数据所有者在离开作用域后自动清除其数据的功能意味着你无须额外编写和调试相关的控制代码。 -所有权系统影响了 Rust 中其他很多部分如何工作，所以我们还会继续讲到这些概念，这将贯穿本书的余下内容。让我们开始下一个章节，来看看如何将多份数据组合进一个 `struct` 中。 \ No newline at end of file +所有权系统影响了 Rust 中很多其他部分的工作方式，所以我们还会继续讲到这些概念，这将贯穿本书的余下内容。让我们开始下一个章节，来看看如何将多份数据组合进一个 `struct` 中。 \ No newline at end of file From 703306226a3ce82676418828cf570ca370ca399a Mon Sep 17 00:00:00 2001 From: dean Date: Wed, 17 Jan 2018 17:08:39 +0800 Subject: [PATCH 112/150] Translate some english sentences that have missed the translation. --- .DS_Store | Bin 0 -> 8196 bytes src/ch15-03-drop.md | 11 +++---- src/ch15-04-rc.md | 19 +++++------- src/ch15-05-interior-mutability.md | 9 +++--- src/ch15-06-reference-cycles.md | 34 +++++++++------------ src/ch16-01-threads.md | 42 ++++++++++++-------------- src/ch16-02-message-passing.md | 46 +++++++++++++---------------- src/ch16-03-shared-state.md | 42 ++++++++++++-------------- 8 files changed, 88 insertions(+), 115 deletions(-) create mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..f37fa75e0de78293b6f1382b2e5e3fb25d3eb724 GIT binary patch literal 8196 zcmeHLPiz!b82`R)ftjJ$X(_Y=E?p@#r4(qFLcvho?iNBrmCE)n1-G+1V>>#XS$Af4 z`^RDvF9y+r2@0P4caU(CcrZ~D7!g>-g}bsz{b z5M&_8K#+kT13?D<4;i36n-yW5eV=QCI>>!M?7=D z7{{OvG7w~7Z3fuSrwkm(K_*>XettI%$8BxBgQ2qW4I4KJq9}-4gbT?DyO?xUH}AyN z+^E+xG(GLN`)%7?YOCo%LocS}nuKk+s$uE5W#;FH3`?_%aXW8mjyF!9>Q0caH&IHi zot>;xrMTB;c;7>ft-^g9$UA7a0BP?R09|9M(d?i!Wa1z8gZOf{{WT+|^Q z6Xet4P=SZdh1F80AP#5j$w>;v;j)+#7vu%u88&gR>bPgJx4!Z+|O+=B055q^SS;5YaK z{)E5aZ`_ELC}TBl#R%@jX55Dz7{e}1U^n*QSxn*p4&o?ksN*!m+>;b zhOgsW_zu2{@8bt}6Fr6pXoYRlQ<5r#9uV@in$-qNk4AFZ{rW2Y1z zAVTR=tEpcix4elFUtr8o>LcN>%xJ^Adm5=5B3kqA-sZ3*ml0`2&-lPWDJ*Xwesb-h zc1e=UiNIWY^cZP35>>gjb0=xR*L5}0Kq!c-iMKB8uER(01$<3}TZA9sXZRIDI7x;pF@*qXJZzpiFR{% z5nsYr@DjdC1iV7@yNcKFZ6e@@tLS#BL^O_g{Vv@K$(&`{);LK@ma literal 0 HcmV?d00001 diff --git a/src/ch15-03-drop.md b/src/ch15-03-drop.md index 0456929..ad41544 100644 --- a/src/ch15-03-drop.md +++ b/src/ch15-03-drop.md @@ -12,7 +12,7 @@ 示例 15-8 展示了并没有实际功能的结构体`CustomSmartPointer`，不过我们会在创建实例之后打印出`CustomSmartPointer created.`，而在实例离开作用域时打印出`Dropping CustomSmartPointer!`，这样就能看出每一段代码是何时被执行的。实际的项目中，我们应该在`drop`中清理任何智能指针运行所需要的资源，而不是这个例子中的`println!`语句： -Filename: src/main.rs +文件名: src/main.rs ```rust struct CustomSmartPointer { @@ -32,9 +32,7 @@ fn main() { } ``` -Listing 15-8: A `CustomSmartPointer` struct that -implements the `Drop` trait, where we could put code that would clean up after -the `CustomSmartPointer`. +示例 15-8: 结构体 `CustomSmartPointer` 实现了 `Drop` trait, 我们能够放入代码以便在 `CustomSmartPointer` 离开作用域后进行清理 `Drop` trait 位于 prelude 中，所以无需导入它。`drop`方法的实现调用了`println!`；这里是你需要放入实际关闭套接字代码的地方。在`main`函数中，我们创建一个`CustomSmartPointer`的新实例并打印出`CustomSmartPointer created.`以便在运行时知道代码运行到此处。在`main`的结尾，`CustomSmartPointer`的实例会离开作用域。注意我们没有显式调用`drop`方法： @@ -50,7 +48,7 @@ Dropping CustomSmartPointer! 可以使用`std::mem::drop`函数来在值离开作用域之前丢弃它。这通常是不必要的；整个`Drop` trait 的要点在于它自动的帮我们处理清理工作。在第十六章讲到并发时我们会看到一个需要在离开作用域之前丢弃值的例子。现在知道这是可能的即可，`std::mem::drop`位于 prelude 中所以可以如示例 15-9 所示直接调用`drop`： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore fn main() { @@ -61,8 +59,7 @@ fn main() { } ``` -Listing 15-9: Calling `std::mem::drop` to explicitly drop -a value before it goes out of scope +示例 15-9: 在一个值离开作用域之前，调用 `std::mem::drop` 显式进行回收 运行这段代码会打印出如下内容，因为`Dropping CustomSmartPointer!`在`CustomSmartPointer created.`和`Wait for it...`之间被打印出来，表明析构代码被执行了： diff --git a/src/ch15-04-rc.md b/src/ch15-04-rc.md index d735eba..861f77a 100644 --- a/src/ch15-04-rc.md +++ b/src/ch15-04-rc.md @@ -18,12 +18,11 @@ Two lists that share ownership of a third list -Figure 15-10: Two lists, `b` and `c`, sharing ownership -of a third list, `a` +图 15-10: 两个列表, `b` 和 `c`, 共享第三个列表 `a` 的所有权 尝试使用`Box`定义的`List`并不能工作，如示例 15-11 所示： -Filename: src/main.rs +文件: src/main.rs ```rust,ignore enum List { @@ -42,8 +41,7 @@ fn main() { } ``` -Listing 15-11: Having two lists using `Box` that try -to share ownership of a third list won't work +示例 15-11: 具有两个使用 `Box` 的列表，试图共享第三个列表的所有权，是不能正常运行的/span> 编译会得出如下错误： @@ -66,7 +64,7 @@ error[E0382]: use of moved value: `a` 如示例 15-12 所示，可以将`List`的定义从`Box`改为`Rc`： -Filename: src/main.rs +文件名: src/main.rs ```rust enum List { @@ -84,8 +82,7 @@ fn main() { } ``` -Listing 15-12: A definition of `List` that uses -`Rc` +示例 15-12: 使用 `Rc` 定义的 `List` 注意必须为`Rc`增加`use`语句因为它不在 prelude 中。在`main`中创建了存放 5 和 10 的列表并将其存放在一个叫做`a`的新的`Rc`中。接着当创建`b`和`c`时，我们对`a`调用了`clone`方法。 @@ -93,7 +90,7 @@ fn main() { 之前我们见过`clone`方法，当时使用它来创建某些数据的完整拷贝。但是对于`Rc`来说，它并不创建一个完整的拷贝。`Rc`存放了**引用计数**，也就是说，一个存在多少个克隆的计数器。让我们像示例 15-13 那样在创建`c`时增加一个内部作用域，并在不同的位置打印出关联函数`Rc::strong_count`的结果。`Rc::strong_count`返回传递给它的`Rc`值的引用计数，而在本章的稍后部分介绍避免引用循环时讲到它为什么叫做`strong_count`。 -Filename: src/main.rs +文件名: src/main.rs ```rust # enum List { @@ -117,7 +114,7 @@ fn main() { } ``` -Listing 15-13: Printing out the reference count +示例 15-13: 打印输出引用计数 这会打印出： @@ -130,4 +127,4 @@ rc after c goes out of scope = 2 不难看出`a`的初始引用计数是一。接着每次调用`clone`，计数会加一。当`c`离开作用域时，计数减一，这发生在`Rc`的`Drop` trait 实现中。这个例子中不能看到的是当`b`接着是`a`在`main`函数的结尾离开作用域时，包含 5 和 10 的列表的引用计数会是 0，这时列表将被丢弃。这个策略允许拥有多个所有者，而引用计数会确保任何所有者存在时这个值保持有效。 -在本部分的开始，我们说`Rc`只允许程序的多个部分读取`Rc`中`T`的不可变引用。如果`Rc`允许一个可变引用，我们将遇到第四章讨论的借用规则所不允许的问题：两个指向同一位置的可变借用会导致数据竞争和不一致。不过可变数据是非常有用的！在下一部分，我们将讨论内部可变性模式和`RefCell`类型，它可以与`Rc`结合使用来处理不可变性的限制。 \ No newline at end of file +在本部分的开始，我们说`Rc`只允许程序的多个部分读取`Rc`中`T`的不可变引用。如果`Rc`允许一个可变引用，我们将遇到第四章讨论的借用规则所不允许的问题：两个指向同一位置的可变借用会导致数据竞争和不一致。不过可变数据是非常有用的！在下一部分，我们将讨论内部可变性模式和`RefCell`类型，它可以与`Rc`结合使用来处理不可变性的限制。 diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index 55cb8bd..d2fcda3 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -29,7 +29,7 @@ Rust 编译器执行的静态分析天生是保守的。代码的一些属性则 示例 15-14 展示了如何使用`RefCell`来使函数不可变的和可变的借用它的参数。注意`data`变量使用`let data`而不是`let mut data`来声明为不可变的，而`a_fn_that_mutably_borrows`则允许可变的借用数据并修改它！ -Filename: src/main.rs +文件名: src/main.rs ```rust use std::cell::RefCell; @@ -54,7 +54,7 @@ fn main() { } ``` -Listing 15-14: Using `RefCell`, `borrow`, and +示例 15-14: 使用 `RefCell`, `borrow` 和 `borrow_mut` 这个例子打印出： @@ -122,7 +122,7 @@ note: Run with `RUST_BACKTRACE=1` for a backtrace. 那么为什么要权衡考虑选择引入`RefCell`呢？好吧，还记得我们说过`Rc`只能拥有一个`T`的不可变引用吗？考虑到`RefCell`是不可变的，但是拥有内部可变性，可以将`Rc`与`RefCell`结合来创造一个既有引用计数又可变的类型。示例 15-15 展示了一个这么做的例子，再次回到示例 15-5 中的 cons list。在这个例子中，不同于在 cons list 中储存`i32`值，我们储存一个`Rc>`值。希望储存这个类型是因为其可以拥有不属于列表一部分的这个值的所有者（`Rc`提供的多个所有者功能），而且还可以改变内部的`i32`值（`RefCell`提供的内部可变性功能）： -Filename: src/main.rs +文件名: src/main.rs ```rust #[derive(Debug)] @@ -152,8 +152,7 @@ fn main() { } ``` -Listing 15-15: Using `Rc>` to create a -`List` that we can mutate +示例 15-15: 使用 `Rc>` 创建能够修改的 `List` 我们创建了一个值，它是`Rc>`的实例。将其储存在变量`value`中因为我们希望之后能直接访问它。接着在`a`中创建了一个拥有存放了`value`值的`Cons`成员的`List`，而且`value`需要被克隆因为我们希望除了`a`之外还拥有`value`的所有权。接着将`a`封装进`Rc`中这样就可以创建都引用`a`的有着不同开头的列表`b`和`c`，类似示例 15-12 中所做的那样。 diff --git a/src/ch15-06-reference-cycles.md b/src/ch15-06-reference-cycles.md index 76bc639..39587d4 100644 --- a/src/ch15-06-reference-cycles.md +++ b/src/ch15-06-reference-cycles.md @@ -10,7 +10,7 @@ 在示例 15-16 中，我们将使用示例 15-5 中`List`定义的另一个变体。我们将回到储存`i32`值作为`Cons`成员的第一个元素。现在`Cons`成员的第二个元素是`RefCell>`：这时就不能修改`i32`值了，但是能够修改`Cons`成员指向的那个`List`。还需要增加一个`tail`方法来方便我们在拥有一个`Cons`成员时访问第二个项： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore #[derive(Debug)] @@ -29,12 +29,11 @@ impl List { } ``` -Listing 15-16: A cons list definition that holds a -`RefCell` so that we can modify what a `Cons` variant is referring to +示例 15-16: 持有 `RefCell` 的 cons 列表定义，我们不能修改 `Cons` 变体引用的内容/span> 接下来，在示例 15-17 中，我们将在变量`a`中创建一个`List`值，其内部是一个`5, Nil`的列表。接着在变量`b`创建一个值 10 和指向`a`中列表的`List`值。最后修改`a`指向`b`而不是`Nil`，这会创建一个循环： -Filename: src/main.rs +文件名: src/main.rs ```rust # #[derive(Debug)] @@ -82,15 +81,13 @@ fn main() { } ``` -Listing 15-17: Creating a reference cycle of two `List` -values pointing to each other +示例 15-17: 创建一个引用循环：两个`List` 的值互相指向彼此 使用`tail`方法来获取`a`中`RefCell`的引用，并将其放入变量`link`中。接着对`RefCell`使用`borrow_mut`方法将其中的值从存放`Nil`值的`Rc`改为`b`中的`Rc`。这创建了一个看起来像图 15-18 所示的引用循环： Reference cycle of lists -Figure 15-18: A reference cycle of lists `a` and `b` -pointing to each other +图 15-18: 列表 `a` 和 `b` 彼此互相指向形成引用循环 如果你注释掉最后的`println!`，Rust 会尝试打印出`a`指向`b`指向`a`这样的循环直到栈溢出。 @@ -122,7 +119,7 @@ struct Node { 我们希望能够`Node`拥有其子节点，同时也希望变量可以拥有每个节点以便可以直接访问他们。这就是为什么`Vec`中的项是`Rc`值。我们也希望能够修改其他节点的子节点，这就是为什么`children`中`Vec`被放进了`RefCell`的原因。在示例 15-19 中创建了一个叫做`leaf`的带有值 3 并没有子节点的`Node`实例，和另一个带有值 5 和以`leaf`作为子节点的实例`branch`： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore fn main() { @@ -138,9 +135,7 @@ fn main() { } ``` -Listing 15-19: Creating a `leaf` node and a `branch` node -where `branch` has `leaf` as one of its children but `leaf` has no reference to -`branch` +示例 15-19: 创建一个 `leaf` 节点 和一个 `branch` 节点，使 `leaf` 作为 `branch` 的一个孩子之一，但是`leaf` 没有持有 `branch` 的引用 `leaf`中的`Node`现在有两个所有者：`leaf`和`branch`，因为我们克隆了`leaf`中的`Rc`并储存在了`branch`中。`branch`中的`Node`知道它与`leaf`相关联因为`branch`在`branch.children`中有`leaf`的引用。然而，`leaf`并不知道它与`branch`相关联，而我们希望`leaf`知道`branch`是其父节点。 @@ -148,7 +143,7 @@ where `branch` has `leaf` as one of its children but `leaf` has no reference to 所以在`parent`的类型中是使用`Weak`而不是`Rc`，具体来说是`RefCell>`： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::rc::{Rc, Weak}; @@ -164,7 +159,7 @@ struct Node { 这样，一个节点就能够在拥有父节点时指向它，而并不拥有其父节点。一个父节点哪怕在拥有指向它的子节点也会被丢弃，只要是其自身也没有一个父节点就行。现在将`main`函数更新为如示例 15-20 所示： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore fn main() { @@ -188,8 +183,8 @@ fn main() { } ``` -Listing 15-20: A `leaf` node and a `branch` node where -`leaf` has a `Weak` reference to its parent, `branch` +示例 15-20: 一个 `leaf` 节点和一个 `branch` 节点， +`leaf` 节点具有一个指向其父节点 `branch` 的 `Weak` 引用 创建`leaf`节点是类似的；因为它作为开始并没有父节点，这里创建了一个新的`Weak`引用实例。当尝试通过`upgrade`方法获取`leaf`父节点的引用时，会得到一个`None`值，如第一个`println!`输出所示： @@ -209,7 +204,7 @@ children: RefCell { value: [] } }] } }) 没有无限的输出（或直到栈溢出）的事实表明这里并没有引用循环。另一种证明的方式时观察调用`Rc::strong_count`和`Rc::weak_count`的值。在示例 15-21 中，创建了一个新的内部作用域并将`branch`的创建放入其中，这样可以观察`branch`被创建时和离开作用域被丢弃时发生了什么： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore fn main() { @@ -255,8 +250,7 @@ fn main() { } ``` -Listing 15-21: Creating `branch` in an inner scope and -examining strong and weak reference counts of `leaf` and `branch` +示例 15-21: 在内部范围创建一个 `branch` 节点，并检查 `leaf` 和 `branch` 的强弱引用计数 创建`leaf`之后，强引用计数是 1 （用于`leaf`自身）而弱引用计数是 0。在内部作用域中，在创建`branch`和关联`leaf`和`branch`之后，`branch`的强引用计数为 1（用于`branch`自身）而弱引用计数为 1（因为`leaf.parent`通过一个`Weak`指向`branch`）。`leaf`的强引用计数为 2，因为`branch`现在有一个`leaf`克隆的`Rc`储存在`branch.children`中。`leaf`的弱引用计数仍然为 0。 @@ -276,4 +270,4 @@ examining strong and weak reference counts of `leaf` and `branch` [The Nomicon]: https://doc.rust-lang.org/stable/nomicon/ -接下来，让我们谈谈 Rust 的并发。我们还会学习到一些新的对并发有帮助的智能指针。 \ No newline at end of file +接下来，让我们谈谈 Rust 的并发。我们还会学习到一些新的对并发有帮助的智能指针。 diff --git a/src/ch16-01-threads.md b/src/ch16-01-threads.md index 2881279..58ebd88 100644 --- a/src/ch16-01-threads.md +++ b/src/ch16-01-threads.md @@ -20,9 +20,9 @@ ### 使用`spawn`创建新线程 -为了创建一个新线程，调用`thread::spawn`函数并传递一个闭包（第十三章学习了闭包），它包含希望在新线程运行的代码。列表 16-1 中的例子在新线程中打印了一些文本而其余的文本在主线程中打印： +为了创建一个新线程，调用`thread::spawn`函数并传递一个闭包（第十三章学习了闭包），它包含希望在新线程运行的代码。示例 16-1 中的例子在新线程中打印了一些文本而其余的文本在主线程中打印： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::thread; @@ -40,8 +40,7 @@ fn main() { } ``` -Listing 16-1: Creating a new thread to print one thing -while the main thread is printing something else +示例 16-1: 创建一个打印某些内容的新线程，但是主线程打印其它内容 注意这个函数编写的方式，当主线程结束时，它也会停止新线程。这个程序的输出每次可能都略微不同，不过它大体上看起来像这样： @@ -62,9 +61,9 @@ hi number 5 from the spawned thread! #### 使用`join`等待所有线程结束 -由于主线程先于新建线程结束，不仅列表 16-1 中的代码大部分时候不能保证新建线程执行完毕，甚至不能实际保证新建线程会被执行！可以通过保存`thread::spawn`的返回值来解决这个问题，这是一个`JoinHandle`。这看起来如列表 16-2 所示： +由于主线程先于新建线程结束，不仅示例 16-1 中的代码大部分时候不能保证新建线程执行完毕，甚至不能实际保证新建线程会被执行！可以通过保存`thread::spawn`的返回值来解决这个问题，这是一个`JoinHandle`。这看起来如示例 16-2 所示： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::thread; @@ -84,8 +83,8 @@ fn main() { } ``` -Listing 16-2: Saving a `JoinHandle` from `thread::spawn` -to guarantee the thread is run to completion +示例 16-2: 从 `thread::spawn` 保存一个 `JoinHandle`， +以确保该线程能够运行至结束 `JoinHandle`是一个拥有所有权的值，它可以等待一个线程结束，这也正是`join`方法所做的。通过调用这个句柄的`join`，当前线程会阻塞直到句柄所代表的线程结束。因为我们将`join`调用放在了主线程的`for`循环之后，运行这个例子将产生类似这样的输出： @@ -109,7 +108,7 @@ hi number 9 from the spawned thread! 如果将`handle.join()`放在主线程的`for`循环之前，像这样： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::thread; @@ -157,9 +156,9 @@ hi number 4 from the main thread! 现在我们正在创建新线程，所以让我们讨论一下获取环境值的闭包吧！ -注意列表 16-1 中传递给`thread::spawn`的闭包并没有任何参数：并没有在新建线程代码中使用任何主线程的数据。为了在新建线程中使用来自于主线程的数据，需要新建线程的闭包获取它需要的值。列表 16-3 展示了一个尝试在主线程中创建一个 vector 并用于新建线程的例子，不过这么写还不能工作： +注意示例 16-1 中传递给`thread::spawn`的闭包并没有任何参数：并没有在新建线程代码中使用任何主线程的数据。为了在新建线程中使用来自于主线程的数据，需要新建线程的闭包获取它需要的值。示例 16-3 展示了一个尝试在主线程中创建一个 vector 并用于新建线程的例子，不过这么写还不能工作： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore use std::thread; @@ -175,8 +174,7 @@ fn main() { } ``` -Listing 16-3: Attempting to use a vector created by the -main thread from another thread +示例 16-3: 在主线程中创建一个 vector，尝试在其它线程中使用它/span> 闭包使用了`v`，所以闭包会获取`v`并使其成为闭包环境的一部分。因为`thread::spawn`在一个新线程中运行这个闭包，所以可以在新线程中访问`v`。 @@ -199,9 +197,9 @@ variables), use the `move` keyword, as shown: 当在闭包环境中获取某些值时，Rust 会尝试推断如何获取它。`println!`只需要`v`的一个引用，所以闭包尝试借用`v`。但是这有一个问题：我们并不知道新建线程会运行多久，所以无法知道`v`是否一直时有效的。 -考虑一下列表 16-4 中的代码，它展示了一个`v`的引用很有可能不再有效的场景： +考虑一下示例 16-4 中的代码，它展示了一个`v`的引用很有可能不再有效的场景： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore use std::thread; @@ -219,8 +217,7 @@ fn main() { } ``` -Listing 16-4: A thread with a closure that attempts to -capture a reference to `v` from a main thread that drops `v` +示例 16-4: 一个具有闭包的线程，尝试使用一个在主线程中被回收的引用 `v` 这些代码可以运行，而新建线程则可能直接就出错了并完全没有机会运行。新建线程内部有一个`v`的引用，不过主线程仍在执行：它立刻丢弃了`v`，使用了第十五章提到的显式丢弃其参数的`drop`函数。接着，新建线程开始执行，现在`v`是无效的了，所以它的引用也就是无效的。噢，这太糟了！ @@ -232,9 +229,9 @@ variables), use the `move` keyword, as shown: | let handle = thread::spawn(move || { ``` -通过在闭包之前增加`move`关键字，我们强制闭包获取它使用的值的所有权，而不是引用借用。列表 16-5 中展示的对列表 16-3 代码的修改可以按照我们的预期编译并运行： +通过在闭包之前增加`move`关键字，我们强制闭包获取它使用的值的所有权，而不是引用借用。示例 16-5 中展示的对示例 16-3 代码的修改可以按照我们的预期编译并运行： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::thread; @@ -250,10 +247,9 @@ fn main() { } ``` -Listing 16-5: Using the `move` keyword to force a closure -to take ownership of the values it uses +示例 16-5: 使用 `move` 关键字强制获取它使用的值的所有权 -那么列表 16-4 中那个主线程调用了`drop`的代码该怎么办呢？如果在闭包上增加了`move`，就将`v`移动到了闭包的环境中，我们将不能对其调用`drop`了。相反会出现这个编译时错误： +那么示例 16-4 中那个主线程调用了`drop`的代码该怎么办呢？如果在闭包上增加了`move`，就将`v`移动到了闭包的环境中，我们将不能对其调用`drop`了。相反会出现这个编译时错误： ``` error[E0382]: use of moved value: `v` @@ -271,4 +267,4 @@ error[E0382]: use of moved value: `v` Rust 的所有权规则又一次帮助了我们！ -现在我们有一个线程和线程 API 的基本了解，让我们讨论一下使用线程实际可以**做**什么吧。 \ No newline at end of file +现在我们有一个线程和线程 API 的基本了解，让我们讨论一下使用线程实际可以**做**什么吧。 diff --git a/src/ch16-02-message-passing.md b/src/ch16-02-message-passing.md index 66a0b6b..b9ffa91 100644 --- a/src/ch16-02-message-passing.md +++ b/src/ch16-02-message-passing.md @@ -17,9 +17,9 @@ 我们将编写一个例子使用一个线程生成值并向通道发送他们。主线程会接收这些值并打印出来。 -首先，如列表 16-6 所示，先创建一个通道但不做任何事： +首先，如示例 16-6 所示，先创建一个通道但不做任何事： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::sync::mpsc; @@ -30,16 +30,15 @@ fn main() { } ``` -Listing 16-6: Creating a channel and assigning the two -halves to `tx` and `rx` +示例 16-6: 创建一个通道，并指派一个包含 `tx` 和 `rx` 的元组 `mpsc::channel`函数创建一个新的通道。`mpsc`是**多个生产者，单个消费者**（*multiple producer, single consumer*）的缩写。简而言之，可以有多个产生值的**发送端**，但只能有一个消费这些值的**接收端**。现在我们以一个单独的生产者开始，不过一旦例子可以工作了就会增加多个生产者。 `mpsc::channel`返回一个元组：第一个元素是发送端，而第二个元素是接收端。由于历史原因，很多人使用`tx`和`rx`作为**发送者**和**接收者**的缩写，所以这就是我们将用来绑定这两端变量的名字。这里使用了一个`let`语句和模式来解构了元组。第十八章会讨论`let`语句中的模式和解构。 -让我们将发送端移动到一个新建线程中并发送一个字符串，如列表 16-7 所示： +让我们将发送端移动到一个新建线程中并发送一个字符串，如示例 16-7 所示： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::thread; @@ -55,16 +54,15 @@ fn main() { } ``` -Listing 16-7: Moving `tx` to a spawned thread and sending -"hi" +示例 16-7: 将 `tx` 移动到一个新建的线程中并发送内容 "hi" 正如上一部分那样使用`thread::spawn`来创建一个新线程。并使用一个`move`闭包来将`tx`移动进闭包这样新建线程就是其所有者。 通道的发送端有一个`send`方法用来获取需要放入通道的值。`send`方法返回一个`Result`类型，因为如果接收端被丢弃了，将没有发送值的目标，所以发送操作会出错。在这个例子中，我们简单的调用`unwrap`来忽略错误，不过对于一个真实程序，需要合理的处理它。第九章是你复习正确错误处理策略的好地方。 -在列表 16-8 中，让我们在主线程中从通道的接收端获取值： +在示例 16-8 中，让我们在主线程中从通道的接收端获取值： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::thread; @@ -83,12 +81,11 @@ fn main() { } ``` -Listing 16-8: Receiving the value "hi" in the main thread -and printing it out +示例 16-8: 在主线程中接收并打印内容 "hi" 通道的接收端有两个有用的方法：`recv`和`try_recv`。这里，我们使用了`recv`，它是 *receive* 的缩写。这个方法会阻塞执行直到从通道中接收一个值。一旦发送了一个值，`recv`会在一个`Result`中返回它。当通道发送端关闭，`recv`会返回一个错误。`try_recv`不会阻塞；相反它立刻返回一个`Result`。 -如果运行列表 16-8 中的代码，我们将会看到主线程打印出这个值： +如果运行示例 16-8 中的代码，我们将会看到主线程打印出这个值： ``` Got: hi @@ -96,9 +93,9 @@ Got: hi ### 通道与所有权如何交互 -现在让我们做一个试验来看看通道与所有权如何在一起工作：我们将尝试在新建线程中的通道中发送完`val`之后再使用它。尝试编译列表 16-9 中的代码： +现在让我们做一个试验来看看通道与所有权如何在一起工作：我们将尝试在新建线程中的通道中发送完`val`之后再使用它。尝试编译示例 16-9 中的代码： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore use std::thread; @@ -118,8 +115,7 @@ fn main() { } ``` -Listing 16-9: Attempting to use `val` after we have sent -it down the channel +示例 16-9: 在我们已经发送到通道中后，尝试使用 `val` 引用 这里尝试在通过`tx.send`发送`val`到通道中之后将其打印出来。这是一个坏主意：一旦将值发送到另一个线程后，那个线程可能会在我们在此使用它之前就修改或者丢弃它。这会由于不一致或不存在的数据而导致错误或意外的结果。 @@ -144,9 +140,9 @@ error[E0382]: use of moved value: `val` ### 发送多个值并观察接收者的等待 -列表 16-8 中的代码可以编译和运行，不过这并不是很有趣：通过它难以看出两个独立的线程在一个通道上相互通讯。列表 16-10 则有一些改进会证明这些代码是并发执行的：新建线程现在会发送多个消息并在每个消息之间暂停一段时间。 +示例 16-8 中的代码可以编译和运行，不过这并不是很有趣：通过它难以看出两个独立的线程在一个通道上相互通讯。示例 16-10 则有一些改进会证明这些代码是并发执行的：新建线程现在会发送多个消息并在每个消息之间暂停一段时间。 -Filename: src/main.rs +文件名: src/main.rs ```rust use std::thread; @@ -176,14 +172,13 @@ fn main() { } ``` -Listing 16-10: Sending multiple messages and pausing -between each one +示例 16-10: 发送多个消息，并在每次发送后暂停一段时间 这一次，在新建线程中有一个字符串 vector 希望发送到主线程。我们遍历他们，单独的发送每一个字符串并通过一个`Duration`值调用`thread::sleep`函数来暂停一秒。 在主线程中，不再显式的调用`recv`函数：而是将`rx`当作一个迭代器。对于每一个接收到的值，我们将其打印出来。当通道被关闭时，迭代器也将结束。 -当运行列表 16-10 中的代码时，将看到如下输出，每一行都会暂停一秒： +当运行示例 16-10 中的代码时，将看到如下输出，每一行都会暂停一秒： ``` Got: hi @@ -196,9 +191,9 @@ Got: thread ### 通过克隆发送者来创建多个生产者 -差不多在本部分的开头，我们提到了`mpsc`是 *multiple producer, single consumer* 的缩写。可以扩展列表 16-11 中的代码来创建都向同一接收者发送值的多个线程。这可以通过克隆通道的发送端在来做到，如列表 16-11 所示： +差不多在本部分的开头，我们提到了`mpsc`是 *multiple producer, single consumer* 的缩写。可以扩展示例 16-11 中的代码来创建都向同一接收者发送值的多个线程。这可以通过克隆通道的发送端在来做到，如示例 16-11 所示： -Filename: src/main.rs +文件名: src/main.rs ```rust # use std::thread; @@ -245,8 +240,7 @@ thread::spawn(move || { # } ``` -Listing 16-11: Sending multiple messages and pausing -between each one +示例 16-11: 发送多个消息，并在每次发送后暂停一段时间 这一次，在创建新线程之前，我们对通道的发送端调用了`clone`方法。这会给我们一个可以传递给第一个新建线程的发送端句柄。我们会将原始的通道发送端传递给第二个新建线程，这样每个线程将向通道的接收端发送不同的消息。 diff --git a/src/ch16-03-shared-state.md b/src/ch16-03-shared-state.md index 5ef8f80..653b463 100644 --- a/src/ch16-03-shared-state.md +++ b/src/ch16-03-shared-state.md @@ -28,9 +28,9 @@ ### `Mutex`的 API -让我们看看列表 16-12 中使用互斥器的例子，现在不涉及多线程： +让我们看看示例 16-12 中使用互斥器的例子，现在不涉及多线程： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::sync::Mutex; @@ -47,23 +47,22 @@ fn main() { } ``` -Listing 16-12: Exploring the API of `Mutex` in a -single threaded context for simplicity +示例 16-12: 为简单，在一个单线程中探索 `Mutex` 的 API -像很多类型一样，我们使用关联函数 `new` 来创建一个 `Mutex`。使用`lock`方法获取锁，以访问互斥器中的数据。这个调用会阻塞，直到我们拥有锁为止。如果另一个线程拥有锁，并且那个线程 panic 了，则这个调用会失败。类似于列表 16-6 那样，我们暂时使用 `unwrap()` 进行错误处理，或者使用第九章中提及的更好的工具。 +像很多类型一样，我们使用关联函数 `new` 来创建一个 `Mutex`。使用`lock`方法获取锁，以访问互斥器中的数据。这个调用会阻塞，直到我们拥有锁为止。如果另一个线程拥有锁，并且那个线程 panic 了，则这个调用会失败。类似于示例 16-6 那样，我们暂时使用 `unwrap()` 进行错误处理，或者使用第九章中提及的更好的工具。 一旦获取了锁，就可以将返回值（在这里是`num`）作为一个数据的可变引用使用了。观察 Rust 类型系统如何保证使用值之前必须获取锁：`Mutex`并不是一个`i32`，所以**必须**获取锁才能使用这个`i32`值。我们是不会忘记这么做的，因为类型系统不允许。 -你也许会怀疑，`Mutex`是一个智能指针？是的！更准确的说，`lock`调用返回一个叫做`MutexGuard`的智能指针。类似我们在第十五章见过的智能指针，它实现了`Deref`来指向其内部数据。另外`MutexGuard`有一个用来释放锁的`Drop`实现。这样就不会忘记释放锁了。这在`MutexGuard`离开作用域时会自动发生，例如它发生于列表 16-12 中内部作用域的结尾。接着可以打印出互斥器的值并发现能够将其内部的`i32`改为 6。 +你也许会怀疑，`Mutex`是一个智能指针？是的！更准确的说，`lock`调用返回一个叫做`MutexGuard`的智能指针。类似我们在第十五章见过的智能指针，它实现了`Deref`来指向其内部数据。另外`MutexGuard`有一个用来释放锁的`Drop`实现。这样就不会忘记释放锁了。这在`MutexGuard`离开作用域时会自动发生，例如它发生于示例 16-12 中内部作用域的结尾。接着可以打印出互斥器的值并发现能够将其内部的`i32`改为 6。 #### 在线程间共享`Mutex` 现在让我们尝试使用`Mutex`在多个线程间共享值。我们将启动十个线程，并在各个线程中对同一个计数器值加一，这样计数器将从 0 变为 10。注意，接下来的几个例子会出现编译错误，而我们将通过这些错误来学习如何使用 -`Mutex`，以及 Rust 又是如何辅助我们以确保正确。列表 16-13 是最开始的例子： +`Mutex`，以及 Rust 又是如何辅助我们以确保正确。示例 16-13 是最开始的例子： -Filename: src/main.rs +文件名: src/main.rs ```rust,ignore use std::sync::Mutex; @@ -90,12 +89,11 @@ fn main() { } ``` -Listing 16-13: The start of a program having 10 threads -each increment a counter guarded by a `Mutex` +示例 16-13: 程序启动了 10 个线程，每个线程都通过 `Mutex` 来增加计数器的值 -这里创建了一个 `counter` 变量来存放内含 `i32` 的 `Mutex`，类似列表 16-12 那样。接下来使用 range 创建了 10 个线程。使用了 `thread::spawn` 并对所有线程使用了相同的闭包：他们每一个都将调用 `lock` 方法来获取 `Mutex` 上的锁，接着将互斥器中的值加一。当一个线程结束执行，`num` 会离开闭包作用域并释放锁，这样另一个线程就可以获取它了。 +这里创建了一个 `counter` 变量来存放内含 `i32` 的 `Mutex`，类似示例 16-12 那样。接下来使用 range 创建了 10 个线程。使用了 `thread::spawn` 并对所有线程使用了相同的闭包：他们每一个都将调用 `lock` 方法来获取 `Mutex` 上的锁，接着将互斥器中的值加一。当一个线程结束执行，`num` 会离开闭包作用域并释放锁，这样另一个线程就可以获取它了。 -在主线程中，我们像列表 16-2 那样收集了所有的 join 句柄，调用它们的 `join` 方法来确保所有线程都会结束。之后，主线程会获取锁并打印出程序的结果。 +在主线程中，我们像示例 16-2 那样收集了所有的 join 句柄，调用它们的 `join` 方法来确保所有线程都会结束。之后，主线程会获取锁并打印出程序的结果。 之前提示过这个例子不能编译，让我们看看为什么！ @@ -114,7 +112,7 @@ referenced variables), use the `move` keyword, as shown: | let handle = thread::spawn(move || { ``` -这类似于列表 16-5 中解决了的问题。考虑到启动了多个线程，Rust 无法知道这些线程会运行多久，而在每一个线程尝试借用 `counter` 时它是否仍然有效。帮助信息提醒了我们如何解决它：可以使用 `move` 来给予每个线程其所有权。尝试在闭包上做一点改动： +这类似于示例 16-5 中解决了的问题。考虑到启动了多个线程，Rust 无法知道这些线程会运行多久，而在每一个线程尝试借用 `counter` 时它是否仍然有效。帮助信息提醒了我们如何解决它：可以使用 `move` 来给予每个线程其所有权。尝试在闭包上做一点改动： ```rust,ignore thread::spawn(move || { @@ -149,9 +147,9 @@ error[E0382]: use of moved value: `counter` error: aborting due to 2 previous errors ``` -`move` 并没有像列表 16-5 中那样解决问题。为什么呢？错误信息有点难懂，因为它表明 `counter` 被移动进了闭包，接着它在调用 `lock` 时被捕获。这似乎是我们希望的，然而不被允许。 +`move` 并没有像示例 16-5 中那样解决问题。为什么呢？错误信息有点难懂，因为它表明 `counter` 被移动进了闭包，接着它在调用 `lock` 时被捕获。这似乎是我们希望的，然而不被允许。 -让我们推理一下。这次不再使用 `for` 循环创建 10 个线程，只创建两个线程，看看会发生什么。将列表 16-13 中第一个`for`循环替换为如下代码： +让我们推理一下。这次不再使用 `for` 循环创建 10 个线程，只创建两个线程，看看会发生什么。将示例 16-13 中第一个`for`循环替换为如下代码： ```rust,ignore let handle = thread::spawn(move || { @@ -203,9 +201,9 @@ error: aborting due to 2 previous errors #### 多线程和多所有权 -在第十五章中，我们通过使用智能指针 `Rc` 来创建引用计数的值，以便拥有多所有权。同时第十五章提到了 `Rc` 只能在单线程环境中使用，不过还是在这里试用 `Rc` 看看会发生什么。列表 16-14 将 `Mutex` 装进了 `Rc` 中，并在移入线程之前克隆了 `Rc`。再用循环来创建线程，保留闭包中的 `move` 关键字： +在第十五章中，我们通过使用智能指针 `Rc` 来创建引用计数的值，以便拥有多所有权。同时第十五章提到了 `Rc` 只能在单线程环境中使用，不过还是在这里试用 `Rc` 看看会发生什么。示例 16-14 将 `Mutex` 装进了 `Rc` 中，并在移入线程之前克隆了 `Rc`。再用循环来创建线程，保留闭包中的 `move` 关键字： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::rc::Rc; @@ -234,8 +232,7 @@ fn main() { } ``` -Listing 16-14: Attempting to use `Rc` to allow -multiple threads to own the `Mutex` +示例 16-14: 尝试使用 `Rc` 来允许多个线程拥有 `Mutex` 再一次编译并...出现了不同的错误！编译器真是教会了我们很多！ @@ -266,9 +263,9 @@ std::marker::Send` is not satisfied 为什么不是所有的原始类型都是原子性的？为什么不是所有标准库中的类型都默认使用`Arc`实现？线程安全带来性能惩罚，我们希望只在必要时才为此买单。如果只是在单线程中对值进行操作，原子性提供的保证并无必要，代码可以因此运行的更快。 -回到之前的例子：`Arc`和`Rc`除了`Arc`内部的原子性之外没有区别。其 API 也相同，所以可以修改`use`行和`new`调用。列表 16-15 中的代码最终可以编译和运行： +回到之前的例子：`Arc`和`Rc`除了`Arc`内部的原子性之外没有区别。其 API 也相同，所以可以修改`use`行和`new`调用。示例 16-15 中的代码最终可以编译和运行： -Filename: src/main.rs +文件名: src/main.rs ```rust use std::sync::{Mutex, Arc}; @@ -296,8 +293,7 @@ fn main() { } ``` -Listing 16-15: Using an `Arc` to wrap the `Mutex` -to be able to share ownership across multiple threads +示例 16-15: 使用 `Arc` 包装一个 `Mutex` 能够实现在多线程之间共享所有权 这会打印出： From 987461504dbde9941dfccc2b7458dc63046dddab Mon Sep 17 00:00:00 2001 From: dean Date: Wed, 17 Jan 2018 17:13:36 +0800 Subject: [PATCH 113/150] Translate some english sentences that have missed the translation. --- src/ch16-01-threads.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch16-01-threads.md b/src/ch16-01-threads.md index 58ebd88..0381ab8 100644 --- a/src/ch16-01-threads.md +++ b/src/ch16-01-threads.md @@ -174,7 +174,7 @@ fn main() { } ``` -示例 16-3: 在主线程中创建一个 vector，尝试在其它线程中使用它/span> +示例 16-3: 在主线程中创建一个 vector，尝试在其它线程中使用它 闭包使用了`v`，所以闭包会获取`v`并使其成为闭包环境的一部分。因为`thread::spawn`在一个新线程中运行这个闭包，所以可以在新线程中访问`v`。 From 9ea8e93c753ef79b44739d60d19afc23edce4d74 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Wed, 17 Jan 2018 17:53:04 +0800 Subject: [PATCH 114/150] check to ch06-01 --- src/ch05-00-structs.md | 4 +- src/ch05-01-defining-structs.md | 44 +++++++++++------- src/ch05-02-example-structs.md | 82 ++++++++++++++++----------------- src/ch05-03-method-syntax.md | 52 +++++++++++---------- src/ch06-00-enums.md | 2 +- src/ch06-01-defining-an-enum.md | 28 +++++------ 6 files changed, 112 insertions(+), 100 deletions(-) diff --git a/src/ch05-00-structs.md b/src/ch05-00-structs.md index 7f045e0..6e646a7 100644 --- a/src/ch05-00-structs.md +++ b/src/ch05-00-structs.md @@ -2,6 +2,6 @@ > [ch05-00-structs.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch05-00-structs.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 55f6c5808a816f2bab0f0a5ad20226c637348c40 -`struct`，是 *structure* 的缩写，是一个允许我们命名并将多个相关值包装进一个有意义的组合的自定义类型。如果你来自一个面向对象编程语言背景，`struct` 就像对象中的数据属性（字段）。在本章中，我们会比较元组与结构体，展示如何使用结构体，并讨论如何在结构体上定义方法和关联函数来指定与结构体数据相关的行为。结构体和 **枚举**（*enum*）（将在第六章讲到）是为了充分利用 Rust 的编译时类型检查来在程序范围内创建新类型的基本组件。 +`struct`，或者 *structure*，是一个允许我们命名并将多个相关值包装进一个有意义的组合的自定义类型。如果你来自一个面向对象编程语言背景，`struct` 就像对象中的数据属性（字段组合）。在本章中，我们会对比元组与结构体的异同，展示如何使用结构体，并讨论如何在结构体上定义方法和关联函数来指定与结构体数据相关的行为。结构体和 **枚举**（*enum*）（将在第六章讲到）是为了充分利用 Rust 的编译时类型检查来在程序范围内创建新类型的基本组件。 diff --git a/src/ch05-01-defining-structs.md b/src/ch05-01-defining-structs.md index d3c56e9..cbe2bfa 100644 --- a/src/ch05-01-defining-structs.md +++ b/src/ch05-01-defining-structs.md @@ -2,7 +2,7 @@ > [ch05-01-defining-structs.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch05-01-defining-structs.md) >
-> commit 56352c28cf3fe0402fa5a7cba73890e314d720eb +> commit e143d8fca3f914811b1388755ff4d325e9d20cc2 我们在第三章讨论过，结构体与元组类似。就像元组，结构体的每一部分可以是不同类型。不同于元组，结构体需要命名各部分数据以便能清楚的表明其值的意义。由于有了这些名字使得结构体比元组更灵活：不需要依赖顺序来指定或访问实例中的值。 @@ -19,7 +19,7 @@ struct User { 示例 5-1：`User` 结构体定义 -一旦定义了结构体后为了使用它，通过为每个字段指定具体值来创建这个结构体的 **实例**。创建一个实例需要以结构体的名字开头，接着在大括号中使用 `key: value` 对的形式提供字段，其中 key 是字段的名字，value 是需要储存在字段中的数据值。实例中具体说明字段的顺序不需要和它们在结构体中声明的顺序一致。换句话说，结构体的定义就像一个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。例如，可以像示例 5-2 这样来声明一个特定的用户： +一旦定义了结构体后，为了使用它，通过为每个字段指定具体值来创建这个结构体的 **实例**。创建一个实例需要以结构体的名字开头，接着在大括号中使用 `key: value` 对的形式提供字段，其中 key 是字段的名字，value 是需要储存在字段中的数据值。实例中具体说明字段的顺序不需要和它们在结构体中声明的顺序一致。换句话说，结构体的定义就像一个类型的通用模板，而实例则会在这个模板中放入特定数据来创建这个类型的值。例如，可以像示例 5-2 这样来声明一个特定的用户： ```rust # struct User { @@ -39,7 +39,7 @@ let user1 = User { 示例 5-2：创建 `User` 结构体的实例 -为了从结构体中获取某个值，可以使用点号。如果我们只想要用户的邮箱地址，可以用 `user1.email`。要更改结构体中的值，如果结构体的实例是可变的，我们可以使用点号并对对应的字段赋值。示例 5-3 展示了如何改变一个可变的 `User` 实例 `email` 字段的值： +为了从结构体中获取某个特定的值，可以使用点号。如果我们只想要用户的邮箱地址，可以用 `user1.email`。要更改结构体中的值，如果结构体的实例是可变的，我们可以使用点号并为对应的字段赋值。示例 5-3 展示了如何改变一个可变的 `User` 实例 `email` 字段的值： ```rust # struct User { @@ -61,7 +61,9 @@ user1.email = String::from("anotheremail@example.com"); 示例 5-3：改变 `User` 结构体 `email` 字段的值 -与其他任何表达式一样，我们可以在函数体的最后一个表达式构造一个结构体，从函数隐式的返回一个结构体的新实例。表 5-4 显示了一个返回带有给定的 `email` 与 `username` 的 `User` 结构体的实例的 `build_user` 函数。`active` 字段的值为 `true`，并且 `sign_in_count` 的值为 `1`。 +注意整个实例必须是可变的；Rust 并不允许只将特定字段标记为可变。另外需要注意同其他任何表达式一样，我们可以在函数体的最后一个表达式构造一个结构体，从函数隐式的返回一个结构体的新实例。 + +示例 5-4 显示了一个返回带有给定的 `email` 与 `username` 的 `User` 结构体的实例的 `build_user` 函数。`active` 字段的值为 `true`，并且 `sign_in_count` 的值为 `1`。 ```rust # struct User { @@ -83,13 +85,13 @@ fn build_user(email: String, username: String) -> User { 示例 5-4：`build_user` 函数获取 email 和用户名并返回 `User` 实例 -不过，重复 `email` 字段与 `email` 变量的名字，同样的对于`username`，感觉有一点无趣。将函数参数起与结构体字段相同的名字是可以理解的，但是如果结构体有更多字段，重复它们是十分烦人的。幸运的是，这里有一个方便的语法！ +为函数参数起与结构体字段相同的名字是可以理解的，但是不得不重复 `email` 和 `username` 字段名称与变量有些冗余。如果结构体有更多字段，重复这些名称就显得更加烦人了。幸运的是，有一个方便的简写语法！ -### 变量与字段同名时的字段初始化语法 +### 变量与字段同名时的字段初始化简写语法 -如果有变量与字段同名的话，你可以使用 **字段初始化语法**（*field init shorthand*）。这可以让创建新的结构体实例的函数更为简练。 +因为示例 5-4 中的参数名与字段名都完全相同，我们可以使用 **字段初始化简写语法**（*field init shorthand*）来重写 `build_user`，这样其行为与之前完全相同，不过无需重复 `email` 和 `username` 了，如示例 5-5 所示。 -在示例 5-4 中，名为 `email` 与 `username` 的参数与结构体 `User` 的字段 `email` 和 `username` 同名。因为名字相同，我们可以写出不重复 `email` 和 `username` 的 `build_user` 函数，如示例 5-5 所示。 这个版本的函数与示例 5-4 中代码的行为完全相同。这个字段初始化语法可以让这类代码更简洁，特别是当结构体有很多字段的时候。 +如果有变量与字段同名的话，你可以使用 **字段初始化简写语法**（*field init shorthand*）。这可以让创建新的结构体实例的函数更为简练。 ```rust # struct User { @@ -109,11 +111,15 @@ fn build_user(email: String, username: String) -> User { } ``` -示例 5-5：`build_user` 函数使用了字段初始化语法，因为 `email` 和 `username` 参数与结构体字段同名 +示例 5-5：`build_user` 函数使用了字段初始化简写语法，因为 `email` 和 `username` 参数与结构体字段同名 + +这里我们创建了一个新的 `User` 结构体实例，它有一个叫做 `email` 的字段。我们想要将 `email` 字段的值设置为 `build_user` 函数 `email` 参数的值。因为 `email` 字段与 `email` 参数有着相同的名称，则只需编写 `email` 而不是 `email: email`。 ### 使用结构体更新语法从其他对象创建对象 -可以从老的对象创建新的对象常常是很有帮助的，即复用大部分老对象的值并只改变一部分。示例 5-6 展示了一个设置 `email` 与 `username` 的值但其余字段使用与示例 5-2 中 `user1` 实例相同的值以创建新的 `User` 实例 `user2` 的例子： +可以从老的对象创建新的对象常常是很有帮助的，即复用大部分老对象的值并只改变一部分值。这可以通过 **结构体更新语法**（*struct update syntax*）实现。 + +作为开始，示例 5-6 展示了如何不使用更新语法来在 `user2` 中创建一个新 `User` 实例。我们为 `email` 和 `username` 设置了新的值，其他值则使用了实例 5-2 中创建的 `user1` 中的同名值： ```rust # struct User { @@ -138,9 +144,9 @@ let user2 = User { }; ``` -示例 5-6：创建 `User` 新实例，`user2`，并将一些字段的值设置为 `user1` 同名字段的值 +示例 5-6：创建 `User` 新实例，其使用了一些来自 `user1` 的值 -**结构体更新语法**（*struct update syntax*）可以利用更少的代码获得与示例 5-6 相同的效果。结构体更新语法利用 `..` 以指定未显式设置的字段应有与给定实例对应字段相同的值。示例 5-7 中的代码同样地创建了有着不同的 `email` 与 `username` 值但 `active` 和 `sign_in_count` 字段与 `user1` 相同的实例 `user2`： +使用结构体更新语法，我们可以通过更少的代码来达到相同的效果，如示例 5-7 所示。`..` 语法指定了剩余未显式设置值的字段应有与给定实例对应字段相同的值。 ```rust # struct User { @@ -164,11 +170,15 @@ let user2 = User { }; ``` -示例 5-7：使用结构体更新语法为 `User` 实例设置新的 `email` 和 `username` 值，但使用 `user1` 变量中剩下字段的值 +示例 5-7：使用结构体更新语法为一个 `User` 实例设置新的 `email` 和 `username` 值，不过其余值来自 `user1` 变量中实例的字段 -### 使用没有命名字段的元组结构体创建不同的类型 +实例 5-7 中的代码也在 `user2` 中创建了一个新实例，其有不同的 `email` 和 `username` 值不过 `active` 和 `sign_in_count` 字段的值与 `user1` 相同。 -也可以定义与元组相像的结构体，称为 **元组结构体**（*tuple structs*），有着结构体名称提供的含义，但没有具体的字段名只有字段的类型。元组结构体的定义仍然以`struct` 关键字与结构体名称，接下来是元组的类型。如以下是命名为 `Color` 与`Point` 的元组结构体的定义与使用： +### 使用没有命名字段的元组结构体来创建不同的类型 + +也可以定义与元组（在第三章讨论过）类似的结构体，称为 **元组结构体**（*tuple structs*），有着结构体名称提供的含义，但没有具体的字段名，只有字段的类型。元组结构体在你希望命名整个元组并使其与其他（同样的）元组为不同类型时很有用，这时像常规结构体那样为每个字段命名就显得冗余和形式化了。 + +定义元组结构体以 `struct` 关键字和结构体名开头并后跟元组中的类型。例如，这里是两个分别叫做 `Color` 和 `Point` 元组结构体的定义和用例： ```rust struct Color(i32, i32, i32); @@ -178,7 +188,7 @@ let black = Color(0, 0, 0); let origin = Point(0, 0, 0); ``` -注意 `black` 和 `origin` 变量是不同的类型，因为它们是不同的元组结构体的实例。我们定义的每一个结构体有着自己的类型，即使结构体中的字段有相同的类型。在其他方面，元组结构体类似我们在第三章提到的元组。 +注意 `black` 和 `origin` 值是不同的类型，因为它们是不同的元组结构体的实例。我们定义的每一个结构体有其自己的类型，即使结构体中的字段有着相同的类型。例如，一个获取 `Color` 类型参数的函数不能接受 `Point` 作为参数，即便这两个类型都由三个 `i32` 值组成。在其他方面，元组结构体实例类似于元组：可以将其解构为单独的部分，也可以使用 `.` 后跟索引来访问单独的值，等等。 ### 没有任何字段的类单元结构体 @@ -186,7 +196,7 @@ let origin = Point(0, 0, 0); > ## 结构体数据的所有权 > -> 在示例 5-1 中的 `User` 结构体的定义中，我们使用了自身拥有所有权的 `String` 类型而不是 `&str` 字符串 slice 类型。这是一个有意而为之的选择，因为我们想要这个结构体拥有它所有的数据，为此只要整个结构体是有效的话其数据也应该是有效的。 +> 在示例 5-1 中的 `User` 结构体的定义中，我们使用了自身拥有所有权的 `String` 类型而不是 `&str` 字符串 slice 类型。这是一个有意而为之的选择，因为我们想要这个结构体拥有它所有的数据，为此只要整个结构体是有效的话其数据也是有效的。 > > 可以使结构体储存被其他对象拥有的数据的引用，不过这么做的话需要用上 **生命周期**（*lifetimes*），这是一个第十章会讨论的 Rust 功能。生命周期确保结构体引用的数据有效性跟结构体本身保持一致。如果你尝试在结构体中储存一个引用而不指定生命周期，比如这样： > diff --git a/src/ch05-02-example-structs.md b/src/ch05-02-example-structs.md index a577c93..5dcbb20 100644 --- a/src/ch05-02-example-structs.md +++ b/src/ch05-02-example-structs.md @@ -2,33 +2,33 @@ > [ch05-02-example-structs.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch05-02-example-structs.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 7bf137c1b8f176638c0a7fa136d2e6bdc1f6e7d3 为了理解何时会需要使用结构体，让我们编写一个计算长方形面积的程序。我们会从单独的变量开始，接着重构程序直到使用结构体替代他们为止。 -使用 Cargo 来创建一个叫做 *rectangles* 的新二进制程序，它会获取一个长方形以像素为单位的长度和宽度并计算它的面积。示例 5-2 中是项目的 *src/main.rs* 文件中为此实现的一个小程序： +使用 Cargo 来创建一个叫做 *rectangles* 的新二进制程序，它会获取一个长方形以像素为单位的宽度和高度并计算它的面积。示例 5-8 中是项目的 *src/main.rs* 文件中为此实现的一个小程序： 文件名: src/main.rs ```rust fn main() { - let length1 = 50; let width1 = 30; + let height1 = 50; println!( "The area of the rectangle is {} square pixels.", - area(length1, width1) + area(width1, height1) ); } -fn area(length: u32, width: u32) -> u32 { - length * width +fn area(width: u32, height: u32) -> u32 { + width * height } ``` -示例 5-8：通过指定长方形的长宽变量来计算长方形面积 +示例 5-8：通过分别指定长方形的宽高变量来计算长方形面积 -尝试使用 `cargo run` 运行程序： +现在使用 `cargo run` 运行程序： ```text The area of the rectangle is 1500 square pixels. @@ -36,21 +36,21 @@ The area of the rectangle is 1500 square pixels. ### 使用元组重构 -虽然示例 5-8 可以运行，并调用 `area` 函数用长方形的每个维度来计算出面积，不过我们可以做的更好。长度和宽度是相关联的，因为他们在一起才能定义一个长方形。 +虽然示例 5-8 可以运行，并调用 `area` 函数用长方形的每个维度来计算出面积，不过我们可以做的更好。宽度和高度是相关联的，因为他们在一起才能定义一个长方形。 -这个做法的问题突显在 `area` 的签名上： +这些代码的问题突显在 `area` 的签名上： ```rust,ignore -fn area(length: u32, width: u32) -> u32 { +fn area(width: u32, height: u32) -> u32 { ``` -函数 `area` 本应该计算一个长方形的面积，不过函数却有两个参数。这两个参数是相关联的，不过程序自身却哪里也没有表现出这一点。将长度和宽度组合在一起将更易懂也更易处理。第三章的 “将值组合进元组” 部分已经讨论过了一种可行的方法：元组。示例 5-9 是另一个使用元组的版本： +函数 `area` 本应该计算一个长方形的面积，不过函数却有两个参数。这两个参数是相关联的，不过程序本身却哪里也没有表现出这一点。将长度和宽度组合在一起将更易懂也更易处理。第三章的 “将值组合进元组” 部分已经讨论过了一种可行的方法：元组。示例 5-9 是另一个使用元组的版本： 文件名: src/main.rs ```rust fn main() { - let rect1 = (50, 30); + let rect1 = (30, 50); println!( "The area of the rectangle is {} square pixels.", @@ -63,26 +63,26 @@ fn area(dimensions: (u32, u32)) -> u32 { } ``` -示例 5-8：使用元组来指定长方形的长宽 +示例 5-8：使用元组来指定长方形的宽高 -在某种程度上说这样好一点了。元组帮助我们增加了一些结构性，现在在调用 `area` 的时候只用传递一个参数。不过在另一方面这个方法却更不明确了：元组并没有给出它元素的名称，所以计算变得更费解了，因为不得不使用索引来获取元组的每一部分： +在某种程度上说这个程序更好一点了。元组帮助我们增加了一些结构性，现在在调用 `area` 的时候只需传递一个参数。不过在另一方面这个方法却更不明确了：元组并没有给出它元素的名称，所以计算变得更费解了，因为不得不使用索引来获取元组的每一部分： -在面积计算时混淆长宽并没有什么问题，不过当在屏幕上绘制长方形时就有问题了！我们将不得不记住元组索引 `0` 是 `length` 而 `1` 是 `width`。如果其他人要使用这些代码，他们也不得不搞清楚并记住他们。容易忘记或者混淆这些值而造成错误，因为我们没有表明代码中数据的意义。 +在面积计算时混淆宽高并没有什么问题，不过当在屏幕上绘制长方形时就有问题了！我们将不得不记住元组索引 `0` 是 `length` 而 `1` 是 `width`。如果其他人要使用这些代码，他们也不得不搞清楚并记住他们。容易忘记或者混淆这些值而造成错误，因为我们没有表明代码中数据的意义。 -### 使用结构体重构：增加更多意义 +### 使用结构体重构：赋予更多意义 -现在是引入结构体的时候了。我们可以将元组转换为一个有整体名称而且每个部分也有对应名字的数据类型，如示例 5-10 所示： +我们使用结构体为数据命令来为其赋予意义。我们可以将元组转换为一个有整体名称而且每个部分也有对应名字的数据类型，如示例 5-10 所示： 文件名: src/main.rs ```rust struct Rectangle { - length: u32, width: u32, + height: u32, } fn main() { - let rect1 = Rectangle { length: 50, width: 30 }; + let rect1 = Rectangle { width: 30, height: 50 }; println!( "The area of the rectangle is {} square pixels.", @@ -91,32 +91,32 @@ fn main() { } fn area(rectangle: &Rectangle) -> u32 { - rectangle.length * rectangle.width + rectangle.width * rectangle.height } ``` 示例 5-10：定义 `Rectangle` 结构体 -这里我们定义了一个结构体并称其为 `Rectangle`。在 `{}` 中定义了字段 `length` 和 `width`，都是 `u32` 类型的。接着在 `main` 中，我们创建了一个长度为 50 和宽度为 30 的 `Rectangle` 的具体实例。 +这里我们定义了一个结构体并称其为 `Rectangle`。在 `{}` 中定义了字段 `length` 和 `width`，都是 `u32` 类型的。接着在 `main` 中，我们创建了一个宽度为 30 和高度为 50 的 `Rectangle` 的具体实例。 -函数 `area` 现在被定义为接收一个名叫 `rectangle` 的参数，它的类型是一个结构体 `Rectangle` 实例的不可变借用。第四章讲到过，我们希望借用结构体而不是获取它的所有权这样 `main` 函数就可以保持 `rect1` 的所有权并继续使用它，所以这就是为什么在函数签名和调用的地方会有 `&`。 +函数 `area` 现在被定义为接收一个名叫 `rectangle` 的参数，其类型是一个结构体 `Rectangle` 实例的不可变借用。第四章讲到过，我们希望借用结构体而不是获取它的所有权这样 `main` 函数就可以保持 `rect1` 的所有权并继续使用它，所以这就是为什么在函数签名和调用的地方会有 `&`。 -`area` 函数访问 `Rectangle` 的 `length` 和 `width` 字段。`area` 的签名现在明确的表明了我们的意图：通过其 `length` 和 `width` 字段，计算一个 `Rectangle` 的面积。这表明了长度和宽度是相互联系的，并为这些值提供了描述性的名称而不是使用元组的索引值 `0` 和 `1` 。结构体胜在更清晰明了。 +`area` 函数访问 `Rectangle` 的 `length` 和 `width` 字段。`area` 的签名现在明确的表明了我们的意图：通过其 `length` 和 `width` 字段，计算一个 `Rectangle` 的面积。这表明了宽高是相互联系的，并为这些值提供了描述性的名称而不是使用元组的索引值 `0` 和 `1` 。结构体胜在更清晰明了。 -### 通过衍生 trait 增加实用功能 +### 通过派生 trait 增加实用功能 -如果能够在调试程序时打印出 `Rectangle` 实例来查看其所有字段的值就更好了。示例 5-11 像往常一样使用 `println!` 宏： +如果能够在调试程序时打印出 `Rectangle` 实例来查看其所有字段的值就更好了。示例 5-11 像第二章、第三章和第四章那样尝试了 `println!` 宏： 文件名: src/main.rs ```rust,ignore struct Rectangle { - length: u32, width: u32, + height: u32, } fn main() { - let rect1 = Rectangle { length: 50, width: 30 }; + let rect1 = Rectangle { width: 30, height: 50 }; println!("rect1 is {}", rect1); } @@ -130,12 +130,12 @@ fn main() { error[E0277]: the trait bound `Rectangle: std::fmt::Display` is not satisfied ``` -`println!` 宏能处理很多类型的格式，不过，`{}`，默认告诉 `println!` 使用被称为 `Display` 的格式：直接提供给终端用户查看的输出。目前为止见过的基本类型都默认实现了 `Display`，因为它就是向用户展示 `1` 或其他任何基本类型的唯一方式。不过对于结构体，`println!` 应该用来输出的格式是不明确的，因为这有更多显示的可能性：是否需要逗号？需要打印出结构体的 `{}` 吗？所有字段都应该显示吗？因为这种不确定性，Rust 不尝试猜测我们的意图所以结构体并没有提供一个 `Display` 实现。 +`println!` 宏能处理很多类型的格式，不过，`{}` 默认告诉 `println!` 使用被称为 `Display` 的格式：意在提供给直接终端用户查看的输出。目前为止见过的基本类型都默认实现了 `Display`，因为它就是向用户展示 `1` 或其他任何基本类型的唯一方式。不过对于结构体，`println!` 应该用来输出的格式是不明确的，因为这有更多显示的可能性：是否需要逗号？需要打印出大括号吗？所有字段都应该显示吗？由于这种不确定性，Rust 不尝试猜测我们的意图所以结构体并没有提供一个 `Display` 实现。 但是如果我们继续阅读错误，将会发现这个有帮助的信息： ```text -note: `Rectangle` cannot be formatted with the default formatter; try using +`Rectangle` cannot be formatted with the default formatter; try using `:?` instead if you are using a format string ``` @@ -144,13 +144,13 @@ note: `Rectangle` cannot be formatted with the default formatter; try using 让我们试试运行这个变化。见鬼了！仍然能看到一个错误： ```text -error: the trait bound `Rectangle: std::fmt::Debug` is not satisfied +error[E0277]: the trait bound `Rectangle: std::fmt::Debug` is not satisfied ``` 不过编译器又一次给出了一个有帮助的信息！ ```text -note: `Rectangle` cannot be formatted using `:?`; if it is defined in your +`Rectangle` cannot be formatted using `:?`; if it is defined in your crate, add `#[derive(Debug)]` or manually implement it ``` @@ -161,34 +161,34 @@ Rust **确实** 包含了打印出调试信息的功能，不过我们必须为 ```rust #[derive(Debug)] struct Rectangle { - length: u32, width: u32, + height: u32, } fn main() { - let rect1 = Rectangle { length: 50, width: 30 }; + let rect1 = Rectangle { width: 30, height: 50 }; println!("rect1 is {:?}", rect1); } ``` -示例 5-12：增加注解来导出 `Debug` trait +示例 5-12：增加注解来派生 `Debug` trait，并使用调试格式打印 `Rectangle` 实例 -现在我们再运行这个程序时，不会有任何错误并会出现如下输出： +现在我们再运行这个程序时，就不会有任何错误并会出现如下输出了： ```text -rect1 is Rectangle { length: 50, width: 30 } +rect1 is Rectangle { width: 30, height: 50 } ``` -好极了！这并不是最漂亮的输出，不过它显示这个实例的所有字段，毫无疑问这对调试有帮助。如果想要输出再好看和易读一点，可以将 `println!` 的字符串中的 `{:?}` 替换为 `{:#?} `，这对更大的结构体会有帮助。如果在这个例子中使用了 `{:#?}` 风格的话，输出会看起来像这样： +好极了！这并不是最漂亮的输出，不过它显示这个实例的所有字段，毫无疑问这对调试有帮助。当我们有一个更大的结构体时，能有更易读一点的输出就好了，为此可以使用 `{:#?}` 替换 `println!` 字符串中的 `{:?}`。如果在这个例子中使用了 `{:#?}` 风格的话，输出会看起来像这样： ```text rect1 is Rectangle { - length: 50, - width: 30 + width: 30, + height: 50 } ``` Rust 为我们提供了很多可以通过 `derive` 注解来使用的 trait，他们可以为我们的自定义类型增加实用的行为。这些 trait 和行为在附录 C 中列出。第十章会涉及到如何通过自定义行为来实现这些 trait，同时还有如何创建你自己的 trait。 -我们的 `area` 函数是非常特化的，它只是计算了长方形的面积。如果这个行为与 `Rectangle` 结构体再结合得更紧密一些就更好了，因为它不能用于其他类型。现在让我们看看如何继续重构这些代码，来将 `area` 函数协调进 `Rectangle` 类型定义的`area` **方法** 中。 +我们的 `area` 函数是非常特化的，它只是计算了长方形的面积。如果这个行为与 `Rectangle` 结构体再结合得更紧密一些就更好了，因为它不能用于其他类型。现在让我们看看如何继续重构这些代码，来将 `area` 函数协调进 `Rectangle` 类型定义的 `area` **方法** 中。 diff --git a/src/ch05-03-method-syntax.md b/src/ch05-03-method-syntax.md index 116f5fe..a8d5d08 100644 --- a/src/ch05-03-method-syntax.md +++ b/src/ch05-03-method-syntax.md @@ -2,9 +2,9 @@ > [ch05-03-method-syntax.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch05-03-method-syntax.md) >
-> commit 44bf3afd93519f8b0f900f21a5f2344d36e13448 +> commit ec65990849230388e4ce4db5b7a0cb8a0f0d60e2 -**方法** 与函数类似：它们使用 `fn` 关键字和名字声明，可以拥有参数和返回值，同时包含一段该方法在某处被调用时会执行的代码。不过方法与函数是不同的，因为它们在结构体的上下文中被定义（或者是枚举或 trait 对象的上下文，将分别在第六章和第十七章讲解），并且它们第一个参数总是 `self`，它代表调用该方法的结构体实例。 +**方法** 与函数类似：它们使用 `fn` 关键字和名称声明，可以拥有参数和返回值，同时包含一段该方法在某处被调用时会执行的代码。不过方法与函数是不同的，因为它们在结构体的上下文中被定义（或者是枚举或 trait 对象的上下文，将分别在第六章和第十七章讲解），并且它们第一个参数总是 `self`，它代表调用该方法的结构体实例。 ### 定义方法 @@ -15,18 +15,18 @@ ```rust #[derive(Debug)] struct Rectangle { - length: u32, width: u32, + height: u32, } impl Rectangle { fn area(&self) -> u32 { - self.length * self.width + self.width * self.height } } fn main() { - let rect1 = Rectangle { length: 50, width: 30 }; + let rect1 = Rectangle { width: 30, height: 50 }; println!( "The area of the rectangle is {} square pixels.", @@ -41,9 +41,9 @@ fn main() { 在 `area` 的签名中，开始使用 `&self` 来替代 `rectangle: &Rectangle`，因为该方法位于 `impl Rectangle` 上下文中所以 Rust 知道 `self` 的类型是 `Rectangle`。注意仍然需要在 `self` 前面加上 `&`，就像 `&Rectangle` 一样。方法可以选择获取 `self` 的所有权，或者像我们这里一样不可变地借用 `self`，或者可变地借用 `self`，就跟其他别的参数一样。 -这里选择 `&self` 跟在函数版本中使用 `&Rectangle` 出于同样的理由：我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入。如果想要在方法中改变调用方法的实例，需要将第一个参数改为 `&mut self`。很少见到通过仅仅使用 `self` 作为第一个参数来使方法获取实例的所有权；这种技术通常用在当方法将 `self` 转换成别的实例的时候，这时我们想要防止调用者在转换之后使用原始的实例。 +这里选择 `&self` 跟在函数版本中使用 `&Rectangle` 出于同样的理由：我们并不想获取所有权，只希望能够读取结构体中的数据，而不是写入。如果想要在方法中改变调用方法的实例，需要将第一个参数改为 `&mut self`。通过仅仅使用 `self` 作为第一个参数来使方法获取实例的所有权是很少见的；这种技术通常用在当方法将 `self` 转换成别的实例的时候，这时我们想要防止调用者在转换之后使用原始的实例。 -尽量使用方法替代函数，除了使用了方法语法和不需要在每个函数签名中重复 `self` 类型之外，其主要好处在于组织性。我们将某个类型实例能做的所有事情都一起放入 `impl` 块中，而不是让将来的用户在我们的代码中到处寻找 `Rectangle` 的功能。 +使用方法替代函数，除了使用了方法语法和不需要在每个函数签名中重复 `self` 类型之外，其主要好处在于组织性。我们将某个类型实例能做的所有事情都一起放入 `impl` 块中，而不是让将来的用户在我们的库中到处寻找 `Rectangle` 的功能。 > ### `->`运算符到哪去了？ > @@ -51,7 +51,7 @@ fn main() { > > Rust 并没有一个与 `->` 等效的运算符；相反，Rust 有一个叫 **自动引用和解引用**（*automatic referencing and dereferencing*）的功能。方法调用是 Rust 中少数几个拥有这种行为的地方。 > -> 这是它如何工作的：当使用 `object.something()` 调用方法时，Rust 会自动增加 `&`、`&mut` 或 `*` 以便使 `object` 符合方法的签名。也就是说，这些代码是等同的： +> 这是它如何工作的：当使用 `object.something()` 调用方法时，Rust 会自动增加 `&`、`&mut` 或 `*` 以便使 `object` 符合方法的签名。也就是说，这些代码是等价的： > > ```rust > # #[derive(Debug,Copy,Clone)] @@ -74,7 +74,7 @@ fn main() { > (&p1).distance(&p2); > ``` > -> 第一行看起来简洁的多。这种自动解引用的行为之所以能行得通是因为方法有一个明确的接收者————`self` 类型。在给出接收者和方法名的前提下，Rust 可以明确地计算出方法是仅仅读取（`&self`），做出修改（`&mut self`）或者是获取所有权（`self`）。Rust 这种使得借用对方法接收者来说是隐式的做法是其所有权系统程序员友好性实践的一大部分。 +> 第一行看起来简洁的多。这种自动解引用的行为之所以能行得通是因为方法有一个明确的接收者———— `self` 类型。在给出接收者和方法名的前提下，Rust 可以明确地计算出方法是仅仅读取（`&self`），做出修改（`&mut self`）或者是获取所有权（`self`）。Rust 这种使得借用对方法接收者来说是隐式的做法是其所有权系统程序员友好性实践的一大部分。 ### 带有更多参数的方法 @@ -84,9 +84,9 @@ fn main() { ```rust,ignore fn main() { - let rect1 = Rectangle { length: 50, width: 30 }; - let rect2 = Rectangle { length: 40, width: 10 }; - let rect3 = Rectangle { length: 45, width: 60 }; + let rect1 = Rectangle { width: 30, height: 50 }; + let rect2 = Rectangle { width: 10, height: 40 }; + let rect3 = Rectangle { width: 60, height: 45 }; println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2)); println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3)); @@ -95,31 +95,31 @@ fn main() { 示例 5-14：展示还未实现的 `can_hold` 方法的应用 -我们希望看到如下输出，因为 `rect2` 的长宽都小于 `rect1`，而 `rect3` 比 `rect1` 要宽： +同时我们希望看到如下输出，因为 `rect2` 的宽高都小于 `rect1`，而 `rect3` 比 `rect1` 要宽： ```text Can rect1 hold rect2? true Can rect1 hold rect3? false ``` -因为我们想定义一个方法，所以它应该位于 `impl Rectangle` 块中。方法名是 `can_hold`，并且它会获取另一个 `Rectangle` 的不可变借用作为参数。通过观察调用位置的代码可以看出参数是什么类型的：`rect1.can_hold(&rect2)` 传入了 `&rect2`，它是一个 `Rectangle` 的实例 `rect2` 的不可变借用。这是可以理解的，因为我们只需要读取 `rect2`（而不是写入，这意味着我们需要一个可变借用）而且希望 `main` 保持 `rect2` 的所有权这样就可以在调用这个方法后继续使用它。`can_hold` 的返回值是一个布尔值，其实现会分别检查 `self` 的长宽是否都大于另一个 `Rectangle`。让我们在示例 5-13 的 `impl` 块中增加这个新方法，如示例 5-15 所示： +因为我们想定义一个方法，所以它应该位于 `impl Rectangle` 块中。方法名是 `can_hold`，并且它会获取另一个 `Rectangle` 的不可变借用作为参数。通过观察调用位置的代码可以看出参数是什么类型的：`rect1.can_hold(&rect2)` 传入了 `&rect2`，它是一个 `Rectangle` 的实例 `rect2` 的不可变借用。这是可以理解的，因为我们只需要读取 `rect2`（而不是写入，这意味着我们需要一个可变借用）而且希望 `main` 保持 `rect2` 的所有权这样就可以在调用这个方法后继续使用它。`can_hold` 的返回值是一个布尔值，其实现会分别检查 `self` 的宽高是否都大于另一个 `Rectangle`。让我们在示例 5-13 的 `impl` 块中增加这个新方法，如示例 5-15 所示： 文件名: src/main.rs ```rust # #[derive(Debug)] # struct Rectangle { -# length: u32, # width: u32, +# height: u32, # } # impl Rectangle { fn area(&self) -> u32 { - self.length * self.width + self.width * self.height } fn can_hold(&self, other: &Rectangle) -> bool { - self.length > other.length && self.width > other.width + self.width > other.width && self.height > other.height } } ``` @@ -130,22 +130,22 @@ impl Rectangle { ### 关联函数 -`impl` 块的另一个有用的功能是：允许在 `impl` 块中定义 **不** 以 `self` 作为参数的函数。这被称为 **关联函数**（*associated functions*），因为它们与结构体相关联。即便如此它们仍是函数而不是方法，因为它们并不作用于一个结构体的实例。你已经使用过一个关联函数了：`String::from`。 +`impl` 块的另一个有用的功能是：允许在 `impl` 块中定义 **不** 以 `self` 作为参数的函数。这被称为 **关联函数**（*associated functions*），因为它们与结构体相关联。即便如此它们仍是函数而不是方法，因为它们并不作用于一个结构体的实例。我们已经使用过 `String::from` 关联函数了。 -关联函数经常被用作返回一个结构体新实例的构造函数。例如我们可以提供一个关联函数，它接受一个维度参数并且同时用来作为长和宽，这样可以更轻松的创建一个正方形 `Rectangle` 而不必指定两次同样的值： +关联函数经常被用作返回一个结构体新实例的构造函数。例如我们可以提供一个关联函数，它接受一个维度参数并且同时用来作为宽和高，这样可以更轻松的创建一个正方形 `Rectangle` 而不必指定两次同样的值： -Filename: src/main.rs +文件名: src/main.rs ```rust # #[derive(Debug)] # struct Rectangle { -# length: u32, # width: u32, +# height: u32, # } # impl Rectangle { fn square(size: u32) -> Rectangle { - Rectangle { length: size, width: size } + Rectangle { width: size, height: size } } } ``` @@ -159,25 +159,27 @@ impl Rectangle { ```rust # #[derive(Debug)] # struct Rectangle { -# length: u32, # width: u32, +# height: u32, # } # impl Rectangle { fn area(&self) -> u32 { - self.length * self.width + self.width * self.height } } impl Rectangle { fn can_hold(&self, other: &Rectangle) -> bool { - self.length > other.length && self.width > other.width + self.width > other.width && self.height > other.height } } ``` 示例 5-16：使用多个 `impl` 块重写示例 5-15 +没有理由将这些方法分散在多个 `impl` 块中，不过这是有效的语法。第十章讨论泛型和 trait 时会看到实用的多 `impl` 块的用例。 + ## 总结 结构体让我们可以在自己的范围内创建有意义的自定义类型。通过结构体，我们可以将相关联的数据片段联系起来并命名它们，这样可以使得代码更加清晰。方法允许为结构体实例指定行为，而关联函数将特定功能置于结构体的命名空间中并且无需一个实例。 diff --git a/src/ch06-00-enums.md b/src/ch06-00-enums.md index 9b34e78..ebf4b20 100644 --- a/src/ch06-00-enums.md +++ b/src/ch06-00-enums.md @@ -6,4 +6,4 @@ 本章介绍 **枚举**（*enumerations*），也被称作 *enums*。枚举允许你通过列举可能的值来定义一个类型。首先，我们会定义并使用一个枚举来展示它是如何连同数据一起编码信息的。接下来，我们会探索一个特别有用的枚举，叫做 `Option`，它代表一个值要么是某个值要么什么都不是。然后会讲到在 `match` 表达式中用模式匹配，针对不同的枚举值编写相应要执行的代码。最后会涉及到 `if let`，另一个简洁方便处理代码中枚举的结构。 -枚举是一个很多语言都有的功能，不过不同语言中的功能各不相同。Rust 的枚举与 F#、OCaml 和 Haskell 这样的函数式编程语言中的 **代数数据类型**（*algebraic data types*）最为相似。 +枚举是一个很多语言都有的功能，不过不同语言中其功能各不相同。Rust 的枚举与 F#、OCaml 和 Haskell 这样的函数式编程语言中的 **代数数据类型**（*algebraic data types*）最为相似。 diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index 182f2df..fa47618 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -2,11 +2,11 @@ > [ch06-01-defining-an-enum.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch06-01-defining-an-enum.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 5544b998ff426aca7d1eaf248a1d9340df5ab9e7 -让我们在一个实际场景中看看在这个特定场景下，使用枚举比使用结构体更合适。假设我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的所有可能的 IP 地址类型：所以可以 **枚举** 出所有可能的值，这也正是它名字的由来。 +让我们看看一个需要诉诸于代码的场景，来考虑为何此时使用枚举更为合适且实用。假设我们要处理 IP 地址。目前被广泛使用的两个主要 IP 标准：IPv4（version four）和 IPv6（version six）。这是我们的程序可能会遇到的所有可能的 IP 地址类型：所以可以 **枚举** 出所有可能的值，这也正是此枚举名字的由来。 -任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理申请任何类型的 IP 地址的场景时应该把它们当作相同的类型。 +任何一个 IP 地址要么是 IPv4 的要么是 IPv6 的，而且不能两者都是。IP 地址的这个特性使得枚举数据结构非常适合这个场景，因为枚举值只可能是其中一个成员。IPv4 和 IPv6 从根本上讲仍是 IP 地址，所以当代码在处理适用于任何类型的 IP 地址的场景时应该把它们当作相同的类型。 可以通过在代码中定义一个 `IpAddrKind` 枚举来表现这个概念并列出可能的 IP 地址类型，`V4` 和 `V6`。这被称为枚举的 **成员**（*variants*）： @@ -44,7 +44,7 @@ let six = IpAddrKind::V6; fn route(ip_type: IpAddrKind) { } ``` -现在可以使用任意成员来调用这个函数： +现在可以使用任一成员来调用这个函数： ```rust # enum IpAddrKind { @@ -58,7 +58,7 @@ route(IpAddrKind::V4); route(IpAddrKind::V6); ``` -使用枚举甚至还有更多优势。进一步考虑一下我们的 IP 地址类型，目前没有一个储存实际 IP 地址 **数据** 的方法；只知道它是什么 **类型** 的。考虑到已经在第五章学习过结构体了，你可能会像示例 6-1 那样修改这个问题： +使用枚举甚至还有更多优势。进一步考虑一下我们的 IP 地址类型，目前没有一个储存实际 IP 地址 **数据** 的方法；只知道它是什么 **类型** 的。考虑到已经在第五章学习过结构体了，你可能会像示例 6-1 那样处理这个问题： ```rust enum IpAddrKind { @@ -101,7 +101,7 @@ let loopback = IpAddr::V6(String::from("::1")); 我们直接将数据附加到枚举的每个成员上，这样就不需要一个额外的结构体了。 -用枚举替代结构体还有另一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将 `V4` 地址储存为四个 `u8` 值而 `V6` 地址仍然表现为一个 `String`，这就不能使用结构体了。枚举可以轻易处理的这个情况： +用枚举替代结构体还有另一个优势：每个成员可以处理不同类型和数量的数据。IPv4 版本的 IP 地址总是含有四个值在 0 和 255 之间的数字部分。如果我们想要将 `V4` 地址储存为四个 `u8` 值而 `V6` 地址仍然表现为一个 `String`，这就不能使用结构体了。枚举则可以轻易处理的这个情况： ```rust enum IpAddr { @@ -114,7 +114,7 @@ let home = IpAddr::V4(127, 0, 0, 1); let loopback = IpAddr::V6(String::from("::1")); ``` -这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了[以致标准库提供了一个可供使用的定义！][IpAddr]让我们看看标准库如何定义 `IpAddr` 的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，它们对不同的成员的定义是不同的： +这些代码展示了使用枚举来储存两种不同 IP 地址的几种可能的选择。然而，事实证明储存和编码 IP 地址实在是太常见了[以致标准库提供了一个开箱即用的定义！][IpAddr]让我们看看标准库是如何定义 `IpAddr` 的：它正有着跟我们定义和使用的一样的枚举和成员，不过它将成员中的地址数据嵌入到了两个不同形式的结构体中，它们对不同的成员的定义是不同的： [IpAddr]: https://doc.rust-lang.org/std/net/enum.IpAddr.html @@ -157,7 +157,7 @@ enum Message { * `Write` 包含单独一个 `String`。 * `ChangeColor` 包含三个 `i32`。 -定义一个像示例 6-2 中的枚举类似于定义不同类型的结构体，除了枚举不使用 `struct` 关键字而且所有成员都被组合在一起位于 `Message` 下之外。如下这些结构体可以包含与之前枚举成员中相同的数据： +定义一个像示例 6-2 中的枚举类似于定义不同类型的结构体，除了枚举不使用 `struct` 关键字并且所有成员都被组合在一起位于 `Message` 下之外。如下这些结构体可以包含与之前枚举成员中相同的数据： ```rust struct QuitMessage; // unit struct @@ -212,7 +212,7 @@ m.call(); > crashes, which have probably caused a billion dollars of pain and damage in > the last forty years. > -> 我称之为我十亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的使用都应该是绝对安全的。不过我未能抗拒引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数十亿美元的苦痛和伤害。 +> 我称之为我十亿美元的错误。当时，我在为一个面向对象语言设计第一个综合性的面向引用的类型系统。我的目标是通过编译器的自动检查来保证所有引用的使用都应该是绝对安全的。不过我未能抵抗住引入一个空引用的诱惑，仅仅是因为它是这么的容易实现。这引发了无数错误、漏洞和系统崩溃，在之后的四十多年中造成了数十亿美元的苦痛和伤害。 空值的问题在于当你尝试像一个非空值那样使用一个空值，会出现某种形式的错误。因为空和非空的属性是无处不在的，非常容易出现这类错误。 @@ -229,7 +229,7 @@ enum Option { } ``` -`Option` 是如此有用以至于它甚至被包含在了 prelude 之中，这意味着我们不需要显式导入它。另外，它的成员也是如此，可以不需要 `Option::` 前缀来直接使用 `Some` 和 `None`。即便如此 `Option` 也仍是常规的枚举，`Some(T)` 和 `None` 仍是 `Option` 的成员。 +`Option` 是如此有用以至于它甚至被包含在了 prelude 之中，这意味着我们不需要显式引入作用域。另外，它的成员也是如此，可以不需要 `Option::` 前缀来直接使用 `Some` 和 `None`。即便如此 `Option` 也仍是常规的枚举，`Some(T)` 和 `None` 仍是 `Option` 的成员。 `` 语法是一个我们还未讲到的 Rust 功能。它是一个泛型类型参数，第十章会更详细的讲解泛型。目前，所有你需要知道的就是 `` 意味着 `Option` 枚举的 `Some` 成员可以包含任意类型的数据。这里是一些包含数字类型和字符串类型 `Option` 值的例子： @@ -261,14 +261,14 @@ error[E0277]: the trait bound `i8: std::ops::Add>` is not satisfied --> | -7 | let sum = x + y; - | ^^^^^ +5 | let sum = x + y; + | ^ no implementation for `i8 + std::option::Option` | ``` 哇哦！事实上，错误信息意味着 Rust 不知道该如何将 `Option` 与 `i8` 相加。当在 Rust 中拥有一个像 `i8` 这样类型的值时，编译器确保它总是有一个有效的值。我们可以自信使用而无需判空。只有当使用 `Option`（或者任何用到的类型）的时候需要担心可能没有一个值，而编译器会确保我们在使用值之前处理为空的情况。 -换句话说，在对 `Option` 进行 `T` 的运算之前必须转换为 `T`。通常这能帮助我们捕获空值最常见的问题之一：假设某值不为空但实际上为空的情况。 +换句话说，在对 `Option` 进行 `T` 的运算之前必须将其转换为 `T`。通常这能帮助我们捕获空值最常见的问题之一：假设某值不为空但实际上为空的情况。 无需担心错过存在非空值的假设让我们对代码更加有信心，为了拥有一个可能为空的值，必须显式的将其放入对应类型的 `Option` 中。接着，当使用这个值时，必须明确的处理值为空的情况。任何地方一个值不是 `Option` 类型的话，**可以** 安全的假设它的值不为空。这是 Rust 的一个有意为之的设计选择，来限制空值的泛滥和增加 Rust 代码的安全性。 @@ -276,4 +276,4 @@ not satisfied [docs]: https://doc.rust-lang.org/std/option/enum.Option.html -总的来说，为了使用 `Option` 值，需要编写处理每个成员的代码。我们想要一些代码只当拥有 `Some(T)` 值时运行，这些代码允许使用其中的 `T`。也希望一些代码当在 `None` 值时运行，这些代码并没有一个可用的 `T` 值。`match` 表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。 +总的来说，为了使用 `Option` 值，需要编写处理每个成员的代码。我们想要一些代码只当拥有 `Some(T)` 值时运行，这些代码允许使用其中的 `T`。也希望一些代码在 `None` 值时运行，这些代码并没有一个可用的 `T` 值。`match` 表达式就是这么一个处理枚举的控制流结构：它会根据枚举的成员运行不同的代码，这些代码可以使用匹配到的值中的数据。 From cc083887a2be542e3189ac874695390d87537349 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Thu, 18 Jan 2018 15:39:53 +0800 Subject: [PATCH 115/150] check to ch08-02 --- src/ch06-02-match.md | 15 ++- src/ch06-03-if-let.md | 6 +- src/ch07-00-modules.md | 8 +- src/ch07-01-mod-and-the-filesystem.md | 62 ++++++------ ...ch07-02-controlling-visibility-with-pub.md | 96 +++++++++++-------- src/ch07-03-importing-names-with-use.md | 32 ++++--- src/ch08-00-common-collections.md | 6 +- src/ch08-01-vectors.md | 91 +++++++++++++----- src/ch08-02-strings.md | 4 +- 9 files changed, 192 insertions(+), 128 deletions(-) diff --git a/src/ch06-02-match.md b/src/ch06-02-match.md index ab0c714..a950e5c 100644 --- a/src/ch06-02-match.md +++ b/src/ch06-02-match.md @@ -2,11 +2,11 @@ > [ch06-02-match.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch06-02-match.md) >
-> commit 01dd4248621c2f510947592e47d16bdab9b14cf0 +> commit 18fd30d70f4d6ee67e0a808710bf7a3135ef7ed6 -Rust 有一个叫做 `match` 的极为强大的控制流运算符，它允许我们将一个值与一系列的模式相比较并根据匹配的模式执行相应代码。模式可由字面值、变量、通配符和许多其他内容构成；第十八章会涉及到所有不同种类的模式以及它们的作用。`match` 的力量来源于模式的表现力以及编译器检查，它确保了所有可能的情况都得到处理。 +Rust 有一个叫做 `match` 的极为强大的控制流运算符，它允许我们将一个值与一系列的模式相比较并根据相匹配的模式执行相应代码。模式可由字面值、变量、通配符和许多其他内容构成；第十八章会涉及到所有不同种类的模式以及它们的作用。`match` 的力量来源于模式的表现力以及编译器检查，它确保了所有可能的情况都得到处理。 -可以把 `match` 表达式想象成某种硬币分类器：硬币滑入有着不同大小孔洞的轨道，每一个硬币都会掉入符合它大小的孔洞。同样地，值也会检查 `match` 的每一个模式，并且在遇到第一个 “符合” 的模式时，值会进入相关联的代码块并在执行中被使用。 +可以把 `match` 表达式想象成某种硬币分类器：硬币滑入有着不同大小孔洞的轨道，每一个硬币都会掉入符合它大小的孔洞。同样地，值也会通过 `match` 的每一个模式，并且在遇到第一个 “符合” 的模式时，值会进入相关联的代码块并在执行中被使用。 因为刚刚提到了硬币，让我们用它们来作为一个使用 `match` 的例子！我们可以编写一个函数来获取一个未知的（美帝）硬币，并以一种类似验钞机的方式，确定它是何种硬币并返回它的美分值，如示例 6-3 中所示： @@ -36,7 +36,7 @@ fn value_in_cents(coin: Coin) -> u32 { 当 `match` 表达式执行时，它将结果值按顺序与每一个分支的模式相比较，如果模式匹配了这个值，这个模式相关联的代码将被执行。如果模式并不匹配这个值，将继续执行下一个分支，非常类似一个硬币分类器。可以拥有任意多的分支：示例 6-3 中的 `match` 有四个分支。 -每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 `match` 表达式的返回值。 +每个分支相关联的代码是一个表达式，而表达式的结果值将作为整个 `match` 表达式的返回值。 如果分支代码较短的话通常不使用大括号，正如示例 6-3 中的每个分支都只是返回一个值。如果想要在分支中运行多行代码，可以使用大括号。例如，如下代码在每次使用`Coin::Penny` 调用时都会打印出 “Lucky penny!”，同时仍然返回代码块最后的值，`1`： @@ -63,7 +63,7 @@ fn value_in_cents(coin: Coin) -> u32 { ### 绑定值的模式 -匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值。这也就是如何从枚举成员中提取值。 +匹配分支的另一个有用的功能是可以绑定匹配的模式的部分值。这也就是如何从枚举成员中提取值的。 作为一个例子，让我们修改枚举的一个成员来存放数据。1999 年到 2008 年间，美帝在 25 美分的硬币的一侧为 50 个州的每一个都印刷了不同的设计。其他的硬币都没有这种区分州的设计，所以只有这些 25 美分硬币有特殊的价值。可以将这些信息加入我们的 `enum`，通过改变 `Quarter` 成员来包含一个 `State` 值，示例 6-4 中完成了这些修改： @@ -85,7 +85,7 @@ enum Coin { 示例 6-4：`Quarter` 成员也存放了一个 `UsState` 值的 `Coin` 枚举 -想象一下我们的一个朋友尝试收集所有 50 个州的 25 美分硬币。在根据硬币类型分类零钱的同时，也可以报告出每个 25 美分硬币所对应的州名称，这样如果我们的朋友没有的话，他可以把它加入收藏。 +想象一下我们的一个朋友尝试收集所有 50 个州的 25 美分硬币。在根据硬币类型分类零钱的同时，也可以报告出每个 25 美分硬币所对应的州名称，这样如果我们的朋友没有的话，他可以将其加入收藏。 在这些代码的匹配表达式中，我们在匹配 `Coin::Quarter` 成员的分支的模式中增加了一个叫做 `state` 的变量。当匹配到 `Coin::Quarter` 时，变量 `state` 将会绑定 25 美分硬币所对应州的值。接着在那个分支的代码中使用 `state`，如下： @@ -155,7 +155,7 @@ None => None, Some(i) => Some(i + 1), ``` -`Some(5)` 与 `Some(i)` 匹配吗？为什么不呢！它们是相同的成员。`i` 绑定了 `Some` 中包含的值，所以 `i` 的值是 `5`。接着匹配分支的代码被执行，所以我们将 `i` 的值加一并返回一个含有值 `6` 的新 `Some`。 +`Some(5)` 与 `Some(i)` 匹配吗？当然匹配！它们是相同的成员。`i` 绑定了 `Some` 中包含的值，所以 `i` 的值是 `5`。接着匹配分支的代码被执行，所以我们将 `i` 的值加一并返回一个含有值 `6` 的新 `Some`。 #### 匹配 `None` @@ -191,7 +191,6 @@ error[E0004]: non-exhaustive patterns: `None` not covered | ^ pattern `None` not covered ``` - Rust 知道我们没有覆盖所有可能的情况甚至知道那些模式被忘记了！Rust 中的匹配是 **穷尽的**（*exhaustive*）：必须穷举到最后的可能性来使代码有效。特别的在这个 `Option` 的例子中，Rust 防止我们忘记明确的处理 `None` 的情况，这使我们免于假设拥有一个实际上为空的值，这造成了之前提到过的价值亿万的错误。 ### `_` 通配符 diff --git a/src/ch06-03-if-let.md b/src/ch06-03-if-let.md index 2df595e..ee60496 100644 --- a/src/ch06-03-if-let.md +++ b/src/ch06-03-if-let.md @@ -4,7 +4,7 @@ >
> commit 3f2a1bd8dbb19cc48b210fc4fb35c305c8d81b56 -`if let` 语法让我们以一种不那么冗长的方式结合 `if` 和 `let`，来处理匹配一个模式的值而忽略其他的值。考虑示例 6-6 中的程序，它匹配一个 `Option` 值并只希望当值为三时执行代码： +`if let` 语法让我们以一种不那么冗长的方式结合 `if` 和 `let`，来处理只匹配一个模式的值而忽略其他模式的情况。考虑示例 6-6 中的程序，它匹配一个 `Option` 值并只希望当值为三时执行代码： ```rust let some_u8_value = Some(0u8); @@ -16,7 +16,7 @@ match some_u8_value { 示例 6-6：`match` 只关心当值为 `Some(3)` 时执行代码 -我们想要对 `Some(3)` 匹配进行操作不过不想处理任何其他 `Some` 值或 `None` 值。为了满足 `match` 表达式（穷尽性）的要求，必须在处理完这唯一的成员后加上 `_ => ()`，这样也要增加很多样板代码。 +我们想要对 `Some(3)` 匹配进行操作但是不想处理任何其他 `Some` 值或 `None` 值。为了满足 `match` 表达式（穷尽性）的要求，必须在处理完这唯一的成员后加上 `_ => ()`，这样也要增加很多样板代码。 不过我们可以使用 `if let` 这种更短的方式编写。如下代码与示例 6-6 中的 `match` 行为一致： @@ -33,7 +33,7 @@ if let Some(3) = some_u8_value { 换句话说，可以认为 `if let` 是 `match` 的一个语法糖，它当值匹配某一模式时执行代码而忽略所有其他值。 -可以在 `if let` 中包含一个 `else`。`else` 块中的代码与 `match` 表达式中的 `_` 分支块中的代码相同，这样的 `match` 表达式就等同于 `if let` 和 `else`。回忆一下示例 6-4 中 `Coin` 枚举的定义，它的 `Quarter` 成员包含一个 `UsState` 值。如果想要计数所有不是 25 美分的硬币的同时也报告 25 美分硬币所属的州，可以使用这样一个 `match` 表达式： +可以在 `if let` 中包含一个 `else`。`else` 块中的代码与 `match` 表达式中的 `_` 分支块中的代码相同，这样的 `match` 表达式就等同于 `if let` 和 `else`。回忆一下示例 6-4 中 `Coin` 枚举的定义，其 `Quarter` 成员也包含一个 `UsState` 值。如果想要计数所有不是 25 美分的硬币的同时也报告 25 美分硬币所属的州，可以使用这样一个 `match` 表达式： ```rust # #[derive(Debug)] diff --git a/src/ch07-00-modules.md b/src/ch07-00-modules.md index 1230dae..d6028d1 100644 --- a/src/ch07-00-modules.md +++ b/src/ch07-00-modules.md @@ -2,14 +2,14 @@ > [ch07-00-modules.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch07-00-modules.md) >
-> commit b707dc664960f0ffc495c373900d6b13e434927d +> commit a0b6dd108ac3896a771c1f6d74b2cd906b8bce19 -在你刚开始编写 Rust 程序时，代码可能仅仅位于 `main` 函数里。随着代码数量的增长，为了复用和更好地组织代码，最终你会将功能移动到其他函数中。通过将代码分隔成更小的块，每一个块代码自身就更易于理解。不过当你发现自己有太多的函数了该怎么办呢？Rust 有一个模块系统可以有组织地复用代码。 +在你刚开始编写 Rust 程序时，代码可能仅仅位于 `main` 函数中。随着代码量的增长，为了复用和更好地组织代码，最终你会将功能移动到其他函数中。通过将代码分隔成更小的块，每一个块代码自身就更易于理解。不过当你发现自己有太多的函数了该怎么办呢？Rust 有一个模块系统可以有组织地复用代码。 就跟你将代码行提取到一个函数中一样，也可以将函数（和其他类似结构体和枚举的代码）提取到不同模块中。**模块**（*module*）是一个包含函数或类型定义的命名空间，你可以选择这些定义能（公有）或不能（私有）在其模块外可见。下面是一个模块如何工作的梗概： -* 使用 `mod` 关键字声明新模块。此模块的代码要么直接位于声明之后的大括号中，要么位于另一个文件。 -* 函数、类型、常量和模块默认都是私有的。可以使用 `pub` 关键字将其变成公有并在命名空间之外可见。 +* 使用 `mod` 关键字声明新模块。此模块中的代码要么直接位于声明之后的大括号中，要么位于另一个文件。 +* 函数、类型、常量和模块默认都是私有的。可以使用 `pub` 关键字将其变成公有并在其命名空间之外可见。 * `use` 关键字将模块或模块中的定义引入到作用域中以便于引用它们。 我们会逐一了解这每一部分并学习如何将它们结合在一起。 diff --git a/src/ch07-01-mod-and-the-filesystem.md b/src/ch07-01-mod-and-the-filesystem.md index 902a74b..e658195 100644 --- a/src/ch07-01-mod-and-the-filesystem.md +++ b/src/ch07-01-mod-and-the-filesystem.md @@ -2,7 +2,7 @@ > [ch07-01-mod-and-the-filesystem.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch07-01-mod-and-the-filesystem.md) >
-> commit c6a9e77a1b1ed367e0a6d5dcd222589ad392a8ac +> commit 478fa6f92b6e7975f5e4da8a84a498fb873b937d 我们将通过使用 Cargo 创建一个新项目来开始我们的模块之旅，不过这次不再创建一个二进制 crate，而是创建一个库 crate：一个其他人可以作为依赖导入的项目。第二章猜猜看游戏中作为依赖使用的 `rand` 就是这样的 crate。 @@ -35,7 +35,7 @@ Cargo 创建了一个空的测试来帮助我们开始库项目，不像使用 ` ### 模块定义 -对于 `communicator` 网络库，首先要定义一个叫做 `network` 的模块，它包含一个叫做 `connect` 的函数定义。Rust 中所有模块的定义以关键字 `mod` 开始。在 *src/lib.rs* 文件的开头在测试代码的上面增加这些代码： +对于 `communicator` 网络库，首先要定义一个叫做 `network` 的模块，它包含一个叫做 `connect` 的函数定义。Rust 中所有模块的定义都以关键字 `mod` 开始。在 *src/lib.rs* 文件的开头在测试代码的上面增加这些代码： 文件名: src/lib.rs @@ -140,9 +140,9 @@ communicator └── server ``` -如果这些模块有很多函数，而这些函数又很长，将难以在文件中寻找我们需要的代码。因为这些函数被嵌套进一个或多个模块中，同时函数中的代码也会开始变长。这就有充分的理由将`client`、`network` 和 `server`每一个模块从 *src/lib.rs* 抽出并放入它们自己的文件中。 +如果这些模块有很多函数，而这些函数又很长，将难以在文件中寻找我们需要的代码。因为这些函数被嵌套进一个或多个 `mod` 块中，同时函数中的代码也会开始变长。这就有充分的理由将 `client`、`network` 和 `server` 每一个模块从 *src/lib.rs* 抽出并放入它们自己的文件中。 -首先，将 `client` 模块的代码替换为只有 `client` 模块声明，这样 *src/lib.rs* 看起来应该像这样： +首先，将 `client` 模块的代码替换为只有 `client` 模块声明，这样 *src/lib.rs* 看起来应该像如示例 7-4 所示： 文件名: src/lib.rs @@ -160,6 +160,8 @@ mod network { } ``` +示例 7-4：提取出 `client` 模块的内容但仍将其声明留在 *src/lib.rs* + 这里我们仍然 **声明** 了 `client` 模块，不过将代码块替换为了分号，这告诉了 Rust 在 `client` 模块的作用域中寻找另一个定义代码的位置。换句话说，`mod client;` 行意味着： ```rust,ignore @@ -170,7 +172,7 @@ mod client { 那么现在需要创建对应模块名的外部文件。在 *src/* 目录创建一个 *client.rs* 文件，接着打开它并输入如下内容，它是上一步被去掉的 `client` 模块中的 `connect` 函数： -Filename: src/client.rs +文件名: src/client.rs ```rust fn connect() { @@ -186,31 +188,35 @@ Rust 默认只知道 *src/lib.rs* 中的内容。如果想要对项目加入更 ```text $ cargo build Compiling communicator v0.1.0 (file:///projects/communicator) - -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/client.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ + | + = note: #[warn(dead_code)] on by default -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/lib.rs:4:5 | -4 | fn connect() { - | ^ +4 | / fn connect() { +5 | | } + | |_____^ -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/lib.rs:8:9 | -8 | fn connect() { - | ^ +8 | / fn connect() { +9 | | } + | |_________^ ``` -这些警告提醒我们有从未被使用的函数。目前不用担心这些警告，在本章后面的 “使用 `pub` 控制可见性” 部分会解决它们。好消息是，它们仅仅是警告，我们的项目能够被成功编译。 +这些警告提醒我们有从未被使用的函数。目前不用担心这些警告，在本章后面的 “使用 `pub` 控制可见性” 部分会解决它们。好消息是，它们仅仅是警告，我们的项目能够成功编译。 下面使用相同的模式将 `network` 模块提取到自己的文件中。删除 *src/lib.rs* 中 `network` 模块的内容并在声明后加上一个分号，像这样： -Filename: src/lib.rs +文件名: src/lib.rs ```rust,ignore mod client; @@ -220,7 +226,7 @@ mod network; 接着新建 *src/network.rs* 文件并输入如下内容： -Filename: src/network.rs +文件名: src/network.rs ```rust fn connect() { @@ -236,7 +242,7 @@ mod server { 现在再次运行 `cargo build`。成功！不过我们还需要再提取出另一个模块：`server`。因为这是一个子模块——也就是模块中的模块——目前的将模块提取到对应名字的文件中的策略就不管用了。如果我们仍这么尝试则会出现错误。对 *src/network.rs* 的第一个修改是用 `mod server;` 替换 `server` 模块的内容： -Filename: src/network.rs +文件名: src/network.rs ```rust,ignore fn connect() { @@ -247,14 +253,14 @@ mod server; 接着创建 *src/server.rs* 文件并输入需要提取的 `server` 模块的内容： -Filename: src/server.rs +文件名: src/server.rs ```rust fn connect() { } ``` -当尝试运行 `cargo build` 时，会出现如示例 7-4 中所示的错误： +当尝试运行 `cargo build` 时，会出现如示例 7-5 中所示的错误： ```text $ cargo build @@ -265,7 +271,7 @@ error: cannot declare a new module at this location 4 | mod server; | ^^^^^^ | -note: maybe move this module `network` to its own directory via `network/mod.rs` +note: maybe move this module `src/network.rs` to its own directory via `src/network/mod.rs` --> src/network.rs:4:5 | 4 | mod server; @@ -277,11 +283,11 @@ note: ... or maybe `use` the module `server` instead of possibly redeclaring it | ^^^^^^ ``` -示例 7-4：尝试将 `server` 子模块提取到 *src/server.rs* 时出现的错误 +示例 7-5：尝试将 `server` 子模块提取到 *src/server.rs* 时出现的错误 这个错误说明 “不能在这个位置新声明一个模块” 并指出 *src/network.rs* 中的 `mod server;` 这一行。看来 *src/network.rs* 与 *src/lib.rs* 在某些方面是不同的；继续阅读以理解这是为什么。 -示例 7-4 中间的 note 事实上是非常有帮助的，因为它指出了一些我们还未讲到的操作： +示例 7-5 中间的 note 事实上是非常有帮助的，因为它指出了一些我们还未讲到的操作： ```text note: maybe move this module `network` to its own directory via @@ -291,7 +297,7 @@ note: maybe move this module `network` to its own directory via 我们可以按照记录所建议的去操作，而不是继续使用之前的与模块同名文件的模式： 1. 新建一个叫做 *network* 的 **目录**，这是父模块的名字 -2. 将 *src/network.rs* 移动到新建的 *network* 目录中并重命名，现在它是 *src/network/mod.rs* +2. 将 *src/network.rs* 移动到新建的 *network* 目录中并重命名为 *src/network/mod.rs* 3. 将子模块文件 *src/server.rs* 移动到 *network* 目录中 如下是执行这些步骤的命令： @@ -322,7 +328,7 @@ communicator │ └── server.rs ``` -那么，当我们想要提取 `network::server` 模块时，为什么也必须将 *src/network.rs* 文件改名成 *src/network/mod.rs* 文件呢，还有为什么要将`network::server`的代码放入 *network* 目录的 *src/network/server.rs* 文件中，而不能将 `network::server` 模块提取到 *src/server.rs* 中呢？原因是如果 *server.rs* 文件在 *src* 目录中那么 Rust 就不能知道 `server` 应当是 `network` 的子模块。为了阐明这里 Rust 的行为，让我们考虑一下有着如下层级的另一个例子，它的所有定义都位于 *src/lib.rs* 中： +那么，当我们想要提取 `network::server` 模块时，为什么也必须将 *src/network.rs* 文件改名成 *src/network/mod.rs* 文件呢，还有为什么要将 `network::server` 的代码放入 *network* 目录的 *src/network/server.rs* 文件中，而不能将 `network::server` 模块提取到 *src/server.rs* 中呢？原因是如果 *server.rs* 文件在 *src* 目录中那么 Rust 就不能知道 `server` 应当是 `network` 的子模块。为了阐明这里 Rust 的行为，让我们考虑一下有着如下层级的另一个例子，其所有定义都位于 *src/lib.rs* 中： ```text communicator @@ -333,11 +339,11 @@ communicator 在这个例子中，仍然有这三个模块，`client`、`network` 和 `network::client`。如果按照与上面最开始将模块提取到文件中相同的步骤来操作，对于 `client` 模块会创建 *src/client.rs*。对于 `network` 模块，会创建 *src/network.rs*。但是接下来不能将 `network::client` 模块提取到 *src/client.rs* 文件中，因为它已经存在了，对应顶层的 `client` 模块！如果将 `client` 和 `network::client` 的代码都放入 *src/client.rs* 文件，Rust 将无从可知这些代码是属于 `client` 还是 `network::client` 的。 -因此，一旦想要将 `network` 模块的子模块 `network::client` 提取到一个文件中，需要为 `network` 模块新建一个目录替代 *src/network.rs* 文件。接着 `network` 模块的代码将进入 *src/network/mod.rs* 文件，而子模块 `network::client` 将拥有其自己的文件 *src/network/client.rs*。现在顶层的 *src/client.rs* 中的代码毫无疑问的都属于 `client` 模块。 +因此，为了将 `network` 模块的子模块 `network::client` 提取到一个文件中，需要为 `network` 模块新建一个目录替代 *src/network.rs* 文件。接着 `network` 模块的代码将进入 *src/network/mod.rs* 文件，而子模块 `network::client` 将拥有其自己的文件 *src/network/client.rs*。现在顶层的 *src/client.rs* 中的代码毫无疑问的都属于 `client` 模块。 ### 模块文件系统的规则 -与文件系统相关的模块规则总结如下： +让我们总结一下与文件有关的模块规则： * 如果一个叫做 `foo` 的模块没有子模块，应该将 `foo` 的声明放入叫做 *foo.rs* 的文件中。 * 如果一个叫做 `foo` 的模块有子模块，应该将 `foo` 的声明放入叫做 *foo/mod.rs* 的文件中。 diff --git a/src/ch07-02-controlling-visibility-with-pub.md b/src/ch07-02-controlling-visibility-with-pub.md index 94381a8..220157e 100644 --- a/src/ch07-02-controlling-visibility-with-pub.md +++ b/src/ch07-02-controlling-visibility-with-pub.md @@ -2,33 +2,38 @@ > [ch07-02-controlling-visibility-with-pub.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch07-02-controlling-visibility-with-pub.md) >
-> commit 0a4ed5875aeba78a81ae03ac73aeb84d2e2aca86 +> commit 478fa6f92b6e7975f5e4da8a84a498fb873b937d -我们通过将 `network` 和 `network::server` 的代码分别移动到 *src/network/mod.rs* 和 *src/network/server.rs* 文件中解决了示例 7-4 中出现的错误信息。现在，`cargo build` 能够构建我们的项目，不过仍然有一些警告信息，表示 `client::connect`、`network::connect` 和`network::server::connect` 函数没有被使用： +我们通过将 `network` 和 `network::server` 的代码分别移动到 *src/network/mod.rs* 和 *src/network/server.rs* 文件中解决了示例 7-5 中出现的错误信息。现在，`cargo build` 能够构建我们的项目，不过仍然有一些警告信息，表示 `client::connect`、`network::connect` 和`network::server::connect` 函数没有被使用： ```text -warning: function is never used: `connect`, #[warn(dead_code)] on by default -src/client.rs:1:1 +warning: function is never used: `connect` + --> src/client.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ + | + = note: #[warn(dead_code)] on by default -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/network/mod.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/network/server.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ ``` -那么为什么会出现这些错误信息呢？我们构建的是一个库，它的函数的目的是被 **用户** 使用，而不一定要被项目自身使用，所以不应该担心这些 `connect` 函数是未使用的。创建它们的意义就在于被另一个项目而不是被我们自己使用。 +那么为什么会出现这些错误信息呢？毕竟我们构建的是一个库，它的函数的目的是被 **用户** 使用，而不一定要被项目自身使用，所以不应该担心这些 `connect` 函数是未使用的。创建它们的意义就在于被另一个项目而不是被我们自己使用。 -为了理解为什么这个程序出现了这些警告，尝试作为另一个项目来使用这个 `connect` 库，从外部调用它们。为此，通过创建一个包含这些代码的 *src/main.rs* 文件，在与库 crate 相同的目录创建一个二进制 crate： +为了理解为什么这个程序出现了这些警告，尝试在另一个项目中使用这个 `connect` 库，从外部调用它们。为此，通过创建一个包含这些代码的 *src/main.rs* 文件，在与库 crate 相同的目录创建一个二进制 crate： 文件名: src/main.rs @@ -40,7 +45,7 @@ fn main() { } ``` -使用 `extern crate` 指令将 `communicator` 库 crate 引入到作用域，因为事实上我们的包现在包含 **两个** crate。Cargo 认为 *src/main.rs* 是一个二进制 crate 的根文件，与现存的以 *src/lib.rs* 为根文件的库 crate 相区分。这个模式在可执行项目中非常常见：大部分功能位于库 crate 中，而二进制 crate 使用这个库 crate。通过这种方式，其他程序也可以使用这个库 crate，这是一个很好的关注分离（separation of concerns）。 +使用 `extern crate` 指令将 `communicator` 库 crate 引入到作用域。我们的包现在包含 **两个** crate。Cargo 认为 *src/main.rs* 是一个二进制 crate 的根文件，与现存的以 *src/lib.rs* 为根文件的库 crate 相区分。这个模式在可执行项目中非常常见：大部分功能位于库 crate 中，而二进制 crate 使用这个库 crate。通过这种方式，其他程序也可以使用这个库 crate，这是一个很好的关注分离（separation of concerns）。 从一个外部 crate 的视角观察 `communicator` 库的内部，我们创建的所有模块都位于一个与 crate 同名的模块内部，`communicator`。这个顶层的模块被称为 crate 的 **根模块**（*root module*）。 @@ -49,7 +54,7 @@ fn main() { 我们的二进制 crate 如今正好调用了库中 `client` 模块的 `connect` 函数。然而，执行 `cargo build` 会在之前的警告之后出现一个错误： ```text -error: module `client` is private +error[E0603]: module `client` is private --> src/main.rs:4:5 | 4 | communicator::client::connect(); @@ -58,11 +63,11 @@ error: module `client` is private 啊哈！这告诉了我们 `client` 模块是私有的，这也正是那些警告的症结所在。这也是我们第一次在 Rust 上下文中涉及到 **公有**（*public*）和 **私有**（*private*）的概念。Rust 所有代码的默认状态是私有的：除了自己之外别人不允许使用这些代码。如果不在自己的项目中使用一个私有函数，因为程序自身是唯一允许使用这个函数的代码，Rust 会警告说函数未被使用。 -一旦我们指定一个像 `client::connect` 的函数为公有，不光二进制 crate 中的函数调用是允许的，函数未被使用的警告也会消失。将其标记为公有让 Rust 知道了我们意在使函数在程序的外部被使用。现在这个可能的理论上的外部可用性使得 Rust 认为这个函数 “已经被使用”。因此。当某项被标记为公有，Rust 不再要求它在程序自身被使用并停止警告某项未被使用。 +一旦我们指定一个像 `client::connect` 的函数为公有，不光二进制 crate 中的函数调用是允许的，函数未被使用的警告也会消失。将其标记为公有让 Rust 知道了函数将会在程序的外部被使用。现在这个可能的理论上的外部可用性使得 Rust 认为这个函数 “已经被使用”。因此。当某项被标记为公有，Rust 不再要求它在程序自身被使用并停止警告函数未被使用。 ### 标记函数为公有 -为了告诉 Rust 某项为公有，在想要标记为公有的项的声明开头加上 `pub` 关键字。现在我们将致力于修复 `client::connect` 未被使用的警告，以及二进制 crate 中 “模块`client`是私有的” 的错误。像这样修改 *src/lib.rs* 使 `client` 模块公有： +为了告诉 Rust 将函数标记为公有，在声明的开头增加 `pub` 关键字。现在我们将致力于修复 `client::connect` 未被使用的警告，以及二进制 crate 中 “模块 `client` 是私有的” 的错误。像这样修改 *src/lib.rs* 使 `client` 模块公有： 文件名: src/lib.rs @@ -75,7 +80,7 @@ mod network; `pub` 写在 `mod` 之前。再次尝试构建： ```text -error: function `connect` is private +error[E0603]: function `connect` is private --> src/main.rs:4:5 | 4 | communicator::client::connect(); @@ -94,22 +99,26 @@ pub fn connect() { 再一次运行 `cargo build`： ```text -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/network/mod.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ + | + = note: #[warn(dead_code)] on by default -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/network/server.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ ``` 编译通过了，关于 `client::connect` 未被使用的警告消失了！ -未被使用的代码并不总是意味着它们需要被设为公有的：如果你 **不** 希望这些函数成为公有 API 的一部分，未被使用的代码警告可能是在警告你这些代码不再需要并可以安全的删除它们。这也可能是警告你出 bug 了，如果你刚刚不小心删除了库中所有这个函数的调用。 +未被使用的代码并不总是意味着它们需要被设为公有的：如果你 **不** 希望这些函数成为公有 API 的一部分，未被使用的代码警告可能是在提醒你这些代码不再需要并可以安全的删除它们。这也可能是警告你出 bug 了，如果你刚刚不小心删除了库中所有这个函数的调用。 当然我们的情况是，**确实** 希望另外两个函数也作为 crate 公有 API 的一部分，所以让我们也将其标记为 `pub` 并去掉剩余的警告。修改 *src/network/mod.rs* 为： @@ -125,20 +134,24 @@ mod server; 并编译代码： ```text -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/network/mod.rs:1:1 | -1 | pub fn connect() { - | ^ +1 | / pub fn connect() { +2 | | } + | |_^ + | + = note: #[warn(dead_code)] on by default -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/network/server.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ ``` -虽然将 `network::connect` 设为 `pub` 了我们仍然得到了一个未被使用函数的警告。这是因为模块中的函数是公有的，不过函数所在的 `network` 模块却不是公有的。这回我们是自内向外修改库文件的，而 `client::connect` 的时候是自外向内修改的。我们需要修改 *src/lib.rs* 让 `network` 也是公有的： +虽然将 `network::connect` 设为 `pub` 了我们仍然得到了一个未被使用函数的警告。这是因为模块中的函数是公有的，不过函数所在的 `network` 模块却不是公有的。这回我们是自内向外修改库文件的，而 `client::connect` 的时候是自外向内修改的。我们需要修改 *src/lib.rs* 让 `network` 也是公有的，如下： 文件名: src/lib.rs @@ -151,11 +164,14 @@ pub mod network; 现在编译的话，那个警告就消失了： ```text -warning: function is never used: `connect`, #[warn(dead_code)] on by default +warning: function is never used: `connect` --> src/network/server.rs:1:1 | -1 | fn connect() { - | ^ +1 | / fn connect() { +2 | | } + | |_^ + | + = note: #[warn(dead_code)] on by default ``` 只剩一个警告了！尝试自食其力修改它吧！ @@ -169,7 +185,7 @@ warning: function is never used: `connect`, #[warn(dead_code)] on by default ### 私有性示例 -让我们看看更多例子作为练习。创建一个新的库项目并在新项目的 *src/lib.rs* 输入示例 7-5 中的代码： +让我们看看更多私有性的例子作为练习。创建一个新的库项目并在新项目的 *src/lib.rs* 输入示例 7-6 中的代码： 文件名: src/lib.rs @@ -194,7 +210,7 @@ fn try_me() { } ``` -示例 7-5：私有和公有函数的例子，其中部分是不正确的 +示例 7-6：私有和公有函数的例子，其中部分是不正确的 在尝试编译这些代码之前，猜测一下 `try_me` 函数的哪一行会出错。接着编译项目来看看是否猜对了，然后继续阅读后面关于错误的讨论！ @@ -204,7 +220,7 @@ fn try_me() { `outermost::middle_function` 的调用是正确的。因为 `middle_function` 是公有的，而 `try_me` 通过其父模块 `outermost` 访问 `middle_function`。根据上一段的规则我们可以确定这个模块是可访问的。 -`outermost::middle_secret_function` 的调用会造成一个编译错误。`middle_secret_function` 是私有的，所以第二条（私有性）规则生效了。根模块既不是 `middle_secret_function` 的当前模块（`outermost`是），也不是 `middle_secret_function` 当前模块的子模块。 +`outermost::middle_secret_function` 的调用会造成一个编译错误。`middle_secret_function` 是私有的，所以第二条（私有性）规则生效了。根模块既不是 `middle_secret_function` 的当前模块（`outermost` 是），也不是 `middle_secret_function` 当前模块的子模块。 叫做 `inside` 的模块是私有的且没有子模块，所以它只能被当前模块 `outermost` 访问。这意味着 `try_me` 函数不允许调用 `outermost::inside::inner_function` 或 `outermost::inside::secret_function` 中的任何一个。 @@ -218,4 +234,4 @@ fn try_me() { 请随意设计更多的实验并尝试理解它们！ -接下来，让我们讨论一下使用 `use` 关键字将模块项目引入作用域。 +接下来，让我们讨论一下使用 `use` 关键字将项引入作用域。 diff --git a/src/ch07-03-importing-names-with-use.md b/src/ch07-03-importing-names-with-use.md index c691eae..95233e3 100644 --- a/src/ch07-03-importing-names-with-use.md +++ b/src/ch07-03-importing-names-with-use.md @@ -1,10 +1,10 @@ -## 导入命名 +## 引用不同模块中的名称 > [ch07-03-importing-names-with-use.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch07-03-importing-names-with-use.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 550c8ea6f74060ff1f7b67e7e1878c4da121682d -我们已经讲到了如何使用模块名称作为调用的一部分，来调用模块中的函数，如示例 7-6 中所示的 `nested_modules` 函数调用。 +我们已经讲到了如何使用模块名称作为调用的一部分，来调用模块中的函数，如示例 7-7 中所示的 `nested_modules` 函数调用。 文件名: src/main.rs @@ -22,13 +22,13 @@ fn main() { } ``` -示例 7-6：通过完全指定模块中的路径来调用函数 +示例 7-7：通过完全指定模块中的路径来调用函数 如你所见，指定函数的完全限定名称可能会非常冗长。所幸 Rust 有一个关键字使得这些调用显得更简洁。 -### 使用 `use` 的简单导入 +### 使用 `use` 关键字将名称导入作用域 -Rust 的 `use` 关键字的工作是缩短冗长的函数调用，通过将想要调用的函数所在的模块引入到作用域中。这是一个将 `a::series::of` 模块导入一个二进制 crate 的根作用域的例子： +Rust 的 `use` 关键字的工作通过将想要调用的函数所在的模块引入到作用域中来缩短冗长的函数调用。这是一个将 `a::series::of` 模块导入一个二进制 crate 的根作用域的例子： 文件名: src/main.rs @@ -72,7 +72,7 @@ fn main() { 这使得我们可以忽略所有的模块并直接引用函数。 -因为枚举也像模块一样组成了某种命名空间，也可以使用 `use` 来导入枚举的成员。对于任何类型的 `use` 语句，如果从一个命名空间导入多个项，可以使用大括号和逗号来列举它们，像这样： +因为枚举也像模块一样组成了某种命名空间，也可以使用 `use` 来导入枚举的成员。对于任何类型的 `use` 语句，如果从一个命名空间导入多个项，可以在最后使用大括号和逗号来列举它们，像这样： ```rust enum TrafficLight { @@ -90,9 +90,11 @@ fn main() { } ``` -### 使用 `*` 的全局引用导入 +我们仍然为 `Green` 成员指定了 `TrafficLight` 命名空间，因为并没有在 `use` 语句中包含 `Green`。 -为了一次导入某个命名空间的所有项，可以使用 `*` 语法。例如： +### 使用 glob 将所有名称引入作用域 + +为了一次将某个命名空间下的所有名称都引入作用域，可以使用 `*` 语法，这称为 **glob 运算符**（*glob operator*）。这个例子将一个枚举的所有成员引入作用域而没有将其一一列举出来： ```rust enum TrafficLight { @@ -110,7 +112,7 @@ fn main() { } ``` -`*` 被称为 **全局导入**（*glob*），它会导入命名空间中所有可见的项。全局导入应该保守的使用：它们是方便的，但是也可能会引入多于你预期的内容从而导致命名冲突。 +`*` 会将 `TrafficLight` 命名空间中所有可见的项都引入作用域。请保守的使用 glob：它们是方便的，但是也可能会引入多于预期的内容从而导致命名冲突。 ### 使用 `super` 访问父模块 @@ -132,7 +134,7 @@ mod tests { } ``` -第十一章会更详细的解释测试，不过其部分内容现在应该可以理解了：有一个叫做 `tests` 的模块紧邻其他模块，同时包含一个叫做 `it_works` 的函数。即便存在一些特殊注解，`tests` 也不过是另外一个模块！所以我们的模块层次结构看起来像这样： +第十一章会更详细的解释测试，不过其中部分内容现在应该可以理解了：有一个叫做 `tests` 的模块紧邻其他模块，同时包含一个叫做 `it_works` 的函数。即便存在一些特殊注解，`tests` 也不过是另外一个模块！所以我们的模块层次结构看起来像这样： ```text communicator @@ -142,7 +144,7 @@ communicator └── tests ``` -测试是为了检验库中的代码而存在的，所以让我们尝试在 `it_works` 函数中调用 `client::connect` 函数，即便现在不准备测试任何功能： +测试是为了检验库中的代码而存在的，所以让我们尝试在 `it_works` 函数中调用 `client::connect` 函数，即便现在不准备测试任何功能。这还不能工作： 文件名: src/lib.rs @@ -165,7 +167,7 @@ error[E0433]: failed to resolve. Use of undeclared type or module `client` --> src/lib.rs:9:9 | 9 | client::connect(); - | ^^^^^^^^^^^^^^^ Use of undeclared type or module `client` + | ^^^^^^ Use of undeclared type or module `client` ``` 编译失败了，不过为什么呢？并不需要像 *src/main.rs* 那样将 `communicator::` 置于函数前，因为这里肯定是在 `communicator` 库 crate 之内的。失败的原因是路径是相对于当前模块的，在这里就是 `tests`。唯一的例外就是 `use` 语句，它默认是相对于 crate 根模块的。我们的 `tests` 模块需要 `client` 模块位于其作用域中！ @@ -176,7 +178,7 @@ error[E0433]: failed to resolve. Use of undeclared type or module `client` ::client::connect(); ``` -要么可以使用 `super` 在层级中获取当前模块的上一级模块： +要么可以使用 `super` 在层级中上移到当前模块的上一级模块，如下： ```rust,ignore super::client::connect(); @@ -212,7 +214,7 @@ $ cargo test running 1 test test tests::it_works ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` ## 总结 diff --git a/src/ch08-00-common-collections.md b/src/ch08-00-common-collections.md index f62c5a7..1048c80 100644 --- a/src/ch08-00-common-collections.md +++ b/src/ch08-00-common-collections.md @@ -2,12 +2,12 @@ > [ch08-00-common-collections.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch08-00-common-collections.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 54e81980185fbb1a4cb5a18dce1dc6deeb66b573 -Rust 标准库中包含一系列被称为 **集合**（*collections*）的非常有用的数据结构。大部分其他数据类型都代表一个特定的值，不过集合可以包含多个值。不同于内建的数组和元组类型，这些集合指向的数据是储存在堆上的，这意味着数据的数量不必在编译时就可知并且可以随着程序的运行增长或缩小。每种集合都有着不同能力和代价，而为所处的场景选择合适的集合则是你将要始终发展的技能。在这一章里，我们将详细的了解三个在 Rust 程序中被广泛使用的集合： +Rust 标准库中包含一系列被称为 **集合**（*collections*）的非常有用的数据结构。大部分其他数据类型都代表一个特定的值，不过集合可以包含多个值。不同于内建的数组和元组类型，这些集合指向的数据是储存在堆上的，这意味着数据的数量不必在编译时就已知并且可以随着程序的运行增长或缩小。每种集合都有着不同能力和代价，而为所处的场景选择合适的集合则是你将要始终成长的技能。在这一章里，我们将详细的了解三个在 Rust 程序中被广泛使用的集合： * *vector* 允许我们一个挨着一个地储存一系列数量可变的值 -* **字符串**（*string*）是一个字符的集合。我们之前见过 `String` 类型，现在将详细介绍它。 +* **字符串**（*string*）是一个字符的集合。我们之前见过 `String` 类型，不过在本章我们将深入了解。 * **哈希 map**（*hash map*）允许我们将值与一个特定的键（key）相关联。这是一个叫做 *map* 的更通用的数据结构的特定实现。 对于标准库提供的其他类型的集合，请查看[文档][collections]。 diff --git a/src/ch08-01-vectors.md b/src/ch08-01-vectors.md index 3601a8e..834d050 100644 --- a/src/ch08-01-vectors.md +++ b/src/ch08-01-vectors.md @@ -1,32 +1,36 @@ -## vector +## vector 用来储存一系列的值 > [ch08-01-vectors.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch08-01-vectors.md) >
-> commit 6c24544ba718bce0755bdaf03423af86280051d5 +> commit 550c8ea6f74060ff1f7b67e7e1878c4da121682d -我们要讲到的第一个类型是`Vec`，也被称为 *vector*。vector 允许我们在一个单独的数据结构中储存多于一个值，它在内存中彼此相邻地排列所有的值。vector 只能储存相同类型的值。它们在拥有一系列项的场景下非常实用，例如文件中的文本行或是购物车中商品的价格。 +我们要讲到的第一个类型是 `Vec`，也被称为 *vector*。vector 允许我们在一个单独的数据结构中储存多于一个的值，它在内存中彼此相邻地排列所有的值。vector 只能储存相同类型的值。它们在拥有一系列项的场景下非常实用，例如文件中的文本行或是购物车中商品的价格。 ### 新建 vector -为了创建一个新的空 vector，可以调用 `Vec::new` 函数： +为了创建一个新的空 vector，可以调用 `Vec::new` 函数，如示例 8-1 所示： ```rust let v: Vec = Vec::new(); ``` -注意这里我们增加了一个类型注解。因为没有向这个 vector 中插入任何值，Rust 并不知道我们想要储存什么类型的元素。这是一个非常重要的点。vector 是同质的（homogeneous）：它们可以储存很多值，不过这些值必须都是相同类型的。vector 是用泛型实现的，第十章会涉及到如何对你自己的类型使用它们。现在，所有你需要知道的就是 `Vec` 是一个由标准库提供的类型，它可以存放任何类型，而当 `Vec` 存放某个特定类型时，那个类型位于尖括号中。这里我们告诉 Rust `v` 这个 `Vec` 将存放 `i32` 类型的元素。 +示例 8-1：新建一个空的 vector 来储存 `i32` 类型的值 -在实际的代码中，一旦插入值 Rust 就可以推断出想要存放的类型，所以你很少会需要这些类型注解。更常见的做法是使用初始值来创建一个 `Vec`，而且为了方便 Rust 提供了 `vec!` 宏。这个宏会根据我们提供的值来创建一个新的 `Vec`。如下代码会新建一个拥有值 `1`、`2` 和 `3` 的 `Vec`： +注意这里我们增加了一个类型注解。因为没有向这个 vector 中插入任何值，Rust 并不知道我们想要储存什么类型的元素。这是一个非常重要的点。vector 是用泛型实现的，第十章会涉及到如何对你自己的类型使用它们。现在，所有你需要知道的就是 `Vec` 是一个由标准库提供的类型，它可以存放任何类型，而当 `Vec` 存放某个特定类型时，那个类型位于尖括号中。这里我们告诉 Rust `v` 这个 `Vec` 将存放 `i32` 类型的元素。 + +在更实际的代码中，一旦插入值 Rust 就可以推断出想要存放的类型，所以你很少会需要这些类型注解。更常见的做法是使用初始值来创建一个 `Vec`，而且为了方便 Rust 提供了 `vec!` 宏。这个宏会根据我们提供的值来创建一个新的 `Vec`。示例 8-2 新建一个拥有值 `1`、`2` 和 `3` 的 `Vec`： ```rust let v = vec![1, 2, 3]; ``` +示例 8-2：新建一个包含初值的 vector + 因为我们提供了 `i32` 类型的初始值，Rust 可以推断出 `v` 的类型是 `Vec`，因此类型注解就不是必须的。接下来让我们看看如何修改一个 vector。 ### 更新 vector -对于新建一个 vector 并向其增加元素，可以使用 `push` 方法： +对于新建一个 vector 并向其增加元素，可以使用 `push` 方法，如示例 8-3 所示： ```rust let mut v = Vec::new(); @@ -37,11 +41,13 @@ v.push(7); v.push(8); ``` -如第三章中讨论的任何变量一样，如果想要能够改变它的值，必须使用 `mut` 关键字使其可变。放入其中的所有值都是 `i32` 类型的，而且 Rust 也根据数据如此判断，所以不需要 `Vec` 注解。 +示例 8-3：使用 `push` 方法向 vector 增加值 + +如第三章中讨论的任何变量一样，如果想要能够改变它的值，必须使用 `mut` 关键字使其可变。放入其中的所有值都是 `i32` 类型的，而且 Rust 也根据数据做出如此判断，所以不需要 `Vec` 注解。 ### 丢弃 vector 时也会丢弃其所有元素 -类似于任何其他的 `struct`，vector 在其离开作用域时会被释放： +类似于任何其他的 `struct`，vector 在其离开作用域时会被释放，如示例 8-4 所标注的： ```rust { @@ -52,13 +58,15 @@ v.push(8); } // <- v goes out of scope and is freed here ``` +示例 8-4：展示 vector 和其元素于何处被丢弃 + 当 vector 被丢弃时，所有其内容也会被丢弃，这意味着这里它包含的整数将被清理。这可能看起来非常直观，不过一旦开始使用 vector 元素的引用，情况就变得有些复杂了。下面让我们处理这种情况！ ### 读取 vector 的元素 现在你知道如何创建、更新和销毁 vector 了，接下来的一步最好了解一下如何读取它们的内容。有两种方法引用 vector 中储存的值。为了更加清楚的说明这个例子，我们标注这些函数返回的值的类型。 -这个例子展示了访问 vector 中一个值的两种方式，索引语法或者 `get` 方法： +示例 8-5 展示了访问 vector 中一个值的两种方式，索引语法或者 `get` 方法： ```rust let v = vec![1, 2, 3, 4, 5]; @@ -67,9 +75,11 @@ let third: &i32 = &v[2]; let third: Option<&i32> = v.get(2); ``` -这里有一些需要注意的地方。首先，我们使用索引值 `2` 来获取第三个元素，索引是从 0 开始的。其次，这两个不同的获取第三个元素的方式分别为：使用 `&` 和 `[]` 返回一个引用；或者使用 `get` 方法以索引作为参数来返回一个 `Option<&T>`。 +列表 8-5：使用索引语法或 `get` 方法来访问 vector 中的项 -Rust 有两个引用元素的方法的原因是程序可以选择如何处理当索引值在 vector 中没有对应值的情况。例如如下情况，如果有一个有五个元素的 vector 接着尝试访问索引为 100 的元素，程序该如何处理： +这里有两个需要注意的地方。首先，我们使用索引值 `2` 来获取第三个元素，索引是从 0 开始的。其次，这两个不同的获取第三个元素的方式分别为：使用 `&` 和 `[]` 返回一个引用；或者使用 `get` 方法以索引作为参数来返回一个 `Option<&T>`。 + +Rust 有两个引用元素的方法的原因是程序可以选择如何处理当索引值在 vector 中没有对应值的情况。作为一个例子，让我们看看如果有一个有五个元素的 vector 接着尝试访问索引为 100 的元素时程序会如何处理，如示例 8-6 所示： ```rust,should_panic let v = vec![1, 2, 3, 4, 5]; @@ -78,13 +88,15 @@ let does_not_exist = &v[100]; let does_not_exist = v.get(100); ``` +示例 8-6：尝试访问一个包含 5 个元素的 vector 的索引 100 处的元素 + 当运行这段代码，你会发现对于第一个 `[]` 方法，当引用一个不存在的元素时 Rust 会造成 `panic!`。这个方法更适合当程序认为尝试访问超过 vector 结尾的元素是一个严重错误的情况，这时应该使程序崩溃。 -当 `get` 方法被传递了一个数组外的索引时，它不会 panic 而是返回 `None`。当偶尔出现超过 vector 范围的访问属于正常情况的时候可以考虑使用它。接着你的代码可以有处理 `Some(&element)` 或 `None` 的逻辑，如第六章讨论的那样。例如，索引可能来源于用户输入的数字。如果它们不慎输入了一个过大的数字那么程序就会得到 `None` 值，你可以告诉用户 `Vec` 当前元素的数量并再请求它们输入一个有效的值。这就比因为输入错误而使程序崩溃要友好的多！ +当 `get` 方法被传递了一个数组外的索引时，它不会 panic 而是返回 `None`。当偶尔出现超过 vector 范围的访问属于正常情况的时候可以考虑使用它。接着你的代码可以有处理 `Some(&element)` 或 `None` 的逻辑，如第六章讨论的那样。例如，索引可能来源于用户输入的数字。如果它们不慎输入了一个过大的数字那么程序就会得到 `None` 值，你可以告诉用户当前 vector 元素的数量并再请求它们输入一个有效的值。这就比因为输入错误而使程序崩溃要友好的多！ #### 无效引用 -一旦程序获取了一个有效的引用，借用检查器将会执行第四章讲到的所有权和借用规则来确保 vector 内容的这个引用和任何其他引用保持有效。回忆一下不能在相同作用域中同时存在可变和不可变引用的规则。这个规则适用于这个例子，当我们获取了 vector 的第一个元素的不可变引用并尝试在 vector 末尾增加一个元素的时候： +一旦程序获取了一个有效的引用，借用检查器将会执行第四章讲到的所有权和借用规则来确保 vector 内容的这个引用和任何其他引用保持有效。回忆一下不能在相同作用域中同时存在可变和不可变引用的规则。这个规则适用于示例 8-7，当我们获取了 vector 的第一个元素的不可变引用并尝试在 vector 末尾增加一个元素的时候，这是行不通的： ```rust,ignore let mut v = vec![1, 2, 3, 4, 5]; @@ -94,30 +106,59 @@ let first = &v[0]; v.push(6); ``` +示例 8-7：在拥有 vector 中项的引用的同时向其增加一个元素 + 编译会给出这个错误： ```text -error[E0502]: cannot borrow `v` as mutable because it is also borrowed as -immutable +error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable + --> | -4 | let first = &v[0]; - | - immutable borrow occurs here +4 | let first = &v[0]; + | - immutable borrow occurs here 5 | -6 | v.push(6); - | ^ mutable borrow occurs here -7 | } +6 | v.push(6); + | ^ mutable borrow occurs here +7 | +8 | } | - immutable borrow ends here ``` -这些代码看起来应该能够运行：为什么第一个元素的引用会关心 vector 结尾的变化？不能这么做的原因是由于 vector 的工作方式。在 vector 的结尾增加新元素时，在没有足够空间将所有所有元素依次相邻存放的情况下，可能会要求分配新内存并将老的元素拷贝到新的空间中。这时，第一个元素的引用就指向了被释放的内存。借用规则阻止程序陷入这种状况。 +示例 8-7 中的代码看起来应该能够运行：为什么第一个元素的引用会关心 vector 结尾的变化？不能这么做的原因是由于 vector 的工作方式。在 vector 的结尾增加新元素时，在没有足够空间将所有所有元素依次相邻存放的情况下，可能会要求分配新内存并将老的元素拷贝到新的空间中。这时，第一个元素的引用就指向了被释放的内存。借用规则阻止程序陷入这种状况。 -> 注意：关于更多内容，查看 Nomicon *https://doc.rust-lang.org/stable/nomicon/vec.html* +> 注意：关于 `Vec` 类型的更多实现细节，在 *https://doc.rust-lang.org/stable/nomicon/vec.html* 查看 “The Nomicon” + +### 遍历 vector 中的元素 + +如果想要依次访问 vector 中的每一个元素，我们可以遍历其所有的元素而无需通过索引一次一个的访问。示例 8-8 展示了如何使用 `for` 循环来获取 `i32` 值的 vector 中的每一个元素的不可变引用并将其打印： + +```rust +let v = vec![100, 32, 57]; +for i in &v { + println!("{}", i); +} +``` + +示例 8-8：通过 `for` 循环遍历 vector 的元素并打印 + +我们也可以遍历可变 vector 的每一个元素的可变引用以便能改变他们。示例 8-9 中的 `for` 循环会给每一个元素加 `50`： + +```rust +let mut v = vec![100, 32, 57]; +for i in &mut v { + *i += 50; +} +``` + +示例8-9：遍历 vector 中元素的可变引用 + +为了修改可变引用所指向的值，在使用 `+=` 运算符之前必须使用解引用运算符（`*`）获取 `i` 中的值。 ### 使用枚举来储存多种类型 在本章的开始，我们提到 vector 只能储存相同类型的值。这是很不方便的；绝对会有需要储存一系列不同类型的值的用例。幸运的是，枚举的成员都被定义为相同的枚举类型，所以当需要在 vector 中储存不同类型值时，我们可以定义并使用一个枚举！ -例如，假如我们想要从电子表格的一行中获取值，而这一行的有些列包含数字，有些包含浮点值，还有些是字符串。我们可以定义一个枚举，其成员会存放这些不同类型的值，同时所有这些枚举成员都会被当作相同类型，那个枚举的类型。接着可以创建一个储存枚举值的 vector，这样最终就能够储存不同类型的值了： +例如，假如我们想要从电子表格的一行中获取值，而这一行的有些列包含数字，有些包含浮点值，还有些是字符串。我们可以定义一个枚举，其成员会存放这些不同类型的值，同时所有这些枚举成员都会被当作相同类型，那个枚举的类型。接着可以创建一个储存枚举值的 vector，这样最终就能够储存不同类型的值了。示例 8-10 展示了其用例： ```rust enum SpreadsheetCell { @@ -133,7 +174,7 @@ let row = vec![ ]; ``` -示例 8-1：定义一个枚举，以便能在 vector 中存放不同类型的数据 +示例 8-10：定义一个枚举，以便能在 vector 中存放不同类型的数据 Rust 在编译时就必须准确的知道 vector 中类型的原因在于它需要知道储存每个元素到底需要多少内存。第二个好处是可以准确的知道这个 vector 中允许什么类型。如果 Rust 允许 vector 存放任意类型，那么当对 vector 元素执行操作时一个或多个类型的值就有可能会造成错误。使用枚举外加 `match` 意味着 Rust 能在编译时就保证总是会处理所有可能的情况，正如第六章讲到的那样。 diff --git a/src/ch08-02-strings.md b/src/ch08-02-strings.md index e19c10e..80f965e 100644 --- a/src/ch08-02-strings.md +++ b/src/ch08-02-strings.md @@ -1,8 +1,8 @@ -## 字符串 +## 字符串存储了 UTF-8 编码的文本 > [ch08-02-strings.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch08-02-strings.md) >
-> commit 692c4a78aac93670bc6f1fa5d33f71ed161b9339 +> commit c2fd7b2d39c4130dd17bb99c101ac94af83d1a44 第四章已经讲过一些字符串的内容，不过现在让我们更深入地了解它。字符串是新晋 Rustacean 们通常会被困住的领域。这是由于三方面内容的结合：Rust 倾向于确保暴露出可能的错误，字符串是比很多程序员所想象的要更为复杂的数据结构，以及 UTF-8。所有这些结合起来对于来自其他语言背景的程序员就可能显得很困难了。 From eac25102eeed8c6818db25f2ca2d4ac0c657b0ff Mon Sep 17 00:00:00 2001 From: KaiserY Date: Sat, 20 Jan 2018 15:59:20 +0800 Subject: [PATCH 116/150] check to ch09-03 --- src/ch08-02-strings.md | 123 +++++++++++------- src/ch08-03-hash-maps.md | 45 ++++--- src/ch09-00-error-handling.md | 4 +- ...ch09-01-unrecoverable-errors-with-panic.md | 95 +++++++------- src/ch09-02-recoverable-errors-with-result.md | 105 ++++++++------- src/ch09-03-to-panic-or-not-to-panic.md | 2 +- 6 files changed, 212 insertions(+), 162 deletions(-) diff --git a/src/ch08-02-strings.md b/src/ch08-02-strings.md index 80f965e..db4dbda 100644 --- a/src/ch08-02-strings.md +++ b/src/ch08-02-strings.md @@ -4,29 +4,31 @@ >
> commit c2fd7b2d39c4130dd17bb99c101ac94af83d1a44 -第四章已经讲过一些字符串的内容，不过现在让我们更深入地了解它。字符串是新晋 Rustacean 们通常会被困住的领域。这是由于三方面内容的结合：Rust 倾向于确保暴露出可能的错误，字符串是比很多程序员所想象的要更为复杂的数据结构，以及 UTF-8。所有这些结合起来对于来自其他语言背景的程序员就可能显得很困难了。 +第四章已经讲过一些字符串的内容，不过现在让我们更深入地了解它。字符串是新晋 Rustacean 们通常会被困住的领域，这是由于三方面内容的结合：Rust 倾向于确保暴露出可能的错误，字符串是比很多程序员所想象的要更为复杂的数据结构，以及 UTF-8。所有这些结合起来对于来自其他语言背景的程序员就可能显得很困难了。 字符串出现在集合章节的原因是，字符串是作为字节的集合外加一些方法实现的，当这些字节被解释为文本时，这些方法提供了实用的功能。在这一部分，我们会讲到 `String` 中那些任何集合类型都有的操作，比如创建、更新和读取。也会讨论 `String` 与其他集合不一样的地方，例如索引` String` 是很复杂的，由于人和计算机理解 `String` 数据方式的不同。 ### 什么是字符串？ -在开始深入这些方面之前，我们需要讨论一下术语 **字符串** 的具体意义。Rust 的核心语言中事实上就只有一种字符串类型：`str`，字符串 slice，它通常以被借用的形式出现，`&str`。第四章讲到了 **字符串 slice**：它们是一些储存在别处的 UTF-8 编码字符串数据的引用。比如字符串字面值被储存在程序的二进制输出中，字符串 slice 也是如此。 +在开始深入这些方面之前，我们需要讨论一下术语 **字符串** 的具体意义。Rust 的核心语言中只有一种字符串类型：`str`，字符串 slice，它通常以被借用的形式出现，`&str`。第四章讲到了 **字符串 slice**：它们是一些储存在别处的 UTF-8 编码字符串数据的引用。比如字符串字面值被储存在程序的二进制输出中，字符串 slice 也是如此。 -称作 `String` 的类型是由标准库提供的，而没有写进核心语言部分，它是可增长的、可变的、有所有权的、UTF-8 编码的字符串类型。当 Rustacean 们谈到 Rust 的 “字符串”时，它们通常指的是 `String` 和字符串 slice `&str`类型，而不是其中一个。这一部分大部分是关于 `String` 的，不过这些类型在 Rust 标准库中都被广泛使用。`String` 和字符串 slice 都是 UTF-8 编码的。 +称作 `String` 的类型是由标准库提供的，而没有写进核心语言部分，它是可增长的、可变的、有所有权的、UTF-8 编码的字符串类型。当 Rustacean 们谈到 Rust 的 “字符串”时，它们通常指的是 `String` 和字符串 slice `&str`类型，而不仅仅是其中之一。虽然本部分内容大多是关于 `String` 的，不过这两个类型在 Rust 标准库中都被广泛使用，`String` 和字符串 slice 都是 UTF-8 编码的。 Rust 标准库中还包含一系列其他字符串类型，比如 `OsString`、`OsStr`、`CString` 和 `CStr`。相关库 crate 甚至会提供更多储存字符串数据的选择。与 `*String`/`*Str` 的命名类似，它们通常也提供有所有权和可借用的变体，就比如说 `String`/`&str`。这些字符串类型在储存的编码或内存表现形式上可能有所不同。本章将不会讨论其他这些字符串类型；查看 API 文档来更多的了解如何使用它们以及各自适合的场景。 ### 新建字符串 -很多 `Vec` 可用的操作在 `String` 中同样可用，从以 `new` 函数创建字符串开始，像这样： +很多 `Vec` 可用的操作在 `String` 中同样可用，从以 `new` 函数创建字符串开始，如示例 8-11 所示： ```rust let mut s = String::new(); ``` +示例 8-11：新建一个空的 `String` + 这新建了一个叫做 `s` 的空的字符串，接着我们可以向其中装载数据。 -通常字符串会有初始数据，因为我们希望一开始就有这个字符串。为此，使用 `to_string` 方法，它能用于任何实现了 `Display` trait 的类型，对于字符串字面值是这样： +通常字符串会有初始数据，因为我们希望一开始就有这个字符串。为此，可以使用 `to_string` 方法，它能用于任何实现了 `Display` trait 的类型，字符串字面值就可以。示例 8-12 展示了两个例子： ```rust let data = "initial contents"; @@ -37,65 +39,82 @@ let s = data.to_string(); let s = "initial contents".to_string(); ``` -这会创建一个包含 `initial contents` 的字符串。 +示例 8-12：使用 `to_string` 方法从字符串字面值创建 `String` -也可以使用 `String::from` 函数来从字符串字面值创建 `String`。下面代码等同于使用 `to_string`： +这些代码会创建包含 `initial contents` 的字符串。 + +也可以使用 `String::from` 函数来从字符串字面值创建 `String`。示例 8-13 中的代码代码等同于使用 `to_string`： ```rust let s = String::from("initial contents"); ``` -因为字符串使用广泛，这里有很多不同的用于字符串的通用 API 可供选择。它们有些可能显得有些多余，不过都有其用武之地！在这个例子中，`String::from` 和 `.to_string` 最终做了完全相同的工作，所以如何选择就是风格问题了。 +示例 8-13：使用 `String::from` 函数从字符串字面值创建 `String` -记住字符串是 UTF-8 编码的，所以可以包含任何可以正确编码的数据： +因为字符串应用广泛，这里有很多不同的用于字符串的通用 API 可供选择。它们有些可能显得有些多余，不过都有其用武之地！在这个例子中，`String::from` 和 `.to_string` 最终做了完全相同的工作，所以如何选择就是风格问题了。 + +记住字符串是 UTF-8 编码的，所以可以包含任何可以正确编码的数据，如示例 8-14 所示： ```rust -let hello = "السلام عليكم"; -let hello = "Dobrý den"; -let hello = "Hello"; -let hello = "שָׁלוֹם"; -let hello = "नमस्ते"; -let hello = "こんにちは"; -let hello = "안녕하세요"; -let hello = "你好"; -let hello = "Olá"; -let hello = "Здравствуйте"; -let hello = "Hola"; +let hello = String::from("السلام عليكم"); +let hello = String::from("Dobrý den"); +let hello = String::from("Hello"); +let hello = String::from("שָׁלוֹם"); +let hello = String::from("नमस्ते"); +let hello = String::from("こんにちは"); +let hello = String::from("안녕하세요"); +let hello = String::from("你好"); +let hello = String::from("Olá"); +let hello = String::from("Здравствуйте"); +let hello = String::from("Hola"); ``` +示例 8-14：在字符串中储存不同语言的问候语 + +所有这些都是有效的 `String`值。 + ### 更新字符串 -`String` 的大小可以增长其内容也可以改变，就像可以放入更多数据来改变 `Vec` 的内容一样。另外，`String` 实现了 `+` 运算符作为级联运算符以便于使用。 +`String` 的大小可以增长其内容也可以改变，就像可以放入更多数据来改变 `Vec` 的内容一样。另外，`String` 实现了 `+` 运算符作为连接运算符以便于使用。 #### 使用 push 附加字符串 -可以通过 `push_str` 方法来附加字符串 slice，从而使 `String` 变长： +可以通过 `push_str` 方法来附加字符串 slice，从而使 `String` 变长，如示例 8-15 所示： ```rust let mut s = String::from("foo"); s.push_str("bar"); ``` -执行这两行代码之后 `s` 将会包含 “foobar”。`push_str` 方法获取字符串 slice，因为我们并不需要获取参数的所有权。例如，如果将 `s2` 的内容附加到 `s1` 中后自身不能被使用就糟糕了： +示例 8-15：使用 `push_str` 方法向 `String` 附加字符串 slice + +执行这两行代码之后 `s` 将会包含 `foobar`。`push_str` 方法获取字符串 slice，因为我们并不需要获取参数的所有权。例如，示例 8-16 展示了如果将 `s2` 的内容附加到 `s1` 中后自身不能被使用就糟糕了： ```rust let mut s1 = String::from("foo"); -let s2 = String::from("bar"); +let s2 = "bar"; s1.push_str(&s2); +println!("s2 is {}", s2); ``` -`push` 方法被定义为获取一个单独的字符作为参数，并附加到 `String` 中： +示例 8-16：将字符串 slice 的内容附加到 `String` 后使用它 + +如果 `push_str` 方法获取了 `s2` 的所有权，就不能在最后一行打印出其值了。好在代码如我们期望那样工作！ + +`push` 方法被定义为获取一个单独的字符作为参数，并附加到 `String` 中。示例 8-17 展示了使用 `push` 方法将字母 l 加入 `String` 的代码： ```rust let mut s = String::from("lo"); s.push('l'); ``` +示例 8-17：使用 `push` 将一个字符加入 `String` 值中 + 执行这些代码之后，`s` 将会包含 “lol”。 -#### 使用 + 运算符或 `format!` 宏级联字符串 +#### 使用 + 运算符或 `format!` 宏连接字符串 -通常我们希望将两个已知的字符串合并在一起。一种办法是像这样使用 `+` 运算符： +通常我们希望将两个已知的字符串合并在一起。一种办法是像这样使用 `+` 运算符，如示例 8-18 所示： ```rust let s1 = String::from("Hello, "); @@ -103,15 +122,19 @@ let s2 = String::from("world!"); let s3 = s1 + &s2; // Note that s1 has been moved here and can no longer be used ``` +示例 8-18：使用 `+` 运算符将两个 `String` 值合并到一个新的 `String` 值中 + 执行完这些代码之后字符串 `s3` 将会包含 `Hello, world!`。`s1` 在相加后不再有效的原因，和使用 `s2` 的引用的原因与使用 `+` 运算符时调用的方法签名有关，这个函数签名看起来像这样： ```rust,ignore fn add(self, s: &str) -> String { ``` -这并不是标准库中实际的签名；那个 `add` 使用泛型定义。这里我们看到的 `add` 的签名使用具体类型代替了泛型，这也正是当使用 `String` 值调用这个方法会发生的。第十章会讨论泛型。这个签名提供了理解 `+` 运算那奇怪的部分的线索。 +这并不是标准库中实际的签名；标准库中的 `add` 使用泛型定义。这里我们看到的 `add` 的签名使用具体类型代替了泛型，这也正是当使用 `String` 值调用这个方法会发生的。第十章会讨论泛型。这个签名提供了理解 `+` 运算那微妙部分的线索。 -首先，`s2` 使用了 `&`，意味着我们使用第二个字符串的 **引用** 与第一个字符串相加。这是因为 `add` 函数的 `s` 参数：只能将 `&str` 和 `String` 相加，不能将两个 `String` 值相加。不过等一下——正如 `add` 的第二个参数所指定的，`&s2` 的类型是 `&String` 而不是 `&str`。那么为什么代码还能编译呢？之所以能够在 `add` 调用中使用 `&s2` 是因为 `&String` 可以被**强转**（*coerced*）成 `&str`——当`add`函数被调用时，Rust 使用了一个被称为 **解引用强制多态**（*deref coercion*）的技术，你可以将其理解为它把 `&s2` 变成了 `&s2[..]` 以供 `add` 函数使用。第十五章会更深入的讨论解引用强制多态。因为 `add` 没有获取参数的所有权，所以 `s2` 在这个操作后仍然是有效的 `String`。 +首先，`s2` 使用了 `&`，意味着我们使用第二个字符串的 **引用** 与第一个字符串相加。这是因为 `add` 函数的 `s` 参数：只能将 `&str` 和 `String` 相加，不能将两个 `String` 值相加。不过等一下——正如 `add` 的第二个参数所指定的，`&s2` 的类型是 `&String` 而不是 `&str`。那么为什么示例 8-18 还能编译呢？ + +之所以能够在 `add` 调用中使用 `&s2` 是因为 `&String` 可以被 **强转**（*coerced*）成 `&str`——当`add`函数被调用时，Rust 使用了一个被称为 **解引用强制多态**（*deref coercion*）的技术，你可以将其理解为它把 `&s2` 变成了 `&s2[..]`。第十五章会更深入的讨论解引用强制多态。因为 `add` 没有获取参数的所有权，所以 `s2` 在这个操作后仍然是有效的 `String`。 其次，可以发现签名中 `add` 获取了 `self` 的所有权，因为 `self` **没有** 使用 `&`。这意味着上面例子中的 `s1` 的所有权将被移动到 `add` 调用中，之后就不再有效。所以虽然 `let s3 = s1 + &s2;` 看起来就像它会复制两个字符串并创建一个新的字符串，而实际上这个语句会获取 `s1` 的所有权，附加上从 `s2` 中拷贝的内容，并返回结果的所有权。换句话说，它看起来好像生成了很多拷贝不过实际上并没有：这个实现比拷贝要更高效。 @@ -135,31 +158,34 @@ let s3 = String::from("toe"); let s = format!("{}-{}-{}", s1, s2, s3); ``` -这些代码也会将 `s` 设置为 “tic-tac-toe”。`format!` 与 `println!` 的工作原理相同，不过不同于将输出打印到屏幕上，它返回一个带有结果的 `String`。这个版本就好理解的多，并且不会获取任何参数的所有权。 +这些代码也会将 `s` 设置为 “tic-tac-toe”。`format!` 与 `println!` 的工作原理相同，不过不同于将输出打印到屏幕上，它返回一个带有结果内容的 `String`。这个版本就好理解的多，并且不会获取任何参数的所有权。 ### 索引字符串 -在很多语言中，通过索引来引用字符串中的单独字符是有效且常见的操作。然而在 Rust 中，如果我们尝试使用索引语法访问 `String` 的一部分，会出现一个错误。比如如下代码： +在很多语言中，通过索引来引用字符串中的单独字符是有效且常见的操作。然而在 Rust 中，如果我们尝试使用索引语法访问 `String` 的一部分，会出现一个错误。考虑一下如示例 8-19 中所示的无效代码： ```rust,ignore let s1 = String::from("hello"); let h = s1[0]; ``` +示例 8-19：尝试对字符串使用索引语法 + 会导致如下错误： ```text -error: the trait bound `std::string::String: std::ops::Index<_>` is not -satisfied [--explain E0277] - |> - |> let h = s1[0]; - |> ^^^^^ -note: the type `std::string::String` cannot be indexed by `_` +error[E0277]: the trait bound `std::string::String: std::ops::Index<{integer}>` is not satisfied + --> + | +3 | let h = s1[0]; + | ^^^^^ the type `std::string::String` cannot be indexed by `{integer}` + | + = help: the trait `std::ops::Index<{integer}>` is not implemented for `std::string::String` ``` 错误和提示说明了全部问题：Rust 的字符串不支持索引。那么接下来的问题是，为什么不支持呢？为了回答这个问题，我们必须先聊一聊 Rust 是如何在内存中储存字符串的。 -#### 内部表示 +#### 内部表现 `String` 是一个 `Vec` 的封装。让我们看看之前一些正确编码的字符串的例子。首先是这一个： @@ -167,22 +193,20 @@ note: the type `std::string::String` cannot be indexed by `_` let len = String::from("Hola").len(); ``` -在这里，`len` 的值是四，这意味着储存字符串 “Hola” 的 `Vec` 的长度是四个字节：每一个字符的 UTF-8 编码都占用一个字节。那下面这个例子又如何呢？ +在这里，`len` 的值是四，这意味着储存字符串 “Hola” 的 `Vec` 的长度是四个字节：这里每一个字母的 UTF-8 编码都占用一个字节。那下面这个例子又如何呢？ ```rust let len = String::from("Здравствуйте").len(); ``` -当问及这个字符是多长的时候有人可能会说是 12。然而，Rust 的回答是 24。这是使用 UTF-8 编码 “Здравствуйте” 所需要的字节数，这是因为每个 Unicode 标量值需要两个字节存储。因此一个字符串字节值的索引并不总是对应一个有效的 Unicode 标量值。 - -作为演示，考虑如下无效的 Rust 代码： +当问及这个字符是多长的时候有人可能会说是 12。然而，Rust 的回答是 24。这是使用 UTF-8 编码 “Здравствуйте” 所需要的字节数，这是因为每个 Unicode 标量值需要两个字节存储。因此一个字符串字节值的索引并不总是对应一个有效的 Unicode 标量值。作为演示，考虑如下无效的 Rust 代码： ```rust,ignore let hello = "Здравствуйте"; let answer = &hello[0]; ``` -`answer` 的值应该是什么呢？它应该是第一个字符 `З` 吗？当使用 UTF-8 编码时，`З` 的第一个字节 `208`，第二个是 `151`，所以 `answer` 实际上应该是 `208`，不过 `208` 自身并不是一个有效的字母。返回 `208` 可不是一个请求字符串第一个字母的人所希望看到的，不过它是 Rust 在字节索引零位置所能提供的唯一数据。返回字节值可能不是人们希望看到的，即便是只有拉丁字母时：`&"hello"[0]` 会返回 `104` 而不是 `h`。为了避免返回意想不到值并造成不能立刻发现的 bug。Rust 选择不编译这些代码并及早杜绝了误会的发生。 +`answer` 的值应该是什么呢？它应该是第一个字符 `З` 吗？当使用 UTF-8 编码时，`З` 的第一个字节 `208`，第二个是 `151`，所以 `answer` 实际上应该是 `208`，不过 `208` 自身并不是一个有效的字母。返回 `208` 可不是一个请求字符串第一个字母的人所希望看到的，不过它是 Rust 在字节索引 0 位置所能提供的唯一数据。返回字节值可能不是人们希望看到的，即便是只有拉丁字母时：`&"hello"[0]` 会返回 `104` 而不是 `h`。为了避免返回意想不到值并造成不能立刻发现的 bug。Rust 选择不编译这些代码并及早杜绝了误会的发生。 #### 字节、标量值和字形簇！天呐！ @@ -213,7 +237,7 @@ Rust 提供了多种不同的方式来解释计算机储存的原始字符串数 ### 字符串 slice -因为字符串索引应该返回的类型是不明确的，而且索引字符串通常也是一个坏点子，所以 Rust 不建议这么做，而如果你确实需要它的话则需要更加明确一些。比使用 `[]` 和单个值的索引更加明确的方式是使用 `[]` 和一个 range 来创建包含特定字节的字符串 slice： +索引字符串通常是一个坏点子，因为字符串索引应该返回的类型是不明确的：字节值、字符、字形簇或者字符串 slice。因此，如果你真的希望使用索引创建字符串 slice 时 Rust 会要求你更明确一些。为了更明确索引并表民你需要一个字符串 slice，相比使用 `[]` 和单个值的索引，可以使用 `[]` 和一个 range 来创建含特定字节的字符串 slice： ```rust let hello = "Здравствуйте"; @@ -221,13 +245,12 @@ let hello = "Здравствуйте"; let s = &hello[0..4]; ``` -这里，`s` 是一个 `&str`，它包含字符串的头四个字节。早些时候，我们提到了这些字母都是两个字节长的，所以这意味着 `s` 将会是 “Зд”。 +这里，`s` 会是一个 `&str`，它包含字符串的头四个字节。早些时候，我们提到了这些字母都是两个字节长的，所以这意味着 `s` 将会是 “Зд”。 如果获取 `&hello[0..1]` 会发生什么呢？答案是：在运行时会 panic，就跟访问 vector 中的无效索引时一样： ```text -thread 'main' panicked at 'index 0 and/or 1 in `Здравствуйте` do not lie on -character boundary', ../src/libcore/str/mod.rs:1694 +thread 'main' panicked at 'byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`', src/libcore/str/mod.rs:2188:4 ``` 你应该小心谨慎的使用这个操作，因为它可能会使你的程序崩溃。 @@ -236,7 +259,7 @@ character boundary', ../src/libcore/str/mod.rs:1694 幸运的是，这里还有其他获取字符串元素的方式。 -如果你需要操作单独的 Unicode 标量值，最好的选择是使用 `chars` 方法。对 “नमस्ते” 调用 `chars` 方法会将其分开并返回六个 `char` 类型的值，接着就可以遍历结果来访问每一个元素了： +如果我们需要操作单独的 Unicode 标量值，最好的选择是使用 `chars` 方法。对 “नमस्ते” 调用 `chars` 方法会将其分开并返回六个 `char` 类型的值，接着就可以遍历其结果来访问每一个元素了： ```rust for c in "नमस्ते".chars() { @@ -275,10 +298,10 @@ for b in "नमस्ते".bytes() { 不过请记住有效的 Unicode 标量值可能会由不止一个字节组成。 -从字符串中获取字形簇是很复杂的，所以标准库并没有提供这个功能。crates.io 上有些提供这样功能的 crate。 +从字符串中获取字形簇是很复杂的，所以标准库并没有提供这个功能。[crates.io](https://crates.io) 上有些提供这样功能的 crate。 ### 字符串并不简单 -总而言之，字符串还是很复杂的。不同的语言选择了不同的向程序员展示其复杂性的方式。Rust 选择了以准确的方式处理 `String` 数据作为所有 Rust 程序的默认行为，这意味着程序员们必须更多的思考如何在前台处理 UTF-8 数据。这种权衡取舍相比其他语言更多的暴露出了字符串的复杂性，不过也使你在开发生命周期中免于处理涉及非 ASCII 字符的错误。 +总而言之，字符串还是很复杂的。不同的语言选择了不同的向程序员展示其复杂性的方式。Rust 选择了以准确的方式处理 `String` 数据作为所有 Rust 程序的默认行为，这意味着程序员们必须更多的思考如何预先处理 UTF-8 数据。这种权衡取舍相比其他语言更多的暴露出了字符串的复杂性，不过也使你在开发生命周期后期免于处理涉及非 ASCII 字符的错误。 现在让我们转向一些不太复杂的集合：哈希 map！ diff --git a/src/ch08-03-hash-maps.md b/src/ch08-03-hash-maps.md index d93aa11..8213d07 100644 --- a/src/ch08-03-hash-maps.md +++ b/src/ch08-03-hash-maps.md @@ -1,8 +1,8 @@ -## 哈希 map +## 哈希 map 储存键值对 > [ch08-03-hash-maps.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch08-03-hash-maps.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit c2fd7b2d39c4130dd17bb99c101ac94af83d1a44 最后介绍的常用集合类型是 **哈希 map**（*hash map*）。`HashMap` 类型储存了一个键类型 `K` 对应一个值类型 `V` 的映射。它通过一个 **哈希函数**（*hashing function*）来实现映射，决定如何将键和值放入内存中。很多编程语言支持这种数据结构，不过通常有不同的名字：哈希、map、对象、哈希表或者关联数组，仅举几例。 @@ -23,10 +23,13 @@ scores.insert(String::from("Blue"), 10); scores.insert(String::from("Yellow"), 50); ``` +示例 8-20：新建一个哈希 map 并插入一些键值对 + 注意必须首先 `use` 标准库中集合部分的 `HashMap`。在这三个常用集合中，`HashMap` 是最不常用的，所以并没有被 prelude 自动引用。标准库中对 `HashMap` 的支持也相对较少，例如，并没有内建的构建宏。 + 像 vector 一样，哈希 map 将它们的数据储存在堆上，这个 `HashMap` 的键类型是 `String` 而值类型是 `i32`。同样类似于 vector，哈希 map 是同质的：所有的键必须是相同类型，值也必须都是相同类型。 -另一个构建哈希 map 的方法是使用一个元组的 vector 的 `collect` 方法，其中每个元组包含一个键值对。`collect` 方法可以将数据收集进一系列的集合类型，包括 `HashMap`。例如，如果队伍的名字和初始分数分别在两个 vector 中，可以使用 `zip` 方法来创建一个元组的 vector，其中 “Blue” 与 10 是一对，依此类推。接着就可以使用 `collect` 方法将这个元组 vector 转换成一个 `HashMap`： +另一个构建哈希 map 的方法是使用一个元组的 vector 的 `collect` 方法，其中每个元组包含一个键值对。`collect` 方法可以将数据收集进一系列的集合类型，包括 `HashMap`。例如，如果队伍的名字和初始分数分别在两个 vector 中，可以使用 `zip` 方法来创建一个元组的 vector，其中 “Blue” 与 10 是一对，依此类推。接着就可以使用 `collect` 方法将这个元组 vector 转换成一个 `HashMap`，如示例 8-21 所示： ```rust use std::collections::HashMap; @@ -37,11 +40,13 @@ let initial_scores = vec![10, 50]; let scores: HashMap<_, _> = teams.iter().zip(initial_scores.iter()).collect(); ``` +示例 8-21：用队伍列表和分数列表创建哈希 map + 这里 `HashMap<_, _>` 类型注解是必要的，因为可能 `collect` 很多不同的数据结构，而除非显式指定否则 Rust 无从得知你需要的类型。但是对于键和值的类型参数来说，可以使用下划线占位，而 Rust 能够根据 vector 中数据的类型推断出 `HashMap` 所包含的类型。 ### 哈希 map 和所有权 -对于像 `i32` 这样的实现了 `Copy` trait 的类型，其值可以拷贝进哈希 map。对于像 `String` 这样拥有所有权的值，其值将被移动而哈希 map 会成为这些值的所有者： +对于像 `i32` 这样的实现了 `Copy` trait 的类型，其值可以拷贝进哈希 map。对于像 `String` 这样拥有所有权的值，其值将被移动而哈希 map 会成为这些值的所有者，如示例 8-22 所示： ```rust use std::collections::HashMap; @@ -51,16 +56,19 @@ let field_value = String::from("Blue"); let mut map = HashMap::new(); map.insert(field_name, field_value); -// field_name and field_value are invalid at this point +// field_name and field_value are invalid at this point, try using them and +// see what compiler error you get! ``` +示例 8-22：展示一旦键值对被插入后就为哈希 map 所拥有 + 当 `insert` 调用将 `field_name` 和 `field_value` 移动到哈希 map 中后，将不能使用这两个绑定。 -如果将值的引用插入哈希 map，这些值本身将不会被移动进哈希 map。但是这些引用指向的值必须至少在哈希 map 有效时也是有效的。第十章生命周期部分将会更多的讨论这个问题。 +如果将值的引用插入哈希 map，这些值本身将不会被移动进哈希 map。但是这些引用指向的值必须至少在哈希 map 有效时也是有效的。第十章 “使用生命周期保证引用有效” 部分将会更多的讨论这个问题。 ### 访问哈希 map 中的值 -可以通过 `get` 方法并提供对应的键来从哈希 map 中获取值： +可以通过 `get` 方法并提供对应的键来从哈希 map 中获取值，如示例 8-23 所示： ```rust use std::collections::HashMap; @@ -74,7 +82,9 @@ let team_name = String::from("Blue"); let score = scores.get(&team_name); ``` -这里，`score` 是与蓝队分数相关的值，应为 `Some(10)`。因为 `get` 返回 `Option`，所以结果被装进 `Some`；如果某个键在哈希 map 中没有对应的值，`get` 会返回 `None`。这时就要用某种第六章提到的方法来处理 `Option`。 +示例 8-23：访问哈希 map 中储存的蓝队分数 + +这里，`score` 是与蓝队分数相关的值，应为 `Some(10)`。因为 `get` 返回 `Option`，所以结果被装进 `Some`；如果某个键在哈希 map 中没有对应的值，`get` 会返回 `None`。这时就要用某种第六章提到的方法之一来处理 `Option`。 可以使用与 vector 类似的方式来遍历哈希 map 中的每一个键值对，也就是 `for` 循环： @@ -104,7 +114,7 @@ Blue: 10 #### 覆盖一个值 -如果我们插入了一个键值对，接着用相同的键插入一个不同的值，与这个键相关联的旧值将被替换。即便下面的代码调用了两次 `insert`，哈希 map 也只会包含一个键值对，因为两次都是对蓝队的键插入的值： +如果我们插入了一个键值对，接着用相同的键插入一个不同的值，与这个键相关联的旧值将被替换。即便示例 8-24 中的代码调用了两次 `insert`，哈希 map 也只会包含一个键值对，因为两次都是对蓝队的键插入的值： ```rust use std::collections::HashMap; @@ -117,11 +127,13 @@ scores.insert(String::from("Blue"), 25); println!("{:?}", scores); ``` -这会打印出 `{"Blue": 25}`。原始的值 10 将被覆盖。 +示例 8-24：替换以特定键储存的值 + +这会打印出 `{"Blue": 25}`。原始的值 `10` 则被覆盖了。 #### 只在键没有对应值时插入 -我们经常会检查某个特定的键是否有值，如果没有就插入一个值。为此哈希 map 有一个特有的 API，叫做 `entry`，它获取我们想要检查的键作为参数。`entry` 函数的返回值是一个枚举，`Entry`，它代表了可能存在也可能不存在的值。比如说我们想要检查黄队的键是否关联了一个值。如果没有，就插入值 50，对于蓝队也是如此。使用 entry API 的代码看起来像这样： +我们经常会检查某个特定的键是否有值，如果没有就插入一个值。为此哈希 map 有一个特有的 API，叫做 `entry`，它获取我们想要检查的键作为参数。`entry` 函数的返回值是一个枚举，`Entry`，它代表了可能存在也可能不存在的值。比如说我们想要检查黄队的键是否关联了一个值。如果没有，就插入值 50，对于蓝队也是如此。使用 entry API 的代码看起来像示例 8-25 这样： ```rust use std::collections::HashMap; @@ -135,14 +147,15 @@ scores.entry(String::from("Blue")).or_insert(50); println!("{:?}", scores); ``` +示例 8-25：使用 `entry` 方法只在键没有对应一个值时插入 + `Entry` 的 `or_insert` 方法在键对应的值存在时就返回这个值的 `Entry`，如果不存在则将参数作为新值插入并返回修改过的 `Entry`。这比编写自己的逻辑要简明的多，另外也与借用检查器结合得更好。 -这段代码会打印出 `{"Yellow": 50, "Blue": 10}`。第一个 `entry` 调用会插入黄队的键和值 50，因为黄队并没有一个值。第二个 `entry` 调用不会改变哈希 map 因为蓝队已经有了值 10。 +运行示例 8-25 的代码会打印出 `{"Yellow": 50, "Blue": 10}`。第一个 `entry` 调用会插入黄队的键和值 `50`，因为黄队并没有一个值。第二个 `entry` 调用不会改变哈希 map 因为蓝队已经有了值 `10`。 #### 根据旧值更新一个值 -另一个常见的哈希 map 的应用场景是找到一个键对应的值并根据旧的值更新它。例如，如果我们想要计数一些文本中每一个单词分别出现了多少次，就可以使用哈希 map，以单词作为键并递增其值来记录我们遇到过几次这个单词。如果是第一次看到某个单词，就插入值 `0`。 - +另一个常见的哈希 map 的应用场景是找到一个键对应的值并根据旧的值更新它。例如，示例 8-26 中的代码计数一些文本中每一个单词分别出现了多少次。我们使用哈希 map 以单词作为键并递增其值来记录我们遇到过几次这个单词。如果是第一次看到某个单词，就插入值 `0`。 ```rust use std::collections::HashMap; @@ -159,11 +172,13 @@ for word in text.split_whitespace() { println!("{:?}", map); ``` +示例 8-26：通过哈希 map 储存单词和计数来统计出现次数 + 这会打印出 `{"world": 2, "hello": 1, "wonderful": 1}`，`or_insert` 方法事实上会返回这个键的值的一个可变引用（`&mut V`）。这里我们将这个可变引用储存在 `count` 变量中，所以为了赋值必须首先使用星号（`*`）解引用 `count`。这个可变引用在 `for` 循环的结尾离开作用域，这样所有这些改变都是安全的并符合借用规则。 ### 哈希函数 -`HashMap` 默认使用一种密码学安全的哈希函数，它可以抵抗拒绝服务（Denial of Service, DoS）攻击。然而并不是最快的，不过为了更高的安全性值得付出一些性能的代价。如果性能监测显示此哈希函数非常慢，以致于你无法接受，你可以指定一个不同的 *hasher* 来切换为其它函数。hasher 是一个实现了 `BuildHasher` trait 的类型。第十章会讨论 trait 和如何实现它们。你并不需要从头开始实现你自己的 hasher；crates.io 有其他人分享的实现了许多常用哈希算法的 hasher 的库。 +`HashMap` 默认使用一种密码学安全的哈希函数，它可以抵抗拒绝服务（Denial of Service, DoS）攻击。然而这并不是可用的最快的算法，不过为了更高的安全性值得付出一些性能的代价。如果性能监测显示此哈希函数非常慢，以致于你无法接受，你可以指定一个不同的 *hasher* 来切换为其它函数。hasher 是一个实现了 `BuildHasher` trait 的类型。第十章会讨论 trait 和如何实现它们。你并不需要从头开始实现你自己的 hasher；crates.io 有其他人分享的实现了许多常用哈希算法的 hasher 的库。 ## 总结 diff --git a/src/ch09-00-error-handling.md b/src/ch09-00-error-handling.md index 609d6ee..791e484 100644 --- a/src/ch09-00-error-handling.md +++ b/src/ch09-00-error-handling.md @@ -2,9 +2,9 @@ > [ch09-00-error-handling.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch09-00-error-handling.md) >
-> commit 4f2dc564851dc04b271a2260c834643dfd86c724 +> commit a764530433720fe09ae2d97874c25341f8322573 -Rust 对可靠性的执着也扩展到了错误处理。错误对于软件来说是不可避免的，所以当出现错误时， Rust 有很多特性来处理当前情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 +Rust 对可靠性的执着也延伸到了错误处理。错误对于软件来说是不可避免的，所以 Rust 有很多特性来处理出现错误的情况。在很多情况下，Rust 要求你承认出错的可能性并在编译代码之前就采取行动。通过确保不会只有在将代码部署到生产环境之后才会发现错误来使得程序更可靠。 Rust 将错误组合成两个主要类别：**可恢复错误**（*recoverable*）和 **不可恢复错误**（*unrecoverable*）。可恢复错误通常代表向用户报告错误和重试操作是合理的情况，比如未找到文件。不可恢复错误通常是 bug 的同义词，比如尝试访问超过数组结尾的位置。 diff --git a/src/ch09-01-unrecoverable-errors-with-panic.md b/src/ch09-01-unrecoverable-errors-with-panic.md index 8d316c2..64c426a 100644 --- a/src/ch09-01-unrecoverable-errors-with-panic.md +++ b/src/ch09-01-unrecoverable-errors-with-panic.md @@ -2,7 +2,7 @@ > [ch09-01-unrecoverable-errors-with-panic.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch09-01-unrecoverable-errors-with-panic.md) >
-> commit 8d24b2a5e61b4eea109d26e38d2144408ae44e53 +> commit a764530433720fe09ae2d97874c25341f8322573 突然有一天，糟糕的事情发生了，而你对此束手无策。对于这种情况，Rust 有 `panic!`宏。当执行这个宏时，程序会打印出一个错误信息，展开并清理栈数据，然后接着退出。出现这种情况的场景通常是检测到一些类型的 bug 而且程序员并不清楚该如何处理它。 @@ -32,18 +32,17 @@ $ cargo run Compiling panic v0.1.0 (file:///projects/panic) Finished dev [unoptimized + debuginfo] target(s) in 0.25 secs Running `target/debug/panic` -thread 'main' panicked at 'crash and burn', src/main.rs:2 +thread 'main' panicked at 'crash and burn', src/main.rs:2:4 note: Run with `RUST_BACKTRACE=1` for a backtrace. -error: Process didn't exit successfully: `target/debug/panic` (exit code: 101) ``` -最后三行包含 `panic!` 造成的错误信息。第一行显示了 panic 提供的信息并指明了源码中 panic 出现的位置：*src/main.rs:2* 表明这是 *src/main.rs* 文件的第二行。 +最后三行包含 `panic!` 造成的错误信息。第一行显示了 panic 提供的信息并指明了源码中 panic 出现的位置：*src/main.rs:2:4* 表明这是 *src/main.rs* 文件的第二行第四个字符。 -在这个例子中，被指明的那一行是我们代码的一部分，而且查看这一行的话就会发现 `panic!` 宏的调用。换句话说，`panic!` 可能会出现在我们的代码调用的代码中。错误信息报告的文件名和行号可能指向别人代码中的 `panic!` 宏调用，而不是我们代码中最终导致 `panic!` 的那一行。可以使用 `panic!` 被调用的函数的 backtrace 来寻找（我们代码中出问题的地方）。 +在这个例子中，被指明的那一行是我们代码的一部分，而且查看这一行的话就会发现 `panic!` 宏的调用。在其他情况下，`panic!` 可能会出现在我们的代码调用的代码中。错误信息报告的文件名和行号可能指向别人代码中的 `panic!` 宏调用，而不是我们代码中最终导致 `panic!` 的那一行。可以使用 `panic!` 被调用的函数的 backtrace 来寻找（我们代码中出问题的地方）。下面我们会详细介绍 backtrace 是什么。 ### 使用 `panic!` 的 backtrace -让我们来看看另一个因为我们代码中的 bug 引起的别的库中 `panic!` 的例子，而不是直接的宏调用： +让我们来看看另一个因为我们代码中的 bug 引起的别的库中 `panic!` 的例子，而不是直接的宏调用。示例 9-1 有一些尝试通过索引访问 vector 中元素的例子： 文件名: src/main.rs @@ -51,10 +50,12 @@ error: Process didn't exit successfully: `target/debug/panic` (exit code: 101) fn main() { let v = vec![1, 2, 3]; - v[100]; + v[99]; } ``` +示例 9-1：尝试访问超越 vector 结尾的元素，这会造成 `panic!` + 这里尝试访问 vector 的第一百个元素，不过它只有三个元素。这种情况下 Rust 会 panic。`[]` 应当返回一个元素，不过如果传递了一个无效索引，就没有可供 Rust 返回的正确的元素。 这种情况下其他像 C 这样语言会尝试直接提供所要求的值，即便这可能不是你期望的：你会得到任何对应 vector 中这个元素的内存位置的值，甚至是这些内存并不属于 vector 的情况。这被称为 **缓冲区溢出**（*buffer overread*），并可能会导致安全漏洞，比如攻击者可以像这样操作索引来读取储存在数组后面不被允许的数据。 @@ -67,59 +68,61 @@ $ cargo run Finished dev [unoptimized + debuginfo] target(s) in 0.27 secs Running `target/debug/panic` thread 'main' panicked at 'index out of bounds: the len is 3 but the index is -100', /stable-dist-rustc/build/src/libcollections/vec.rs:1362 +99', /checkout/src/liballoc/vec.rs:1555:10 note: Run with `RUST_BACKTRACE=1` for a backtrace. error: Process didn't exit successfully: `target/debug/panic` (exit code: 101) ``` 这指向了一个不是我们编写的文件，*libcollections/vec.rs*。这是标准库中 `Vec` 的实现。这是当对 vector `v` 使用 `[]` 时 *libcollections/vec.rs* 中会执行的代码，也是真正出现 `panic!` 的地方。 -接下来的几行提醒我们可以设置 `RUST_BACKTRACE` 环境变量来得到一个 backtrace 来调查究竟是什么导致了错误。让我们来试试看。示例 9-1 显示了其输出： +接下来的几行提醒我们可以设置 `RUST_BACKTRACE` 环境变量来得到一个 backtrace *backtrace* 是一个执行到目前位置所有被调用的函数的列表。Rust 的 backtrace 跟其他语言中的一样：阅读 backtrace 的关键是从头开始读直到发现你编写的文件。这就是问题的发源地。这一行往上是你的代码调用的代码；往下则是调用你的代码的代码。这些行可能包含核心 Rust 代码，标准库代码或用到的 crate 代码。让我们尝试获取一个 backtrace：示例 9-2 展示了与你看到类似的输出： ```text $ RUST_BACKTRACE=1 cargo run Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs Running `target/debug/panic` -thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 100', /stable-dist-rustc/build/src/libcollections/vec.rs:1392 +thread 'main' panicked at 'index out of bounds: the len is 3 but the index is 99', /checkout/src/liballoc/vec.rs:1555:10 stack backtrace: - 1: 0x560ed90ec04c - std::sys::imp::backtrace::tracing::imp::write::hf33ae72d0baa11ed - at /stable-dist-rustc/build/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs:42 - 2: 0x560ed90ee03e - std::panicking::default_hook::{{closure}}::h59672b733cc6a455 - at /stable-dist-rustc/build/src/libstd/panicking.rs:351 - 3: 0x560ed90edc44 - std::panicking::default_hook::h1670459d2f3f8843 - at /stable-dist-rustc/build/src/libstd/panicking.rs:367 - 4: 0x560ed90ee41b - std::panicking::rust_panic_with_hook::hcf0ddb069e7abcd7 - at /stable-dist-rustc/build/src/libstd/panicking.rs:555 - 5: 0x560ed90ee2b4 - std::panicking::begin_panic::hd6eb68e27bdf6140 - at /stable-dist-rustc/build/src/libstd/panicking.rs:517 - 6: 0x560ed90ee1d9 - std::panicking::begin_panic_fmt::abcd5965948b877f8 - at /stable-dist-rustc/build/src/libstd/panicking.rs:501 - 7: 0x560ed90ee167 - rust_begin_unwind - at /stable-dist-rustc/build/src/libstd/panicking.rs:477 - 8: 0x560ed911401d - core::panicking::panic_fmt::hc0f6d7b2c300cdd9 - at /stable-dist-rustc/build/src/libcore/panicking.rs:69 - 9: 0x560ed9113fc8 - core::panicking::panic_bounds_check::h02a4af86d01b3e96 - at /stable-dist-rustc/build/src/libcore/panicking.rs:56 - 10: 0x560ed90e71c5 - as core::ops::Index>::index::h98abcd4e2a74c41 - at /stable-dist-rustc/build/src/libcollections/vec.rs:1392 - 11: 0x560ed90e727a - panic::main::h5d6b77c20526bc35 - at /home/you/projects/panic/src/main.rs:4 - 12: 0x560ed90f5d6a - __rust_maybe_catch_panic - at /stable-dist-rustc/build/src/libpanic_unwind/lib.rs:98 - 13: 0x560ed90ee926 - std::rt::lang_start::hd7c880a37a646e81 - at /stable-dist-rustc/build/src/libstd/panicking.rs:436 - at /stable-dist-rustc/build/src/libstd/panic.rs:361 - at /stable-dist-rustc/build/src/libstd/rt.rs:57 - 14: 0x560ed90e7302 - main - 15: 0x7f0d53f16400 - __libc_start_main - 16: 0x560ed90e6659 - _start - 17: 0x0 - + 0: std::sys::imp::backtrace::tracing::imp::unwind_backtrace + at /checkout/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs:49 + 1: std::sys_common::backtrace::_print + at /checkout/src/libstd/sys_common/backtrace.rs:71 + 2: std::panicking::default_hook::{{closure}} + at /checkout/src/libstd/sys_common/backtrace.rs:60 + at /checkout/src/libstd/panicking.rs:381 + 3: std::panicking::default_hook + at /checkout/src/libstd/panicking.rs:397 + 4: std::panicking::rust_panic_with_hook + at /checkout/src/libstd/panicking.rs:611 + 5: std::panicking::begin_panic + at /checkout/src/libstd/panicking.rs:572 + 6: std::panicking::begin_panic_fmt + at /checkout/src/libstd/panicking.rs:522 + 7: rust_begin_unwind + at /checkout/src/libstd/panicking.rs:498 + 8: core::panicking::panic_fmt + at /checkout/src/libcore/panicking.rs:71 + 9: core::panicking::panic_bounds_check + at /checkout/src/libcore/panicking.rs:58 + 10: as core::ops::index::Index>::index + at /checkout/src/liballoc/vec.rs:1555 + 11: panic::main + at src/main.rs:4 + 12: __rust_maybe_catch_panic + at /checkout/src/libpanic_unwind/lib.rs:99 + 13: std::rt::lang_start + at /checkout/src/libstd/panicking.rs:459 + at /checkout/src/libstd/panic.rs:361 + at /checkout/src/libstd/rt.rs:61 + 14: main + 15: __libc_start_main + 16: ``` -示例 9-1：当设置 `RUST_BACKTRACE` 环境变量时 `panic!` 调用所生成的 backtrace 信息 +示例 9-2：当设置 `RUST_BACKTRACE` 环境变量时 `panic!` 调用所生成的 backtrace 信息 -这里有大量的输出！backtrace 第 11 行指向了我们程序中引起错误的行：*src/main.rs* 的第四行。backtrace 是一个执行到目前位置所有被调用的函数的列表。Rust 的 backtrace 跟其他语言中的一样：阅读 backtrace 的关键是从头开始读直到发现你编写的文件。这就是问题的发源地。这一行往上是你的代码调用的代码；往下则是调用你的代码的代码。这些行可能包含核心 Rust 代码，标准库代码或用到的 crate 代码。 +这里有大量的输出！你实际看到的输出可能因不同的操作系统和 Rust 版本而有所不同。为了获取带有这些信息的 backtrace，必须启用 debug 标识。当不使用 --release 参数运行 cargo build 或 cargo run 时 debug 标识会默认启用，这里便是如此。 -如果你不希望我们的程序 panic，第一个提到我们编写的代码行的位置是你应该开始调查的，以便查明是什么值如何在这个地方引起了 panic。在上面的例子中，我们故意编写会 panic 的代码来演示如何使用 backtrace，修复这个 panic 的方法就是不要尝试在一个只包含三个项的 vector 中请求索引是 100 的元素。当将来你的代码出现了 panic，你需要搞清楚在这特定的场景下代码中执行了什么操作和什么值导致了 panic，以及应当如何处理才能避免这个问题。 +示例 9-2 的输出中，backtrace 的 11 行指向了我们项目中造成问题的行：*src/main.rs* 的第 4 行。如果你不希望程序 panic，第一个提到我们编写的代码行的位置是你应该开始调查的，以便查明是什么值如何在这个地方引起了 panic。在上面的例子中，我们故意编写会 panic 的代码来演示如何使用 backtrace，修复这个 panic 的方法就是不要尝试在一个只包含三个项的 vector 中请求索引是 100 的元素。当将来你的代码出现了 panic，你需要搞清楚在这特定的场景下代码中执行了什么操作和什么值导致了 panic，以及应当如何处理才能避免这个问题。 -本章的后面会再次回到 `panic!` 并讲到何时应该何时不应该使用这个方式。接下来，我们来看看如何使用 `Result` 来从错误中恢复。 +本章的后面会再次回到 `panic!` 并讲到何时应该及何时不应该使用这个方式。接下来，我们来看看如何使用 `Result` 来从错误中恢复。 diff --git a/src/ch09-02-recoverable-errors-with-result.md b/src/ch09-02-recoverable-errors-with-result.md index c477999..2bf6518 100644 --- a/src/ch09-02-recoverable-errors-with-result.md +++ b/src/ch09-02-recoverable-errors-with-result.md @@ -2,7 +2,7 @@ > [ch09-02-recoverable-errors-with-result.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch09-02-recoverable-errors-with-result.md) >
-> commit e6d6caab41471f7115a621029bd428a812c5260e +> commit a764530433720fe09ae2d97874c25341f8322573 大部分错误并没有严重到需要程序完全停止执行。有时，一个函数会因为一个容易理解并做出反应的原因失败。例如，如果尝试打开一个文件不过由于文件并不存在而操作失败，这时我们可能想要创建这个文件而不是终止进程。 @@ -19,7 +19,7 @@ enum Result { `T` 和 `E` 是泛型类型参数；第十章会详细介绍泛型。现在你需要知道的就是 `T` 代表成功时返回的 `Ok` 成员中的数据的类型，而 `E` 代表失败时返回的 `Err` 成员中的错误的类型。因为 `Result` 有这些泛型类型参数，我们可以将 `Result` 类型和标准库中为其定义的函数用于很多不同的场景，这些情况中需要返回的成功值和失败值可能会各不相同。 -让我们调用一个返回 `Result` 的函数，因为它可能会失败：如示例 9-2 所示打开一个文件： +让我们调用一个返回 `Result` 的函数，因为它可能会失败：如示例 9-3 所示打开一个文件： 文件名: src/main.rs @@ -31,15 +31,15 @@ fn main() { } ``` -示例 9-2：打开文件 +示例 9-3：打开文件 -如何知道 `File::open` 返回一个 `Result` 呢？我们可以查看标准库 API 文档，或者可以直接问编译器！如果给 `f` 某个我们知道 **不是** 函数返回值类型的类型注解，接着尝试编译代码，编译器会告诉我们类型不匹配。然后错误信息会告诉我们 `f` 的类型 **应该** 是什么，为此我们将 `let f` 语句改为： +如何知道 `File::open` 返回一个 `Result` 呢？我们可以查看标准库 API 文档，或者可以直接问编译器！如果给 `f` 某个我们知道 **不是** 函数返回值类型的类型注解，接着尝试编译代码，编译器会告诉我们类型不匹配。然后错误信息会告诉我们 `f` 的类型 **应该** 是什么.让我们试试：我们知道 `File::open` 的返回值不是 `u32` 类型的，所以将 `let f` 语句改为如下： ```rust,ignore let f: u32 = File::open("hello.txt"); ``` -现在尝试编译会给出如下错误： +现在尝试编译会给出如下输出： ```text error[E0308]: mismatched types @@ -50,16 +50,16 @@ error[E0308]: mismatched types `std::result::Result` | = note: expected type `u32` - = note: found type `std::result::Result` + found type `std::result::Result` ``` -这就告诉我们了 `File::open` 函数的返回值类型是 `Result`。这里泛型参数 `T` 放入了成功值的类型 `std::fs::File`，它是一个文件句柄。`E` 被用在失败值上时其类型是 `std::io::Error`。 +这就告诉我们了 `File::open` 函数的返回值类型是 `Result`。这里泛型参数 `T` 放入了成功值的类型 `std::fs::File`，它是一个文件句柄。`E` 被用在失败值上时 `E` 的类型是 `std::io::Error`。 这个返回值类型说明 `File::open` 调用可能会成功并返回一个可以进行读写的文件句柄。这个函数也可能会失败：例如，文件可能并不存在，或者可能没有访问文件的权限。`File::open` 需要一个方式告诉我们是成功还是失败，并同时提供给我们文件句柄或错误信息。而这些信息正是 `Result` 枚举可以提供的。 -当 `File::open` 成功的情况下，变量 `f` 的值将会是一个包含文件句柄的 `Ok` 实例。在失败的情况下，`f` 会是一个包含更多关于出现了何种错误信息的 `Err` 实例。 +当 `File::open` 成功的情况下，变量 `f` 的值将会是一个包含文件句柄的 `Ok` 实例。在失败的情况下，`f` 的值会是一个包含更多关于出现了何种错误信息的 `Err` 实例。 -我们需要在示例 9-2 的代码中增加根据 `File::open` 返回值进行不同处理的逻辑。示例 9-3 展示了一个使用基本工具处理 `Result` 的例子：第六章学习过的 `match` 表达式。 +我们需要在示例 9-3 的代码中增加根据 `File::open` 返回值进行不同处理的逻辑。示例 9-4 展示了一个使用基本工具处理 `Result` 的例子：第六章学习过的 `match` 表达式。 文件名: src/main.rs @@ -78,7 +78,7 @@ fn main() { } ``` -示例 9-3：使用 `match` 表达式处理可能的 `Result` 成员 +示例 9-4：使用 `match` 表达式处理可能的 `Result` 成员 注意与 `Option` 枚举一样，`Result` 枚举和其成员也被导入到了 prelude 中，所以就不需要在 `match` 分支中的 `Ok` 和 `Err` 之前指定 `Result::`。 @@ -88,12 +88,14 @@ fn main() { ```text thread 'main' panicked at 'There was a problem opening the file: Error { repr: -Os { code: 2, message: "No such file or directory" } }', src/main.rs:8 +Os { code: 2, message: "No such file or directory" } }', src/main.rs:9:12 ``` +输出一如既往告诉了我们到底出了什么错。 + ### 匹配不同的错误 -示例 9-3 中的代码不管 `File::open` 是因为什么原因失败都会 `panic!`。我们真正希望的是对不同的错误原因采取不同的行为：如果 `File::open `因为文件不存在而失败，我们希望创建这个文件并返回新文件的句柄。如果 `File::open` 因为任何其他原因失败，例如没有打开文件的权限，我们仍然希望像示例 9-3 那样 `panic!`。让我们看看示例 9-4，其中 `match` 增加了另一个分支： +示例 9-4 中的代码不管 `File::open` 是因为什么原因失败都会 `panic!`。我们真正希望的是对不同的错误原因采取不同的行为：如果 `File::open `因为文件不存在而失败，我们希望创建这个文件并返回新文件的句柄。如果 `File::open` 因为任何其他原因失败，例如没有打开文件的权限，我们仍然希望像示例 9-4 那样 `panic!`。让我们看看示例 9-5，其中 `match` 增加了另一个分支： 文件名: src/main.rs @@ -127,7 +129,7 @@ fn main() { } ``` -示例 9-4：使用不同的方式处理不同类型的错误 +示例 9-5：使用不同的方式处理不同类型的错误 `File::open` 返回的 `Err` 成员中的值类型 `io::Error`，它是一个标准库中提供的结构体。这个结构体有一个返回 `io::ErrorKind` 值的 `kind` 方法可供调用。`io::ErrorKind` 是一个标准库提供的枚举，它的成员对应 `io` 操作可能导致的不同错误类型。我们感兴趣的成员是 `ErrorKind::NotFound`，它代表尝试打开的文件并不存在。 @@ -135,9 +137,9 @@ fn main() { 在 match guard 中我们想要检查的条件是 `error.kind()` 是否是 `ErrorKind` 枚举的 `NotFound` 成员。如果是，尝试用 `File::create` 创建文件。然而 `File::create` 也可能会失败，还需要增加一个内部 `match` 语句。当文件不能被打开，会打印出一个不同的错误信息。外部 `match` 的最后一个分支保持不变这样对任何除了文件不存在的错误会使程序 panic。 -### 失败时 panic 的捷径：`unwrap` 和 `expect` +### 失败时 panic 的简写：`unwrap` 和 `expect` -`match` 能够胜任它的工作，不过它可能有点冗长并且不总是能很好的表明意图。`Result` 类型定义了很多辅助方法来处理各种情况。其中之一叫做 `unwrap`，它的实现就类似于示例 9-3 中的 `match` 语句。如果 `Result` 值是成员 `Ok`，`unwrap` 会返回 `Ok` 中的值。如果 `Result` 是成员 `Err`，`unwrap` 会为我们调用 `panic!`。 +`match` 能够胜任它的工作，不过它可能有点冗长并且不总是能很好的表明其意图。`Result` 类型定义了很多辅助方法来处理各种情况。其中之一叫做 `unwrap`，它的实现就类似于示例 9-4 中的 `match` 语句。如果 `Result` 值是成员 `Ok`，`unwrap` 会返回 `Ok` 中的值。如果 `Result` 是成员 `Err`，`unwrap` 会为我们调用 `panic!`。 ```rust,should_panic use std::fs::File; @@ -152,10 +154,12 @@ fn main() { ```text thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error { repr: Os { code: 2, message: "No such file or directory" } }', -/stable-dist-rustc/build/src/libcore/result.rs:868 +src/libcore/result.rs:906:4 ``` -还有另一个类似于 `unwrap` 的方法它还允许我们选择 `panic!` 的错误信息：`expect`。使用 `expect` 而不是 `unwrap` 并提供一个好的错误信息可以表明你的意图并有助于追踪 panic 的根源。`expect` 的语法看起来像这样： +还有另一个类似于 `unwrap` 的方法它还允许我们选择 `panic!` 的错误信息：`expect`。使用 `expect` 而不是 `unwrap` 并提供一个好的错误信息可以表明你的意图并更易于追踪 panic 的根源。`expect` 的语法看起来像这样： + +文件名: src/main.rs ```rust,should_panic use std::fs::File; @@ -169,15 +173,18 @@ fn main() { ```text thread 'main' panicked at 'Failed to open hello.txt: Error { repr: Os { code: -2, message: "No such file or directory" } }', -/stable-dist-rustc/build/src/libcore/result.rs:868 +2, message: "No such file or directory" } }', src/libcore/result.rs:906:4 ``` +因为这个错误信息以我们指定的文本开始，`Failed to open hello.txt`，将会更容易找到代码中的错误信息来自何处。如果在多处使用 `unwrap`，则需要花更多的时间来分析到底是哪一个 `unwrap` 造成了 panic，因为所有的 `unwrap` 调用都打印相同的信息。 + ### 传播错误 当编写一个其实现会调用一些可能会失败的操作的函数时，除了在这个函数中处理错误外，还可以选择让调用者知道这个错误并决定该如何处理。这被称为 **传播**（*propagating*）错误，这样能更好的控制代码调用，因为比起你代码所拥有的上下文，调用者可能拥有更多信息或逻辑来决定应该如何处理错误。 -例如，示例 9-5 展示了一个从文件中读取用户名的函数。如果文件不存在或不能读取，这个函数会将这些错误返回给调用它的代码： +例如，示例 9-6 展示了一个从文件中读取用户名的函数。如果文件不存在或不能读取，这个函数会将这些错误返回给调用它的代码： + +Filename: src/main.rs ```rust use std::io; @@ -201,21 +208,23 @@ fn read_username_from_file() -> Result { } ``` -示例 9-5：一个函数使用 `match` 将错误返回给代码调用者 +示例 9-6：一个函数使用 `match` 将错误返回给代码调用者 首先让我们看看函数的返回值：`Result`。这意味着函数返回一个 `Result` 类型的值，其中泛型参数 `T` 的具体类型是 `String`，而 `E` 的具体类型是 `io::Error`。如果这个函数没有出任何错误成功返回，函数的调用者会收到一个包含 `String` 的 `Ok` 值————函数从文件中读取到的用户名。如果函数遇到任何错误，函数的调用者会收到一个 `Err` 值，它储存了一个包含更多这个问题相关信息的 `io::Error` 实例。这里选择 `io::Error` 作为函数的返回值是因为它正好是函数体中那两个可能会失败的操作的错误返回值：`File::open` 函数和 `read_to_string` 方法。 -函数体以 `File::open` 函数开头。接着使用 `match` 处理返回值 `Result`，类似于示例 9-3 中的 `match`，唯一的区别是当 `Err` 时不再调用 `panic!`，而是提早返回并将 `File::open` 返回的错误值作为函数的错误返回值传递给调用者。如果 `File::open` 成功了，我们将文件句柄储存在变量 `f` 中并继续。 +函数体以 `File::open` 函数开头。接着使用 `match` 处理返回值 `Result`，类似于示例 9-4 中的 `match`，唯一的区别是当 `Err` 时不再调用 `panic!`，而是提早返回并将 `File::open` 返回的错误值作为函数的错误返回值传递给调用者。如果 `File::open` 成功了，我们将文件句柄储存在变量 `f` 中并继续。 -接着我们在变量 `s` 中创建了一个新 `String` 并调用文件句柄 `f` 的 `read_to_string` 方法来将文件的内容读取到 `s` 中。`read_to_string` 方法也返回一个 `Result` 因为它也可能会失败：哪怕是 `File::open` 已经成功了。所以我们需要另一个 `match` 来处理这个 `Result`：如果 `read_to_string` 成功了，那么这个函数就成功了，并返回文件中的用户名，它现在位于被封装进 `Ok` 的 `s` 中。如果`read_to_string` 失败了，则像之前处理 `File::open` 的返回值的 `match` 那样返回错误值。并不需要显式的调用 `return`，因为这是函数的最后一个表达式。 +接着我们在变量 `s` 中创建了一个新 `String` 并调用文件句柄 `f` 的 `read_to_string` 方法来将文件的内容读取到 `s` 中。`read_to_string` 方法也返回一个 `Result` 因为它也可能会失败：哪怕是 `File::open` 已经成功了。所以我们需要另一个 `match` 来处理这个 `Result`：如果 `read_to_string` 成功了，那么这个函数就成功了，并返回文件中的用户名，它现在位于被封装进 `Ok` 的 `s` 中。如果`read_to_string` 失败了，则像之前处理 `File::open` 的返回值的 `match` 那样返回错误值。不过并不需要显式的调用 `return`，因为这是函数的最后一个表达式。 调用这个函数的代码最终会得到一个包含用户名的 `Ok` 值，或者一个包含 `io::Error` 的 `Err` 值。我们无从得知调用者会如何处理这些值。例如，如果他们得到了一个 `Err` 值，他们可能会选择 `panic!` 并使程序崩溃、使用一个默认的用户名或者从文件之外的地方寻找用户名。我们没有足够的信息知晓调用者具体会如何尝试，所以将所有的成功或失败信息向上传播，让他们选择合适的处理方法。 这种传播错误的模式在 Rust 是如此的常见，以至于有一个更简便的专用语法：`?`。 -### 传播错误的捷径：`?` +### 传播错误的简写：`?` -示例 9-6 展示了一个 `read_username_from_file` 的实现，它实现了与示例 9-5 中的代码相同的功能，不过这个实现是使用了问号运算符的： +示例 9-7 展示了一个 `read_username_from_file` 的实现，它实现了与示例 9-6 中的代码相同的功能，不过这个实现使用了问号运算符： + +文件名: src/main.rs ```rust use std::io; @@ -232,11 +241,15 @@ fn read_username_from_file() -> Result { 示例 9-6：一个使用 `?` 向调用者返回错误的函数 -`Result` 值之后的 `?` 被定义为与示例 9-5 中定义的处理 `Result` 值的 `match` 表达式有着完全相同的工作方式。如果 `Result` 的值是 `Ok`，这个表达式将会返回 `Ok` 中的值而程序将继续执行。如果值是 `Err`，`Err` 中的值将作为整个函数的返回值，就好像使用了 `return` 关键字一样，这样错误值就被传播给了调用者。 +`Result` 值之后的 `?` 被定义为与示例 9-6 中定义的处理 `Result` 值的 `match` 表达式有着完全相同的工作方式。如果 `Result` 的值是 `Ok`，这个表达式将会返回 `Ok` 中的值而程序将继续执行。如果值是 `Err`，`Err` 中的值将作为整个函数的返回值，就好像使用了 `return` 关键字一样，这样错误值就被传播给了调用者。 -在示例 9-6 的上下文中，`File::open` 调用结尾的 `?` 将会把 `Ok` 中的值返回给变量 `f`。如果出现了错误，`?` 会提早返回整个函数并将一些 `Err` 值传播给调用者。同理也适用于 `read_to_string` 调用结尾的 `?`。 +示例 9-6 中的 `match` 表达式与问号运算符所做的有一点不同：`?` 所使用的错误值被传递给了 `from` 函数，它定义于标准库的 `From` trait 中，其用来将错误从一种类型转换为另一种类型。到问号运算符调用 `from` 函数时，收到的错误类型被转换为定义为当前函数返回的错误类型。这在当一个函数返回一个错误类型来代表所有可能失败的方式时很有用，即使其可能会因很多种原因失败。只要每一个错误类型都实现了 `from` 函数来定义如将其转换为返回的错误类型，问号运算符会自动处理这些转换。 -`?` 消除了大量样板代码并使得函数的实现更简单。我们甚至可以在 `?` 之后直接使用链式方法调用来进一步缩短代码： +在示例 9-7 的上下文中，`File::open` 调用结尾的 `?` 将会把 `Ok` 中的值返回给变量 `f`。如果出现了错误，`?` 会提早返回整个函数并将一些 `Err` 值传播给调用者。同理也适用于 `read_to_string` 调用结尾的 `?`。 + +`?` 消除了大量样板代码并使得函数的实现更简单。我们甚至可以在 `?` 之后直接使用链式方法调用来进一步缩短代码，如示例 9-8 所示： + +文件名: src/main.rs ```rust use std::io; @@ -252,13 +265,15 @@ fn read_username_from_file() -> Result { } ``` -在 `s` 中创建新的 `String` 被放到了函数开头；这没有什么变化。我们对 `File::open("hello.txt")?` 的结果直接链式调用了 `read_to_string`，而不再创建变量 `f`。仍然需要 `read_to_string` 调用结尾的 `?`，而且当 `File::open` 和 `read_to_string` 都成功没有失败时返回包含用户名 `s` 的 `Ok` 值。其功能再一次与示例 9-5 和示例 9-6 保持一致，不过这是一个与众不同且更符合工程学的写法。 +示例 9-8：问号运算符之后的链式方法调用 + +在 `s` 中创建新的 `String` 被放到了函数开头；这一部分没有变化。我们对 `File::open("hello.txt")?` 的结果直接链式调用了 `read_to_string`，而不再创建变量 `f`。仍然需要 `read_to_string` 调用结尾的 `?`，而且当 `File::open` 和 `read_to_string` 都成功没有失败时返回包含用户名 `s` 的 `Ok` 值。其功能再一次与示例 9-6 和示例 9-7 保持一致，不过这是一个与众不同且更符合工程学的写法。 ### `?` 只能被用于返回 `Result` 的函数 -`?` 只能被用于返回值类型为 `Result` 的函数，因为他被定义为与示例 9-5 中的 `match` 表达式有着完全相同的工作方式。`match` 的 `return Err(e)` 部分要求返回值类型是 `Result`，所以函数的返回值必须是 `Result` 才能与这个 `return` 相兼容。 +`?` 只能被用于返回值类型为 `Result` 的函数，因为他被定义为与示例 9-6 中的 `match` 表达式有着完全相同的工作方式。`match` 的 `return Err(e)` 部分要求返回值类型是 `Result`，所以函数的返回值必须是 `Result` 才能与这个 `return` 相兼容。 -让我们看看在 `main` 函数中使用 `?` 会发生什么，如果你还记得的话它的返回值类型是`()`： +让我们看看在 `main` 函数中使用 `?` 会发生什么，如果你还记得的话其返回值类型是`()`： ```rust,ignore use std::fs::File; @@ -268,29 +283,23 @@ fn main() { } ``` - - 当编译这些代码，会得到如下错误信息： ```text -error[E0308]: mismatched types - --> +error[E0277]: the trait bound `(): std::ops::Try` is not satisfied + --> src/main.rs:4:13 | -3 | let f = File::open("hello.txt")?; - | ^^^^^^^^^^^^^^^^^^^^^^^^^ expected (), found enum -`std::result::Result` +4 | let f = File::open("hello.txt")?; + | ------------------------ + | | + | the `?` operator can only be used in a function that returns + `Result` (or another type that implements `std::ops::Try`) + | in this macro invocation | - = note: expected type `()` - = note: found type `std::result::Result<_, _>` + = help: the trait `std::ops::Try` is not implemented for `()` + = note: required by `std::ops::Try::from_error` ``` -错误指出存在不匹配的类型：`main` 函数返回一个 `()` 类型，而 `?` 返回一个 `Result`。编写不返回 `Result` 的函数时，如果调用其他返回 `Result` 的函数，需要使用 `match` 或者 `Result` 的方法之一来处理它，而不能用 `?` 将潜在的错误传播给调用者。 +错误指出只能在返回 `Result` 的函数中使用问号运算符。在不返回 `Result` 的函数中，当调用其他返回 `Result` 的函数时，需要使用 `match` 或 `Result` 的方法之一来处理，而不能用 `?` 将潜在的错误传播给调用者。 现在我们讨论过了调用 `panic!` 或返回 `Result` 的细节，是时候返回他们各自适合哪些场景的话题了。 diff --git a/src/ch09-03-to-panic-or-not-to-panic.md b/src/ch09-03-to-panic-or-not-to-panic.md index 280f5c6..93abbbc 100644 --- a/src/ch09-03-to-panic-or-not-to-panic.md +++ b/src/ch09-03-to-panic-or-not-to-panic.md @@ -2,7 +2,7 @@ > [ch09-03-to-panic-or-not-to-panic.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch09-03-to-panic-or-not-to-panic.md) >
-> commit 88dee413c0792dcaf563d753e00400cc191f1fbe +> commit 3e79fb6f3f85ac6d4a0ce46612e5a7381dc7f1b1 那么，该如何决定何时应该 `panic!` 以及何时应该返回 `Result` 呢？如果代码 panic，就没有恢复的可能。你可以选择对任何错误场景都调用 `panic!`，不管是否有可能恢复，不过这样就是你代替调用者决定了这是不可恢复的。选择返回 `Result` 值的话，就将选择权交给了调用者，而不是代替他们做出决定。调用者可能会选择以符合他们场景的方式尝试恢复，或者也可能干脆就认为 `Err` 是不可恢复的，所以他们也可能会调用 `panic!` 并将可恢复的错误变成了不可恢复的错误。因此返回 `Result` 是定义可能会失败的函数的一个好的默认选择。 From 5f3aa59bb8ec008166085bbead992b31dc80e815 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Sun, 21 Jan 2018 19:23:30 +0800 Subject: [PATCH 117/150] check to ch10-03 --- src/ch09-03-to-panic-or-not-to-panic.md | 22 +++++++++++----------- src/ch10-00-generics.md | 2 +- src/ch10-01-syntax.md | 4 ++-- src/ch10-02-traits.md | 17 ++++++++--------- src/ch10-03-lifetime-syntax.md | 2 +- 5 files changed, 23 insertions(+), 24 deletions(-) diff --git a/src/ch09-03-to-panic-or-not-to-panic.md b/src/ch09-03-to-panic-or-not-to-panic.md index 93abbbc..b37970a 100644 --- a/src/ch09-03-to-panic-or-not-to-panic.md +++ b/src/ch09-03-to-panic-or-not-to-panic.md @@ -8,7 +8,7 @@ 有一些情况 panic 比返回 `Result` 更为合适，不过他们并不常见。让我们讨论一下为何在示例、代码原型和测试中，以及那些人们认为不会失败而编译器不这么看的情况下， panic 是合适的，最后会总结一些在库代码中如何决定是否要 panic 的通用指导原则。 -### 示例、代码原型和测试：非常适合 panic +### 示例、代码原型和测试都非常适合 panic 当你编写一个示例来展示一些概念时，在拥有健壮的错误处理代码的同时也会使得例子不那么明确。例如，调用一个类似 `unwrap` 这样可能 `panic!` 的方法可以被理解为一个你实际希望程序处理错误方式的占位符，它根据其余代码运行方式可能会各不相同。 @@ -23,24 +23,24 @@ ```rust use std::net::IpAddr; -let home = "127.0.0.1".parse::().unwrap(); +let home: IpAddr = "127.0.0.1".parse().unwrap(); ``` -我们通过解析一个硬编码的字符来创建一个 `IpAddr`实例。可以看出 `127.0.0.1` 是一个有效的 IP 地址，所以这里使用 `unwrap` 是没有问题的。然而，拥有一个硬编码的有效的字符串也不能改变 `parse` 方法的返回值类型：它仍然是一个 `Result` 值，而编译器仍然就好像还是有可能出现 `Err` 成员那样要求我们处理 `Result`，因为编译器还没有智能到可以识别出这个字符串总是一个有效的 IP 地址。如果 IP 地址字符串来源于用户而不是硬编码进程序中的话，那么就 **确实** 有失败的可能性，这时就绝对需要我们以一种更健壮的方式处理 `Result` 了。 +我们通过解析一个硬编码的字符来创建一个 `IpAddr` 实例。可以看出 `127.0.0.1` 是一个有效的 IP 地址，所以这里使用 `unwrap` 是可以接受的。然而，拥有一个硬编码的有效的字符串也不能改变 `parse` 方法的返回值类型：它仍然是一个 `Result` 值，而编译器仍然就好像还是有可能出现 `Err` 成员那样要求我们处理 `Result`，因为编译器还没有智能到可以识别出这个字符串总是一个有效的 IP 地址。如果 IP 地址字符串来源于用户而不是硬编码进程序中的话，那么就 **确实** 有失败的可能性，这时就绝对需要我们以一种更健壮的方式处理 `Result` 了。 ### 错误处理指导原则 -在当有可能会导致有害状态的情况下建议使用 `panic!`——在这里，有害状态是指当一些假设、保证、协议或不可变性被打破的状态，例如无效的值、自相矛盾的值或者被传递了不存在的值——外加如下几种情况： +在当有可能会导致有害状态的情况下建议使用 `panic!` —— 在这里，有害状态是指当一些假设、保证、协议或不可变性被打破的状态，例如无效的值、自相矛盾的值或者被传递了不存在的值 —— 外加如下几种情况： * 有害状态并不包含 **预期** 会偶尔发生的错误 -* 之后的代码的运行依赖于不再处于这种有害状态 +* 之后的代码的运行依赖于处于这种有害状态 * 当没有可行的手段来将有害状态信息编码进所使用的类型中的情况 如果别人调用你的代码并传递了一个没有意义的值，最好的情况也许就是 `panic!` 并警告使用你的库的人他的代码中有 bug 以便他能在开发时就修复它。类似的，`panic!` 通常适合调用不能够控制的外部代码时，这时无法修复其返回的无效状态。 无论代码编写的多么好，当有害状态是预期会出现时，返回 `Result` 仍要比调用 `panic!` 更为合适。这样的例子包括解析器接收到错误数据，或者 HTTP 请求返回一个表明触发了限流的状态。在这些例子中，应该通过返回 `Result` 来表明失败预期是可能的，这样将有害状态向上传播，这样调用者就可以决定该如何处理这个问题。使用 `panic!` 来处理这些情况就不是最好的选择。 -当代码对值进行操作时，应该首先验证值是有效的，并在其无效时 `panic!`。这主要是出于安全的原因：尝试操作无效数据会暴露代码漏洞，这就是标准库在尝试越界访问数组时会 `panic!` 的主要原因：尝试访问不属于当前数据结构的内存是一个常见的安全隐患。函数通常都遵循 **契约**（*contracts*）：他们的行为只有在输入满足特定条件时才能得到保证。当违反契约时 panic 是有道理的，因为这通常代表调用方的 bug，而且这也不是那种你希望调用方必须处理的错误。事实上也没有合理的方式来恢复调用方的代码：调用方的 **程序员** 需要修复他的代码。函数的契约，尤其是当违反它会造成 panic 的契约，应该在函数的 API 文档中得到解释。 +当代码对值进行操作时，应该首先验证值是有效的，并在其无效时 `panic!`。这主要是出于安全的原因：尝试操作无效数据会暴露代码漏洞，这就是标准库在尝试越界访问数组时会 `panic!` 的主要原因：尝试访问不属于当前数据结构的内存是一个常见的安全隐患。函数通常都遵循 **契约**（*contracts*）：他们的行为只有在输入满足特定条件时才能得到保证。当违反契约时 panic 是有道理的，因为这通常代表调用方的 bug，而且这也不是那种你希望调用方必须处理的错误。事实上也没有合理的方式来恢复调用方的代码：调用方的 **程序员** 需要修复其代码。函数的契约，尤其是当违反它会造成 panic 的契约，应该在函数的 API 文档中得到解释。 虽然在所有函数中都拥有许多错误检查是冗长而烦人的。幸运的是，可以利用 Rust 的类型系统（以及编译器的类型检查）为你进行很多检查。如果函数有一个特定类型的参数，可以在知晓编译器已经确保其拥有一个有效值的前提下进行你的代码逻辑。例如，如果你使用了一个不同于 `Option` 的类型，而且程序期望它是 **有值** 的并且不是 **空值**。你的代码无需处理 `Some` 和 `None` 这两种情况，它只会有一种情况就是绝对会有一个值。尝试向函数传递空值的代码甚至根本不能编译，所以你的函数在运行时没有必要判空。另外一个例子是使用像 `u32` 这样的无符号整型，也会确保它永远不为负。 @@ -52,7 +52,7 @@ let home = "127.0.0.1".parse::().unwrap(); ```rust,ignore loop { - // snip + // --snip-- let guess: i32 = match guess.trim().parse() { Ok(num) => num, @@ -65,7 +65,7 @@ loop { } match guess.cmp(&secret_number) { - // snip + // --snip-- } ``` @@ -73,7 +73,7 @@ loop { 然而，这并不是一个理想的解决方案：程序只处理 1 到 100 之间的值是绝对不可取的，而且如果有很多函数都有这样的要求，在每个函数中都有这样的检查将是非常冗余的（并可能潜在的影响性能）。 -相反我们可以创建一个新类型来将验证放入创建其实例的函数中，而不是到处重复这些检查。这样就可以安全的在函数签名中使用新类型并相信他们接收到的值。示例 9-8 中展示了一个定义 `Guess` 类型的方法，只有在 `new` 函数接收到 1 到 100 之间的值时才会创建 `Guess` 的实例： +相反我们可以创建一个新类型来将验证放入创建其实例的函数中，而不是到处重复这些检查。这样就可以安全的在函数签名中使用新类型并相信他们接收到的值。示例 9-9 中展示了一个定义 `Guess` 类型的方法，只有在 `new` 函数接收到 1 到 100 之间的值时才会创建 `Guess` 的实例： ```rust pub struct Guess { @@ -97,7 +97,7 @@ impl Guess { } ``` -示例 9-8：一个 `Guess` 类型，它只在值位于 1 和 100 之间时才继续 +示例 9-9：一个 `Guess` 类型，它只在值位于 1 和 100 之间时才继续 首先，我们定义了一个包含 `u32` 类型字段 `value` 的结构体 `Guess`。这里是储存猜测值的地方。 @@ -111,4 +111,4 @@ impl Guess { Rust 的错误处理功能被设计为帮助你编写更加健壮的代码。`panic!` 宏代表一个程序无法处理的状态，并停止执行而不是使用无效或不正确的值继续处理。Rust 类型系统的 `Result` 枚举代表操作可能会在一种可以恢复的情况下失败。可以使用 `Result` 来告诉代码调用者他需要处理潜在的成功或失败。在适当的场景使用 `panic!` 和 `Result` 将会使你的代码在面对无处不在的错误时显得更加可靠。 -现在我们已经见识过了标准库中 `Option` 和 `Result` 泛型枚举的能力了，让我们聊聊泛型是如何工作的，以及如何在你的代码中利用他们。 \ No newline at end of file +现在我们已经见识过了标准库中 `Option` 和 `Result` 泛型枚举的能力了，在下一章让我们聊聊泛型是如何工作的，以及如何在你的代码中利用他们。 \ No newline at end of file diff --git a/src/ch10-00-generics.md b/src/ch10-00-generics.md index 04410fa..3039c8e 100644 --- a/src/ch10-00-generics.md +++ b/src/ch10-00-generics.md @@ -4,7 +4,7 @@ >
> commit f65676e17d7fc4c0c7cd7275a7bf15447364831a -每一个编程语言都有高效的处理重复概念的工具；在 Rust 中工具之一就是 **泛型**（*generics*）。泛型是具体类型或其他属性的抽象替代。我们可以表达泛型的属性，比如他们的行为或如何与其他泛型相关联，而不需要在编写和编译代码时知道他们在这里实际上代表什么。 +每一个编程语言都有高效的处理重复概念的工具；在 Rust 中其工具之一就是 **泛型**（*generics*）。泛型是具体类型或其他属性的抽象替代。我们可以表达泛型的属性，比如他们的行为或如何与其他泛型相关联，而不需要在编写和编译代码时知道他们在这里实际上代表什么。 同理为了编写一份可以用于多种具体值的代码，函数并不知道其参数为何值，这时就可以让函数获取泛型而不是像 `i32` 或 `String` 这样的具体值。我们已经使用过第六章的 `Option`，第八章的 `Vec` 和 `HashMap`，以及第九章的 `Result` 这些泛型了。本章会探索如何使用泛型定义我们自己的类型、函数和方法！ diff --git a/src/ch10-01-syntax.md b/src/ch10-01-syntax.md index 650b6a5..19a5562 100644 --- a/src/ch10-01-syntax.md +++ b/src/ch10-01-syntax.md @@ -114,7 +114,7 @@ error[E0369]: binary operation `>` cannot be applied to type `T` note: an implementation of `std::cmp::PartialOrd` might be missing for `T` ``` -注释中提到了 `std::cmp::PartialOrd`，这是一个 *trait*。下一部分会讲到 trait，不过简单来说，这个错误表明 `largest` 的函数体不能适用于 `T` 的所有可能的类型；因为在函数体需要比较 `T` 类型的值，不过它只能用于我们知道如何排序的类型。标准库中定义的 `std::cmp::PartialOrd` trait 可以实现类型的排序功能。在下一部分会再次回到 trait 并讲解如何为泛型指定一个 trait，不过让我们先把这个例子放在一边并探索其他那些可以使用泛型类型参数的地方。 +注释中提到了 `std::cmp::PartialOrd`，这是一个 *trait*。下一部分会讲到 trait，不过简单来说，这个错误表明 `largest` 的函数体不能适用于 `T` 的所有可能的类型；因为在函数体需要比较 `T` 类型的值，不过它只能用于我们知道如何排序的类型。标准库中定义的 `std::cmp::PartialOrd` trait 可以实现类型的比较功能。在下一部分会再次回到 trait 并讲解如何为泛型指定一个 trait，不过让我们先把这个例子放在一边并探索其他那些可以使用泛型类型参数的地方。 -我们将 `r` 的生命周期标记为 `'a` 并将 `x` 的生命周期标记为 `'b`。如你所见，内部的 `'b` 块要比外部的生命周期 `'a` 小得多。在编译时，Rust 比较这两个生命周期的大小，并发现 `r` 拥有声明周期 `'a`，不过它引用了一个拥有生命周期 `'b` 的对象。程序被拒绝编译，因为生命周期 `'b` 比生命周期 `'a` 要小：被引用的对象比它的引用者存活的时间更短。 +我们将 `r` 的生命周期标记为 `'a` 并将 `x` 的生命周期标记为 `'b`。如你所见，内部的 `'b` 块要比外部的生命周期 `'a` 小得多。在编译时，Rust 比较这两个生命周期的大小，并发现 `r` 拥有声明周期 `'a`，不过它引用了一个拥有生命周期 `'b` 的对象。程序被拒绝编译，因为生命周期 `'b` 比生命周期 `'a` 要小：被引用的对象比它的引用者存在的时间更短。 让我们看看示例 10-20 中这个并没有产生悬垂引用且可以正确编译的例子： @@ -204,15 +202,15 @@ fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { 示例 10-23：`longest` 函数定义指定了签名中所有的引用必须有相同的生命周期 `'a` -这段代码能够编译并会产生我们想要使用示例 10-21 中的 `main` 函数得到的结果。 +这段代码能够编译并会产生我们希望得到的示例 10-21 中的 `main` 函数的结果。 -现在函数签名表明对于某些生命周期 `'a`，函数会获取两个参数，他们都是与生命周期 `'a` 存在的一样长的字符串 slice。函数会返回一个同样也与生命周期 `'a` 存在的一样长的字符串 slice。这就是我们告诉 Rust 需要其保证的协议。 +现在函数签名表明对于某些生命周期 `'a`，函数会获取两个参数，他们都是与生命周期 `'a` 存在的一样长的字符串 slice。函数会返回一个同样也与生命周期 `'a` 存在的一样长的字符串 slice。这就是我们告诉 Rust 需要其保证的契约。 -我们并不会通过“在函数签名中指定生命周期参数”这种方式来改变任何参数或返回值的生命周期，而是指出任何不遵守这个协议的传入值都将被借用检查器拒绝。这个函数并不知道（或需要知道）`x` 和 `y` 具体会存在多久，而只需要知道有某个可以被 `'a` 替代的作用域将会满足这个签名。 +通过在函数签名中指定生命周期参数，我们并没有改变任何传入后返回的值的生命周期，而是指出任何不遵守这个协议的传入值都将被借用检查器拒绝。这个函数并不知道（或需要知道）`x` 和 `y` 具体会存在多久，而只需要知道有某个可以被 `'a` 替代的作用域将会满足这个签名。 当在函数中使用生命周期注解时，这些注解出现在函数签名中，而不存在于函数体中的任何代码中。这是因为 Rust 能够分析函数中代码而不需要任何协助，不过当函数引用或被函数之外的代码引用时，参数或返回值的生命周期可能在每次函数被调用时都不同。这可能会产生惊人的消耗并且对于 Rust 来说通常是不可能分析的。在这种情况下，我们需要自己标注生命周期。 -当具体的引用被传递给 `longest` 时，被 `'a` 所替代的具体生命周期是 `x` 的作用域与 `y` 的作用域相重叠的那一部分。因为作用域总是嵌套的，所以换一种说法就是泛型生命周期 `'a` 的具体生命周期等同于 `x` 和 `y` 的生命周期中较小的那一个。因为我们用相同的生命周期参数标注了返回的引用值，所以返回的引用值就能保证在 `x` 和 `y` 中较短的那个生命周期结束之前保持有效。 +当具体的引用被传递给 `longest` 时，被 `'a` 所替代的具体生命周期是 `x` 的作用域与 `y` 的作用域相重叠的那一部分。因为作用域总是嵌套的，所以换一种说法就是泛型生命周期 `'a` 的具体生命周期等同于 `x` 和 `y` 的生命周期中较小的那一个。因为我们用相同的生命周期参数 `'a` 标注了返回的引用值，所以返回的引用值就能保证在 `x` 和 `y` 中较短的那个生命周期结束之前保持有效。 让我们看看如何通过传递拥有不同具体生命周期的引用来限制 `longest` 函数的使用。示例 10-24 是一个应该在任何编程语言中都很直观的例子：`string1` 直到外部作用域结束都是有效的，`string2` 则在内部作用域中是有效的，而 `result` 则引用了一些直到内部作用域结束都是有效的值。借用检查器认可这些代码；它能够编译和运行，并打印出 `The longest string is long string is long`： @@ -240,7 +238,7 @@ fn main() { 示例 10-24：通过拥有不同的具体生命周期的 `String` 值调用 `longest` 函数 -接下来，让我们尝试一个 `result` 的引用的生命周期肯定比两个参数的要短的例子。将 `result` 变量的声明从内部作用域中移动出来，但是将 `result` 和 `string2` 变量的赋值语句一同放在内部作用域里。接下来，我们将使用 `result` 的 `println!` 移动到内部作用域之外，就在其结束之后。注意示例 10-25 中的代码不能编译： +接下来，让我们尝试一个 `result` 的引用的生命周期肯定比两个参数的要短的例子。将 `result` 变量的声明从内部作用域中移动出来，但是将 `result` 和 `string2` 变量的赋值语句一同留在内部作用域里。接下来，我们将使用 `result` 的 `println!` 移动到内部作用域之外，就在其结束之后。注意示例 10-25 中的代码不能编译： 文件名: src/main.rs @@ -274,7 +272,7 @@ error: `string2` does not live long enough 错误表明为了保证 `println!` 中的 `result` 是有效的，`string2` 需要直到外部作用域结束都是有效的。Rust 知道这些是因为（`longest`）函数的参数和返回值都使用了相同的生命周期参数 `'a`。 -以我们的理解 `string1` 更长，因此 `result` 会包含指向 `string1` 的引用。因为 `string1` 尚未离开作用域，对于 `println!` 来说 `string1` 的引用仍然是有效的。然而，我们通过生命周期参数告诉 Rust 的是 `longest` 函数返回的引用的生命周期应该与传入参数的生命周期中较短那个保持一致。因此，借用检查器不允许示例 10-25 中的代码，因为它可能会存在无效的引用。 +以人类的理解 `string1` 更长，因此 `result` 会包含指向 `string1` 的引用。因为 `string1` 尚未离开作用域，对于 `println!` 来说 `string1` 的引用仍然是有效的。然而，我们通过生命周期参数告诉 Rust 的是 `longest` 函数返回的引用的生命周期应该与传入参数的生命周期中较短那个保持一致。因此，借用检查器不允许示例 10-25 中的代码，因为它可能会存在无效的引用。 请尝试更多采用不同的值和不同生命周期的引用作为 `longest` 函数的参数和返回值的实验。并在开始编译前猜想你的实验能否通过借用检查器，接着编译一下看看你的理解是否正确！ @@ -350,7 +348,7 @@ fn main() { 这里的 `main` 函数创建了一个 `ImportantExcerpt` 的实例，它存放了变量 `novel` 所拥有的 `String` 的第一个句子的引用。 -### 生命周期省略 +### 生命周期省略（Lifetime Elision） 在这一部分，我们知道了每一个引用都有一个生命周期，而且需要为使用了引用的函数或结构体指定生命周期。然而，第四章的 “字符串 slice” 部分有一个函数，我们在示例 10-27 中再次展示出来，它没有生命周期注解却能成功编译： @@ -372,7 +370,7 @@ fn first_word(s: &str) -> &str { 示例 10-27：第四章定义了一个没有使用生命周期注解的函数，即便其参数和返回值都是引用 -这个函数没有生命周期注解却能编译是由于一些历史原因：在早期 1.0 之前版本的 Rust 中，这的确是不能编译的。每一个引用都必须有明确的生命周期。那时的函数签名将会写成这样： +这个函数没有生命周期注解却能编译是由于一些历史原因：在早期 pre-1.0 版本的 Rust 中，这的确是不能编译的。每一个引用都必须有明确的生命周期。那时的函数签名将会写成这样： ```rust,ignore fn first_word<'a>(s: &'a str) -> &'a str { @@ -392,9 +390,9 @@ fn first_word<'a>(s: &'a str) -> &'a str { 1. 每一个是引用的参数都有它自己的生命周期参数。换句话说就是，有一个引用参数的函数有一个生命周期参数：`fn foo<'a>(x: &'a i32)`，有两个引用参数的函数有两个不同的生命周期参数，`fn foo<'a, 'b>(x: &'a i32, y: &'b i32)`，依此类推。 -2. 如果只有一个输入生命周期参数，那么它被赋给所有输出生命周期参数：`fn foo<'a>(x: &'a i32) -> &'a i32`。 +2. 如果只有一个输入生命周期参数，那么它被赋予所有输出生命周期参数：`fn foo<'a>(x: &'a i32) -> &'a i32`。 -3. 如果方法有多个输入生命周期参数，不过其中之一因为方法的缘故为 `&self` 或 `&mut self`，那么 `self` 的生命周期被赋给所有输出生命周期参数。这使得方法写起来更简洁。 +3. 如果方法有多个输入生命周期参数，不过其中之一因为方法的缘故为 `&self` 或 `&mut self`，那么 `self` 的生命周期被赋给所有输出生命周期参数。这使得方法编写起来更简洁。 假设我们自己就是编译器并来计算示例 10-25 `first_word` 函数的签名中的引用的生命周期。开始时签名中的引用并没有关联任何生命周期： @@ -414,7 +412,7 @@ fn first_word<'a>(s: &'a str) -> &str { fn first_word<'a>(s: &'a str) -> &'a str { ``` -现在这个函数签名中的所有引用都有了生命周期，而编译器可以继续它的分析而无须程序员标记这个函数签名中的生命周期。 +现在这个函数签名中的所有引用都有了生命周期，如此编译器可以继续它的分析而无须程序员标记这个函数签名中的生命周期。 让我们再看看另一个例子，这次我们从示例 10-22 中没有生命周期参数的 `longest` 函数开始： @@ -422,13 +420,13 @@ fn first_word<'a>(s: &'a str) -> &'a str { fn longest(x: &str, y: &str) -> &str { ``` -再次假设我们自己就是编译器并应用第一条规则：每个引用参数都有其自己的生命周期。这次有两个参数，所以就有两个生命周期： +再次假设我们自己就是编译器并应用第一条规则：每个引用参数都有其自己的生命周期。这次有两个参数，所以就有两个（不同的）生命周期： ```rust,ignore fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str { ``` -再来应用第二条规则，它并不适用因为存在多于一个输入生命周期。再来看第三条规则，它同样也不适用因为没有 `self` 参数。然后我们就没有更多规则了，不过还没有计算出返回值的类型的生命周期。这就是为什么在编译示例 10-22 的代码时会出现错误的原因：编译器使用所有已知的生命周期省略规则，不过仍然不能计算出签名中所有引用的生命周期。 +再来应用第二条规则，它并不适用因为存在多于一个输入生命周期。再来看第三条规则，它同样也不适用因为没有 `self` 参数。然后我们就没有更多规则了，不过还没有计算出返回值的类型的生命周期。这就是为什么在编译示例 10-22 的代码时会出现错误的原因：编译器使用所有已知的生命周期省略规则，不过仍不能计算出签名中所有引用的生命周期。 因为第三条规则真正能够适用的就只有方法签名，现在就让我们看看那种情况中的生命周期，并看看为什么这条规则意味着我们经常不需要在方法签名中标注生命周期。 @@ -498,7 +496,7 @@ let s: &'static str = "I have a static lifetime."; ### 结合泛型类型参数、trait bounds 和生命周期 -让我们简单的看一下在同一函数中指定泛型类型参数、trait bounds 和生命周期的语法！ +让我们简要的看一下在同一函数中指定泛型类型参数、trait bounds 和生命周期的语法！ ```rust use std::fmt::Display; diff --git a/src/ch11-00-testing.md b/src/ch11-00-testing.md index 0190454..f44a328 100644 --- a/src/ch11-00-testing.md +++ b/src/ch11-00-testing.md @@ -2,20 +2,20 @@ > [ch11-00-testing.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch11-00-testing.md) >
-> commit 1047433147b27d19e5acc068a0ebca5782d64f99 +> commit 4464eab0892297b83db7134b7ace12762a89b389 > Program testing can be a very effective way to show the presence of bugs, but it is hopelessly inadequate for showing their absence. > > Edsger W. Dijkstra, "The Humble Programmer" (1972) > -> 软件测试是证明 bug 存在的有效方法，而证明它们不存在时则显得令人绝望的不足。 +> 软件测试是证明 bug 存在的有效方法，而证明其不存在时则显得令人绝望的不足。 > > Edsger W. Dijkstra，【谦卑的程序员】（1972） -程序的正确性意味着代码如我们期望的那样运行。Rust 是一个非常注重正确性的编程语言，不过正确性是一个难以证明的复杂主题。Rust 的类型系统在此问题上下了很大的功夫，不过它不可能捕获所有种类的错误。为此，Rust 也在语言本身包含了编写软件测试的支持。 +这并不意味着我们不该尽可能测试软件！程序的正确性意味着代码如我们期望的那样运行。Rust 是一个相当注重正确性的编程语言，不过正确性是一个难以证明的复杂主题。Rust 的类型系统在此问题上下了很大的功夫，不过它不可能捕获所有种类的错误。为此，Rust 也在语言本身包含了编写软件测试的支持。 例如，我们可以编写一个叫做 `add_two` 的将传递给它的值加二的函数。它的签名有一个整型参数并返回一个整型值。当实现和编译这个函数时，Rust 会进行所有目前我们已经见过的类型检查和借用检查，例如，这些检查会确保我们不会传递 `String` 或无效的引用给这个函数。Rust 所 **不能** 检查的是这个函数是否会准确的完成我们期望的工作：返回参数加二后的值，而不是比如说参数加 10 或减 50 的值！这也就是测试出场的地方。 -我们可以编写测试断言，比如说，当传递 `3` 给 `add_two` 函数时，应该得到 `5`。当对代码进行修改时可以运行测试来确保任何现存的正确行为没有被改变。 +我们可以编写测试断言，比如说，当传递 `3` 给 `add_two` 函数时，返回值是 `5`。无论何时对代码进行修改，都可以运行测试来确保任何现存的正确行为没有被改变。 -测试是一项复杂的技能，而且我们也不能期望在一本书的一个章节中就涉及到编写好的测试的所有内容，所以这里仅仅讨论 Rust 测试功能的机制。我们会讲到编写测试时会用到的注解和宏，Rust 提供用来运行测试的默认行为和选项，以及如何将测试组织成单元测试和集成测试。 \ No newline at end of file +测试是一项复杂的技能：虽然不能在一本书的一个章节中就涉及到编写好的测试的所有细节，我们还是会讨论 Rust 测试功能的机制。我们会讲到编写测试时会用到的注解和宏，Rust 提供用来运行测试的默认行为和选项，以及如何将测试组织成单元测试和集成测试。 \ No newline at end of file diff --git a/src/ch11-01-writing-tests.md b/src/ch11-01-writing-tests.md index fd75a62..25b0cea 100644 --- a/src/ch11-01-writing-tests.md +++ b/src/ch11-01-writing-tests.md @@ -1,10 +1,17 @@ -## 编写测试 +## 如何编写测试 > [ch11-01-writing-tests.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch11-01-writing-tests.md) >
-> commit db08b34db5f1c78b4866b391c802344ec94ecc38 +> commit 4464eab0892297b83db7134b7ace12762a89b389 -测试用来验证非测试的代码是否按照期望的方式运行的 Rust 函数。测试函数体通常包括一些设置，运行需要测试的代码，接着断言其结果是我们所期望的。让我们看看 Rust 提供的专门用来编写测试的功能：`test` 属性、一些宏和 `should_panic` 属性。 +测试用来验证非测试的代码是否按照期望的方式运行的 Rust 函数。测试函数体通常执行如下三种操作： + +1. 设置任何所需的数据或状态 +2. 运行需要测试的代码 +3. 断言其结果是我们所期望的 + + +让我们看看 Rust 提供的专门用来编写测试的功能：`test` 属性、一些宏和 `should_panic` 属性。 ### 测试函数剖析 @@ -12,7 +19,7 @@ 第七章当使用 Cargo 新建一个库项目时，它会自动为我们生成一个测试模块和一个测试函数。这有助于我们开始编写测试，因为这样每次开始新项目时不必去查找测试函数的具体结构和语法了。当然也可以额外增加任意多的测试函数以及测试模块！ -我们将先通过对自动生成的测试模板做一些试验来探索测试如何工作方面的一些内容，而不实际测试任何代码。接着会写一些真实的测试来调用我们编写的代码并断言他们的行为是否正确。 +我们将先通过对自动生成的测试模板做一些试验来探索一些测试如何工作方面的内容，而不实际测试任何代码。接着会写一些真实的测试来调用我们编写的代码并断言他们的行为是否正确。 让我们创建一个新的库项目 `adder`： @@ -22,7 +29,7 @@ $ cargo new adder $ cd adder ``` -adder 库中 `src/lib.rs` 的内容应该看起来像这样： +adder 库中 `src/lib.rs` 的内容应该看起来如示例 11-1 所示： 文件名: src/lib.rs @@ -31,15 +38,16 @@ adder 库中 `src/lib.rs` 的内容应该看起来像这样： mod tests { #[test] fn it_works() { + assert_eq!(2 + 2, 4); } } ``` 示例 11-1：由 `cargo new` 自动生成的测试模块和函数 -现在让我们暂时忽略 `tests` 模块和 `#[cfg(test)]` 注解并只关注函数来了解其如何工作。注意 `fn` 行之前的 `#[test]`：这个属性表明这是一个测试函数，这样测试执行者就知道将其作为测试处理。也可以在 `tests` 模块中拥有非测试的函数来帮助我们建立通用场景或进行常见操作，所以需要使用 `#[test]` 属性标明哪些函数是测试。 +现在让我们暂时忽略 `tests` 模块和 `#[cfg(test)]` 注解并只关注函数来了解其如何工作。注意 `fn` 行之前的 `#[test]`：这个属性表明这是一个测试函数，这样测试执行者就知道将其作为测试处理。因为也可以在 `tests` 模块中拥有非测试的函数来帮助我们建立通用场景或进行常见操作，所以需要使用 `#[test]` 属性标明哪些函数是测试。 -这个函数目前没有任何内容，这意味着没有代码会使测试失败；一个空的测试是可以通过的！让我们运行一下看看它是否通过了。 +函数体使用 `assert_eq!` 宏断言 2 加 2 等于 4。这个断言作为一个典型测试格式的例子。让我们运行以便看到测试通过。 `cargo test` 命令会运行项目中所有的测试，如示例 11-2 所示： @@ -52,32 +60,35 @@ $ cargo test running 1 test test tests::it_works ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Doc-tests adder running 0 tests -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 示例 11-2：运行自动生成测试的输出 Cargo 编译并运行了测试。在 `Compiling`、`Finished` 和 `Running` 这几行之后，可以看到 `running 1 test` 这一行。下一行显示了生成的测试函数的名称，它是 `it_works`，以及测试的运行结果，`ok`。接着可以看到全体测试运行结果的总结：`test result: ok.` 意味着所有测试都通过了。`1 passed; 0 failed` 表示通过或失败的测试数量。 -这里并没有任何被标记为忽略的测试，所以总结表明 `0 ignored`。在下一部分关于运行测试的不同方式中会讨论忽略测试。`0 measured` 统计是针对测试性能的性能测试的。性能测试（benchmark tests）在编写本书时，仍只能用于 Rust 开发版（nightly Rust）。请查看附录 D 来了解更多 Rust 开发版的信息。 +这里并没有任何被标记为忽略的测试，所以总结表明 `0 ignored`。我们也没有过滤需要运行的测试，所以总结的结尾显示`0 filtered out`。在下一部分 “控制测试如何运行” 会讨论忽略和过滤测试。 + +`0 measured` 统计是针对性能测试的。性能测试（benchmark tests）在编写本书时，仍只能用于 Rust 开发版（nightly Rust）。请查看第一章来了解更多 Rust 开发版的信息。 测试输出中以 `Doc-tests adder` 开头的这一部分是所有文档测试的结果。现在并没有任何文档测试，不过 Rust 会编译任何出现在 API 文档中的代码示例。这个功能帮助我们使文档和代码保持同步！在第十四章的 “文档注释” 部分会讲到如何编写文档测试。现在我们将忽略 `Doc-tests` 部分的输出。 让我们改变测试的名称并看看这如何改变测试的输出。给 `it_works` 函数起个不同的名字，比如 `exploration`，像这样： -Filename: src/lib.rs +文件名: src/lib.rs ```rust #[cfg(test)] mod tests { #[test] fn exploration() { + assert_eq!(2 + 2, 4); } } ``` @@ -88,10 +99,10 @@ mod tests { running 1 test test tests::exploration ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` -让我们增加另一个测试，不过这一次是一个会失败的测试！当测试函数中出现 panic 时测试就失败了。每一个测试都在一个新线程中运行，当主线程发现测试线程异常了，就将对应测试标记为失败。第九章讲到了最简单的造成 panic 的方法：调用 `panic!` 宏！写入新函数后 `src/lib.rs` 现在看起来如示例 11-3 所示： +让我们增加另一个测试，不过这一次是一个会失败的测试！当测试函数中出现 panic 时测试就失败了。每一个测试都在一个新线程中运行，当主线程发现测试线程异常了，就将对应测试标记为失败。第九章讲到了最简单的造成 panic 的方法：调用 `panic!` 宏。写入新测试 `another` 后， src/lib.rs` 现在看起来如示例 11-3 所示： 文件名: src/lib.rs @@ -100,6 +111,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured mod tests { #[test] fn exploration() { + assert_eq!(2 + 2, 4); } #[test] @@ -109,7 +121,7 @@ mod tests { } ``` -示例 11-3：增加第二个测试：他会失败因为调用了 `panic!` 宏 +示例 11-3：增加第二个测试：他会因为调用了 `panic!` 宏而失败 再次 `cargo test` 运行测试。输出应该看起来像示例 11-4，它表明 `exploration` 测试通过了而 `another` 失败了： @@ -122,30 +134,30 @@ test tests::another ... FAILED failures: ---- tests::another stdout ---- - thread 'tests::another' panicked at 'Make this test fail', src/lib.rs:9 + thread 'tests::another' panicked at 'Make this test fail', src/lib.rs:10:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. failures: tests::another -test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out error: test failed ``` 示例 11-4：一个测试通过和一个测试失败的测试结果 -`test tests::another` 这一行是 `FAILED` 而不是 `ok` 了。在单独测试结果和总结之间多了两个新的部分：第一个部分显示了测试失败的详细原因。在这个例子中，`another` 因为 `panicked at 'Make this test fail'` 而失败，这位于 *src/lib.rs* 的第 9 行。下一部分仅仅列出了所有失败的测试，这在有很多测试和很多失败测试的详细输出时很有帮助。可以使用失败测试的名称来只运行这个测试，这样比较方便调试；下一部分会讲到更多运行测试的方法。 +`test tests::another` 这一行是 `FAILED` 而不是 `ok` 了。在单独测试结果和总结之间多了两个新的部分：第一个部分显示了测试失败的详细原因。在这个例子中，`another` 因为 `panicked at 'Make this test fail'` 而失败，这位于 *src/lib.rs* 的第 10 行。下一部分仅仅列出了所有失败的测试，这在有很多测试和很多失败测试的详细输出时很有帮助。可以使用失败测试的名称来只运行这个测试，这样比较方便调试；下一部分 “控制测试如何运行” 会讲到更多运行测试的方法。 -最后是总结行：总体上讲，一个测试结果是 `FAILED` 的。有一个测试通过和一个测试失败。 +最后是总结行：总体上讲，测试结果是 `FAILED`。有一个测试通过和一个测试失败。 现在我们见过不同场景中测试结果是什么样子的了，再来看看除 `panic!` 之外的一些在测试中有帮助的宏吧。 ### 使用 `assert!` 宏来检查结果 -`assert!` 宏由标准库提供，在希望确保测试中一些条件为 `true` 时非常有用。需要向 `assert!` 宏提供一个计算为布尔值的参数。如果值是 `true`，`assert!` 什么也不做同时测试会通过。如果值为 `false`，`assert!` 调用 `panic!` 宏，这会导致测试失败。这是一个帮助我们检查代码是否以期望的方式运行的宏。 +`assert!` 宏由标准库提供，在希望确保测试中一些条件为 `true` 时非常有用。需要向 `assert!` 宏提供一个计算为布尔值的参数。如果值是 `true`，`assert!` 什么也不做同时测试会通过。如果值为 `false`，`assert!` 调用 `panic!` 宏，这会导致测试失败。`assert!` 宏帮助我们检查代码是否以期望的方式运行。 -回忆一下第五章中，示例 5-9 中有一个 `Rectangle` 结构体和一个 `can_hold` 方法，在示例 11-5 中再次使用他们。将他们放进 *src/lib.rs* 而不是 *src/main.rs* 并使用 `assert!` 宏编写一些测试。 +回忆一下第五章中，示例 5-15 中有一个 `Rectangle` 结构体和一个 `can_hold` 方法，在示例 11-5 中再次使用他们。将他们放进 *src/lib.rs* 并使用 `assert!` 宏编写一些测试。 文件名: src/lib.rs @@ -186,7 +198,7 @@ mod tests { 示例 11-6：一个 `can_hold` 的测试，检查一个较大的矩形确实能放得下一个较小的矩形 -注意在 `tests` 模块中新增加了一行：`use super::*;`。`tests` 是一个普通的模块，它遵循第七章介绍的通常的可见性规则。因为这是一个内部模块，需要将外部模块中被测试的代码引入到内部模块的作用域中。这里选择使用全局导入使得外部模块定义的所有内容在 `tests` 模块中都是可用的。 +注意在 `tests` 模块中新增加了一行：`use super::*;`。`tests` 是一个普通的模块，它遵循第七章 “私有性规则” 部分介绍的常用可见性规则。因为这是一个内部模块，需要将外部模块中被测试的代码引入到内部模块的作用域中。这里选择使用全局导入使得外部模块定义的所有内容在 `tests` 模块中都是可用的。 我们将测试命名为 `larger_can_hold_smaller`，并创建所需的两个 `Rectangle` 实例。接着调用 `assert!` 宏并传递 `larger.can_hold(&smaller)` 调用的结果作为参数。这个表达式预期会返回 `true`，所以测试应该通过。让我们拭目以待！ @@ -194,7 +206,7 @@ mod tests { running 1 test test tests::larger_can_hold_smaller ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 它确实通过了！再来增加另一个测试，这一回断言一个更小的矩形不能放下一个更大的矩形： @@ -208,10 +220,7 @@ mod tests { #[test] fn larger_can_hold_smaller() { - let larger = Rectangle { length: 8, width: 7 }; - let smaller = Rectangle { length: 5, width: 1 }; - - assert!(larger.can_hold(&smaller)); + // --snip-- } #[test] @@ -231,17 +240,18 @@ running 2 tests test tests::smaller_cannot_hold_larger ... ok test tests::larger_can_hold_smaller ... ok -test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 两个通过的测试！现在让我们看看如果引入一个 bug 的话测试结果会发生什么。将 `can_hold` 方法中比较长度时本应使用大于号的地方改成小于号： ```rust -#[derive(Debug)] -pub struct Rectangle { - length: u32, - width: u32, -} +# #[derive(Debug)] +# pub struct Rectangle { +# length: u32, +# width: u32, +# } +// --snip-- impl Rectangle { pub fn can_hold(&self, other: &Rectangle) -> bool { @@ -260,21 +270,21 @@ test tests::larger_can_hold_smaller ... FAILED failures: ---- tests::larger_can_hold_smaller stdout ---- - thread 'tests::larger_can_hold_smaller' panicked at 'assertion failed: - larger.can_hold(&smaller)', src/lib.rs:22 + thread 'tests::larger_can_hold_smaller' panicked at 'assertion failed: + larger.can_hold(&smaller)', src/lib.rs:22:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. failures: tests::larger_can_hold_smaller -test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out ``` 我们的测试捕获了 bug！因为 `larger.length` 是 8 而 `smaller.length` 是 5，`can_hold` 中的长度比较现在因为 8 不小于 5 而返回 `false`。 ### 使用 `assert_eq!` 和 `assert_ne!` 宏来测试相等 -测试功能的一个常用方法是将需要测试代码的值与期望值做比较，并检查是否相等。可以通过向 `assert!` 宏传递一个使用 `==` 运算符的表达式来做到。不过这个操作实在是太常见了，以至于标注库提供了一对宏来方便处理这些操作：`assert_eq!` 和 `assert_ne!`。这两个宏分别比较两个值是相等还是不相等。当断言失败时他们也会打印出这两个值具体是什么，以便于观察测试 **为什么** 失败，而 `assert!` 只会打印出它从 `==` 表达式中得到了 `false` 值，而不是导致 `false` 的两个值。 +测试功能的一个常用方法是将需要测试代码的值与期望值做比较，并检查是否相等。可以通过向 `assert!` 宏传递一个使用 `==` 运算符的表达式来做到。不过这个操作实在是太常见了，以至于标注库提供了一对宏来更方便的处理这些操作：`assert_eq!` 和 `assert_ne!`。这两个宏分别比较两个值是相等还是不相等。当断言失败时他们也会打印出这两个值具体是什么，以便于观察测试 **为什么** 失败，而 `assert!` 只会打印出它从 `==` 表达式中得到了 `false` 值，而不是导致 `false` 的两个值。 示例 11-7 中，让我们编写一个对其参数加二并返回结果的函数 `add_two`。接着使用 `assert_eq!` 宏测试这个函数： @@ -304,7 +314,7 @@ mod tests { running 1 test test tests::it_adds_two ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 传递给 `assert_eq!` 宏的第一个参数，4，等于调用 `add_two(2)` 的结果。我们将会看到这个测试的那一行说 `test tests::it_adds_two ... ok`，`ok` 表明测试通过了！ @@ -326,23 +336,24 @@ test tests::it_adds_two ... FAILED failures: ---- tests::it_adds_two stdout ---- - thread 'tests::it_adds_two' panicked at 'assertion failed: `(left == - right)` (left: `4`, right: `5`)', src/lib.rs:11 + thread 'tests::it_adds_two' panicked at 'assertion failed: `(left == right)` + left: `4`, + right: `5`', src/lib.rs:11:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. failures: tests::it_adds_two -test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out ``` -测试捕获到了 bug！`it_adds_two` 测试失败并显示信息 `` assertion failed: `(left == right)` (left: `4`, right: `5`) ``。这个信息有助于我们开始调试：它说 `assert_eq!` 的 `left` 参数是 4，而 `right` 参数，也就是 `add_two(2)` 的结果，是 5。 +测试捕获到了 bug！`it_adds_two` 测试失败，显示信息 `` assertion failed: `(left == right)` `` 并表明 `left` 是 `4` 而 `right` 是 `5`。这个信息有助于我们开始调试：它说 `assert_eq!` 的 `left` 参数是 `4`，而 `right` 参数，也就是 `add_two(2)` 的结果，是 `5`。 -注意在一些语言和测试框架中，断言两个值相等的函数的参数叫做 `expected` 和 `actual`，而且指定参数的顺序是需要注意的。然而在 Rust 中，他们则叫做 `left` 和 `right`，同时指定期望的值和被测试代码产生的值的顺序并不重要。这个测试中的断言也可以写成 `assert_eq!(add_two(2), 4)`，这时错误信息会变成 `` assertion failed: `(left == right)` (left: `5`, right: `4`) ``。 +注意在一些语言和测试框架中，断言两个值相等的函数的参数叫做 `expected` 和 `actual`，而且指定参数的顺序是需要注意的。然而在 Rust 中，他们则叫做 `left` 和 `right`，同时指定期望的值和被测试代码产生的值的顺序并不重要。这个测试中的断言也可以写成 `assert_eq!(add_two(2), 4)`，这时错误信息会变成 `` assertion failed: `(left == right)` `` 其中 `left` 是 `5` 而 `right` 是 `4`。 `assert_ne!` 宏在传递给它的两个值不相等时通过而在相等时失败。这个宏在代码按照我们期望运行时不确定值 **会** 是什么，不过知道他们绝对 **不会** 是什么的时候最有用处。例如，如果一个函数确定会以某种方式改变其输出，不过这种方式由运行测试是星期几来决定，这时最好的断言可能就是函数的输出不等于其输入。 -`assert_eq!` 和 `assert_ne!` 宏在底层分别使用了 `==` 和 `!=`。当断言失败时，这些宏会使用调试格式打印出其参数，这意味着被比较的值必需实现了 `PartialEq` 和 `Debug` trait。所有的基本类型和大部分标准库类型都实现了这些 trait。对于自定义的结构体和枚举，需要实现 `PartialEq` 才能断言他们的值是否相等。需要实现 `Debug` 才能在断言失败时打印他们的值。因为这两个 trait 都是可推导 trait，如第五章所提到的，通常可以直接在结构体或枚举上添加 `#[derive(PartialEq, Debug)]` 注解。附录 C 中有更多关于这些和其他可推导 trait 的详细信息。 +`assert_eq!` 和 `assert_ne!` 宏在底层分别使用了 `==` 和 `!=`。当断言失败时，这些宏会使用调试格式打印出其参数，这意味着被比较的值必需实现了 `PartialEq` 和 `Debug` trait。所有的基本类型和大部分标准库类型都实现了这些 trait。对于自定义的结构体和枚举，需要实现 `PartialEq` 才能断言他们的值是否相等。需要实现 `Debug` 才能在断言失败时打印他们的值。因为这两个 trait 都是派生 trait，如第五章示例 5-12 所提到的，通常可以直接在结构体或枚举上添加 `#[derive(PartialEq, Debug)]` 注解。附录 C 中有更多关于这些和其他派生 trait 的详细信息。 ### 自定义错误信息 @@ -350,7 +361,7 @@ test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured 例如，比如说有一个根据人名进行问候的函数，而我们希望测试将传递给函数的人名显示在输出中： -Filename: src/lib.rs +文件名: src/lib.rs ```rust pub fn greeting(name: &str) -> String { @@ -369,8 +380,7 @@ mod tests { } ``` -这个程序的需求还没有被确定，而我们非常确定问候开始的 `Hello` 文本不会改变。我们决定并不想在人名改变时 -不得不更新测试，所以相比检查 `greeting` 函数返回的确切的值，我们将仅仅断言输出的文本中包含输入参数。 +这个程序的需求还没有被确定，而我们非常确定问候开始的 `Hello` 文本不会改变。我们决定并不想在人名改变时不得不更新测试，所以相比检查 `greeting` 函数返回的确切的值，我们将仅仅断言输出的文本中包含输入参数。 让我们通过将 `greeting` 改为不包含 `name` 来在代码中引入一个 bug 来测试失败时是怎样的， @@ -389,8 +399,8 @@ test tests::greeting_contains_name ... FAILED failures: ---- tests::greeting_contains_name stdout ---- - thread 'tests::greeting_contains_name' panicked at 'assertion failed: - result.contains("Carol")', src/lib.rs:12 + thread 'tests::greeting_contains_name' panicked at 'assertion failed: +result.contains("Carol")', src/lib.rs:12:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. failures: @@ -412,18 +422,19 @@ fn greeting_contains_name() { 现在如果再次运行测试，将会看到更有价值的错误信息： + ```text ---- tests::greeting_contains_name stdout ---- - thread 'tests::greeting_contains_name' panicked at 'Greeting did not contain - name, value was `Hello`', src/lib.rs:12 + thread 'tests::greeting_contains_name' panicked at 'Greeting did not +contain name, value was `Hello!`', src/lib.rs:12:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. ``` -可以在测试输出中看到所取得的确切的值，这会帮助我们理解发生了什么而不是期望发生什么。 +可以在测试输出中看到所取得的确切的值，这会帮助我们理解真正发生了什么而不是期望发生什么。 ### 使用 `should_panic` 检查 panic -除了检查代码是否返回期望的正确的值之外，检查代码是否按照期望处理错误情况也是很重要的。例如，考虑第九章示例 9-8 创建的 `Guess` 类型。其他使用 `Guess` 的代码依赖于 `Guess` 实例只会包含 1 到 100 的值的保证。可以编写一个测试来确保创建一个超出范围的值的 `Guess` 实例会 panic。 +除了检查代码是否返回期望的正确的值之外，检查代码是否按照期望处理错误情况也是很重要的。例如，考虑第九章示例 9-9 创建的 `Guess` 类型。其他使用 `Guess` 的代码依赖于 `Guess` 实例只会包含 1 到 100 的值的保证。可以编写一个测试来确保创建一个超出范围的值的 `Guess` 实例会 panic。 可以通过对函数增加另一个属性 `should_panic` 来实现这些。这个属性在函数中的代码 panic 时会通过，而在其中的代码没有 panic 时失败。 @@ -432,7 +443,7 @@ note: Run with `RUST_BACKTRACE=1` for a backtrace. 文件名: src/lib.rs ```rust -struct Guess { +pub struct Guess { value: u32, } @@ -468,16 +479,18 @@ mod tests { running 1 test test tests::greater_than_100 ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 看起来不错！现在在代码中引入 bug，移除 `new` 函数在值大于 100 时会 panic 的条件： ```rust -# struct Guess { +# pub struct Guess { # value: u32, # } # +// --snip-- + impl Guess { pub fn new(value: u32) -> Guess { if value < 1 { @@ -502,7 +515,7 @@ failures: failures: tests::greater_than_100 -test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out ``` 这回并没有得到非常有用的信息，不过一旦我们观察测试函数，会发现它标注了 `#[should_panic]`。这个错误意味着代码中函数 `Guess::new(200)` 并没有产生 panic。 @@ -512,9 +525,11 @@ test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured 文件名: src/lib.rs ```rust -struct Guess { - value: u32, -} +# pub struct Guess { +# value: u32, +# } +# +// --snip-- impl Guess { pub fn new(value: u32) -> Guess { @@ -567,8 +582,8 @@ test tests::greater_than_100 ... FAILED failures: ---- tests::greater_than_100 stdout ---- - thread 'tests::greater_than_100' panicked at 'Guess value must be greater - than or equal to 1, got 200.', src/lib.rs:10 + thread 'tests::greater_than_100' panicked at 'Guess value must be +greater than or equal to 1, got 200.', src/lib.rs:11:12 note: Run with `RUST_BACKTRACE=1` for a backtrace. note: Panic did not include expected string 'Guess value must be less than or equal to 100' @@ -576,9 +591,9 @@ equal to 100' failures: tests::greater_than_100 -test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out ``` 错误信息表明测试确实如期望 panic 了，不过 panic 信息是 `did not include expected string 'Guess value must be less than or equal to 100'`。可以看到我们得到的 panic 信息，在这个例子中是 `Guess value must be greater than or equal to 1, got 200.`。这样就可以开始寻找 bug 在哪了！ -现在我们讲完了编写测试的方法，让我们看看运行测试时会发生什么并讨论可以用于 `cargo test` 的不同选项。 \ No newline at end of file +现在你知道了几种编写测试的方法，让我们看看运行测试时会发生什么并讨论可以用于 `cargo test` 的不同选项。 \ No newline at end of file diff --git a/src/ch11-02-running-tests.md b/src/ch11-02-running-tests.md index bf66c66..2fb7f42 100644 --- a/src/ch11-02-running-tests.md +++ b/src/ch11-02-running-tests.md @@ -1,16 +1,16 @@ -## 运行测试 +## 控制测试如何运行 > [ch11-02-running-tests.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch11-02-running-tests.md) >
-> commit db08b34db5f1c78b4866b391c802344ec94ecc38 +> commit 550c8ea6f74060ff1f7b67e7e1878c4da121682d -就像 `cargo run` 会编译代码并运行生成的二进制文件一样，`cargo test` 在测试模式下编译代码并运行生成的测试二进制文件。这里有一些选项可以用来改变 `cargo test` 的默认行为。例如，`cargo test` 生成的二进制文件的默认行为是并行的运行所有测试，并捕获测试运行过程中产生的输出避免他们被显示出来，使得阅读测试结果相关的内容变得更容易。你可以指定命令行参数来改变这些默认行为。 +就像 `cargo run` 会编译代码并运行生成的二进制文件一样，`cargo test` 在测试模式下编译代码并运行生成的测试二进制文件。可以指定命令行参数来改变 `cargo test` 的默认行为。例如，`cargo test` 生成的二进制文件的默认行为是并行的运行所有测试，并捕获测试运行过程中产生的输出避免他们被显示出来，使得阅读测试结果相关的内容变得更容易。 这些选项的一部分可以传递给 `cargo test`，而另一些则需要传递给生成的测试二进制文件。为了分隔两种类型的参数，首先列出传递给 `cargo test` 的参数，接着是分隔符 `--`，再之后是传递给测试二进制文件的参数。运行 `cargo test --help` 会告诉你 `cargo test` 的相关参数，而运行 `cargo test -- --help` 则会告诉你位于分隔符 `--` 之后的相关参数。 ### 并行或连续的运行测试 -当运行多个测试时，他们默认使用线程来并行的运行。这意味着测试会更快的运行完毕，所以可以更快的得到代码能否工作的反馈。因为测试是在同时运行的，你应该小心测试不能相互依赖或依赖任何共享状态，包括类似于当前工作目录或者环境变量这样的共享环境。 +当运行多个测试时，他们默认使用线程来并行的运行。这意味着测试会更快的运行完毕，所以可以更快的得到代码能否工作的反馈。因为测试是在同时运行的，你应该小心测试不能相互依赖或依赖任何共享状态，这包括类似于当前工作目录或者环境变量这样的共享环境。 例如，每一个测试都运行一些代码在硬盘上创建一个 `test-output.txt` 文件并写入一些数据。接着每一个测试都读取文件中的数据并断言这个文件包含特定的值，而这个值在每个测试中都是不同的。因为所有测试都是同时运行的，一个测试可能会在另一个测试读写文件过程中覆盖了文件。那么第二个测试就会失败，并不是因为代码不正确，而是因为测试并行运行时相互干涉。一个解决方案是使每一个测试读写不同的文件；另一个是一次运行一个测试。 @@ -26,7 +26,7 @@ $ cargo test -- --test-threads=1 如果测试通过了，Rust 的测试库默认会捕获打印到标准输出的任何内容。例如，如果在测试中调用 `println!` 而测试通过了，我们将不会在终端看到 `println!` 的输出：只会看到说明测试通过的行。如果测试失败了，就会看到所有标准输出和其他错误信息。 -例如，示例 11-20 有一个无意义的函数它打印出其参数的值并接着返回 10。接着还有一个会通过的测试和一个会失败的测试： +例如，示例 11-10 有一个无意义的函数它打印出其参数的值并接着返回 10。接着还有一个会通过的测试和一个会失败的测试： 文件名: src/lib.rs @@ -66,15 +66,16 @@ test tests::this_test_will_fail ... FAILED failures: ---- tests::this_test_will_fail stdout ---- - I got the value 8 -thread 'tests::this_test_will_fail' panicked at 'assertion failed: `(left == -right)` (left: `5`, right: `10`)', src/lib.rs:19 + I got the value 8 +thread 'tests::this_test_will_fail' panicked at 'assertion failed: `(left == right)` + left: `5`, + right: `10`', src/lib.rs:19:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. failures: tests::this_test_will_fail -test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out ``` 注意输出中哪里也不会出现 `I got the value 4`，这是当测试通过时打印的内容。这些输出被捕获。失败测试的输出，`I got the value 8`，则出现在输出的测试总结部分，同时也显示了测试失败的原因。 @@ -85,15 +86,16 @@ test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured $ cargo test -- --nocapture ``` -使用 `--nocapture` 参数再次运行示例 11-10 中的测试会显示： +使用 `--nocapture` 参数再次运行示例 11-10 中的测试会显示如下输出： ```text running 2 tests I got the value 4 I got the value 8 test tests::this_test_will_pass ... ok -thread 'tests::this_test_will_fail' panicked at 'assertion failed: `(left == -right)` (left: `5`, right: `10`)', src/lib.rs:19 +thread 'tests::this_test_will_fail' panicked at 'assertion failed: `(left == right)` + left: `5`, + right: `10`', src/lib.rs:19:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. test tests::this_test_will_fail ... FAILED @@ -102,16 +104,16 @@ failures: failures: tests::this_test_will_fail -test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out ``` -注意测试的输出和测试结果的输出是相互交叉的；这是由于上一部分讲到的测试是并行运行的。尝试一同使用`--test-threads=1`和`--nocapture`功能来看看输出是什么样子！ +注意测试的输出和测试结果的输出是相互交叉的；这是由于上一部分讲到的测试是并行运行的。尝试一同使用 `--test-threads=1` 和 `--nocapture` 功能来看看输出是什么样子！ ### 通过名称来运行测试的子集 有时运行整个测试集会耗费很长时间。如果你负责特定位置的代码，你可能会希望只运行这些代码相关的测试。可以向 `cargo test` 传递希望运行的测试的（部分）名称作为参数来选择运行哪些测试。 -为了展示如何运行测试的子集，示例 11-11 使用 `add_two` 函数创建了三个测试来供我们选择运行哪一个： +为了展示如何运行测试的子集，示例 11-11 为 `add_two` 函数创建了三个测试来供我们选择运行哪一个： 文件名: src/lib.rs @@ -151,7 +153,7 @@ test tests::add_two_and_two ... ok test tests::add_three_and_two ... ok test tests::one_hundred ... ok -test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` #### 运行单个测试 @@ -166,10 +168,12 @@ $ cargo test one_hundred running 1 test test tests::one_hundred ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out ``` -不能像这样指定多个测试名称，只有传递给 `cargo test` 的第一个值才会被使用。 +只有名称为 `one_hundred` 的测试被运行了；其余两个测试并不匹配这个名称。测试输出在总结行的结尾显示了 `2 filtered out` 表明存在比本命令所运行的更多的测试。 + +不能像这样指定多个测试名称，只有传递给 `cargo test` 的第一个值才会被使用。不过有运行多个测试的方法。 #### 过滤运行多个测试 @@ -184,21 +188,21 @@ running 2 tests test tests::add_two_and_two ... ok test tests::add_three_and_two ... ok -test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out ``` 这运行了所有名字中带有 `add` 的测试。同时注意测试所在的模块作为测试名称的一部分，所以可以通过模块名来过滤运行一个模块中的所有测试。 ### 除非指定否则忽略某些测试 -有时一些特定的测试执行起来是非常耗费时间的，所以在大多数运行 `cargo test` 的时候希望能排除他们。与其通过参数列举出所有希望运行的测试，也可以使用 `ignore` 属性来标记耗时的测试来排除他们： +有时一些特定的测试执行起来是非常耗费时间的，所以在大多数运行 `cargo test` 的时候希望能排除他们。与其通过参数列举出所有希望运行的测试，也可以使用 `ignore` 属性来标记耗时的测试并排除他们，如下所示： 文件名: src/lib.rs ```rust #[test] fn it_works() { - assert!(true); + assert_eq!(2 + 2, 4); } #[test] @@ -220,16 +224,10 @@ running 2 tests test expensive_test ... ignored test it_works ... ok -test result: ok. 1 passed; 0 failed; 1 ignored; 0 measured - - Doc-tests adder - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out ``` -`expensive_test` 被列为 `ignored`，如果只希望运行被忽略的测试，可以使用 `cargo test -- --ignored` 来请求运行他们： +`expensive_test` 被列为 `ignored`，如果只希望运行被忽略的测试，可以使用 `cargo test -- --ignored`： ```text $ cargo test -- --ignored @@ -239,7 +237,7 @@ $ cargo test -- --ignored running 1 test test expensive_test ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 1 filtered out ``` 通过控制运行哪些测试，可以确保运行 `cargo test` 的结果是快速的。当某个时刻需要检查 `ignored` 测试的结果而且你也有时间等待这个结果的话，可以选择执行 `cargo test -- --ignored`。 \ No newline at end of file diff --git a/src/ch11-03-test-organization.md b/src/ch11-03-test-organization.md index 2d325c4..8f1ffa5 100644 --- a/src/ch11-03-test-organization.md +++ b/src/ch11-03-test-organization.md @@ -2,9 +2,9 @@ > [ch11-03-test-organization.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch11-03-test-organization.md) >
-> commit 0665bc5646339a6bcda21838f46d4357b9435e75 +> commit b3eddb8edc0c3f83647143673d18efac0a44083a -正如之前提到的，测试是一个很广泛的学科，而且不同的开发者也采用不同的技术和组织。Rust 社区倾向于根据测试的两个主要分类来考虑问题：**单元测试**（*unit tests*）与 **集成测试**（*integration tests*）。单元测试倾向于更小而更专注，在隔离的环境中一次测试一个模块，也可以测试私有接口。集成测试对于你的库来说则完全是外部的。他们与其他用户使用相同的方式使用你的代码，他们只针对公有接口而且每个测试都会测试多个模块。 +正如之前提到的，测试是一个复杂的概念，而且不同的开发者也采用不同的技术和组织。Rust 社区倾向于根据测试的两个主要分类来考虑问题：**单元测试**（*unit tests*）与 **集成测试**（*integration tests*）。单元测试倾向于更小而更专注，在隔离的环境中一次测试一个模块，也可以测试私有接口。集成测试对于你的库来说则完全是外部的。他们与其他用户采用相同的方式使用你的代码，他们只针对公有接口而且每个测试都会测试多个模块。 编写这两类测试对于从独立和整体的角度保证你的库符合期望是非常重要的。 @@ -12,9 +12,9 @@ 单元测试的目的是在与其他部分隔离的环境中测试每一个单元的代码，以便于快速而准确的定位代码位于何处和是否符合预期。单元测试位于 *src* 目录中，与他们要测试的代码存在于相同的文件中。传统做法是在每个文件中创建包含测试函数的 `tests` 模块，并使用 `cfg(test)` 标注模块。 -#### 测试模块和`cfg(test)` +#### 测试模块和 `cfg(test)` -测试模块的 `#[cfg(test)]` 注解告诉 Rust 只在执行 `cargo test` 时才编译和运行测试代码，而在运行 `cargo build` 时不这么做。这在只希望构建库的时候可以节省编译时间，并能节省编译产物的空间因为他们并没有包含测试。我们将会看到因为集成测试位于另一个文件夹，他们并不需要 `#[cfg(test)]` 注解。但是因为单元测试位于与源码相同的文件中，所以使用 `#[cfg(test)]` 来指定他们不应该被包含进编译产物中。 +测试模块的 `#[cfg(test)]` 注解告诉 Rust 只在执行 `cargo test` 时才编译和运行测试代码，而在运行 `cargo build` 时不这么做。这在只希望构建库的时候可以节省编译时间，并能节省编译产物的空间因为他们并没有包含测试。我们将会看到因为集成测试位于另一个文件夹，他们并不需要 `#[cfg(test)]` 注解。但是因为单元测试位于与源码相同的文件中，所以使用 `#[cfg(test)]` 来指定他们不应该被包含进编译结果中。 还记得本章第一部分新建的 `adder` 项目吗？Cargo 为我们生成了如下代码： @@ -25,6 +25,7 @@ mod tests { #[test] fn it_works() { + assert_eq!(2 + 2, 4); } } ``` @@ -63,13 +64,13 @@ mod tests { ### 集成测试 -在 Rust 中，集成测试对于需要测试的库来说是完全独立。他们同其他代码一样使用库文件，这意味着他们只能调用作为库公有 API 的一部分函数。他们的目的是测试库的多个部分能否一起正常工作。每个能单独正确运行的代码单元集成在一起也可能会出现问题，所以集成测试的覆盖率也是很重要的。为了创建集成测试，首先需要一个 *tests* 目录。 +在 Rust 中，集成测试对于需要测试的库来完全说是外部的。他们同其他代码一样使用库文件，这意味着他们只能调用作为库公有 API 的一部分函数。他们的目的是测试库的多个部分能否一起正常工作。每个能单独正确运行的代码单元集成在一起也可能会出现问题，所以集成测试的覆盖率也是很重要的。为了创建集成测试，首先需要一个 *tests* 目录。 #### *tests* 目录 为了编写集成测试，需要在项目根目录创建一个 *tests* 目录，与 *src* 同级。Cargo 知道如何去寻找这个目录中的集成测试文件。接着可以随意在这个目录中创建任意多的测试文件，Cargo 会将每一个文件当作单独的 crate 来编译。 -让我们试一试吧！保留示例 11-12 中 *src/lib.rs* 的代码。创建一个 *tests* 目录，新建一个文件 *tests/integration_test.rs*，并输入示例 11-13 中的代码。 +让我们来创建一个集成测试！保留示例 11-12 中 *src/lib.rs* 的代码。创建一个 *tests* 目录，新建一个文件 *tests/integration_test.rs*，并输入示例 11-13 中的代码。 文件名: tests/integration_test.rs @@ -84,12 +85,12 @@ fn it_adds_two() { 示例 11-13：一个 `adder` crate 中函数的集成测试 -我们在顶部增加了 `extern crate adder`，这在单元测试中是不需要的。这是因为每一个 `tests` 目录中的测试文件都是完全独立的 crate，所以需要在每一个文件中导入库。集成测试就像其他库使用者那样通过导入 crate 并只使用公有 API。 +我们在顶部增加了 `extern crate adder`，这在单元测试中是不需要的。这是因为每一个 `tests` 目录中的测试文件都是完全独立的 crate，所以需要在每一个文件中导入库。 -并不需要将 *tests/integration_test.rs* 中的任何代码标注为 `#[cfg(test)]`。Cargo 对 `tests` 文件夹特殊处理并只会在运行 `cargo test` 时编译这个目录中的文件。现在就试试运行 `cargo test`： +并不需要将 *tests/integration_test.rs* 中的任何代码标注为 `#[cfg(test)]`。Cargo 对 `tests` 文件夹特殊处理并只会在运行 `cargo test` 时编译这个目录中的文件。现在就运行 `cargo test` 试试： ```text -cargo test +$ cargo test Compiling adder v0.1.0 (file:///projects/adder) Finished dev [unoptimized + debuginfo] target(s) in 0.31 secs Running target/debug/deps/adder-abcabcabc @@ -97,20 +98,20 @@ cargo test running 1 test test tests::internal ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Running target/debug/deps/integration_test-ce99bcc2479f4607 running 1 test test it_adds_two ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Doc-tests adder running 0 tests -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 现在有了三个部分的输出：单元测试、集成测试和文档测试。第一部分单元测试与我们之前见过的一样：每一个单元测试一行（示例 11-12 中有一个叫做 `internal` 的测试），接着是一个单元测试的总结行。 @@ -129,18 +130,18 @@ $ cargo test --test integration_test running 1 test test it_adds_two ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 这些只是 *tests* 目录中我们指定的文件中的测试。 #### 集成测试中的子模块 -随着集成测试的增加，你可能希望在 `tests` 目录增加更多文件，例如根据测试的功能来将测试分组。正如我们之前提到的，每一个 *tests* 目录中的文件都被编译为单独的 crate。 +随着集成测试的增加，你可能希望在 `tests` 目录增加更多文件辅助组织他们，例如根据测试的功能来将测试分组。正如我们之前提到的，每一个 *tests* 目录中的文件都被编译为单独的 crate。 -将每个集成测试文件当作其自己的 crate 来对待有助于创建更类似与终端用户使用 crate 那样的单独的作用域。然而，这意味着考虑到第七章学习的如何将代码分隔进模块和文件的知识，*tests* 目录中的文件不能像 *src* 中的文件那样共享相同的行为，。 +将每个集成测试文件当作其自己的 crate 来对待有助于创建更类似与终端用户使用 crate 那样的单独的作用域。然而，这意味着考虑到第七章学习的如何将代码分隔进模块和文件的知识，*tests* 目录中的文件不能像 *src* 中的文件那样共享相同的行为。 -对于 *tests* 目录中不同文件的行为，通常在如果有一系列有助于多个集成测试文件的帮助函数，而你尝试遵循第七章的步骤将他们提取到一个通用的模块中时显得很明显。例如，如果我们创建了 *tests/common.rs* 并将 `setup` 函数放入其中，这里将放入一些希望能够在多个测试文件的多个测试函数中调用的代码： +对于 *tests* 目录中不同文件的行为，通常在如果有一系列有助于多个集成测试文件的帮助函数，而你尝试遵循第七章 “将模块移动到其他文件” 部分的步骤将他们提取到一个通用的模块中时显得很明显。例如，如果我们创建了 *tests/common.rs* 并将 `setup` 函数放入其中，这里将放入一些我们希望能够在多个测试文件的多个测试函数中调用的代码： 文件名: tests/common.rs @@ -156,31 +157,31 @@ pub fn setup() { running 1 test test tests::internal ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Running target/debug/deps/common-b8b07b6f1be2db70 running 0 tests -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Running target/debug/deps/integration_test-d993c68b431d39df running 1 test test it_adds_two ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out Doc-tests adder running 0 tests -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` `common` 出现在测试结果中并显示 `running 0 tests`，这不是我们想要的；我们只是希望能够在其他集成测试文件中分享一些代码罢了。 -为了使 `common` 不出现在测试输出中，需要使用第七章学习到的另一个将代码提取到文件的方式：不再创建 *tests/common.rs*，而是创建 *tests/common/mod.rs*。当将 `setup` 代码移动到 *tests/common/mod.rs* 并去掉 *tests/common.rs* 文件之后，测试输出中将不会出现这一部分。*tests* 目录中的子目录不会被作为单独的 crate 编译或作为一部分出现在测试输出中。 +为了避免 `common` 出现在测试输出中，不同于创建 *tests/common.rs*，我们将创建 *tests/common/mod.rs*。在第七章的 “模块文件系统规则” 部分，对于拥有子模块的模块文件使用了 *module_name/mod.rs* 命名规范，虽然这里 `common` 并没有子模块，但是这样命名告诉 Rust 不要将 `common` 看作一个集成测试文件。当将 `setup` 代码移动到 *tests/common/mod.rs* 并去掉 *tests/common.rs* 文件之后，测试输出中将不会出现这一部分。*tests* 目录中的子目录不会被作为单独的 crate 编译或作为一部分出现在测试输出中。 一旦拥有了 *tests/common/mod.rs*，就可以将其作为模块来在任何集成测试文件中使用。这里是一个 *tests/integration_test.rs* 中调用 `setup` 函数的 `it_adds_two` 测试的例子： @@ -198,7 +199,7 @@ fn it_adds_two() { } ``` -注意 `mod common;` 声明与第七章中的模块声明相同。接着在测试函数中就可以调用 `common::setup()` 了。 +注意 `mod common;` 声明与示例 7-4 中展示的模块声明相同。接着在测试函数中就可以调用 `common::setup()` 了。 #### 二进制 crate 的集成测试 @@ -208,6 +209,6 @@ fn it_adds_two() { ## 总结 -Rust 的测试功能提供了一个如何确保即使函数做出改变也能继续以指定方式运行的途径。单元测试独立的验证库的不同部分并能够测试私有实现细节。集成测试则涉及多个部分结合起来工作时的用例，并像其他外部代码那样测试库的公有 API。即使 Rust 的类型系统和所有权规则可以帮助避免一些 bug，不过测试对于减少代码是否符合期望相关的逻辑 bug 仍然是很重要的。 +Rust 的测试功能提供了一个如何确保即使函数做出改变也能继续以期望的方式运行的途径。单元测试独立的验证库的不同部分并能够测试私有实现细节。集成测试则涉及多个部分结合起来工作时的用例，并像其他外部代码那样测试库的公有 API。即使 Rust 的类型系统和所有权规则可以帮助避免一些 bug，不过测试对于减少代码是否符合期望相关的逻辑 bug 仍然是很重要的。 接下来让我们结合本章所学和其他之前章节的知识，在下一章一起编写一个项目！ diff --git a/src/ch12-00-an-io-project.md b/src/ch12-00-an-io-project.md index e9576d5..6026eeb 100644 --- a/src/ch12-00-an-io-project.md +++ b/src/ch12-00-an-io-project.md @@ -2,17 +2,17 @@ > [ch12-00-an-io-project.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch12-00-an-io-project.md) >
-> commit 096db3d06b25692ee701750e1f995ba00d0f5c55 +> commit 97e60b3cb623d4a5b85419212b085ade8a11cbe1 本章既是一个目前所学的很多技能的概括，也是一个更多标准库功能的探索。我们将构建一个与文件和命令行输入/输出交互的命令行工具来练习现在一些你已经掌握的 Rust 技能。 -Rust 的运行速度、安全性、**单二进制文件** 输出和跨平台支持使其成为创建命令行程序的绝佳选择，所以我们的项目将创建一个我们自己版本的经典命令行工具：`grep`。grep 是 “**G**lobally search a **R**egular **E**xpression and **P**rint.” 的首字母缩写。`grep` 最简单的使用场景是在特定文件中搜索指定字符串。为此，`grep` 获取一个文件名和一个字符串作为参数，接着读取文件并找到其中包含字符串参数的行，然后打印出这些行。 +Rust 的运行速度、安全性、**单二进制文件** 输出和跨平台支持使其成为创建命令行程序的绝佳选择，所以我们的项目将创建一个我们自己版本的经典命令行工具：`grep`。grep 是 “**G**lobally search a **R**egular **E**xpression and **P**rint.” 的首字母缩写。`grep` 最简单的使用场景是在特定文件中搜索指定字符串。为此，`grep` 获取一个文件名和一个字符串作为参数，接着读取文件并找到其中包含字符串参数的行。然后打印出这些行。 在这个过程中，我们会展示如何让我们的命令行工具利用很多命令行工具中用到的终端功能。读取环境变量来使得用户可以配置工具的行为。打印到标准错误控制流（`stderr`） 而不是标准输出（`stdout`），例如这样用户可以选择将成功输出重定向到文件中而仍然在屏幕上显示错误信息。 -一位 Rust 社区的成员，Andrew Gallant，已经创建了一个功能完整且非常快速的 `grep` 版本，叫做 [`ripgrep`](https://github.com/BurntSushi/ripgrep)。相比之下，我们的 `grep` 版本将非常简单，本章将教会你一些帮助理解像 `ripgrep` 这样真实项目的背景知识。 +一位 Rust 社区的成员，Andrew Gallant，已经创建了一个功能完整且非常快速的 `grep` 版本，叫做 `ripgrep`。相比之下，我们的 `grep` 版本将非常简单，本章将教会你一些帮助理解像 `ripgrep` 这样真实项目的背景知识。 -这个项目将会结合之前所学的一些内容： +我们的 `grep` 项目将会结合之前所学的一些内容： - 代码组织（使用第七章学习的模块） - vector 和字符串（第八章，集合） diff --git a/src/ch12-01-accepting-command-line-arguments.md b/src/ch12-01-accepting-command-line-arguments.md index ad78888..a562cca 100644 --- a/src/ch12-01-accepting-command-line-arguments.md +++ b/src/ch12-01-accepting-command-line-arguments.md @@ -2,7 +2,7 @@ > [ch12-01-accepting-command-line-arguments.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch12-01-accepting-command-line-arguments.md) >
-> commit 50658e654fb6a9208b635179cdd79939aa0ab133 +> commit 97e60b3cb623d4a5b85419212b085ade8a11cbe1 一如之前使用 `cargo new` 新建一个项目。我们称之为 `minigrep` 以便与可能已经安装在系统上的`grep`工具相区别： @@ -18,13 +18,13 @@ $ cd minigrep $ cargo run searchstring example-filename.txt ``` -现在 `cargo new` 生成的程序忽略任何传递给它的参数。crates.io 上有一些现成的库可以帮助我们接受命令行参数，不过因为正在学习，让我们自己来实现一个。 +现在 `cargo new` 生成的程序忽略任何传递给它的参数。[Crates.io](https://crates.io/) 上有一些现成的库可以帮助我们接受命令行参数，不过因为正在学习，让我们自己来实现一个。 ### 读取参数值 -首先我们需要程序能够获取传递给它的命令行参数的值，为此需要一个 Rust 标准库提供的函数：`std::env::args`。这个函数返回一个传递给程序的命令行参数的 **迭代器**（*iterator*）。我们还未讨论到迭代器，第十三章会全面的介绍他们。但是对于我们现在的目的来说只需要明白两点：迭代器生成一系列的值，可以在迭代器上调用 `collect` 方法将其转换为一个 vector，比如包含所有迭代器产生元素的 vector。 +为了确保 `minigrep` 能够获取传递给它的命令行参数的值，我们需要一个 Rust 标准库提供的函数，也就是 `std::env::args`。这个函数返回一个传递给程序的命令行参数的 **迭代器**（*iterator*）。我们还未讨论到迭代器（第十三章会全面的介绍他们），但是现在只需理解迭代器的两个细节：迭代器生成一系列的值，可以在迭代器上调用 `collect` 方法将其转换为一个集合，比如包含所有迭代器产生元素的 vector。 -让我们尝试一下：使用示例 12-1 中的代码来读取任何传递给 `minigrep` 的命令行参数并将其收集到一个 vector 中。 +使用示例 12-1 中的代码来读取任何传递给 `minigrep` 的命令行参数并将其收集到一个 vector 中。 文件名: src/main.rs @@ -37,13 +37,14 @@ fn main() { } ``` -示例 12-1：将命令行参数收集到一个 vector 中并打印出来 -首先使用 `use` 语句来将 `std::env` 模块引入作用域以便可以使用它的 `args` 函数。注意 `std::env::args` 函数被嵌套进了两层模块中。正如第七章讲到的，当所需函数嵌套了多于一层模块时，通常将父模块引入作用域，而不是其自身。这便于我们利用 `std::env` 中的其他函数。这比增加了 `use std::env::args;` 后仅仅使用 `args` 调用函数要更明确一些；这样容易被错认成一个定义于当前模块的函数。 +示例 12-1：将命令行参数收集到一个 vector 中并打印出来 + +首先使用 `use` 语句来将 `std::env` 模块引入作用域以便可以使用它的 `args` 函数。注意 `std::env::args` 函数被嵌套进了两层模块中。正如第七章讲到的，当所需函数嵌套了多于一层模块时，通常将父模块引入作用域，而不是其自身。这便于我们利用 `std::env` 中的其他函数。这比增加了 `use std::env::args;` 后仅仅使用 `args` 调用函数要更明确一些，因为 `args` 容易被错认成一个定义于当前模块的函数。 > ### `args` 函数和无效的 Unicode > -> 注意 `std::env::args` 在其任何参数包含无效 Unicode 字符时会 panic。如果你需要接受包含无效 Unicode 字符的参数，使用 `std::env::args_os` 代替。这个函数返回 `OsString` 值而不是 `String` 值。这里出于简单考虑使用了 `std::env::args`，因为 `OsString` 值每个平台都不一样而且比 `String` 值处理起来更复杂。 +> 注意 `std::env::args` 在其任何参数包含无效 Unicode 字符时会 panic。如果你需要接受包含无效 Unicode 字符的参数，使用 `std::env::args_os` 代替。这个函数返回 `OsString` 值而不是 `String` 值。这里出于简单考虑使用了 `std::env::args`，因为 `OsString` 值每个平台都不一样而且比 `String` 值处理起来更为复杂。 在 `main` 函数的第一行，我们调用了 `env::args`，并立即使用 `collect` 来创建了一个包含迭代器所有值的 vector。`collect` 可以被用来创建很多类型的集合，所以这里显式注明 `args` 的类型来指定我们需要一个字符串 vector。虽然在 Rust 中我们很少会需要注明类型，`collect` 就是一个经常需要注明类型的函数，因为 Rust 不能推断出你想要什么类型的集合。 @@ -51,18 +52,19 @@ fn main() { ```text $ cargo run +--snip-- ["target/debug/minigrep"] $ cargo run needle haystack -...snip... +--snip-- ["target/debug/minigrep", "needle", "haystack"] ``` -你可能注意到了 vector 的第一个值是 `"target/debug/minigrep"`，它是我们二进制文件的名称。这与 C 中的参数列表的行为相符合，并使得程序可以在执行过程中使用它的名字。能够访问程序名称在需要在信息中打印时，或者需要根据执行程序所使用的命令行别名来改变程序行为时显得很方便，不过考虑到本章的目的，我们将忽略它并只保存所需的两个参数。 +注意 vector 的第一个值是 `"target/debug/minigrep"`，它是我们二进制文件的名称。这与 C 中的参数列表的行为相符合，并使得程序可以在执行过程中使用它的名字。能够访问程序名称在需要在信息中打印时，或者需要根据执行程序所使用的命令行别名来改变程序行为时显得很方便，不过考虑到本章的目的，我们将忽略它并只保存所需的两个参数。 ### 将参数值保存进变量 -打印出参数 vector 中的值展示了程序可以访问指定为命令行参数的值。现在需要将这两个参数的值保存进变量这样就可以在程序的余下部分使用这些值。让我们如示例 12-2 这样做： +打印出参数 vector 中的值展示了程序可以访问指定为命令行参数的值。现在需要将这两个参数的值保存进变量这样就可以在程序的余下部分使用这些值了。让我们如示例 12-2 这样做： 文件名: src/main.rs @@ -80,14 +82,15 @@ fn main() { } ``` -示例 12-2：创建变量来存放查询参数和文件名参数 +示例 12-2：创建变量来存放查询参数和文件名参数 正如之前打印出 vector 时所所看到的，程序的名称占据了 vector 的第一个值 `args[0]`，所以我们从索引 `1` 开始。`minigrep` 获取的第一个参数是需要搜索的字符串，所以将其将第一个参数的引用存放在变量 `query` 中。第二个参数将是文件名，所以将第二个参数的引用放入变量 `filename` 中。 -我们将临时打印出这些变量的值，再一次证明代码如我们期望的那样工作。让我们使用参数 `test` 和 `sample.txt` 再次运行这个程序： +我们将临时打印出这些变量的值来证明代码如我们期望的那样工作。使用参数 `test` 和 `sample.txt` 再次运行这个程序： ```text $ cargo run test sample.txt + Compiling minigrep v0.1.0 (file:///projects/minigrep) Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs Running `target/debug/minigrep test sample.txt` Searching for test diff --git a/src/ch12-02-reading-a-file.md b/src/ch12-02-reading-a-file.md index bd1770e..9516029 100644 --- a/src/ch12-02-reading-a-file.md +++ b/src/ch12-02-reading-a-file.md @@ -2,9 +2,9 @@ > [ch12-02-reading-a-file.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch12-02-reading-a-file.md) >
-> commit b693c8400817f1022820fd63e3529cbecc35070c +> commit 97e60b3cb623d4a5b85419212b085ade8a11cbe1 -接下来我们将读取由命令行文件名参数指定的文件。首先，需要一个用来测试的示例文件——用来确保 `minigrep` 正常工作的最好的文件是拥有少量文本和多个行且有一些重复单词的文件。示例 12-3 是一首艾米莉·狄金森（Emily Dickinson）的诗，它正适合这个工作！在项目根目录创建一个文件 `poem.txt`，并输入诗 "I'm nobody! Who are you?"： +接下来我们将读取由命令行文件名参数指定的文件。首先，需要一个用来测试的示例文件——用来确保 `minigrep` 正常工作的最好的文件是拥有多行少量文本且有一些重复单词的文件。示例 12-3 是一首艾米莉·狄金森（Emily Dickinson）的诗，它正适合这个工作！在项目根目录创建一个文件 `poem.txt`，并输入诗 "I'm nobody! Who are you?"： 文件名: poem.txt @@ -38,7 +38,7 @@ fn main() { # let filename = &args[2]; # # println!("Searching for {}", query); - // ...snip... + // --snip-- println!("In file {}", filename); let mut f = File::open(filename).expect("file not found"); @@ -55,7 +55,7 @@ fn main() { 首先，我们增加了更多的 `use` 语句来引入标准库中的相关部分：需要 `std::fs::File` 来处理文件，而 `std::io::prelude::*` 则包含许多对于 I/O 包括文件 I/O 有帮助的 trait。类似于 Rust 有一个通用的 prelude 来自动引入特定内容，`std::io` 也有其自己的 prelude 来引入处理 I/O 时所需的通用内容。不同于默认的 prelude，必须显式 `use` 位于 `std::io` 中的 prelude。 -在 `main` 中，我们增加了三点内容：第一，通过传递变量 `filename` 的值调用 `File::open` 函数来获取文件的可变句柄。创建了叫做 `contents` 的变量并将其设置为一个可变的，空的`String`。它将会存放之后读取的文件的内容。第三，对文件句柄调用 `read_to_string` 并传递 `contents` 的可变引用作为参数。 +在 `main` 中，我们增加了三点内容：第一，通过传递变量 `filename` 的值调用 `File::open` 函数来获取文件的可变句柄。创建了叫做 `contents` 的变量并将其设置为一个可变的，空的 `String`。它将会存放之后读取的文件的内容。第三，对文件句柄调用 `read_to_string` 并传递 `contents` 的可变引用作为参数。 在这些代码之后，我们再次增加了临时的 `println!` 打印出读取文件后 `contents` 的值，这样就可以检查目前为止的程序能否工作。 @@ -63,6 +63,7 @@ fn main() { ```text $ cargo run the poem.txt + Compiling minigrep v0.1.0 (file:///projects/minigrep) Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs Running `target/debug/minigrep the poem.txt` Searching for the From ddeacb50a5060b32d2c285a5a48a4320802c5d5d Mon Sep 17 00:00:00 2001 From: KaiserY Date: Mon, 22 Jan 2018 22:51:24 +0800 Subject: [PATCH 119/150] check to ch13-01 --- ...improving-error-handling-and-modularity.md | 100 +++++----- ...2-04-testing-the-librarys-functionality.md | 76 ++++---- ...2-05-working-with-environment-variables.md | 24 ++- ...-06-writing-to-stderr-instead-of-stdout.md | 24 +-- src/ch13-00-functional-features.md | 12 +- src/ch13-01-closures.md | 178 ++++++++++-------- 6 files changed, 227 insertions(+), 187 deletions(-) diff --git a/src/ch12-03-improving-error-handling-and-modularity.md b/src/ch12-03-improving-error-handling-and-modularity.md index eb455ce..bffb8d9 100644 --- a/src/ch12-03-improving-error-handling-and-modularity.md +++ b/src/ch12-03-improving-error-handling-and-modularity.md @@ -2,13 +2,13 @@ > [ch12-03-improving-error-handling-and-modularity.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch12-03-improving-error-handling-and-modularity.md) >
-> commit 5908c59a5a4cc58fd863605b80b295a335c2cbdf +> commit c1fb695e6c9091c9a5145320498ef80a649af33c 为了改善我们的程序这里有四个问题需要修复，而且他们都与程序的组织方式和如何处理潜在错误有关。 -第一，`main` 现在进行了两个任务：它解析了参数并打开了文件。对于一个这样的小函数，这并不是一个大问题。然而如果 `main` 中的功能持续增加，`main` 函数处理的独立的任务也会增加。当函数承担了更多责任，它就更难以推导，更难以测试，并且更难以在不破坏其他部分的情况下做出修改。最好能分离出功能以便每个函数就负责一个任务。 +第一，`main` 现在进行了两个任务：它解析了参数并打开了文件。对于一个这样的小函数，这并不是一个大问题。然而如果 `main` 中的功能持续增加，`main` 函数处理的独立任务也会增加。当函数承担了更多责任，它就更难以推导，更难以测试，并且更难以在不破坏其他部分的情况下做出修改。最好能分离出功能以便每个函数就负责一个任务。 -这同时也关系到第二个问题：`search` 和 `filename` 是程序中的配置变量，而像 `f` 和 `contents` 则用来执行程序逻辑。随着 `main` 函数的增长，就需要引入更多的变量到作用域中，而当作用域中有更多的变量时，将更难以追踪每个变量的目的。最好能将配置变量组织进一个结构这样就能使他们的目的更明确了。 +这同时也关系到第二个问题：`search` 和 `filename` 是程序中的配置变量，而像 `f` 和 `contents` 则用来执行程序逻辑。随着 `main` 函数的增长，就需要引入更多的变量到作用域中，而当作用域中有更多的变量时，将更难以追踪每个变量的目的。最好能将配置变量组织进一个结构，这样就能使他们的目的更明确了。 第三个问题是如果打开文件失败我们使用 `expect` 来打印出错误信息，不过这个错误信息只是说 `file not found`。除了缺少文件之外还有很多打开文件可能失败的方式：例如，文件可能存在，不过可能没有打开它的权限。如果我们现在就出于这种情况，打印出的 `file not found` 错误信息就给了用户错误的建议！ @@ -22,18 +22,18 @@ 1. 将程序拆分成 *main.rs* 和 *lib.rs* 并将程序的逻辑放入 *lib.rs* 中。 2. 当命令行解析逻辑比较小时，可以保留在 *main.rs* 中。 -3. 当命令行解析开始变得复杂时，也同样将其从 *main.rs* 提取到 *lib.rs*中。 +3. 当命令行解析开始变得复杂时，也同样将其从 *main.rs* 提取到 *lib.rs* 中。 4. 经过这些过程之后保留在 `main` 函数中的责任应该被限制为： * 使用参数值调用命令行解析逻辑 * 设置任何其他的配置 * 调用 *lib.rs* 中的 `run` 函数 * 如果 `run` 返回错误，则处理这个错误 -这个模式的一切就是为了关注分离：*main.rs* 处理程序运行，而 *lib.rs* 处理所有的真正的任务逻辑。因为不能直接测试 `main` 函数，这个结构通过将所有的程序逻辑移动到 *lib.rs* 的函数中使得我们可以测试他们。仅仅保留在 *main.rs* 中的代码将足够小以便阅读就可以验证其正确性。 +这个模式的一切就是为了关注分离：*main.rs* 处理程序运行，而 *lib.rs* 处理所有的真正的任务逻辑。因为不能直接测试 `main` 函数，这个结构通过将所有的程序逻辑移动到 *lib.rs* 的函数中使得我们可以测试他们。仅仅保留在 *main.rs* 中的代码将足够小以便阅读就可以验证其正确性。让我们遵循这些步骤来重构程序。 ### 提取参数解析器 -首先，我们将解析参数的功能提取到一个 `main` 将会调用的函数中，为将命令行解析逻辑移动到 *src/lib.rs* 做准备。示例 12-5 中展示了新 `main` 函数的开头，它调用了新函数 `parse_config`。目前它仍将定义在 *src/main.rs* 中： +首先，我们将解析参数的功能提取到一个 `main` 将会调用的函数中，为将命令行解析逻辑移动到 *src/lib.rs* 中做准备。示例 12-5 中展示了新 `main` 函数的开头，它调用了新函数 `parse_config`。目前它仍将定义在 *src/main.rs* 中： 文件名: src/main.rs @@ -43,7 +43,7 @@ fn main() { let (query, filename) = parse_config(&args); - // ...snip... + // --snip-- } fn parse_config(args: &[String]) -> (&str, &str) { @@ -56,17 +56,17 @@ fn parse_config(args: &[String]) -> (&str, &str) { 示例 12-5：从 `main` 中提取出 `parse_config` 函数 -我们仍然将命令行参数收集进一个 vector，不过不同于在`main`函数中将索引 1 的参数值赋值给变量 `query` 和将索引 2 的值赋值给变量 `filename`，我们将整个 vector 传递给 `parse_config` 函数。接着 `parse_config` 函数将包含决定哪个参数该放入哪个变量的逻辑，并将这些值返回到 `main`。仍然在 `main` 中创建变量 `query` 和 `filename`，不过 `main` 不再负责处理命令行参数与变量如何对应。 +我们仍然将命令行参数收集进一个 vector，不过不同于在 `main` 函数中将索引 1 的参数值赋值给变量 `query` 和将索引 2 的值赋值给变量 `filename`，我们将整个 vector 传递给 `parse_config` 函数。接着 `parse_config` 函数将包含决定哪个参数该放入哪个变量的逻辑，并将这些值返回到 `main`。仍然在 `main` 中创建变量 `query` 和 `filename`，不过 `main` 不再负责处理命令行参数与变量如何对应。 -这对我们这小程序可能有点大材小用，不过我们将采用小的、增量的步骤进行重构。在做出这些改变之后，再次运行程序并验证参数解析是否仍然正常。经常验证你的进展是一个好习惯，这样在遇到问题时能帮助你定位问题的成因。 +这对重构我们这小程序可能有点大材小用，不过我们将采用小的、增量的步骤进行重构。在做出这些改变之后，再次运行程序并验证参数解析是否仍然正常。经常验证你的进展是一个好习惯，这样在遇到问题时能帮助你定位问题的成因。 ### 组合配置值 -我们可以采取另一个小的步骤来进一步改善这个函数。现在函数返回一个元组，不过立刻又就将元组拆成了独立的部分。这是一个我们可能没有进行正确抽象的信号。 +我们可以采取另一个小的步骤来进一步改善这个函数。现在函数返回一个元组，不过立刻又将元组拆成了独立的部分。这是一个我们可能没有进行正确抽象的信号。 另一个表明还有改进空间的迹象是 `parse_config` 名称的 `config` 部分，它暗示了我们返回的两个值是相关的并都是一个配置值的一部分。目前除了将这两个值组合进元组之外并没有表达这个数据结构的意义：我们可以将这两个值放入一个结构体并给每个字段一个有意义的名字。这会让未来的维护者更容易理解不同的值如何相互关联以及他们的目的。 -> 注意：一些同学将这种拒绝使用相对而言更为合适的复合类型而使用基本类型的模式称为 **基本类型偏执**（*primitive obsession*）。 +> 注意：一些同学将这种在复杂类型更为合适的场景下使用基本类型的反模式称为 **基本类型偏执**（*primitive obsession*）。 示例 12-6 展示了新定义的结构体 `Config`，它有字段 `query` 和 `filename`。我们也改变了 `parse_config` 函数来返回一个 `Config` 结构体的实例，并更新 `main` 来使用结构体字段而不是单独的变量： @@ -86,7 +86,7 @@ fn main() { let mut f = File::open(config.filename).expect("file not found"); - // ...snip... + // --snip-- } struct Config { @@ -114,7 +114,7 @@ fn parse_config(args: &[String]) -> Config { 我们更新 `main` 将 `parse_config` 返回的 `Config` 实例放入变量 `config` 中，并将之前分别使用 `search` 和 `filename` 变量的代码更新为现在的使用 `Config` 结构体的字段的代码。 -现在代码更明确的表现了我们的意图，`query` 和 `filename` 是相关联的并且他们的目的是配置程序如何工作的。任何使用这些值的代码就知道在 `config` 实例中对应目的的字段名中寻找他们。 +现在代码更明确的表现了我们的意图，`query` 和 `filename` 是相关联的并且他们的目的是配置程序如何工作。任何使用这些值的代码就知道在 `config` 实例中对应目的的字段名中寻找他们。 ### 创建一个 `Config` 构造函数 @@ -122,7 +122,6 @@ fn parse_config(args: &[String]) -> Config { 所以现在 `parse_config` 函数的目的是创建一个 `Config` 实例，我们可以将 `parse_config` 从一个普通函数变为一个叫做 `new` 的与结构体关联的函数。做出这个改变使得代码更符合习惯：可以像标准库中的 `String` 调用 `String::new` 来创建一个该类型的实例那样，将 `parse_config` 变为一个与 `Config` 关联的 `new` 函数。示例 12-7 展示了需要做出的修改： - 文件名: src/main.rs ```rust,should_panic @@ -133,7 +132,7 @@ fn main() { let config = Config::new(&args); - // ...snip... + // --snip-- } # struct Config { @@ -141,7 +140,7 @@ fn main() { # filename: String, # } # -// ...snip... +// --snip-- impl Config { fn new(args: &[String]) -> Config { @@ -159,50 +158,52 @@ impl Config { ### 修复错误处理 -现在我们开始修复错误处理。回忆一下之前提到过如果 `args` vector 包含少于 3 个项并尝试访问 vector 中索引 1 或 索引 2 的值会造成程序 panic。尝试不带任何参数运行程序；这将看起来像这样： +现在我们开始修复错误处理。回忆一下之前提到过如果 `args` vector 包含少于 3 个项并尝试访问 vector 中索引 `1` 或索引 `2` 的值会造成程序 panic。尝试不带任何参数运行程序；这将看起来像这样： ```text $ cargo run + Compiling minigrep v0.1.0 (file:///projects/minigrep) Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs Running `target/debug/minigrep` thread 'main' panicked at 'index out of bounds: the len is 1 -but the index is 1', /stable-dist-rustc/build/src/libcollections/vec.rs:1307 +but the index is 1', src/main.rs:29:21 note: Run with `RUST_BACKTRACE=1` for a backtrace. ``` `index out of bounds: the len is 1 but the index is 1` 是一个针对程序员的错误信息，然而这并不能真正帮助终端用户理解发生了什么和他们应该做什么。现在就让我们修复它吧。 -### 改善错误信息 +#### 改善错误信息 在示例 12-8 中，在 `new` 函数中增加了一个检查在访问索引 1 和 2 之前检查 slice 是否足够长。如果 slice 不够长，我们使用一个更好的错误信息 panic 而不是 `index out of bounds` 信息： 文件名: src/main.rs ```rust,ignore -// ...snip... +// --snip-- fn new(args: &[String]) -> Config { if args.len() < 3 { panic!("not enough arguments"); } - // ...snip... + // --snip-- ``` 示例 12-8：增加一个参数数量检查 -这类似于示例 9-8 中的 `Guess::new` 函数，那里如果 `value` 参数超出了有效值的范围就调用 `panic!`。不同于检查值的范围，这里检查 `args` 的长度至少是 3，而函数的剩余部分则可以在假设这个条件成立的基础上运行。如果 +这类似于示例 9-9 中的 `Guess::new` 函数，那里如果 `value` 参数超出了有效值的范围就调用 `panic!`。不同于检查值的范围，这里检查 `args` 的长度至少是 3，而函数的剩余部分则可以在假设这个条件成立的基础上运行。如果 `args` 少于 3 个项，则这个条件将为真，并调用 `panic!` 立即终止程序。 有了 `new` 中这几行额外的代码，再次不带任何参数运行程序并看看现在错误看起来像什么： -```bash +```text $ cargo run + Compiling minigrep v0.1.0 (file:///projects/minigrep) Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs Running `target/debug/minigrep` -thread 'main' panicked at 'not enough arguments', src/main.rs:29 +thread 'main' panicked at 'not enough arguments', src/main.rs:30:12 note: Run with `RUST_BACKTRACE=1` for a backtrace. ``` -这个输出就好多了，现在有了一个合理的错误信息。然而，我们还有一堆额外的信息不希望提供给用户。所以在这里使用示例 9-8 中的技术可能不是最好的；正如第九章所讲到的一样，`panic!` 的调用更趋向于程序上的问题而不是使用上的问题。相反我们可以使用那一章学习的另一个技术：返回一个可以表明成功或错误的 `Result`。 +这个输出就好多了，现在有了一个合理的错误信息。然而，还是有一堆额外的信息我们不希望提供给用户。所以在这里使用示例 9-9 中的技术可能不是最好的；正如第九章所讲到的一样，`panic!` 的调用更趋向于程序上的问题而不是使用上的问题。相反我们可以使用第九章学习的另一个技术：返回一个可以表明成功或错误的 `Result`。 #### 从 `new` 中返回 `Result` 而不是调用 `panic!` @@ -229,13 +230,13 @@ impl Config { 示例 12-9：从 `Config::new` 中返回 `Result` -现在 `new` 函数返回一个 `Result`，在成功时带有一个 `Config` 实例而在出现错误时带有一个 `&'static str`。回忆一下第十章 “静态生命周期” 中讲到 `&'static str` 是一个字符串字面值，也是目前的错误信息。 +现在 `new` 函数返回一个 `Result`，在成功时带有一个 `Config` 实例而在出现错误时带有一个 `&'static str`。回忆一下第十章 “静态生命周期” 中讲到 `&'static str` 是字符串字面值的类型，也是目前的错误信息。 `new` 函数体中有两处修改：当没有足够参数时不再调用 `panic!`，而是返回 `Err` 值。同时我们将 `Config` 返回值包装进 `Ok` 成员中。这些修改使得函数符合其新的类型签名。 通过让 `Config::new` 返回一个 `Err` 值，这就允许 `main` 函数处理 `new` 函数返回的 `Result` 值并在出现错误的情况更明确的结束进程。 -### `Config::new` 调用并处理错误 +#### `Config::new` 调用并处理错误 为了处理错误情况并打印一个对用户友好的信息，我们需要像示例 12-10 那样更新 `main` 函数来处理现在 `Config::new` 返回的 `Result`。另外还需要负责手动实现 `panic!` 的使用非零错误码退出命令行工具的工作。非零的退出状态是一个告诉调用程序的进程我们的程序以错误状态退出的惯例信号。 @@ -252,7 +253,7 @@ fn main() { process::exit(1); }); - // ...snip... + // --snip-- ``` 示例 12-10：如果新建 `Config` 失败则使用错误码退出 @@ -281,7 +282,7 @@ Problem parsing arguments: not enough arguments ```rust,ignore fn main() { - // ...snip... + // --snip-- println!("Searching for {}", config.query); println!("In file {}", config.filename); @@ -299,7 +300,7 @@ fn run(config: Config) { println!("With text:\n{}", contents); } -// ...snip... +// --snip-- ``` 示例 12-11：提取 `run` 函数来包含剩余的程序逻辑 @@ -315,7 +316,7 @@ fn run(config: Config) { ```rust,ignore use std::error::Error; -// ...snip... +// --snip-- fn run(config: Config) -> Result<(), Box> { let mut f = File::open(config.filename)?; @@ -330,7 +331,8 @@ fn run(config: Config) -> Result<(), Box> { ``` 示例 12-12：修改 `run` 函数返回 `Result` - `Result<(), Box>`。之前这个函数返回 unit 类型 `()`，现在它仍然保持作为 `Ok` 时的返回值。 + +这里我们做出了三个明显的修改。首先，将 `run` 函数的返回类型变为 `Result<(), Box>`。之前这个函数返回 unit 类型 `()`，现在它仍然保持作为 `Ok` 时的返回值。 对于错误类型，使用了 **trait 对象** `Box`（在开头使用了 `use` 语句将 `std::error::Error` 引入作用域）。第十七章会涉及 trait 对象。目前只需知道 `Box` 意味着函数会返回实现了 `Error` trait 的类型，不过无需指定具体将会返回的值的类型。这提供了在不同的错误场景可能有不同类型的错误返回值的灵活性。 @@ -341,12 +343,12 @@ fn run(config: Config) -> Result<(), Box> { 上述代码能够编译，不过会有一个警告： ```text -warning: unused result which must be used, #[warn(unused_must_use)] on by -default - --> src/main.rs:39:5 +warning: unused `std::result::Result` which must be used + --> src/main.rs:18:5 | -39 | run(config); +18 | run(config); | ^^^^^^^^^^^^ += note: #[warn(unused_must_use)] on by default ``` Rust 提示我们的代码忽略了 `Result` 值，它可能表明这里存在一个错误。虽然我们没有检查这里是否有一个错误，而编译器提醒我们这里应该有一些错误处理代码！现在就让我们修正他们。 @@ -359,7 +361,7 @@ Rust 提示我们的代码忽略了 `Result` 值，它可能表明这里存在 ```rust,ignore fn main() { - // ...snip... + // --snip-- println!("Searching for {}", config.query); println!("In file {}", config.filename); @@ -372,22 +374,22 @@ fn main() { } ``` -我们使用 `if let` 来检查 `run` 是否返回一个 `Err` 值，不同于 `unwrap_or_else`，并在出错时调用 `process::exit(1)`。`run` 并不返回像 `Config::new` 返回的 `Config` 实例那样需要 `unwrap` 的值。因为 `run` 在成功时返回 `()`，而我们只关心发现一个错误，所以并不需要 `unwrap_or_else` 来返回未封装的值，因为它只会是 `()`。 +我们使用 `if let` 来检查 `run` 是否返回一个 `Err` 值，不同于 `unwrap_or_else`，并在出错时调用 `process::exit(1)`。`run` 并不返回像 `Config::new` 返回的 `Config` 实例那样需要 `unwrap` 的值。因为 `run` 在成功时返回 `()`，而我们只关心检测错误，所以并不需要 `unwrap_or_else` 来返回未封装的值，因为它只会是 `()`。 不过两个例子中 `if let` 和 `unwrap_or_else` 的函数体都一样：打印出错误并退出。 ### 将代码拆分到库 crate -现在项目看起来好多了！现在我们将要拆分 *src/main.rs* 并将一些代码放入 *src/lib.rs*，这样就能测试他们并拥有一个拥有更少功能的 `main` 函数。 +现在我们的 `minigrep` 项目看起来好多了！现在我们将要拆分 *src/main.rs* 并将一些代码放入 *src/lib.rs*，这样就能测试他们并拥有一个含有更少功能的 `main` 函数。 -让我们将如下代码片段从 *src/main.rs* 移动到新文件 *src/lib.rs* 中： +让我们将所有不是 `main` 函数的代码从 *src/main.rs* 移动到新文件 *src/lib.rs* 中： - `run` 函数定义 - 相关的 `use` 语句 - `Config` 的定义 - `Config::new` 函数定义 -现在 *src/lib.rs* 的内容应该看起来像示例 12-13（为了简洁省略了函数体）： +现在 *src/lib.rs* 的内容应该看起来像示例 12-13（为了简洁省略了函数体）。注意直到下一个示例修改完 *src/main.rs* 之后，代码还不能编译： 文件名: src/lib.rs @@ -403,20 +405,20 @@ pub struct Config { impl Config { pub fn new(args: &[String]) -> Result { - // ...snip... + // --snip-- } } pub fn run(config: Config) -> Result<(), Box> { - // ...snip... + // --snip-- } ``` 示例 12-13：将 `Config` 和 `run` 移动到 *src/lib.rs* -这里使用了公有的 `pub`：在 `Config`、其字段和其 `new`方法，以及 `run` 函数上。现在我们有了一个拥有可以测试的公有 API 的库 crate 了。 +这里使用了公有的 `pub`：在 `Config`、其字段和其 `new` 方法，以及 `run` 函数上。现在我们有了一个拥有可以测试的公有 API 的库 crate 了。 -现在需要在 *src/main.rs* 中使用 `extern crate minigrep` 将移动到 *src/lib.rs* 的代码引入二进制 crate 的作用域。接着我们将增加一个 `use minigrep::Config` 行将 `Config` 类型引入作用域，并使用库 crate 的名称作为 `run` 函数的前缀，如示例 12-14 所示： +现在需要在 *src/main.rs* 中将移动到 *src/lib.rs* 的代码引入二进制 crate 的作用域中，如示例 12-14 所示： Filename: src/main.rs @@ -429,17 +431,17 @@ use std::process; use minigrep::Config; fn main() { - // ...snip... + // --snip-- if let Err(e) = minigrep::run(config) { - // ...snip... + // --snip-- } } ``` -示例 12-14：将 `minigrep` crate 引入 *src/main.rs* 的作用域 +示例 12-14：将 `minigrep` crate 引入 *src/main.rs* 的作用域中 为了将库 crate 引入二进制 crate，我们使用 `extern crate minigrep`。接着增加 `use minigrep::Config` 将 `Config` 类型引入作用域，并使用 crate 名作为 `run` 函数的前缀。通过这些重构，所有功能应该能够联系在一起并运行了。运行 `cargo run` 来确保一切都正确的衔接在一起。 -哇哦！这可有很多的工作，不过我们为将来成功打下了基础。现在处理错误将更容易，同时代码也更加模块化。从现在开始几乎所有的工作都将在 *src/lib.rs* 中进行。 +哇哦！这可有很多的工作，不过我们为将来的成功打下了基础。现在处理错误将更容易，同时代码也更加模块化。从现在开始几乎所有的工作都将在 *src/lib.rs* 中进行。 让我们利用这些新创建的模块的优势来进行一些在旧代码中难以展开的工作，他们在新代码中却很简单：编写测试！ diff --git a/src/ch12-04-testing-the-librarys-functionality.md b/src/ch12-04-testing-the-librarys-functionality.md index 810c6d2..903aaf5 100644 --- a/src/ch12-04-testing-the-librarys-functionality.md +++ b/src/ch12-04-testing-the-librarys-functionality.md @@ -1,17 +1,17 @@ -## 测试库的功能 +## 采用测试驱动开发完善库的功能 > [ch12-04-testing-the-librarys-functionality.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch12-04-testing-the-librarys-functionality.md) >
-> commit 5908c59a5a4cc58fd863605b80b295a335c2cbdf +> commit 1fe78a83f37ecc69b840fdc8dcfc727f88a3a3d4 现在我们将逻辑提取到了 *src/lib.rs* 并将所有的参数解析和错误处理留在了 *src/main.rs* 中，为代码的核心功能编写测试将更加容易。我们可以直接使用多种参数调用函数并检查返回值而无需从命令行运行二进制文件了。如果你愿意的话，请自行为 `Config::new` 和 `run` 函数的功能编写一些测试。 -在这一部分，我们将遵循测试驱动开发（Test Driven Development, TTD）的模式来逐步增加 `minigrep` 的搜索逻辑。这是一个软件开发技术，它遵循如下步骤： +在这一部分，我们将遵循测试驱动开发（Test Driven Development, TDD）的模式来逐步增加 `minigrep` 的搜索逻辑。这是一个软件开发技术，它遵循如下步骤： 1. 编写一个会失败的测试，并运行它以确保其因为你期望的原因失败。 2. 编写或修改刚好足够的代码来使得新的测试通过。 3. 重构刚刚增加或修改的代码，并确保测试仍然能通过。 -4. 重复上述步骤！ +4. 从步骤 1 开始重复！ 这只是众多编写软件的方法之一，不过 TDD 有助于驱动代码的设计。在编写能使测试通过的代码之前编写测试有助于在开发过程中保持高测试覆盖率。 @@ -19,7 +19,7 @@ ### 编写失败测试 -首先，去掉 *src/lib.rs* 和 *src/main.rs* 中的`println!`语句，因为不再真正需要他们了。接着我们会像第十一章那样增加一个 `test` 模块和一个测试函数。测试函数指定了 `search` 函数期望拥有的行为：它会获取一个需要查询的字符串和用来查询的文本，并只会返回包含请求的文本行。示例 12-15 展示了这个测试： +去掉 *src/lib.rs* 和 *src/main.rs* 中用于检查程序行为的 `println!` 语句，因为不再真正需要他们了。接着我们会像第十一章那样增加一个 `test` 模块和一个测试函数。测试函数指定了 `search` 函数期望拥有的行为：它会获取一个需要查询的字符串和用来查询的文本，并只会返回包含请求的文本行。示例 12-15 展示了这个测试，它还不能编译： 文件名: src/lib.rs @@ -52,11 +52,11 @@ Pick three."; 这里选择使用 "duct" 作为这个测试中需要搜索的字符串。用来搜索的文本有三行，其中只有一行包含 "duct"。我们断言 `search` 函数的返回值只包含期望的那一行。 -我们还不能运行这个测试并看到它失败，因为它甚至都还不能编译！我们将增加足够的代码来使其能够编译：一个总是会返回空 vector 的 `search` 函数定义，如示例 12-16 所示。一旦有了它，这个测试应该能够编译并因为空 vector 并不匹配一个包含一行 `"safe, fast, productive."` 的 vector 而失败。 +我们还不能运行这个测试并看到它失败，因为它甚至都还不能编译！我们将增加足够的代码来使其能够编译：一个总是会返回空 vector 的 `search` 函数定义，如示例 12-16 所示。然后这个测试应该能够编译并因为空 vector 并不匹配一个包含一行 `"safe, fast, productive."` 的 vector 而失败。 文件名: src/lib.rs -``` +```rust pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { vec![] } @@ -72,10 +72,11 @@ pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { ```text error[E0106]: missing lifetime specifier - --> src/lib.rs:5:47 + --> src/lib.rs:5:51 | -5 | fn search(query: &str, contents: &str) -> Vec<&str> { - | ^ expected lifetime parameter +5 | pub fn search(query: &str, contents: &str) -> Vec<&str> { + | ^ expected lifetime +parameter | = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `query` or `contents` @@ -83,13 +84,14 @@ error[E0106]: missing lifetime specifier Rust 不可能知道我们需要的是哪一个参数，所以需要告诉它。因为参数 `contents` 包含了所有的文本而且我们希望返回匹配的那部分文本，所以我们知道 `contents` 是应该要使用生命周期语法来与返回值相关联的参数。 -其他语言中并不需要你在函数签名中将参数与返回值相关联，所以这么做可能仍然感觉有些陌生，随着时间的推移会越来越容易。你可能想要将这个例子与第十章中生命周期语法部分做对比。 +其他语言中并不需要你在函数签名中将参数与返回值相关联，所以这么做可能仍然感觉有些陌生，随着时间的推移这将会变得越来越容易。你可能想要将这个例子与第十章中生命周期语法部分做对比。 -现在试尝试运行测试： +现在运行测试： ```text $ cargo test -...warnings... + Compiling minigrep v0.1.0 (file:///projects/minigrep) +--warnings-- Finished dev [unoptimized + debuginfo] target(s) in 0.43 secs Running target/debug/deps/minigrep-abcabcabc @@ -99,17 +101,19 @@ test test::one_result ... FAILED failures: ---- test::one_result stdout ---- - thread 'test::one_result' panicked at 'assertion failed: `(left == right)` -(left: `["safe, fast, productive."]`, right: `[]`)', src/lib.rs:16 + thread 'test::one_result' panicked at 'assertion failed: `(left == +right)` +left: `["safe, fast, productive."]`, +right: `[]`)', src/lib.rs:48:8 note: Run with `RUST_BACKTRACE=1` for a backtrace. failures: test::one_result -test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured +test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out -error: test failed +error: test failed, to rerun pass '--lib' ``` 好的，测试失败了，这正是我们所期望的。修改代码来让测试通过吧！ @@ -118,19 +122,19 @@ error: test failed 目前测试之所以会失败是因为我们总是返回一个空的 vector。为了修复并实现 `search`，我们的程序需要遵循如下步骤： -* 遍历每一行文本。 +* 遍历内容的每一行文本。 * 查看这一行是否包含要搜索的字符串。 -* 如果有，将这一行加入返回示例中。 +* 如果有，将这一行加入列表返回值中。 * 如果没有，什么也不做。 -* 返回匹配到的示例 +* 返回匹配到的结果列表 让我们一步一步的来，从遍历每行开始。 #### 使用 `lines` 方法遍历每一行 -Rust 有一个有助于一行一行遍历字符串的方法，出于方便它被命名为 `lines`，它如示例 12-17 这样工作： +Rust 有一个有助于一行一行遍历字符串的方法，出于方便它被命名为 `lines`，它如示例 12-17 这样工作。注意这还不能编译： -Filename: src/lib.rs +文件名: src/lib.rs ```rust,ignore pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { @@ -142,11 +146,11 @@ pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { 示例 12-17：遍历 `contents` 的每一行 -`lines` 方法返回一个迭代器。第十三章会深入了解迭代器，不过我们已经在示例 3-6 中见过使用迭代器的方法，在那里使用了一个 `for` 循环和迭代器在一个集合的每一项上运行了一些代码。 +`lines` 方法返回一个迭代器。第十三章会深入了解迭代器，不过我们已经在示例 3-4 中见过使用迭代器的方法了，在那里使用了一个 `for` 循环和迭代器在一个集合的每一项上运行了一些代码。 #### 用查询字符串搜索每一行 -接下来将会增加检查当前行是否包含查询字符串的功能。幸运的是，字符串类型为此也有一个叫做 `contains` 的实用方法！如示例 12-18 所示在 `search` 函数中加入 `contains` 方法调用： +接下来将会增加检查当前行是否包含查询字符串的功能。幸运的是，字符串类型为此也有一个叫做 `contains` 的实用方法！如示例 12-18 所示在 `search` 函数中加入 `contains` 方法调用。注意这仍然不能编译： 文件名: src/lib.rs @@ -164,7 +168,7 @@ pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { #### 存储匹配的行 -最后我们需要一个方法来存储包含查询字符串的行。为此可以在 `for` 循环之前创建一个可变的 vector 并调用 `push` 方法在 vector 中存放一个 `line`。在 `for` 循环之后，返回这个 vector，如示例 12-19 所示： +我们还需要一个方法来存储包含查询字符串的行。为此可以在 `for` 循环之前创建一个可变的 vector 并调用 `push` 方法在 vector 中存放一个 `line`。在 `for` 循环之后，返回这个 vector，如示例 12-19 所示： 文件名: src/lib.rs @@ -188,15 +192,16 @@ pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> { ```text $ cargo test +--snip-- running 1 test test test::one_result ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` -测试通过了，很好，它可以工作了！ +测试通过了，它可以工作了！ -现在测试通过了，我们可以考虑一下重构 `search` 的实现并时刻保持测试通过来保持其功能不变的机会了。`search` 函数中的代码并不坏，不过并没有利用迭代器的一些实用功能。第十三章将回到这个例子并深入探索迭代器并看看如何改进代码。 +到此为止，我们可以考虑一下重构 `search` 的实现并时刻保持测试通过来保持其功能不变的机会了。`search` 函数中的代码并不坏，不过并没有利用迭代器的一些实用功能。第十三章将回到这个例子并深入探索迭代器并看看如何改进代码。 #### 在 `run` 函数中使用 `search` 函数 @@ -221,7 +226,7 @@ pub fn run(config: Config) -> Result<(), Box> { 这里仍然使用了 `for` 循环获取了 `search` 返回的每一行并打印出来。 -现在整个程序应该可以工作了！让我们试一试，首先使用一个只会在艾米莉·狄金森的诗中返回一行的单词 "frog"： +现在整个程序应该可以工作了！让我们试一试，首先使用一个只会在艾米莉·狄金森的诗中返回一行的单词 “frog”： ```text $ cargo run frog poem.txt @@ -231,14 +236,15 @@ $ cargo run frog poem.txt How public, like a frog ``` -好的！接下来，像 "the" 这样会匹配多行的单词会怎么样呢： +好的！现在试试一个会匹配多行的单词，比如 “body”： ```text -$ cargo run the poem.txt +$ cargo run body poem.txt Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs - Running `target/debug/minigrep the poem.txt` -Then there’s a pair of us — don’t tell! -To tell your name the livelong day + Running `target/debug/minigrep body poem.txt` +I’m nobody! Who are you? +Are you nobody, too? +How dreary to be somebody! ``` 最后，让我们确保搜索一个在诗中哪里都没有的单词时不会得到任何行，比如 "monomorphization"： @@ -251,4 +257,4 @@ $ cargo run monomorphization poem.txt 非常好！我们创建了一个属于自己的迷你版经典工具，并学习了很多如何组织程序的知识。我们还学习了一些文件输入输出、生命周期、测试和命令行解析的内容。 -为了使这个项目章节更丰满，我们将简要的展示如何处理环境变量和打印到标准错误，这两者在编写命令行程序时都很有用。现在如果你希望的话请随意移动到第十三章。 +为了使这个项目更丰满，我们将简要的展示如何处理环境变量和打印到标准错误，这两者在编写命令行程序时都很有用。 diff --git a/src/ch12-05-working-with-environment-variables.md b/src/ch12-05-working-with-environment-variables.md index 422d9c9..a61ef43 100644 --- a/src/ch12-05-working-with-environment-variables.md +++ b/src/ch12-05-working-with-environment-variables.md @@ -2,15 +2,13 @@ > [ch12-05-working-with-environment-variables.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch12-05-working-with-environment-variables.md) >
-> commit adababc48956f4d39c97c8b6fc14a104d90e20dc +> commit 1fe78a83f37ecc69b840fdc8dcfc727f88a3a3d4 -我们将用一个额外的功能来改进我们的工具：一个通过环境变量启用的大小写不敏感搜索的选项。我们可以将其设计为一个命令行参数并要求用户每次需要时都加上它，不过相反我们将使用环境变量。这允许用户设置环境变量一次之后在整个终端会话中所有的搜索都将是大小写不敏感的。 +我们将增加一个额外的功能来改进 `minigrep`：一个通过环境变量启用的大小写不敏感搜索的选项。可以将其设计为一个命令行参数并要求用户每次需要时都加上它，不过相反我们将使用环境变量。这允许用户设置环境变量一次之后在整个终端会话中所有的搜索都将是大小写不敏感的。 ### 编写一个大小写不敏感 `search` 函数的失败测试 -首先，增加一个新函数，当设置了环境变量时会调用它。 - -这里将继续遵循上一部分开始使用的 TDD 过程，其第一步是再次编写一个失败测试。我们将为新的大小写不敏感搜索函数新增一个测试函数，并将老的测试函数从 `one_result` 改名为 `case_sensitive` 来更清楚的表明这两个测试的区别，如示例 12-20 所示： +我们希望增加一个新函数 `search_case_insensitive`，并将会在设置了环境变量时调用它。这里将继续遵循 TDD 过程，其第一步是再次编写一个失败测试。我们将为新的大小写不敏感搜索函数新增一个测试函数，并将老的测试函数从 `one_result` 改名为 `case_sensitive` 来更清楚的表明这两个测试的区别，如示例 12-20 所示： 文件名: src/lib.rs @@ -93,7 +91,7 @@ running 2 tests test test::case_insensitive ... ok test test::case_sensitive ... ok -test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 好的！现在，让我们在 `run` 函数中实际调用新 `search_case_insensitive` 函数。首先，我们将在 `Config` 结构体中增加一个配置项来切换大小写敏感和大小写不敏感搜索： @@ -108,7 +106,7 @@ pub struct Config { } ``` -这里增加了 `case_sensitive` 字符来存放一个布尔值。接着我们需要 `run` 函数检查 `case_sensitive` 字段的值并使用它来决定是否调用 `search` 函数或 `search_case_insensitive` 函数，如示例 12-22 所示： +这里增加了 `case_sensitive` 字符来存放一个布尔值。接着我们需要 `run` 函数检查 `case_sensitive` 字段的值并使用它来决定是否调用 `search` 函数或 `search_case_insensitive` 函数，如示例 12-22 所示。注意这还不能编译： 文件名: src/lib.rs @@ -131,7 +129,7 @@ pub struct Config { # case_sensitive: bool, # } # -pub fn run(config: Config) -> Result<(), Box>{ +pub fn run(config: Config) -> Result<(), Box> { let mut f = File::open(config.filename)?; let mut contents = String::new(); @@ -165,7 +163,7 @@ use std::env; # case_sensitive: bool, # } -// ...snip... +// --snip-- impl Config { pub fn new(args: &[String]) -> Result { @@ -195,6 +193,7 @@ impl Config { ```text $ cargo run to poem.txt + Compiling minigrep v0.1.0 (file:///projects/minigrep) Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs Running `target/debug/minigrep to poem.txt` Are you nobody, too? @@ -213,6 +212,13 @@ To tell your name the livelong day To an admiring bog! ``` +如果你使用 PowerShell，则需要用两句命令而不是一句来设置环境变量并运行程序： + +```text +$ $env.CASE_INSENSITIVE=1 +$ cargo run to poem.txt +``` + 好极了，我们也得到了包含 “To” 的行！现在 `minigrep` 程序可以通过环境变量控制进行大小写不敏感搜索了。现在你知道了如何管理由命令行参数或环境变量设置的选项了！ 一些程序允许对相同配置同时使用参数 **和** 环境变量。在这种情况下，程序来决定参数和环境变量的优先级。作为一个留给你的测试，尝试通过一个命令行参数或一个环境变量来控制大小写不敏感搜索。并在运行程序时遇到矛盾值时决定命令行参数和环境变量的优先级。 diff --git a/src/ch12-06-writing-to-stderr-instead-of-stdout.md b/src/ch12-06-writing-to-stderr-instead-of-stdout.md index ed39973..3decb28 100644 --- a/src/ch12-06-writing-to-stderr-instead-of-stdout.md +++ b/src/ch12-06-writing-to-stderr-instead-of-stdout.md @@ -1,24 +1,26 @@ -## 输出到`stderr`而不是`stdout` +## 将错误信息输出到标准错误而不是标准输出 > [ch12-06-writing-to-stderr-instead-of-stdout.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch12-06-writing-to-stderr-instead-of-stdout.md) >
-> commit 7db14aa689553706198ffcb11a8c60b478e752fe +> commit 1fe78a83f37ecc69b840fdc8dcfc727f88a3a3d4 -目前为止，我们将所有的输出都 `println!` 到了终端。大部分终端都提供了两种输出：**标准输出**（*standard output*）对应大部分信息（有时在代码中使用缩写 `stdout`），**标准错误**（*standard error*）则用于错误信息（`stderr`）。这种区别允许用户选择将程序正常输出定向到一个文件中并仍将错误信息打印到屏幕上。 +目前为止，我们将所有的输出都 `println!` 到了终端。大部分终端都提供了两种输出：**标准输出**（*standard output*，`stdout`）对应通用信息，**标准错误**（*standard error*，`stderr`）则用于错误信息。这种区别允许用户选择将程序正常输出定向到一个文件中并仍将错误信息打印到屏幕上。 但是 `println!` 函数只能够打印到标准输出，所以我们必需使用其他方法来打印到标准错误。 ### 检查错误应该写入何处 -首先，让我们观察一下目前 `minigrep` 打印的所有内容都被写入了标准输出，包括应该被写入标准错误的错误信息。可以通过将标准输出流重定向到一个文件同时有意产生一个错误来做到这一点。我们没有重定向标准错误流，所以任何发送到标准错误的内容将会继续显示在屏幕上。命令行程序被期望将错误信息发送到标准错误流，这样即便选择将标准输出流重定向到文件中时仍然能看到错误信息。目前我们的程序并不符合期望；我们将看到相反它将错误信息输出保存到了文件中。 +首先，让我们观察一下目前 `minigrep` 打印的所有内容都被写入了标准输出，包括应该被写入标准错误的错误信息。可以通过将标准输出流重定向到一个文件同时有意产生一个错误来做到这一点。我们没有重定向标准错误流，所以任何发送到标准错误的内容将会继续显示在屏幕上。 -展示这种行为的方式是通过 `>` 和文件名 *output.txt* 来与运行程序，这个文件是期望重定向标准输出流的位置。并不传递任何参数这样应该会产生一个错误： +命令行程序被期望将错误信息发送到标准错误流，这样即便选择将标准输出流重定向到文件中时仍然能看到错误信息。目前我们的程序并不符合期望；相反我们将看到它将错误信息输出保存到了文件中。 + +展示这种行为的方式是通过 `>` 和文件名 *output.txt* 来与运行程序，这个文件是期望重定向标准输出流的位置。并不传递任何参数应该会产生一个错误： ```text $ cargo run > output.txt ``` -`>` 语法告诉 shell 将标准输出的内容写入到 *output.txt* 文件中而不是屏幕上。我们并没有看到期望的错误信息打印到屏幕上，所以这意味着它一定被写入了文件中。让我们看看 *output.txt* 包含什么： +`>` 语法告诉 shell 将标准输出的内容写入到 *output.txt* 文件中而不是屏幕上。我们并没有看到期望的错误信息打印到屏幕上，所以这意味着它一定被写入了文件中。如下是 *output.txt* 所包含的： ```text Problem parsing arguments: not enough arguments @@ -28,7 +30,7 @@ Problem parsing arguments: not enough arguments ### 将错误打印到标准错误 -让我们如示例 12-24 所示的代码改变错误信息是如何被打印的。得益于本章早些时候的重构，所有打印错误信息的代码都位于 `main` 一个函数中。标准库提供了 `eprintln!` 宏来打印到标准错误流，所以将两个调用 `println!` 打印错误信息的维持替换为 `eprintln!`： +让我们如示例 12-24 所示的代码改变错误信息是如何被打印的。得益于本章早些时候的重构，所有打印错误信息的代码都位于 `main` 一个函数中。标准库提供了 `eprintln!` 宏来打印到标准错误流，所以将两个调用 `println!` 打印错误信息的位置替换为 `eprintln!`： 文件名: src/main.rs @@ -58,9 +60,9 @@ $ cargo run > output.txt Problem parsing arguments: not enough arguments ``` -现在我们看到了屏幕上的错误信息，同时 `output.txt` 里什么也没有，这也就是命令行程序所期望的行为。 +现在我们看到了屏幕上的错误信息，同时 `output.txt` 里什么也没有，这正是命令行程序所期望的行为。 -如果使用不会造成错误的参数再次运行程序，不过仍然将标准输出重定向到一个文件： +如果使用不会造成错误的参数再次运行程序，不过仍然将标准输出重定向到一个文件，像这样： ```text $ cargo run to poem.txt > output.txt @@ -75,10 +77,10 @@ Are you nobody, too? How dreary to be somebody! ``` -这一部分展示了现在我们适当的使用成功时产生的标准输出和错误时产生的标准错误。 +这一部分展示了现在我们适当的使用了成功时产生的标准输出和错误时产生的标准错误。 ## 总结 在这一章中，我们回顾了目前为止的一些主要章节并涉及了如何在 Rust 环境中进行常规的 I/O 操作。通过使用命令行参数、文件、环境变量和打印错误的 `eprintln!` 宏，现在你已经准备好编写命令行程序了。通过结合前几章的知识，你的代码将会是组织良好的，并能有效的将数据存储到合适的数据结构中、更好的处理错误，并且还是经过良好测试的。 -接下来，让我们探索如何利用一些 Rust 中受函数式编程语言影响的功能：闭包和迭代器。 \ No newline at end of file +接下来，让我们探索一些 Rust 中受函数式编程语言影响的功能：闭包和迭代器。 \ No newline at end of file diff --git a/src/ch13-00-functional-features.md b/src/ch13-00-functional-features.md index e7b91b3..6de9f6e 100644 --- a/src/ch13-00-functional-features.md +++ b/src/ch13-00-functional-features.md @@ -1,16 +1,16 @@ -# Rust 中的函数式语言功能 —— 迭代器和闭包 +# Rust 中的函数式语言功能：迭代器与闭包 > [ch13-00-functional-features.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch13-00-functional-features.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 2bcb126815a381acc3d46b0d6fc382cb4c98fbc5 -Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。我们不会在这里讨论函数式编程是或不是什么的问题，而是展示Rust的一些在功能上与其他语言类似的特性。 +Rust 的设计灵感来源于很多现存的语言和技术。其中一个显著的影响就是 **函数式编程**（*functional programming*）。函数式编程风格通常包含将函数作为参数值或其他函数的返回值、将函数赋值给变量以供之后执行等等。我们不会在这里讨论函数式编程是或不是什么的问题，而是展示 Rust 的一些在功能上与其他被认为是函数式语言类似的特性。 更具体的，我们将要涉及： -* **闭包**（*Closures*），一个可以储存在变量里的类似函数的结构。 -* **迭代器**（*Iterators*），一种处理元素序列的方式。。 +* **闭包**（*Closures*），一个可以储存在变量里的类似函数的结构 +* **迭代器**（*Iterators*），一种处理元素序列的方式 * 如何使用这些功能来改进第十二章的 I/O 项目。 -* 这些功能的性能。**剧透高能：** 他们的速度超乎你的想象！ +* 这两个功能的性能。（**剧透高能：** 他们的速度超乎你的想象！） 还有其它受函数式风格影响的 Rust 功能，比如模式匹配和枚举，这些已经在其他章节中讲到过了。掌握闭包和迭代器则是编写符合语言风格的高性能 Rust 代码的重要一环，所以我们将专门用一整章来讲解他们。 diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 58e71d3..9be96af 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -2,15 +2,17 @@ > [ch13-01-closures.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch13-01-closures.md) >
-> commit 56352c28cf3fe0402fa5a7cba73890e314d720eb +> commit f23a91d6a2f37ba6d415d2c8ca4302bf1b3a4e9e -Rust 的闭包是可以保存进变量或作为参数传递给其他函数的匿名函数。可以在一个地方创建闭包，然后在以不同的上下文中执行闭包运算。不同于函数，闭包允许捕获调用者作用域中的值。我们将展示闭包的这些功能如何复用代码和自定义行为。 +Rust 的 **闭包**（*closures*）是可以保存进变量或作为参数传递给其他函数的匿名函数。可以在一个地方创建闭包，然后在不同的上下文中执行闭包运算。不同于函数，闭包允许捕获调用者作用域中的值。我们将展示闭包的这些功能如何复用代码和自定义行为。 ### 使用闭包创建行为的抽象 -让我们看看一个展示储存闭包并在之后执行如何有用的情形的例子。其间我们会讨论闭包的语法、类型推断和 trait。 +让我们看看一个展示储存闭包并在之后执行是如何有价值的用例。其间我们会讨论闭包的语法、类型推断和 trait。 -这个假想的情况如下：我们在一个通过 app 生成自定义健身计划的初创企业工作。其后端使用 Rust 编写，而生成健身计划的算法需要考虑很多不同的因素，比如用户的年龄、身体质量指数（Body Mass Index）、用户喜好、最近的健身活动和用户指定的强度系数。本例中实际的算法并不重要。我们只希望在需要时调用算法，并且只希望调用一次，这样就不会让用户等得太久。这里将通过调用 `simulated_expensive_calculation` 函数来模拟调用假象的算法，如示例 13-1 所示，它会打印出 `calculating slowly...`，等待两秒，并接着返回传递给它的数字： +考虑一下这个假想的情况：我们在一个通过 app 生成自定义健身计划的初创企业工作。其后端使用 Rust 编写，而生成健身计划的算法需要考虑很多不同的因素，比如用户的年龄、身体质量指数（Body Mass Index）、用户喜好、最近的健身活动和用户指定的强度系数。本例中实际的算法并不重要，重要的是这个计算只花费几秒钟。我们只希望在需要时调用算法，并且只希望调用一次，这样就不会让用户等得太久。 + +这里将通过调用 `simulated_expensive_calculation` 函数来模拟调用假象的算法，如示例 13-1 所示，它会打印出 `calculating slowly...`，等待两秒，并接着返回传递给它的数字： 文件名: src/main.rs @@ -18,25 +20,23 @@ Rust 的闭包是可以保存进变量或作为参数传递给其他函数的匿 use std::thread; use std::time::Duration; -fn simulated_expensive_calculation(intensity: i32) -> i32 { +fn simulated_expensive_calculation(intensity: u32) -> u32 { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); intensity } ``` -示例 13-1：一个用来代替假象计算的函数，它大约会执行两秒 +示例 13-1：一个用来代替假象计算的函数，它大约会执行两秒钟 接下来，`main` 函数中将会包含本例的健身 app 中的重要部分。这代表当用户请求健身计划时 app 会调用的代码。因为与 app 前端的交互与闭包的使用并不相关，所以我们将硬编码代表程序输入的值并打印输出。 -程序的输入有： +所需的输入有： -- 一个来自用户的 `intensity` 数字，请求健身计划时指定，它代表用户喜好低强度还是高强度健身 -- 一个会在健身计划中生成变化的随机数 +* **一个来自用户的 intensity 数字**，请求健身计划时指定，它代表用户喜好低强度还是高强度健身。 +* **一个随机数**，其会在健身计划中生成变化。 -程序的输出将会是建议的锻炼计划。 - -示例 13-2 展示了我们将要使用的 `main` 函数。处于简单考虑这里硬编码了 `simulated_user_specified_value` 变量的值为 10 和 `simulated_random_number` 变量的值为 7；一个实际的程序会从 app 前端获取强度系数并使用 `rand` crate 来生成随机数，正如第二章的猜猜看游戏所做的那样。`main` 函数使用模拟的输入值调用 `generate_workout` 函数： +程序的输出将会是建议的锻炼计划。示例 13-2 展示了我们将要使用的 `main` 函数： 文件名: src/main.rs @@ -45,14 +45,19 @@ fn main() { let simulated_user_specified_value = 10; let simulated_random_number = 7; - generate_workout(simulated_user_specified_value, simulated_random_number); + generate_workout( + simulated_user_specified_value, + simulated_random_number + ); } -# fn generate_workout(intensity: i32, random_number: i32) {} +# fn generate_workout(intensity: u32, random_number: u32) {} ``` 示例 13-2：`main` 函数包含了用于 `generate_workout` 函数的模拟用户输入和模拟随机数输入 -这就是我们的执行上下文。示例 13-3 中的 `generate_workout` 函数包含我们最关心的 app 业务逻辑。本例中余下的代码修改都将在这个函数中： +处于简单考虑这里硬编码了 `simulated_user_specified_value` 变量的值为 10 和 `simulated_random_number` 变量的值为 7；一个实际的程序会从 app 前端获取强度系数并使用 `rand` crate 来生成随机数，正如第二章的猜猜看游戏所做的那样。`main` 函数使用模拟的输入值调用 `generate_workout` 函数： + +现在有了执行上下文，让我们编写算法。示例 13-3 中的 `generate_workout` 函数包含本例中我们最关心的 app 业务逻辑。本例中余下的代码修改都将在这个函数中进行： 文件名: src/main.rs @@ -60,13 +65,13 @@ fn main() { # use std::thread; # use std::time::Duration; # -# fn simulated_expensive_calculation(num: i32) -> i32 { +# fn simulated_expensive_calculation(num: u32) -> u32 { # println!("calculating slowly..."); # thread::sleep(Duration::from_secs(2)); # num # } # -fn generate_workout(intensity: i32, random_number: i32) { +fn generate_workout(intensity: u32, random_number: u32) { if intensity < 25 { println!( "Today, do {} pushups!", @@ -91,13 +96,19 @@ fn generate_workout(intensity: i32, random_number: i32) { 示例 13-3：程序的业务逻辑，它根据输入并调用 `simulated_expensive_calculation` 函数来打印出健身计划 -示例 13-3 中的代码有多处慢计算函数的调用。第一个 `if` 块调用了 `simulated_expensive_calculation` 两次，外部 `else` 中的 `if` 完全没有调用它，`else` 中的 `else` 调用了它一次。 +示例 13-3 中的代码有多处慢计算函数的调用。第一个 `if` 块调用了 `simulated_expensive_calculation` 两次，外部 `else` 中的 `if` 完全没有调用它，第二个 `else` 中的代码调用了它一次。 -`generate_workout` 函数的期望行为是首先检查用户需要低强度（由小于 25 的系数表示）锻炼还是高强度（25 或以上）锻炼。低强度锻炼计划会根据由 `simulated_expensive_calculation` 函数所模拟的复杂算法建议一定数量的俯卧撑和仰卧起坐，此函数需要强度系数作为输入。 + + +`generate_workout` 函数的期望行为是首先检查用户需要低强度（由小于 25 的系数表示）锻炼还是高强度（25 或以上）锻炼。 + +低强度锻炼计划会根据由 `simulated_expensive_calculation` 函数所模拟的复杂算法建议一定数量的俯卧撑和仰卧起坐。 如果用户需要高强度锻炼，这里有一些额外的逻辑：如果 app 生成的随机数刚好是 3，app 相反会建议用户稍做休息并补充水分。如果不是，则用户会从复杂算法中得到数分钟跑步的高强度锻炼计划。 -数据科学部门的同学告知我们将来会对调用算法的方式做出一些改变。为了在要做这些改动的时候简化更新步骤，我们将重构代码来让它只调用 `simulated_expensive_calculation` 一次。同时还希望去掉目前多余的连续两次函数调用，并不希望在计算过程中增加任何其他此函数的调用。也就是说，我们不希望在完全无需其结果的情况调用函数，不过最终仍然需要调用函数一次。 +数据科学部门的同学告知我们将来会对调用算法的方式做出一些改变。为了在要做这些改动的时候简化更新步骤，我们将重构代码来让它只调用 `simulated_expensive_calculation` 一次。同时还希望去掉目前多余的连续两次函数调用，并不希望在计算过程中增加任何其他此函数的调用。也就是说，我们不希望在完全无需其结果的情况调用函数，不过仍然希望只调用函数一次。 + +#### 使用函数重构 有多种方法可以重构此程序。我们首先尝试的是将重复的慢计算函数调用提取到一个变量中，如示例 13-4 所示： @@ -107,13 +118,13 @@ fn generate_workout(intensity: i32, random_number: i32) { # use std::thread; # use std::time::Duration; # -# fn simulated_expensive_calculation(num: i32) -> i32 { +# fn simulated_expensive_calculation(num: u32) -> u32 { # println!("calculating slowly..."); # thread::sleep(Duration::from_secs(2)); # num # } # -fn generate_workout(intensity: i32, random_number: i32) { +fn generate_workout(intensity: u32, random_number: u32) { let expensive_result = simulated_expensive_calculation(intensity); @@ -133,19 +144,19 @@ fn generate_workout(intensity: i32, random_number: i32) { println!( "Today, run for {} minutes!", expensive_result - ) + ); } } } ``` -示例 13-4：将 `simulated_expensive_calculation` 调用提取到一个位置，位于 `if` 块之前并将结果储存在变量 `expensive_result` 中 +示例 13-4：将 `simulated_expensive_calculation` 调用提取到一个位置，并将结果储存在变量 `expensive_result` 中 这个修改统一了 `simulated_expensive_calculation` 调用并解决了第一个 `if` 块中不必要的两次调用函数的问题。不幸的是，现在所有的情况下都需要调用函数并等待结果，包括那个完全不需要这一结果的内部 `if` 块。 -我们希望能够在程序的一个位置指定某些代码，并只在程序的某处实际需要结果的时候执行这些代码。这正是闭包的用武之地！ +我们希望能够在程序的一个位置指定某些代码，并只在程序的某处实际需要结果的时候 **执行** 这些代码。这正是闭包的用武之地！ -### 闭包储存了之后会执行的代码 +#### 重构使用闭包储存代码 不同于总是在 `if` 块之前调用 `simulated_expensive_calculation` 函数并储存其结果，我们可以定义一个闭包并将其储存在变量中，如示例 13-5 所示。实际上可以选择将整个 `simulated_expensive_calculation` 函数体移动到这里引入的闭包中： @@ -163,15 +174,15 @@ let expensive_closure = |num| { # expensive_closure(5); ``` -示例 13-5：使用慢计算的函数体定义一个闭包并储存到变量 `expensive_closure` 中 +示例 13-5：定义一个闭包并储存到变量 `expensive_closure` 中 -闭包定义是 `expensive_closure` 赋值的 `=` 之后的部分。闭包的定义以一对竖线（`|`）开始。在竖线中指定闭包的参数；之所以选择这个语法是因为它与 Smalltalk 和 Ruby 的闭包定义类似。这个闭包有一个参数 `num`；如果有多于一个参数，可以使用逗号分隔，比如 `|param1, param2|`。 +闭包定义是 `expensive_closure` 赋值的 `=` 之后的部分。闭包的定义以一对竖线（`|`）开始，在竖线中指定闭包的参数；之所以选择这个语法是因为它与 Smalltalk 和 Ruby 的闭包定义类似。这个闭包有一个参数 `num`；如果有多于一个参数，可以使用逗号分隔，比如 `|param1, param2|`。 -参数之后是存放闭包体的大括号。如果闭包体只有一行则大括号是可以省略的。大括号之后，需要用于 `let` 语句的分号。闭包体的最后一行（`num`）返回的值将是调用闭包时返回的值，因为最后一行没有分号，正如函数体中的一样。 +参数之后是存放闭包体的大括号 ———— 如果闭包体只有一行则大括号是可以省略的。大括号之后闭包的结尾，需要用于 `let` 语句的分号。闭包体的最后一行（`num`）返回的值将是调用闭包时返回的值，因为最后一行没有分号；正如函数体中的一样。 注意这个 `let` 语句意味着 `expensive_closure` 包含一个匿名函数的 **定义**，不是调用匿名函数的 **返回值**。回忆一下使用闭包的原因是我们需要在一个位置定义代码，储存代码，并在之后的位置实际调用它；期望调用的代码现在储存在 `expensive_closure` 中。 -现在我们定义了闭包，可以改变 `if` 块中的代码来调用闭包以执行代码并获取结果值。调用闭包看起来非常类似调用函数；指定存放闭包定义的变量名并后跟包含期望使用的参数的括号，如示例 13-6 所示： +定义了闭包之后，可以改变 `if` 块中的代码来调用闭包以执行代码并获取结果值。调用闭包类似于调用函数；指定存放闭包定义的变量名并后跟包含期望使用的参数的括号，如示例 13-6 所示： 文件名: src/main.rs @@ -179,7 +190,7 @@ let expensive_closure = |num| { # use std::thread; # use std::time::Duration; # -fn generate_workout(intensity: i32, random_number: i32) { +fn generate_workout(intensity: u32, random_number: u32) { let expensive_closure = |num| { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); @@ -202,7 +213,7 @@ fn generate_workout(intensity: i32, random_number: i32) { println!( "Today, run for {} minutes!", expensive_closure(intensity) - ) + ); } } } @@ -210,15 +221,17 @@ fn generate_workout(intensity: i32, random_number: i32) { 示例 13-6：调用定义的 `expensive_closure` -现在我们达成了将慢计算统一到一个地方的目标，并只会在需要结果的时候执行改代码。然而，我们又重新引入了示例 13-3 中的问题：仍然在第一个 `if` 块中调用了闭包两次，这会调用慢计算两次并使用户多等待一倍的时间。可以通过在 `if` 块中创建一个本地变量存放闭包调用的结果来解决这个问题，不过正因为使用了闭包还有另一个解决方案。稍后会回到这个方案上；首先讨论一下为何闭包定义中和所涉及的 trait 中没有类型注解。 +现在耗时的计算只在一个地方被调用，并只会在需要结果的时候执行改代码。 + +然而，我们又重新引入了示例 13-3 中的问题：仍然在第一个 `if` 块中调用了闭包两次，这会调用慢计算两次并使用户多等待一倍的时间。可以通过在 `if` 块中创建一个本地变量存放闭包调用的结果来解决这个问题，不过正因为使用了闭包还有另一个解决方案。稍后会回到这个方案上；首先讨论一下为何闭包定义中和所涉及的 trait 中没有类型注解。 ### 闭包类型推断和注解 -闭包与由 `fn` 关键字定义的函数有一些区别。第一是不要求像 `fn` 函数那样在参数和返回值上注明类型。 +闭包不要求像 `fn` 函数那样在参数和返回值上注明类型。函数中需要类型注解是因为他们是暴露给用户的显式接口的一部分。严格的定义这些接口对于保证所有人都认同函数使用和返回值的类型来说是很重要的。但是闭包并不用于这样暴露在外的接口：他们储存在变量中并被使用，不用命名他们或暴露给库的用户调用。 -函数中需要类型注解是因为他们是暴露给用户的显式接口的一部分。严格的定义这些接口对于保证所有人都认同函数使用和返回值的类型来说是很重要的。但是闭包并不用于这样暴露在外的接口：他们储存在变量中并被使用，不用命名他们或暴露给库的用户调用。 +另外，闭包通常很短并只与对应相对任意的场景较小的上下文中。在这些有限制的上下文中，编译器能可靠的推断参数和返回值的类型，类似于它是如何能够推断大部分变量的类型一样。 -另外，闭包通常很短并只与对应相对任意的场景较小的上下文中。在这些有限制的上下文中，编译器能可靠的推断参数和返回值的类型，类似于它是如何能够推断大部分变量的类型一样。强制在这些小的匿名函数中注明类型是很恼人的，并且与编译器已知的信息存在大量的重复。 +强制在这些小的匿名函数中注明类型是很恼人的，并且与编译器已知的信息存在大量的重复。 类似于变量，如果相比严格的必要性你更希望增加明确性并变得更啰嗦，可以选择增加类型注解；为示例 13-4 中定义的闭包标注类型将看起来像示例 13-7 中的定义： @@ -228,7 +241,7 @@ fn generate_workout(intensity: i32, random_number: i32) { # use std::thread; # use std::time::Duration; # -let expensive_closure = |num: i32| -> i32 { +let expensive_closure = |num: u32| -> u32 { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); num @@ -237,18 +250,18 @@ let expensive_closure = |num: i32| -> i32 { 示例 13-7：为闭包的参数和返回值增加可选的类型注解 -有了类型注解闭包的语法就更类似函数了。如下是一个对其参数加一的函数的定义与拥有相同行为闭包语法的纵向对比。这里增加了一些空格来对齐相应部分。这展示了闭包语法如何类似于函数语法，除了使用竖线而不是括号以及几个可选的语法： +有了类型注解闭包的语法就更类似函数了。如下是一个对其参数加一的函数的定义与拥有相同行为闭包语法的纵向对比。这里增加了一些空格来对齐相应部分。这展示了闭包语法如何类似于函数语法，除了使用竖线而不是括号以及几个可选的语法之外： ```rust,ignore -fn add_one_v1 (x: i32) -> i32 { x + 1 } -let add_one_v2 = |x: i32| -> i32 { x + 1 }; +fn add_one_v1 (x: u32) -> u32 { x + 1 } +let add_one_v2 = |x: u32| -> u32 { x + 1 }; let add_one_v3 = |x| { x + 1 }; let add_one_v4 = |x| x + 1 ; ``` -第一行展示了一个函数定义，而第二行展示了一个完整标注的闭包定义。第三行闭包定义中省略了类型注解，而第四行去掉了可选的大括号，因为闭包体只有一行。 +第一行展示了一个函数定义，而第二行展示了一个完整标注的闭包定义。第三行闭包定义中省略了类型注解，而第四行去掉了可选的大括号，因为闭包体只有一行。这些都是有效的闭包定义，并在调用时产生相同的行为。 -闭包定义会为每个参数和返回值推断一个具体类型。例如，示例 13-8 中展示了仅仅将参数作为返回值的简短的闭包定义。除了作为示例的目的这个闭包并不是很实用。注意其定义并没有增加任何类型注解：如果尝试调用闭包两次，第一次使用 `String` 类型作为参数而第二次使用 `i32`，则会得到一个错误： +闭包定义会为每个参数和返回值推断一个具体类型。例如，示例 13-8 中展示了仅仅将参数作为返回值的简短的闭包定义。除了作为示例的目的这个闭包并不是很实用。注意其定义并没有增加任何类型注解：如果尝试调用闭包两次，第一次使用 `String` 类型作为参数而第二次使用 `u32`，则会得到一个错误： 文件名: src/main.rs @@ -279,15 +292,15 @@ error[E0308]: mismatched types ### 使用带有泛型和 `Fn` trait 的闭包 -回到我们的健身计划生成 app ，在示例 13-6 中的代码仍然调用了多于需要的慢计算闭包。在全部代码中的每一个需要多个慢计算闭包结果的地方，可以将结果保存进变量以供复用，这样就可以使用变量而不是再次调用闭包。但是这样就会有很多重复的保存结果变量的地方。 +回到我们的健身计划生成 app ，在示例 13-6 中的代码仍然调用了多于需要的慢计算闭包。解决这个问题的一个方法是在全部代码中的每一个需要多个慢计算闭包结果的地方，可以将结果保存进变量以供复用，这样就可以使用变量而不是再次调用闭包。但是这样就会有很多重复的保存结果变量的地方。 -然而，因为拥有一个慢计算的闭包，我们还可以采取另一个解决方案。可以创建一个存放闭包和调用闭包结果的结构体。该结构体只会在需要结果时执行闭包，并会缓存结果值，这样余下的代码就不必再负责保存结果并可以复用该值。你可能见过这种模式被称 *memoization* 或 *lazy evaluation*。 +幸运的是，还有另一个可用的方案。可以创建一个存放闭包和调用闭包结果的结构体。该结构体只会在需要结果时执行闭包，并会缓存结果值，这样余下的代码就不必再负责保存结果并可以复用该值。你可能见过这种模式被称 *memoization* 或 *lazy evaluation*。 -为了让结构体存放闭包，我们需要能够指定闭包的类型。每一个闭包实例有其自己独有的匿名类型：也就是说，即便两个闭包有着相同的签名，他们的类型仍然可以被认为是不同。为了定义使用闭包的结构体、枚举或函数参数，需要像第十章讨论的那样使用泛型和 trait bound。 +为了让结构体存放闭包，我们需要能够指定闭包的类型，因为结构体定义需要知道其每一个字段的类型。每一个闭包实例有其自己独有的匿名类型：也就是说，即便两个闭包有着相同的签名，他们的类型仍然可以被认为是不同。为了定义使用闭包的结构体、枚举或函数参数，需要像第十章讨论的那样使用泛型和 trait bound。 `Fn` 系列 trait 由标准库提供。所有的闭包都实现了 trait `Fn`、`FnMut` 或 `FnOnce` 中的一个。在下一部分捕获环境部分我们会讨论这些 trait 的区别；在这个例子中可以使用 `Fn` trait。 -为了满足 `Fn` trait bound 我们增加了代表闭包所必须的参数和返回值类型的类型。在这个例子中，闭包有一个 `i32` 的参数并返回一个 `i32`，这样所指定的 trait bound 就是 `Fn(i32) -> i32`。 +为了满足 `Fn` trait bound 我们增加了代表闭包所必须的参数和返回值类型的类型。在这个例子中，闭包有一个 `u32` 的参数并返回一个 `u32`，这样所指定的 trait bound 就是 `Fn(u32) -> u32`。 示例 13-9 展示了存放了闭包和一个 Option 结果值的 `Cacher` 结构体的定义： @@ -295,16 +308,18 @@ error[E0308]: mismatched types ```rust struct Cacher - where T: Fn(i32) -> i32 + where T: Fn(u32) -> u32 { calculation: T, - value: Option, + value: Option, } ``` 示例 13-9：定义一个 `Cacher` 结构体来在 `calculation` 中存放闭包并在 `value` 中存放 Option 值 -结构体 `Cacher` 有一个泛型 `T` 的字段 `calculation`。`T` 的 trait bound 指定了 `T` 是一个使用 `Fn` 的闭包。任何我们希望储存到 `Cacher` 实例的 `calculation` 字段的闭包必须有一个 `i32` 参数（由 `Fn` 之后的括号的内容指定）并必须返回一个 `i32`（由 `->` 之后的内容）。 +结构体 `Cacher` 有一个泛型 `T` 的字段 `calculation`。`T` 的 trait bound 指定了 `T` 是一个使用 `Fn` 的闭包。任何我们希望储存到 `Cacher` 实例的 `calculation` 字段的闭包必须有一个 `u32` 参数（由 `Fn` 之后的括号的内容指定）并必须返回一个 `u32`（由 `->` 之后的内容）。 + +> 注意：函数也都实现了这三个 `Fn` trait。如果不需要捕获环境中的值，则在需要实现 `Fn` trait 是可以使用函数而不是闭包。 `value` 是 `Option` 类型的。在执行闭包之前，`value` 将是 `None`。如果使用 `Cacher` 的代码请求闭包的结果，这时会执行闭包并将结果储存在 `value` 字段的 `Some` 成员中。接着如果代码再次请求闭包的结果，这时不再执行闭包，而是会返回存放在 `Some` 成员中的结果。 @@ -314,14 +329,14 @@ struct Cacher ```rust # struct Cacher -# where T: Fn(i32) -> i32 +# where T: Fn(u32) -> u32 # { # calculation: T, -# value: Option, +# value: Option, # } # impl Cacher - where T: Fn(i32) -> i32 + where T: Fn(u32) -> u32 { fn new(calculation: T) -> Cacher { Cacher { @@ -330,7 +345,7 @@ impl Cacher } } - fn value(&mut self, arg: i32) -> i32 { + fn value(&mut self, arg: u32) -> u32 { match self.value { Some(v) => v, None => { @@ -343,9 +358,11 @@ impl Cacher } ``` -示例 13-10：一个 `Cacher` 的关联函数 `new` 和管理缓存逻辑的 `value` 方法的实现 +示例 13-10：`Cacher` 的缓存逻辑 -`Cacher` 结构体的字段是私有的，因为我们希望 `Cacher` 管理这些值而不是任由调用代码潜在的直接改变他们。`Cacher::new` 函数获取一个泛型参数 `T`，它定义于 `impl` 块上下文中并与 `Cacher` 结构体有着相同的 trait bound。`Cacher::new` 返回一个在 `calculation` 字段中存放了指定闭包和在 `value` 字段中存放了 `None` 值的 `Cacher` 实例，因为我们还未执行闭包。 +`Cacher` 结构体的字段是私有的，因为我们希望 `Cacher` 管理这些值而不是任由调用代码潜在的直接改变他们。 + +`Cacher::new` 函数获取一个泛型参数 `T`，它定义于 `impl` 块上下文中并与 `Cacher` 结构体有着相同的 trait bound。`Cacher::new` 返回一个在 `calculation` 字段中存放了指定闭包和在 `value` 字段中存放了 `None` 值的 `Cacher` 实例，因为我们还未执行闭包。 当调用代码需要闭包的执行结果时，不同于直接调用闭包，它会调用 `value` 方法。这个方法会检查 `self.value` 是否已经有了一个 `Some` 的结果值；如果有，它返回 `Some` 中的值并不会再次执行闭包。 @@ -360,14 +377,14 @@ impl Cacher # use std::time::Duration; # # struct Cacher -# where T: Fn(i32) -> i32 +# where T: Fn(u32) -> u32 # { # calculation: T, -# value: Option, +# value: Option, # } # # impl Cacher -# where T: Fn(i32) -> i32 +# where T: Fn(u32) -> u32 # { # fn new(calculation: T) -> Cacher { # Cacher { @@ -376,7 +393,7 @@ impl Cacher # } # } # -# fn value(&mut self, arg: i32) -> i32 { +# fn value(&mut self, arg: u32) -> u32 { # match self.value { # Some(v) => v, # None => { @@ -388,7 +405,7 @@ impl Cacher # } # } # -fn generate_workout(intensity: i32, random_number: i32) { +fn generate_workout(intensity: u32, random_number: u32) { let mut expensive_result = Cacher::new(|num| { println!("calculating slowly..."); thread::sleep(Duration::from_secs(2)); @@ -411,7 +428,7 @@ fn generate_workout(intensity: i32, random_number: i32) { println!( "Today, run for {} minutes!", expensive_result.value(intensity) - ) + ); } } } @@ -419,9 +436,13 @@ fn generate_workout(intensity: i32, random_number: i32) { 示例 13-11：在 `generate_workout` 函数中利用 `Cacher` 结构体来抽象出缓存逻辑 -不同于直接将闭包保存进一个变量，我们保存一个新的 `Cacher` 实例来存放闭包。接着，在每一个需要结果的地方，调用 `Cacher` 实例的 `value` 方法。可以调用 `value` 方法任意多次，或者一次也不调用，而慢计算最多只会运行一次。尝试使用示例 13-2 中的 `main` 函数来运行这段程序，并将 `simulated_user_specified_value` 和 `simulated_random_number` 变量中的值来验证在所有情况下在多个 `if` 和 `else` 块中，闭包打印的 `calculating slowly...` 只会在需要时出现并只会出现一次。 +不同于直接将闭包保存进一个变量，我们保存一个新的 `Cacher` 实例来存放闭包。接着，在每一个需要结果的地方，调用 `Cacher` 实例的 `value` 方法。可以调用 `value` 方法任意多次，或者一次也不调用，而慢计算最多只会运行一次。 -`Cacher` 负责确保不会调用超过所需的慢计算所需的逻辑，这样 `generate_workout` 就可以专注业务逻辑了。值缓存是一种更加广泛的实用行为，我们可能希望在代码中的其他闭包中也使用他们。然而，目前 `Cacher` 的实现存在一些小问题，这使得在不同上下文中复用变得很困难。 +尝试使用示例 13-2 中的 `main` 函数来运行这段程序，并改变 `simulated_user_specified_value` 和 `simulated_random_number` 变量中的值来验证在所有情况下在多个 `if` 和 `else` 块中，闭包打印的 `calculating slowly...` 只会在需要时出现并只会出现一次。`Cacher` 负责确保不会调用超过所需的慢计算所需的逻辑，这样 `generate_workout` 就可以专注业务逻辑了。 + +### `Cacher` 实现的限制 + +值缓存是一种更加广泛的实用行为，我们可能希望在代码中的其他闭包中也使用他们。然而，目前 `Cacher` 的实现存在一些小问题，这使得在不同上下文中复用变得很困难。 第一个问题是 `Cacher` 实例假设对于 `value` 方法的任何 `arg` 参数值总是会返回相同的值。也就是说，这个 `Cacher` 的测试会失败： @@ -442,19 +463,20 @@ fn call_with_different_values() { 使用示例 13-9 和示例 13-10 的 `Cacher` 实现运行测试，它会在 `assert_eq!` 失败并显示如下信息： ```text -thread 'call_with_different_arg_values' panicked at 'assertion failed: -`(left == right)` (left: `1`, right: `2`)', src/main.rs +thread 'call_with_different_values' panicked at 'assertion failed: `(left == right)` + left: `1`, + right: `2`', src/main.rs ``` 这里的问题是第一次使用 1 调用 `c.value`，`Cacher` 实例将 `Some(1)` 保存进 `self.value`。在这之后，无论传递什么值调用 `value`，它总是会返回 1。 -尝试修改 `Cacher` 存放一个哈希 map 而不是单独一个值。哈希 map 的 key 将是传递进来的 `arg` 值，而 value 则是对应 key 调用闭包的结果值。相比之前检查 `self.value` 是 `Some` 还是 `None` 值，现在 `value` 会在哈希 map 中寻找 `arg`，如果存在就返回它。如果不存在，`Cacher` 会调用闭包并将结果值保存在哈希 map 对应 `arg` 值的位置。 +尝试修改 `Cacher` 存放一个哈希 map 而不是单独一个值。哈希 map 的 key 将是传递进来的 `arg` 值，而 value 则是对应 key 调用闭包的结果值。相比之前检查 `self.value` 直接是 `Some` 还是 `None` 值，现在 `value` 会在哈希 map 中寻找 `arg`，如果存在就返回它。如果不存在，`Cacher` 会调用闭包并将结果值保存在哈希 map 对应 `arg` 值的位置。 -当前 `Cacher` 实现的另一个问题是它的应用被限制为只接受获取一个 `i32` 值并返回一个 `i32` 值的闭包。比如说，我们可能需要能够缓存一个获取字符串 slice 并返回 `usize` 值的闭包的结果。请尝试引入更多泛型参数来增加 `Cacher` 功能的灵活性。 +当前 `Cacher` 实现的另一个问题是它的应用被限制为只接受获取一个 `u32` 值并返回一个 `u32` 值的闭包。比如说，我们可能需要能够缓存一个获取字符串 slice 并返回 `usize` 值的闭包的结果。请尝试引入更多泛型参数来增加 `Cacher` 功能的灵活性。 ### 闭包会捕获其环境 -在健身计划生成器的例子中，我们只将闭包作为内联匿名函数来使用。不过闭包还有另一个函数所没有的功能：他们可以捕获其环境并访问定义他们的作用域的变量。 +在健身计划生成器的例子中，我们只将闭包作为内联匿名函数来使用。不过闭包还有另一个函数所没有的功能：他们可以捕获其环境并访问其被定义的作用域的变量。 示例 13-12 有一个储存在 `equal_to_x` 变量中闭包的例子，它使用了闭包环境中的变量 `x`： @@ -476,7 +498,7 @@ fn main() { 这里，即便 `x` 并不是 `equal_to_x` 的一个参数，`equal_to_x` 闭包也被允许使用变量 `x`，因为它与 `equal_to_x` 定义于相同的作用域。 -函数则不能做到同样的事，让我们试试会发生什么： +函数则不能做到同样的事，如果尝试如下例子，它并不能编译： 文件名: src/main.rs @@ -495,9 +517,9 @@ fn main() { 这会得到一个错误： ```text -error[E0434]: can't capture dynamic environment in a fn item; use the || { ... } -closure form instead - --> +error[E0434]: can't capture dynamic environment in a fn item; use the || { ... +} closure form instead + --> src/main.rs | 4 | fn equal_to_x(z: i32) -> bool { z == x } | ^ @@ -509,13 +531,15 @@ closure form instead 闭包可以通过三种方式捕获其环境，他们直接对应函数的三种获取参数的方式：获取所有权，不可变借用和可变借用。这三种捕获值的方式被编码为如下三个 `Fn` trait： -* `FnOnce` 消费从周围作用域捕获的变量（闭包周围的作用域被称为其 **环境**，*environment*）。为了消费捕获到的变量，闭包必须获取其所有权并在定义闭包时将其移动进闭包。其名称的 `Once` 部分是因为闭包不能多次获取相同变量的所有权，所以它只能被调用一次。 +* `FnOnce` 消费从周围作用域捕获的变量，闭包周围的作用域被称为其 **环境**，*environment*。为了消费捕获到的变量，闭包必须获取其所有权并在定义闭包时将其移动进闭包。其名称的 `Once` 部分代表了闭包不能多次获取相同变量的所有权的事实，所以它只能被调用一次。 * `Fn` 从其环境不可变的借用值 * `FnMut` 可变的借用值所以可以改变其环境 当创建一个闭包时，Rust 根据其如何使用环境中变量来推断我们希望如何引用环境。在示例 13-12 中，`equal_to_x` 闭包不可变的借用了 `x`（所以 `equal_to_x` 使用 `Fn` trait），因为闭包体只需要读取 `x` 的值。 -如果我们希望强制闭包获取其使用的环境值的所有权，可以在参数列表前使用 `move` 关键字。这在将闭包传递给新线程以便将数据移动到新线程中时最为实用。第十六章讨论并发时会展示更多 `move` 闭包的例子，不过现在这里修改了示例 13-12 中的代码（作为演示），在闭包定义中增加 `move` 关键字并使用 vector 代替整型，因为整型可以被拷贝而不是移动： +如果我们希望强制闭包获取其使用的环境值的所有权，可以在参数列表前使用 `move` 关键字。这在将闭包传递给新线程以便将数据移动到新线程中时最为实用。 + +第十六章讨论并发时会展示更多 `move` 闭包的例子，不过现在这里修改了示例 13-12 中的代码（作为演示），在闭包定义中增加 `move` 关键字并使用 vector 代替整型，因为整型可以被拷贝而不是移动；注意这些代码还不能编译： 文件名: src/main.rs @@ -546,11 +570,11 @@ error[E0382]: use of moved value: `x` | ^ value used here after move | = note: move occurs because `x` has type `std::vec::Vec`, which does not - implement the `Copy` trait + implement the `Copy` trait ``` -`x` 被移动进了闭包，因为闭包使用 `move` 关键字定义。接着闭包获取了 `x` 的所有权，同时 `main` 就不再允许使用它了。去掉 `println!` 即可修复问题。 +`x` 被移动进了闭包，因为闭包使用 `move` 关键字定义。接着闭包获取了 `x` 的所有权，同时 `main` 就不再允许在 `println!` 语句中使用 `x` 了。去掉 `println!` 即可修复问题。 -大部分需要指定一个 `Fn` trait bound 的时候，可以从 `Fn` 开始，编译器会根据闭包体中的情况告诉你是否需要 `FnMut` 或 `FnOnce`。 +大部分需要指定一个 `Fn` trait bound 的时候，可以从 `Fn` 开始，而编译器会根据闭包体中的情况告诉你是否需要 `FnMut` 或 `FnOnce`。 为了展示闭包作为函数参数时捕获其环境的作用，让我们移动到下一个主题：迭代器。 From a53133a0d7d984f1f4fd1155cc8829711a67c615 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Tue, 23 Jan 2018 16:47:47 +0800 Subject: [PATCH 120/150] check to ch14-03 --- src/ch10-03-lifetime-syntax.md | 4 +- src/ch13-02-iterators.md | 70 +++++---- src/ch13-03-improving-our-io-project.md | 36 ++--- src/ch13-04-performance.md | 14 +- src/ch14-00-more-about-cargo.md | 10 +- src/ch14-01-release-profiles.md | 27 +--- src/ch14-02-publishing-to-crates-io.md | 109 +++++++------- src/ch14-03-cargo-workspaces.md | 183 +++++++++++++++++------ src/img/trpl14-01.png | Bin 0 -> 65437 bytes src/img/trpl14-02.png | Bin 0 -> 175642 bytes src/img/trpl14-03.png | Bin 65437 -> 43085 bytes src/img/{trpl14-10.png => trpl14-04.png} | Bin src/img/trpl14-05.png | Bin 60311 -> 0 bytes src/img/trpl14-07.png | Bin 43085 -> 0 bytes 14 files changed, 279 insertions(+), 174 deletions(-) create mode 100644 src/img/trpl14-01.png create mode 100644 src/img/trpl14-02.png rename src/img/{trpl14-10.png => trpl14-04.png} (100%) delete mode 100644 src/img/trpl14-05.png delete mode 100644 src/img/trpl14-07.png diff --git a/src/ch10-03-lifetime-syntax.md b/src/ch10-03-lifetime-syntax.md index 5fd2d9e..52e8eb5 100644 --- a/src/ch10-03-lifetime-syntax.md +++ b/src/ch10-03-lifetime-syntax.md @@ -51,7 +51,7 @@ error: `x` does not live long enough #### 借用检查器 -编译器的这一部分叫做 **借用检查器**（*borrow checker*），它比较作用域来确保所有的借用都是有效的。示例 10-19 展示了与示例 10-18 相同的例子不过带有变量声明周期的注释： +编译器的这一部分叫做 **借用检查器**（*borrow checker*），它比较作用域来确保所有的借用都是有效的。示例 10-19 展示了与示例 10-18 相同的例子不过带有变量生命周期的注释： ```rust,ignore { @@ -76,7 +76,7 @@ line and ends with the first closing curly brace on the 7th line. Do you think the text art comments work or should we make an SVG diagram that has nicer looking arrows and labels? /Carol --> -我们将 `r` 的生命周期标记为 `'a` 并将 `x` 的生命周期标记为 `'b`。如你所见，内部的 `'b` 块要比外部的生命周期 `'a` 小得多。在编译时，Rust 比较这两个生命周期的大小，并发现 `r` 拥有声明周期 `'a`，不过它引用了一个拥有生命周期 `'b` 的对象。程序被拒绝编译，因为生命周期 `'b` 比生命周期 `'a` 要小：被引用的对象比它的引用者存在的时间更短。 +我们将 `r` 的生命周期标记为 `'a` 并将 `x` 的生命周期标记为 `'b`。如你所见，内部的 `'b` 块要比外部的生命周期 `'a` 小得多。在编译时，Rust 比较这两个生命周期的大小，并发现 `r` 拥有生命周期 `'a`，不过它引用了一个拥有生命周期 `'b` 的对象。程序被拒绝编译，因为生命周期 `'b` 比生命周期 `'a` 要小：被引用的对象比它的引用者存在的时间更短。 让我们看看示例 10-20 中这个并没有产生悬垂引用且可以正确编译的例子： diff --git a/src/ch13-02-iterators.md b/src/ch13-02-iterators.md index 5711296..7f6668c 100644 --- a/src/ch13-02-iterators.md +++ b/src/ch13-02-iterators.md @@ -1,8 +1,8 @@ -## 迭代器 +## 使用迭代器处理元素序列 > [ch13-02-iterators.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch13-02-iterators.md) >
-> commit 40910f557c328858f230123d1234c1cb3029dda3 +> commit ceb31210263d49994bbf09456a35a135da690f24 迭代器模式允许你对一个项的序列进行某些处理。**迭代器**（*iterator*）负责遍历序列中的每一项和决定序列何时结束的逻辑。当使用迭代器时，我们无需重新实现这些逻辑。 @@ -14,9 +14,11 @@ let v1 = vec![1, 2, 3]; let v1_iter = v1.iter(); ``` -示例 13-13：创建了迭代器 +示例 13-13：创建一个迭代器 -创建迭代器之后，可以选择用多种方式利用它。在示例 3-6 中，我们实际上使用了迭代器和 `for` 循环在每一个项上执行了一些代码，直到现在我们才解释了 `iter` 调用做了什么。示例 13-14 中的例子将迭代器的创建和 `for` 循环中的使用分开。迭代器被储存在 `v1_iter` 变量中，而这时没有进行迭代。一旦 `for` 循环开始使用 `v1_iter`，接着迭代器中的每一个元素被用于循环的一次迭代，这会打印出其每一个值： +创建迭代器之后，可以选择用多种方式利用它。在示例 3-4 中，我们使用迭代器和 `for` 循环在每一个项上执行了一些代码，不过直到现在我们掩盖了 `iter` 调用做了什么。 + +示例 13-14 中的例子将迭代器的创建和 `for` 循环中的使用分开。迭代器被储存在 `v1_iter` 变量中，而这时没有进行迭代。一旦 `for` 循环开始使用 `v1_iter`，接着迭代器中的每一个元素被用于循环的一次迭代，这会打印出其每一个值： ```rust let v1 = vec![1, 2, 3]; @@ -30,11 +32,13 @@ for val in v1_iter { 示例 13-14：在一个 `for` 循环中使用迭代器 -在标准库中没有提供迭代器的语言中，我们可能会使用一个从 0 开始的索引变量，使用这个变量索引 vector 中的值，并循环增加其值直到达到 vector 的元素数量。迭代器为我们处理了所有这些逻辑，这减少了重复代码并潜在的消除了混乱。另外，迭代器的实现方式提供了对多种不同的序列使用相同逻辑的灵活性，而不仅仅是像 vector 这样可索引的数据结构.让我们看看迭代器是如何做到这些的。 +在标准库中没有提供迭代器的语言中，我们可能会使用一个从 0 开始的索引变量，使用这个变量索引 vector 中的值，并循环增加其值直到达到 vector 的元素数量。 + +迭代器为我们处理了所有这些逻辑，这减少了重复代码并潜在的消除了混乱。另外，迭代器的实现方式提供了对多种不同的序列使用相同逻辑的灵活性，而不仅仅是像 vector 这样可索引的数据结构.让我们看看迭代器是如何做到这些的。 ### `Iterator` trait 和 `next` 方法 -迭代器都实现了一个叫做 `Iterator` 的定义于标准库的 trait。这个 trait 的定义看起来像： +迭代器都实现了一个叫做 `Iterator` 的定义于标准库的 trait。这个 trait 的定义看起来像这样： ```rust trait Iterator { @@ -46,7 +50,7 @@ trait Iterator { } ``` -这里有一下我们还未讲到的新语法：`type Item` 和 `Self::Item`，他们定义了 trait 的 **关联类型**（*associated type*）。第十九章会深入讲解关联类型，不过现在只需知道这段代码表明实现 `Iterator` trait 要求同时定义一个 `Item` 类型，这个 `Item` 类型被用作 `next` 方法的返回值类型。换句话说，`Item` 类型将是迭代器返回元素的类型。 +注意这里有一下我们还未讲到的新语法：`type Item` 和 `Self::Item`，他们定义了 trait 的 **关联类型**（*associated type*）。第十九章会深入讲解关联类型，不过现在只需知道这段代码表明实现 `Iterator` trait 要求同时定义一个 `Item` 类型，这个 `Item` 类型被用作 `next` 方法的返回值类型。换句话说，`Item` 类型将是迭代器返回元素的类型。 `next` 是 `Iterator` 实现者被要求定义的唯一方法。`next` 一次返回迭代器中的一个项，封装在 `Some` 中，当迭代器结束时，它返回 `None`。如果你希望的话可以直接调用迭代器的 `next` 方法；示例 13-15 有一个测试展示了重复调用由 vector 创建的迭代器的 `next` 方法所得到的值： @@ -68,11 +72,11 @@ fn iterator_demonstration() { 示例 13-15：在迭代器上（直接）调用 `next` 方法 -注意 `v1_iter` 需要是可变的：在迭代器上调用 `next` 方法改变了迭代器中用来记录序列位置的状态。换句话说，代码 **消费**（consume）了，或使用了迭代器。每一个 `next` 调用都会从迭代器中吃掉一个项。使用 `for` 循环时无需使 `v1_iter` 可变因为 `for` 循环会获取 `v1_iter` 的所有权并在后台使 `v1_iter` 可变。 +注意 `v1_iter` 需要是可变的：在迭代器上调用 `next` 方法改变了迭代器中用来记录序列位置的状态。换句话说，代码 **消费**（consume）了，或使用了迭代器。每一个 `next` 调用都会从迭代器中消费一个项。使用 `for` 循环时无需使 `v1_iter` 可变因为 `for` 循环会获取 `v1_iter` 的所有权并在后台使 `v1_iter` 可变。 另外需要注意到从 `next` 调用中得到的值是 vector 的不可变引用。`iter` 方法生成一个不可变引用的迭代器。如果我们需要一个获取 `v1` 所有权并返回拥有所有权的迭代器，则可以调用 `into_iter` 而不是 `iter`。类似的，如果我们希望迭代可变引用，则可以调用 `iter_mut` 而不是 `iter`。 -### `Iterator` trait 中消费迭代器的方法 +### 消费迭代器的方法 `Iterator` trait 有一系列不同的由标准库提供默认实现的方法；你可以在 `Iterator` trait 的标准库 API 文档中找到所有这些方法。一些方法在其定义中调用了 `next` 方法，这也就是为什么在实现 `Iterator` trait 时要求实现 `next` 方法的原因。 @@ -97,9 +101,11 @@ fn iterator_sum() { 调用 `sum` 之后不再允许使用 `v1_iter` 因为调用 `sum` 时它会获取迭代器的所有权。 -### `Iterator` trait 中产生其他迭代器的方法 +### 产生其他迭代器的方法 -`Iterator` trait 中定义的另一类方法会产生其他的迭代器。这些方法被称为 **迭代器适配器**（*iterator adaptors*），他们允许我们将当前迭代器变为不同类型的迭代器。可以链式调用多个迭代器适配器。不过因为所有的迭代器都是惰性的，必须调用一个消费适配器方法以便获取迭代器适配器调用的结果。示例 13-17 展示了一个调用迭代器适配器方法 `map` 的例子，该 `map` 方法使用闭包来调用每个元素以生成新的迭代器。 这里的闭包创建了一个新的迭代器，其中 `vector` 中的每个元素都被加1。不过这些代码会产生一个警告： +`Iterator` trait 中定义了另一类方法，被称为 **迭代器适配器**（*iterator adaptors*），他们允许我们将当前迭代器变为不同类型的迭代器。可以链式调用多个迭代器适配器。不过因为所有的迭代器都是惰性的，必须调用一个消费适配器方法以便获取迭代器适配器调用的结果。 + +示例 13-17 展示了一个调用迭代器适配器方法 `map` 的例子，该 `map` 方法使用闭包来调用每个元素以生成新的迭代器。 这里的闭包创建了一个新的迭代器，对其中 vector 中的每个元素都被加 1。不过这些代码会产生一个警告： 文件名: src/main.rs @@ -114,19 +120,21 @@ v1.iter().map(|x| x + 1); 得到的警告是： ```text -warning: unused result which must be used: iterator adaptors are lazy and do -nothing unless consumed - --> src/main.rs:4:1 +warning: unused `std::iter::Map` which must be used: iterator adaptors are lazy +and do nothing unless consumed + --> src/main.rs:4:5 | -4 | v1.iter().map(|x| x + 1); - | ^^^^^^^^^^^^^^^^^^^^^^^^^ +4 | v1.iter().map(|x| x + 1); + | ^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[warn(unused_must_use)] on by default ``` -示例 13-17 中的代码实际上并没有做任何事；所指定的闭包从未被调用过。警告提醒了我们为什么：迭代器适配器是惰性的，而这里我们可能意在消费迭代器。 +示例 13-17 中的代码实际上并没有做任何事；所指定的闭包从未被调用过。警告提醒了我们为什么：迭代器适配器是惰性的，而这里我们需要消费迭代器。 -为了修复这个警告并消费迭代器获取有用的结果，我们将使用第十二章简要讲到的 `collect` 方法。这个方法消费迭代器并将结果收集到一个数据结构中。在示例 13-18 中，我们将遍历由 `map` 调用生成的迭代器的结果收集到一个 vector 中，它将会含有原始 vector 中每个元素加一的结果： +为了修复这个警告并消费迭代器获取有用的结果，我们将使用第十二章简要讲到的 `collect` 方法。这个方法消费迭代器并将结果收集到一个数据结构中。 + +在示例 13-18 中，我们将遍历由 `map` 调用生成的迭代器的结果收集到一个 vector 中，它将会含有原始 vector 中每个元素加一的结果： 文件名: src/main.rs @@ -142,20 +150,22 @@ assert_eq!(v2, vec![2, 3, 4]); 因为 `map` 获取一个闭包，可以指定任何希望在遍历的每个元素上执行的操作。这是一个展示如何使用闭包来自定义行为同时又复用 `Iterator` trait 提供的迭代行为的绝佳例子。 -### 使用闭包获取环境与迭代器 +### 使用闭包获取环境 -现在我们介绍了迭代器，让我们展示一个通过使用 `filter` 迭代器适配器和捕获环境的闭包的常规用例。迭代器的 `filter` 方法获取一个使用迭代器的每一个项并返回布尔值的闭包。如果闭包返回 `true`，其值将会包含在 `filter` 提供的新迭代器中。如果闭包返回 `false`，其值不会包含在结果迭代器中。示例 13-19 展示了使用 `filter` 和一个捕获环境中变量 `shoe_size` 的闭包，这样闭包就可以遍历一个 `Shoe` 结构体集合以便只返回指定大小的鞋子： +现在我们介绍了迭代器，让我们展示一个通过使用 `filter` 迭代器适配器和捕获环境的闭包的常规用例。迭代器的 `filter` 方法获取一个使用迭代器的每一个项并返回布尔值的闭包。如果闭包返回 `true`，其值将会包含在 `filter` 提供的新迭代器中。如果闭包返回 `false`，其值不会包含在结果迭代器中。 + +示例 13-19 展示了使用 `filter` 和一个捕获环境中变量 `shoe_size` 的闭包，这样闭包就可以遍历一个 `Shoe` 结构体集合以便只返回指定大小的鞋子： 文件名: src/lib.rs ```rust,test_harness #[derive(PartialEq, Debug)] struct Shoe { - size: i32, + size: u32, style: String, } -fn shoes_in_my_size(shoes: Vec, shoe_size: i32) -> Vec { +fn shoes_in_my_size(shoes: Vec, shoe_size: u32) -> Vec { shoes.into_iter() .filter(|s| s.size == shoe_size) .collect() @@ -183,7 +193,11 @@ fn filters_by_size() { 示例 13-19：使用 `filter` 方法和一个捕获 `shoe_size` 的闭包 -`shoes_in_my_size` 函数获取一个鞋子 vector 的所有权和一个鞋子大小作为参数。它返回一个只包含指定大小鞋子的 vector。在 `shoes_in_my_size` 函数体中调用了 `into_iter` 来创建一个获取 vector 所有权的迭代器。接着调用 `filter` 将这个迭代器适配成只含有闭包返回 `true` 元素的新迭代器。我们指定的闭包从环境中捕获了 `shoe_size` 变量并使用其值与每一只鞋的大小作比较，只保留指定大小的鞋子。最终，调用 `collect` 将迭代器适配器返回的值收集进一个 vector 并返回。 +`shoes_in_my_size` 函数获取一个鞋子 vector 的所有权和一个鞋子大小作为参数。它返回一个只包含指定大小鞋子的 vector。 + +在 `shoes_in_my_size` 函数体中调用了 `into_iter` 来创建一个获取 vector 所有权的迭代器。接着调用 `filter` 将这个迭代器适配成只含有闭包返回 `true` 元素的新迭代器。 + +闭包从环境中捕获了 `shoe_size` 变量并使用其值与每一只鞋的大小作比较，只保留指定大小的鞋子。最终，调用 `collect` 将迭代器适配器返回的值收集进一个 vector 并返回。 这个测试展示当调用 `shoes_in_my_size` 时，我们只会得到与指定值相同大小的鞋子。 @@ -191,7 +205,7 @@ fn filters_by_size() { 我们已经展示了可以通过在 vector 上调用 `iter`、`into_iter` 或 `iter_mut` 来创建一个迭代器。也可以用标准库中其他的集合类型创建迭代器，比如哈希 map。另外，可以实现 `Iterator` trait 来创建任何我们希望的迭代器。正如之前提到的，定义中唯一要求提供的方法就是 `next` 方法。一旦定义了它，就可以使用所有其他由 `Iterator` trait 提供的拥有默认实现的方法来创建自定义迭代器了！ -我们将要创建的迭代器只会从 1 数到 5。首先，我们会创建一个结构体来存放一些值，接着实现 `Iterator` trait 将这个结构体放入迭代器中并在此实现中使用其值。 +作为展示，让我们创建一个只会从 1 数到 5 的迭代器。首先，创建一个结构体来存放一些值，接着实现 `Iterator` trait 将这个结构体放入迭代器中并在此实现中使用其值。 示例 13-20 有一个 `Counter` 结构体定义和一个创建 `Counter` 实例的关联函数 `new`： @@ -240,11 +254,13 @@ impl Iterator for Counter { 示例 13-21：在 `Counter` 结构体上实现 `Iterator` trait -这里将迭代器的关联类型 `Item` 设置为 `u32`，意味着迭代器会返回 `u32` 值集合。再一次，这里仍无需担心关联类型，第十九章会讲到。我们希望迭代器对其内部状态加一，这也就是为何将 `count` 初始化为 0：我们希望迭代器首先返回 1。如果 `count` 值小于 6，`next` 会返回封装在 `Some` 中的当前值，不过如果 `count` 大于或等于 6，迭代器会返回 `None`。 +这里将迭代器的关联类型 `Item` 设置为 `u32`，意味着迭代器会返回 `u32` 值集合。再一次，这里仍无需担心关联类型，第十九章会讲到。 + +我们希望迭代器对其内部状态加一，这也就是为何将 `count` 初始化为 0：我们希望迭代器首先返回 1。如果 `count` 值小于 6，`next` 会返回封装在 `Some` 中的当前值，不过如果 `count` 大于或等于 6，迭代器会返回 `None`。 #### 使用 `Counter` 迭代器的 `next` 方法 -一旦实现了 `Iterator` trait，我们就有了一个迭代器！示例 13-22 展示了一个测试用来演示现在我们可以使用 `Counter` 结构体的迭代器功能，通过直接调用 `next` 方法，正如示例 13-15 中从 vector 创建的迭代器那样： +一旦实现了 `Iterator` trait，我们就有了一个迭代器！示例 13-22 展示了一个测试用来演示使用 `Counter` 结构体的迭代器功能，通过直接调用 `next` 方法，正如示例 13-15 中从 vector 创建的迭代器那样： 文件名: src/lib.rs @@ -332,6 +348,6 @@ fn using_other_iterator_trait_methods() { 示例 13-23：使用自定义的 `Counter` 迭代器的多种方法 -注意 `zip` 只产生4对值；理论上第五对值 `(5, None)` 从未被产生，因为 `zip` 在任一输入迭代器返回 `None` 时也返回 `None`。 +注意 `zip` 只产生四对值；理论上第五对值 `(5, None)` 从未被产生，因为 `zip` 在任一输入迭代器返回 `None` 时也返回 `None`。 所有这些方法调用都是可能的，因为我们通过指定 `next` 如何工作来实现 `Iterator` trait 而标准库则提供其他调用 `next` 的默认方法实现。 diff --git a/src/ch13-03-improving-our-io-project.md b/src/ch13-03-improving-our-io-project.md index 29103e0..0b63745 100644 --- a/src/ch13-03-improving-our-io-project.md +++ b/src/ch13-03-improving-our-io-project.md @@ -2,13 +2,13 @@ > [ch13-03-improving-our-io-project.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch13-03-improving-our-io-project.md) >
-> commit 714be7f0d6b2f6110afe8808a7f528f9eae75c61 +> commit 2bcb126815a381acc3d46b0d6fc382cb4c98fbc5 -我们可以使用迭代器来改进第十二章中 I/O 项目的实现来使得代码更简洁明了。让我们看看迭代器如何能够改进 `Config::new` 函数和 `search` 函数的实现。 +有了这些关于迭代器的新知识，我们可以使用迭代器来改进第十二章中 I/O 项目的实现来使得代码更简洁明了。让我们看看迭代器如何能够改进 `Config::new` 函数和 `search` 函数的实现。 ### 使用迭代器并去掉 `clone` -在示例 12-6 中，我们增加了一些代码获取一个 `String` slice 并创建一个 `Config` 结构体的实例，他们索引 slice 中的值并克隆这些值以便 `Config` 结构体可以拥有这些值。在示例 13-24 中原原本本的重现了第十二章结尾 `Config::new` 函数的实现： +在示例 12-6 中，我们增加了一些代码获取一个 `String` slice 并创建一个 `Config` 结构体的实例，他们索引 slice 中的值并克隆这些值以便 `Config` 结构体可以拥有这些值。在示例 13-24 中原原本本的重现了第十二章结尾示例 12-23 中 `Config::new` 函数的实现： 文件名: src/lib.rs @@ -35,13 +35,15 @@ impl Config { 起初这里需要 `clone` 的原因是参数 `args` 中有一个 `String` 元素的 slice，而 `new` 函数并不拥有 `args`。为了能够返回 `Config` 实例的所有权，我们需要克隆 `Config` 中字段 `query` 和 `filename` 的值，这样 `Config` 实例就能拥有这些值。 -通过迭代器的新知识，我们可以将 `new` 函数改为获取一个有所有权的迭代器作为参数而不是借用 slice。我们将使用迭代器功能之前检查 slice 长度和索引特定位置的代码。这会清理 `Config::new` 的工作因为迭代器会负责访问这些值。 +通过迭代器的新知识，我们可以将 `new` 函数改为获取一个有所有权的迭代器作为参数而不是借用 slice。我们将使用迭代器功能之前检查 slice 长度和索引特定位置的代码。这会明确 `Config::new` 的工作因为迭代器会负责访问这些值。 一旦 `Config::new` 获取了迭代器的所有权并不再使用借用的索引操作，就可以将迭代器中的 `String` 值移动到 `Config` 中，而不是调用 `clone` 分配新的空间。 #### 直接使用 `env::args` 返回的迭代器 -在 I/O 项目的 *src/main.rs* 中，让我们修改第十二章结尾 `main` 函数中的这些代码： +打开 I/O 项目的 *src/main.rs* 文件，它看起来应该像这样： + +文件名: src/main.rs ```rust,ignore fn main() { @@ -52,10 +54,12 @@ fn main() { process::exit(1); }); - // ...snip... + // --snip-- } ``` +我们会修改第十二章结尾示例 12-24 中的 `main` 函数的开头为示例 13-25 中的代码。直到同时更新 `Config::new` 这些代码还不能编译： + 将他们改为如示例 13-25 所示： 文件名: src/main.rs @@ -67,7 +71,7 @@ fn main() { process::exit(1); }); - // ...snip... + // --snip-- } ``` @@ -75,21 +79,21 @@ fn main() { `env::args` 函数返回一个迭代器！不同于将迭代器的值收集到一个 vector 中接着传递一个 slice 给 `Config::new`，现在我们直接将 `env::args` 返回的迭代器的所有权传递给 `Config::new`。 -接下来需要更新 `Config::new` 的定义。在 I/O 项目的 *src/lib.rs* 中，将 `Config::new` 的签名改为如示例 13-26 所示： +接下来需要更新 `Config::new` 的定义。在 I/O 项目的 *src/lib.rs* 中，将 `Config::new` 的签名改为如示例 13-26 所示。这仍然不能编译因为我们还需更新函数体： 文件名: src/lib.rs ```rust,ignore impl Config { - pub fn new(args: std::env::Args) -> Result { - // ...snip... + pub fn new(mut args: std::env::Args) -> Result { + // --snip-- ``` 示例 13-26：更新 `Config::new` 的签名来接受一个迭代器 -`env::args` 函数的标准库文档展示了其返回的迭代器类型是 `std::env::Args`。需要更新 `Config::new` 函数的签名中 `args` 参数的类型为 `std::env::Args` 而不是 `&[String]`。 +`env::args` 函数的标准库文档展示了其返回的迭代器类型是 `std::env::Args`。需要更新 `Config::new` 函数的签名中 `args` 参数的类型为 `std::env::Args` 而不是 `&[String]`。因为这里需要获取 `args` 的所有权且通过迭代改变 `args`，我们可以在 `args` 参数前指定 `mut` 关键字使其可变。 -#### 使用 `Iterator` trait 方法带起索引 +#### 使用 `Iterator` trait 方法代替索引 接下来修复 `Config::new` 的函数体。标准库文档也提到了 `std::env::Args` 实现了 `Iterator` trait，所以可以在其上调用 `next` 方法！示例 13-27 更新了示例 12-23 中的代码为使用 `next` 方法： @@ -106,7 +110,7 @@ impl Config { # impl Config { pub fn new(mut args: std::env::Args) -> Result { - args.next(); + args.next(); let query = match args.next() { Some(arg) => arg, @@ -120,9 +124,7 @@ impl Config { let case_sensitive = env::var("CASE_INSENSITIVE").is_err(); - Ok(Config { - query, filename, case_sensitive - }) + Ok(Config { query, filename, case_sensitive }) } } ``` @@ -133,7 +135,7 @@ impl Config { ### 使用迭代器适配器来使代码更简明 -I/O 项目中其他可以利用迭代器优势的地方位于 `search` 函数，在示例 13-28 中重现了第十二章结尾的此函数定义： +I/O 项目中其他可以利用迭代器优势的地方位于 `search` 函数，在示例 13-28 中重现了第十二章结尾示例 12-19 中此函数的定义： 文件名: src/lib.rs diff --git a/src/ch13-04-performance.md b/src/ch13-04-performance.md index 14da59a..de39e1d 100644 --- a/src/ch13-04-performance.md +++ b/src/ch13-04-performance.md @@ -2,7 +2,7 @@ > [ch13-04-performance.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch13-04-performance.md) >
-> commit 40910f557c328858f230123d1234c1cb3029dda3 +> commit 2bcb126815a381acc3d46b0d6fc382cb4c98fbc5 为了决定使用哪个实现，我们需要知道哪个版本的 `search` 函数更快：直接使用 `for` 循环的版本还是使用迭代器的版本。 @@ -13,7 +13,9 @@ test bench_search_for ... bench: 19,620,300 ns/iter (+/- 915,700) test bench_search_iter ... bench: 19,234,900 ns/iter (+/- 657,200) ``` -结果迭代器版本还要稍微快一点！这里我们将不会查看性能测试的代码，我们的目的并不是为了证明他们是完全等同的，而是得出一个怎样比较这两种实现方式性能的基本思路。对于一个更全面的性能测试，将会检查不同长度的文本、不同的搜索单词、不同长度的单词和所有其他的可变情况。这里所要表达的是：迭代器，作为一个高级的抽象，被编译成了与手写的底层代码大体一致性能代码。迭代器是 Rust 的 **零成本抽象**（*zero-cost abstractions*）之一，它意味着抽象并不会强加运行时开销，它与本贾尼·斯特劳斯特卢普，C++ 的设计和实现者所定义的 **零开销**（*zero-overhead*）如出一辙： +结果迭代器版本还要稍微快一点！这里我们将不会查看性能测试的代码，我们的目的并不是为了证明他们是完全等同的，而是得出一个怎样比较这两种实现方式性能的基本思路。 + +对于一个更全面的性能测试，将会检查不同长度的文本、不同的搜索单词、不同长度的单词和所有其他的可变情况。这里所要表达的是：迭代器，作为一个高级的抽象，被编译成了与手写的底层代码大体一致性能代码。迭代器是 Rust 的 **零成本抽象**（*zero-cost abstractions*）之一，它意味着抽象并不会强加运行时开销，它与本贾尼·斯特劳斯特卢普，C++ 的设计和实现者所定义的 **零开销**（*zero-overhead*）如出一辙： > In general, C++ implementations obey the zero-overhead principle: What you don’t use, you don’t pay for. And further: What you do use, you couldn’t hand code any better. > @@ -23,7 +25,7 @@ test bench_search_iter ... bench: 19,234,900 ns/iter (+/- 657,200) > > - 本贾尼·斯特劳斯特卢普 "Foundations of C++" -作为另一个例子，这里有一些取自于音频解码器的代码。这些代码使用迭代器链来对作用域中的三个变量进行了某种数学计算：一个叫 `buffer` 的数据 slice、一个有 12 个元素的数组 `coefficients`、和一个代表位移位数的 `qlp_shift`。例子中声明了这些变量但并没有提供任何值；虽然这些代码在其上下文之外没有什么意义，不过仍是一个简明的现实中的例子，来展示 Rust 如何将高级概念转换为底层代码： +作为另一个例子，这里有一些取自于音频解码器的代码。解码算法使用线性预测数学运算（linear prediction mathematical operation）来根据之前样本的线性函数预测将来的值。这些代码使用迭代器链来对作用域中的三个变量进行了某种数学计算：一个叫 `buffer` 的数据 slice、一个有 12 个元素的数组 `coefficients`、和一个代表位移位数的 `qlp_shift`。例子中声明了这些变量但并没有提供任何值；虽然这些代码在其上下文之外没有什么意义，不过仍是一个简明的现实中的例子，来展示 Rust 如何将高级概念转换为底层代码： ```rust,ignore let buffer: &mut [i32]; @@ -42,11 +44,9 @@ for i in 12..buffer.len() { 为了计算 `prediction` 的值，这些代码遍历了 `coefficients` 中的 12 个值，使用 `zip` 方法将系数与 `buffer` 的前 12 个值组合在一起。接着将每一对值相乘，再将所有结果相加，然后将总和右移 `qlp_shift` 位。 -像音频解码器这样的程序通常最看重计算的性能。这里，我们创建了一个迭代器，使用了两个适配器，接着消费了其值。Rust 代码将会被编译为什么样的汇编代码呢？好吧，在编写本书的这个时候，它被编译成与手写的相同的汇编代码。遍历 `coefficients` 的值完全用不到循环：Rust 知道这里会迭代 12 次，所以它“展开”（unroll）了循环。展开是一种移除循环的控制代码开销并替换为每个迭代中的重复代码的优化。 +像音频解码器这样的程序通常最看重计算的性能。这里，我们创建了一个迭代器，使用了两个适配器，接着消费了其值。Rust 代码将会被编译为什么样的汇编代码呢？好吧，在编写本书的这个时候，它被编译成与手写的相同的汇编代码。遍历 `coefficients` 的值完全用不到循环：Rust 知道这里会迭代 12 次，所以它“展开”（unroll）了循环。展开是一种移除循环控制代码的开销并替换为每个迭代中的重复代码的优化。 -所有的系数都被储存在了寄存器中，这意味着访问他们非常快。这里也没有运行时数组访问边界检查。所有这些 Rust 能够提供的优化使得结果代码极为高效。 - -现在知道这些了，请放心大胆的使用迭代器和闭包吧！他们使得代码看起来更高级，但并不为此引入运行时性能损失。 +所有的系数都被储存在了寄存器中，这意味着访问他们非常快。这里也没有运行时数组访问边界检查。所有这些 Rust 能够提供的优化使得结果代码极为高效。现在知道这些了，请放心大胆的使用迭代器和闭包吧！他们使得代码看起来更高级，但并不为此引入运行时性能损失。 ## 总结 diff --git a/src/ch14-00-more-about-cargo.md b/src/ch14-00-more-about-cargo.md index 116a27f..f9d54ae 100644 --- a/src/ch14-00-more-about-cargo.md +++ b/src/ch14-00-more-about-cargo.md @@ -2,14 +2,14 @@ > [ch14-00-more-about-cargo.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch14-00-more-about-cargo.md) >
-> commit db6129a30d7c7baed34dd38dbc56f7ed8a66ae92 +> commit ff93f82ff63ade5a352d9ccc430945d4ec804cdf -目前为止我们只使用过 Cargo 构建、运行和测试代码的最基本功能，不过它还可以做到更多。这里我们将了解一些 Cargo 其他更高级的功能，他们将展示如何： +目前为止我们只使用过 Cargo 构建、运行和测试代码的最基本功能，不过它还可以做到更多。这里我们将了解一些 Cargo 其他更为高级的功能，他们将展示如何： * 使用发布配置来自定义构建 -* 将库发布到 crates.io +* 将库发布到 [crates.io](https://crates.io) * 使用工作空间来组织更大的项目 -* 从 crates.io 安装二进制文件 +* 从 [crates.io](https://crates.io) 安装二进制文件 * 使用自定义的命令来扩展 Cargo -相比本章能够涉及的工作 Cargo 甚至还可以做到更多，关于其功能的全部解释，请查看[文档](http://doc.rust-lang.org/cargo/) \ No newline at end of file +相比本章能够涉及的工作 Cargo 甚至还可以做到更多，关于其功能的全部解释，请查看 [其文档](http://doc.rust-lang.org/cargo/) \ No newline at end of file diff --git a/src/ch14-01-release-profiles.md b/src/ch14-01-release-profiles.md index beeeaad..d772793 100644 --- a/src/ch14-01-release-profiles.md +++ b/src/ch14-01-release-profiles.md @@ -1,23 +1,14 @@ -## 发布配置 +## 采用发布配置自定义构建 > [ch14-01-release-profiles.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch14-01-release-profiles.md) >
-> commit db6129a30d7c7baed34dd38dbc56f7ed8a66ae92 +> commit ff93f82ff63ade5a352d9ccc430945d4ec804cdf 在 Rust 中 **发布配置**（*release profiles*）是预定义的、可定制的带有不同选项的配置，他们允许程序员更多的控制代码编译的多种选项。每一个配置都彼此相互独立。 -Cargo 定义了四种有着良好默认值的可用于各自使用场景的配置。Cargo 根据运行的命令来选择不同的配置。不同命令所对应的配置如表格 14-1 所示： +Cargo 有两个主要的配置：运行 `cargo build` 时采用的 `dev` 配置和运行 `cargo build --release` 的 `release` 配置。`dev` 配置被定义为开发时的好的默认配置，`release` 配置则有着良好的发布构建的默认配置。 -| 命令 | 配置 | -|-------------------------|-----------| -| `cargo build` | `dev` | -| `cargo build --release` | `release` | -| `cargo test` | `test` | -| `cargo doc` | `doc` | - -表格 14-1：运行不同 Cargo 命令所使用的配置 - -这可能很熟悉，他们出现在构建的输出中，他们展示了构建中所使用的配置： +我们应该很熟悉这些配置名称因为他们出现在构建的输出中，这会展示构建所使用的配置： ```text $ cargo build @@ -26,11 +17,11 @@ $ cargo build --release Finished release [optimized] target(s) in 0.0 secs ``` -这里的 “dev” 和 “release” 提示表明编译器在使用不同的配置。 +构建输出中的 `dev` 和 `release` 表明编译器在使用不同的配置。 -### 定制发布配置 +Cargo 对每一个配置都有默认设置，当项目的 *Cargo.toml* 文件中没有任何 `[profile.*]` 部分的时候。通过增加任何希望定制的配置对应的 `[profile.*]` 部分，我们可以选择覆盖任意默认设置的子集。例如，如下是 `dev` 和 `release` 配置的 `opt-level` 设置的默认值： -Cargo 对每一个配置都有默认设置，当项目的 *Cargo.toml* 文件的 `[profile.*]` 部分没有指定时使用。通过增加任何希望定制的配置对应的 `[profile.*]` 部分，我们可以选择覆盖任意默认设置的子集。例如，如下是 `dev` 和 `release` 配置的 `opt-level` 设置的默认值： +文件名: Cargo.toml ```toml [profile.dev] @@ -53,6 +44,4 @@ opt-level = 1 这会覆盖默认的设置 `0`。现在运行 `cargo build` 时，Cargo 将会使用 `dev` 的默认配置加上定制的 `opt-level`。因为 `opt-level` 设置为 `1`，Cargo 会比默认进行更多的优化，但是没有发布构建那么多。 -对于每个配置的设置和其默认值的完整列表，请查看[Cargo 的文档][cargodoc]。 - -[cargodoc]: http://doc.crates.io/ \ No newline at end of file +对于每个配置的设置和其默认值的完整列表，请查看 [Cargo 的文档](https://doc.rust-lang.org/cargo/)。 diff --git a/src/ch14-02-publishing-to-crates-io.md b/src/ch14-02-publishing-to-crates-io.md index 2527c04..2e3c0fd 100644 --- a/src/ch14-02-publishing-to-crates-io.md +++ b/src/ch14-02-publishing-to-crates-io.md @@ -2,18 +2,18 @@ > [ch14-02-publishing-to-crates-io.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch14-02-publishing-to-crates-io.md) >
-> commit 56352c28cf3fe0402fa5a7cba73890e314d720eb +> commit ff93f82ff63ade5a352d9ccc430945d4ec804cdf -我们曾经在项目中增加 crates.io 上的包作为依赖，不过你也可以通过发布自己的包来向它人分享代码。Crates.io 用来分发包的源代码，所以它主要托管开源代码。 +我们曾经在项目中使用 [crates.io](https://crates.io) 上的包作为依赖，不过你也可以通过发布自己的包来向它人分享代码。[crates.io](https://crates.io) 用来分发包的源代码，所以它主要托管开源代码。 Rust 和 Cargo 有一些帮助它人更方便找到和使用你发布的包的功能。我们将介绍一些这样的功能，接着讲到如何发布一个包。 ### 编写有用的文档注释 -准确的包文档有助于其他用户立即如何以及何时使用他们，所以花一些时间编写文档是值得的。第三章中我们讨论了如何使用 `//` 注释 Rust 代码。Rust 也有特定的用于文档的注释类型，通常被称为 **文档注释**（*documentation comments*），他们会生成 HTML 文档。这些 HTML 展示公有 API 文档注释的内容，他们意在让对库感兴趣的程序员理解如何 **使用** 这个 crate，而不是它是如何被 **实现** 的。 +准确的包文档有助于其他用户理解如何以及何时使用他们，所以花一些时间编写文档是值得的。第三章中我们讨论了如何使用 `//` 注释 Rust 代码。Rust 也有特定的用于文档的注释类型，通常被称为 **文档注释**（*documentation comments*），他们会生成 HTML 文档。这些 HTML 展示公有 API 文档注释的内容，他们意在让对库感兴趣的程序员理解如何 **使用** 这个 crate，而不是它是如何被 **实现** 的。 -文档注释使用 `///` 而不是 `//` 并支持 Markdown 注解来格式化文本。文档注释就位于需要文档的项的之前。示例 14-2 展示了一个 `my_crate` crate 中 `add_one` 函数的文档注释： +文档注释使用 `///` 而不是 `//` 并支持 Markdown 注解来格式化文本。文档注释就位于需要文档的项的之前。示例 14-1 展示了一个 `my_crate` crate 中 `add_one` 函数的文档注释： 文件名: src/lib.rs @@ -32,29 +32,29 @@ pub fn add_one(x: i32) -> i32 { } ``` -示例 14-2：一个函数的文档注释 +示例 14-1：一个函数的文档注释 这里，我们提供了一个 `add_one` 函数工作的描述，接着开始了一个标题为 “Examples” 的部分，和展示如何使用 `add_one` 函数的代码。可以运行 `cargo doc` 来生成这个文档注释的 HTML 文档。这个命令运行由 Rust 分发的工具 `rustdoc` 并将生成的 HTML 文档放入 *target/doc* 目录。 -为了方便起见，运行 `cargo doc --open` 会构建当前 crate 文档（同时还有所有 ceate 依赖的文档）的 HTML 并在浏览器中打开。导航到 `add_one` 函数将会发现文档注释的文本是如何渲染的，如图 13-3 所示： +为了方便起见，运行 `cargo doc --open` 会构建当前 crate 文档（同时还有所有 crate 依赖的文档）的 HTML 并在浏览器中打开。导航到 `add_one` 函数将会发现文档注释的文本是如何渲染的，如图 14-1 所示： -`my_crate` 的 `add_one` 函数所渲染的文档注释 HTML +`my_crate` 的 `add_one` 函数所渲染的文档注释 HTML -图 14-3：`add_one` 函数的文档注释 HTML +图 14-1：`add_one` 函数的文档注释 HTML #### 常用（文档注释）部分 -示例 14-2 中使用了 `# Examples` Markdown 标题在 HTML 中创建了一个以 “Examples” 为标题的部分。一些其他经常在文档注释中使用的部分有： +示例 14-1 中使用了 `# Examples` Markdown 标题在 HTML 中创建了一个以 “Examples” 为标题的部分。其他一些 crate 作者经常在文档注释中使用的部分有： -- Panics：这个函数可能会 `panic!` 的场景。并不希望程序崩溃的函数调用者应该确保他们不会在这些情况下调用此函数。 -- Errors：如果这个函数返回 `Result`，此部分描述可能会出现何种错误以及什么情况会造成这些错误，这有助于调用者编写代码来采用不同的方式处理不同的错误。 -- Safety：如果这个函数使用 `unsafe` 代码（这会在第十九章讨论），这一部分应该会涉及到期望函数调用者支持的确保 `unsafe` 块中代码正常工作的不变条件（invariants）。 +- **Panics**：这个函数可能会 `panic!` 的场景。并不希望程序崩溃的函数调用者应该确保他们不会在这些情况下调用此函数。 +- **Errors**：如果这个函数返回 `Result`，此部分描述可能会出现何种错误以及什么情况会造成这些错误，这有助于调用者编写代码来采用不同的方式处理不同的错误。 +- **Safety**：如果这个函数使用 `unsafe` 代码（这会在第十九章讨论），这一部分应该会涉及到期望函数调用者支持的确保 `unsafe` 块中代码正常工作的不变条件（invariants）。 大部分文档注释不需要所有这些部分，不过这是一个提醒你检查调用你代码的人有兴趣了解的内容的列表。 #### 文档注释作为测试 -在文档注释中增加示例代码块是一个清楚的表明如何使用库的方法，这么做还有一个额外的好处：`cargo test` 也会像测试那样运行文档中的示例代码！没有什么比有例子的文档更好的了！也没有什么比不能正常工作的例子更糟的了，因为代码在编写文档时已经改变。尝试 `cargo test` 运行像示例 14-2 中 `add_one` 函数的文档；应该在测试结果中看到像这样的部分： +在文档注释中增加示例代码块是一个清楚的表明如何使用库的方法，这么做还有一个额外的好处：`cargo test` 也会像测试那样运行文档中的示例代码！没有什么比有例子的文档更好的了！也没有什么比不能正常工作的例子更糟的了，因为代码在编写文档时已经改变。尝试 `cargo test` 运行像示例 14-1 中 `add_one` 函数的文档；应该在测试结果中看到像这样的部分： ```text Doc-tests my_crate @@ -62,16 +62,16 @@ pub fn add_one(x: i32) -> i32 { running 1 test test src/lib.rs - add_one (line 5) ... ok -test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` 现在尝试改变函数或例子来使例子中的 `assert_eq!` 产生 panic。再次运行 `cargo test`，你将会看到文档测试捕获到了例子与代码不再同步！ #### 注释包含项的结构 -还有另一种风格的文档注释，`//!`，这为包含注释的项，而不是注释之后的项增加文档。这通常用于 crate 根文件或模块的根文件为 crate 或模块整体提供文档。 +还有另一种风格的文档注释，`//!`，这为包含注释的项，而不是注释之后的项增加文档。这通常用于 crate 根文件（通常是 *src/lib.rs*）或模块的根文件为 crate 或模块整体提供文档。 -作为一个例子，如果我们希望增加描述包含 `add_one` 函数的 `my_crate` crate 目的的文档，可以在 *src/lib.rs* 开头增加以 `//!` 开头的注释，如示例 14-4 所示： +作为一个例子，如果我们希望增加描述包含 `add_one` 函数的 `my_crate` crate 目的的文档，可以在 *src/lib.rs* 开头增加以 `//!` 开头的注释，如示例 14-2 所示： 文件名: src/lib.rs @@ -82,22 +82,21 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured //! calculations more convenient. /// Adds one to the number given. -// ...snip... +// --snip-- ``` -示例 14-4：`my_crate` crate 整体的文档 +示例 14-2：`my_crate` crate 整体的文档 注意 `//!` 的最后一行之后没有任何代码。因为他们以 `//!` 开头而不是 `///`，这是属于包含此注释的项而不是注释之后项的文档。在这个情况中，包含这个注释的项是 *src/lib.rs* 文件，也就是 crate 根文件。这些注释描述了整个 crate。 -如果运行 `cargo doc --open`，将会发现这些注释显示在 `my_crate` 文档的首页，位于 crate 中公有项列表之上，如图 14-5 所示： +如果运行 `cargo doc --open`，将会发现这些注释显示在 `my_crate` 文档的首页，位于 crate 中公有项列表之上，如图 14-2 所示： -crate 整体注释所渲染的 HTML 文档 +crate 整体注释所渲染的 HTML 文档 -图 14-5：包含 `my_crate` 整体描述的注释所渲染的文档 +图 14-2：包含 `my_crate` 整体描述的注释所渲染的文档 位于项之中的文档注释对于描述 crate 和模块特别有用。使用他们描述其容器整体的目的来帮助 crate 用户理解你的代码组织。 - ### 使用 `pub use` 导出合适的公有 API 第七章介绍了如何使用 `mod` 关键字来将代码组织进模块中，如何使用 `pub` 关键字将项变为公有，和如何使用 `use` 关键字将项引入作用域。然而对你开发来说很有道理的结果可能对用户来说就不太方便了。你可能希望将结构组织进有多个层次的层级中，不过想要使用被定义在很深层级中的类型的人可能很难发现这些类型是否存在。他们也可能会厌烦 `use my_crate::some_module::another_module::UsefulType;` 而不是 `use my_crate::UsefulType;` 来使用类型。 @@ -106,7 +105,7 @@ test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured 好消息是，如果结果对于用户来说 **不是** 很方便，你也无需重新安排内部组织：你可以选择使用 `pub use` 重导出（re-export）项来使公有结构不同于私有结构。重导出获取位于一个位置的公有项并将其公开到另一个位置，好像它就定义在这个新位置一样。 -例如，假设我们创建了一个模块化了充满艺术化气息的库 `art`。在这个库中是一个包含两个枚举 `PrimaryColor` 和 `SecondaryColor` 的模块 `kinds`，以及一个包含函数 `mix` 的模块 `utils`，如示例 14-6 所示： +例如，假设我们创建了一个模块化了充满艺术化气息的库 `art`。在这个库中是一个包含两个枚举 `PrimaryColor` 和 `SecondaryColor` 的模块 `kinds`，以及一个包含函数 `mix` 的模块 `utils`，如示例 14-3 所示： 文件名: src/lib.rs @@ -137,23 +136,22 @@ pub mod utils { /// Combines two primary colors in equal amounts to create /// a secondary color. pub fn mix(c1: PrimaryColor, c2: PrimaryColor) -> SecondaryColor { - // ...snip... -# SecondaryColor::Green + // --snip-- } } ``` -示例 14-6：一个库 `art` 其组织包含 `kinds` 和 `utils` 模块 +示例 14-3：一个库 `art` 其组织包含 `kinds` 和 `utils` 模块 -`cargo doc` 所生成的 crate 文档首页如图 14-7 所示： +`cargo doc` 所生成的 crate 文档首页如图 14-3 所示： -包含 `kinds` 和 `utils` 模块的 `art` +包含 `kinds` 和 `utils` 模块的 `art` -图 14-7：包含 `kinds` 和 `utils` 模块的库 `art` 的文档首页 +图 14-3：包含 `kinds` 和 `utils` 模块的库 `art` 的文档首页 注意 `PrimaryColor` 和 `SecondaryColor` 类型没有在首页中列出，`mix` 函数也是。必须点击 `kinds` 或 `utils` 才能看到他们。 -另一个依赖这个库的 crate 需要 `use` 语句来导入 `art` 中的项，这包含指定其当前定义的模块结构。示例 14-8 展示了一个使用 `art` crate 中 `PrimaryColor` 和 `mix` 项的 crate 的例子： +另一个依赖这个库的 crate 需要 `use` 语句来导入 `art` 中的项，这包含指定其当前定义的模块结构。示例 14-4 展示了一个使用 `art` crate 中 `PrimaryColor` 和 `mix` 项的 crate 的例子： 文件名: src/main.rs @@ -170,11 +168,11 @@ fn main() { } ``` -示例 14-8：一个通过导出内部结构使用 `art` crate 中项的 crate +示例 14-4：一个通过导出内部结构使用 `art` crate 中项的 crate -示例 14-8 中使用 `art` crate 代码的作者不得不搞清楚 `PrimaryColor` 位于 `kinds` 模块而 `mix` 位于 `utils` 模块。`art` crate 的模块结构相比使用它的开发者来说对编写它的开发者更有意义。其内部的 `kinds` 模块和 `utils` 模块的组织结构并没有对尝试理解如何使用它的人提供任何有价值的信息。`art` crate 的模块结构因不得不搞清楚所需的内容在何处和必须在 `use` 语句中指定模块名称而显得混乱和不便。 +示例 14-4 中使用 `art` crate 代码的作者不得不搞清楚 `PrimaryColor` 位于 `kinds` 模块而 `mix` 位于 `utils` 模块。`art` crate 的模块结构相比使用它的开发者来说对编写它的开发者更有意义。其内部的 `kinds` 模块和 `utils` 模块的组织结构并没有对尝试理解如何使用它的人提供任何有价值的信息。`art` crate 的模块结构因不得不搞清楚所需的内容在何处和必须在 `use` 语句中指定模块名称而显得混乱和不便。 -为了从公有 API 中去掉 crate 的内部组织，我们可以采用示例 14-6 中的 `art` crate 并增加 `pub use` 语句来重导出项到顶层结构，如示例 14-9 所示： +为了从公有 API 中去掉 crate 的内部组织，我们可以采用示例 14-3 中的 `art` crate 并增加 `pub use` 语句来重导出项到顶层结构，如示例 14-5 所示： 文件名: src/lib.rs @@ -188,23 +186,23 @@ pub use kinds::SecondaryColor; pub use utils::mix; pub mod kinds { - // ...snip... + // --snip-- } pub mod utils { - // ...snip... + // --snip-- } ``` -示例 14-9：增加 `pub use` 语句重导出项 +示例 14-5：增加 `pub use` 语句重导出项 -现在此 crate 由 `cargo doc` 生成的 API 文档会在首页列出重导出的项以及其链接，如图 14-10 所示，这就使得这些类型易于查找。 +现在此 crate 由 `cargo doc` 生成的 API 文档会在首页列出重导出的项以及其链接，如图 14-4 所示，这就使得这些类型易于查找。 -Rendered documentation for the `art` crate with the re-exports on the front page +Rendered documentation for the `art` crate with the re-exports on the front page 图 14-10：`art` 文档的首页，这里列出了重导出的项 -`art` crate 的用户仍然可以看见和选择使用示例 14-8 中的内部结构，或者可以使用示例 14-9 中更为方便的结构，如示例 14-11 所示： +`art` crate 的用户仍然可以看见和选择使用示例 14-3 中的内部结构，或者可以使用示例 14-4 中更为方便的结构，如示例 14-6 所示： 文件名: src/main.rs @@ -215,31 +213,33 @@ use art::PrimaryColor; use art::mix; fn main() { - // ...snip... + // --snip-- } ``` -示例 14-11：一个使用 `art` crate +示例 14-6：一个使用 `art` crate 中重导出项的程序 对于有很多嵌套模块的情况，使用 `pub use` 将类型重导出到顶级结构对于使用 crate 的人来说将会是大为不同的体验。 -创建一个有用的公有 API 结构更像是一门艺术而非科学，你可以反复检视他们来找出最适合用户的 API。选择 `pub use` 提供了组织 crate 内部结构和与终端用户体现解耦的灵活性。观察一些你所安装的 crate 的代码来看看其内部结构是否不同于公有 API。 +创建一个有用的公有 API 结构更像是一门艺术而非科学，你可以反复检视他们来找出最适合用户的 API。选择 `pub use` 提供了解耦组织 crate 内部结构和与终端用户体现的灵活性。观察一些你所安装的 crate 的代码来看看其内部结构是否不同于公有 API。 ### 创建 Crates.io 账号 -在你可以发布任何 crate 之前，需要在 crates.io 上注册账号并获取一个 API token。为此，访问位于 *https://crates.io* 的官网并使用 GitHub 账号登陆————目前 GitHub 账号是必须的，不过将来该网站可能会支持其他创建账号的方法。一旦登陆之后，查看位于 *https://crates.io/me* 的账户设置页面并获取 API token。接着使用该 API token 运行 `cargo login` 命令，像这样： +在你可以发布任何 crate 之前，需要在 [crates.io](https://crates.io) 上注册账号并获取一个 API token。为此，访问位于 [crates.io](https://crates.io) 的首页并使用 GitHub 账号登陆————目前 GitHub 账号是必须的，不过将来该网站可能会支持其他创建账号的方法。一旦登陆之后，查看位于 [https://crates.io/me/](https://crates.io/me/) 的账户设置页面并获取 API token。接着使用该 API token 运行 `cargo login` 命令，像这样： ```text $ cargo login abcdefghijklmnopqrstuvwxyz012345 ``` -这个命令会通知 Cargo 你的 API token 并将其储存在本地的 *~/.cargo/config* 文件中。注意这个 token 是一个 **秘密**（**secret**）且不应该与其他人共享。如果因为任何原因与他人共享了这个信息，应该立即重新生成这个 token。 +这个命令会通知 Cargo 你的 API token 并将其储存在本地的 *~/.cargo/credentials* 文件中。注意这个 token 是一个 **秘密**（**secret**）且不应该与其他人共享。如果因为任何原因与他人共享了这个信息，应该立即到 [crates.io](https://crates.io) 重新生成这个 token。 ### 发布新 crate 之前 有了账号之后，比如说你已经有一个希望发布的 crate。在发布之前，你需要在 crate 的 *Cargo.toml* 文件的 `[package]` 部分增加一些本 crate 的元信息（metadata）。 -首先 crate 需要一个唯一的名称。虽然在本地开发 crate 时，可以使用任何你喜欢的名称。不过 Crates.io 上的 crate 名称遵守先到先得的分配原则。一旦某个 crate 名称被使用，其他人就不能再发布这个名称的 crate 了。请在网站上搜索你希望使用的名称来找出它是否已被使用。如果没有，修改 *Cargo.toml* 中 `[package]` 里的名称为你希望用于发布的名称，像这样： +首先 crate 需要一个唯一的名称。虽然在本地开发 crate 时，可以使用任何你喜欢的名称。不过 [crates.io](https://crates.io) 上的 crate 名称遵守先到先得的分配原则。一旦某个 crate 名称被使用，其他人就不能再发布这个名称的 crate 了。请在网站上搜索你希望使用的名称来找出它是否已被使用。如果没有，修改 *Cargo.toml* 中 `[package]` 里的名称为你希望用于发布的名称，像这样： + +文件名: Cargo.toml ```toml [package] @@ -253,13 +253,15 @@ $ cargo publish Updating registry `https://github.com/rust-lang/crates.io-index` warning: manifest has no description, license, license-file, documentation, homepage or repository. -...snip... +--snip-- error: api errors: missing or empty metadata fields: description, license. ``` 这是因为我们缺少一些关键信息：关于该 crate 用途的描述和用户可能在何种条款下使用该 crate 的 license。为了修正这个错误，需要在 *Cargo.toml* 中引入这些信息。 -描述通常是一两句话，因为它会出现在 crate 的搜索结果中和 crate 页面里。对于 `license` 字段，你需要一个 **license 标识符值 **（*license identifier value*）。Linux 基金会位于 *http://spdx.org/licenses/* 的 Software Package Data Exchange (SPDX) 列出了可以使用的标识符。例如，为了指定 crate 使用 MIT License，增加 `MIT` 标识符： +描述通常是一两句话，因为它会出现在 crate 的搜索结果中和 crate 页面里。对于 `license` 字段，你需要一个 **license 标识符值**（*license identifier value*）。Linux 基金会位于 *http://spdx.org/licenses/* 的 Software Package Data Exchange (SPDX) 列出了可以使用的标识符。例如，为了指定 crate 使用 MIT License，增加 `MIT` 标识符： + +文件名: Cargo.toml ```toml [package] @@ -269,17 +271,19 @@ license = "MIT" 如果你希望使用不存在于 SPDX 的 license，则需要将 license 文本放入一个文件，将该文件包含进项目中，接着使用 `license-file` 来指定文件名而不是使用 `license` 字段。 -关于项目所适用的 license 指导超出了本书的范畴。很多 Rust 社区成员选择与 Rust 自身相同的 license，这是一个双许可的 `MIT/Apache-2.0`————这展示了也可以通过斜杠来分隔来指定多个 license 标识符。 +关于项目所适用的 license 指导超出了本书的范畴。很多 Rust 社区成员选择与 Rust 自身相同的 license，这是一个双许可的 `MIT OR Apache-2.0` ———— 这展示了也可以通过 `OR` 来分隔来为项目指定多个 license 标识符。 那么，有了唯一的名称、版本号、由 `cargo new` 新建项目时增加的作者信息、描述和所选择的 license，已经准备好发布的项目的 *Cargo.toml* 文件可能看起来像这样： +文件名: Cargo.toml + ```toml [package] name = "guessing_game" version = "0.1.0" authors = ["Your Name "] description = "A fun game where you guess what number the computer has chosen." -license = "MIT/Apache-2.0" +license = "MIT OR Apache-2.0" [dependencies] ``` @@ -288,11 +292,11 @@ license = "MIT/Apache-2.0" ### 发布到 Crates.io -现在我们创建了一个账号，保存了 API token，为 crate 选择了一个名字，并指定了所需的元数据，你已经准备好发布了！发布 crate 会上传特定版本的 crate 到 crates.io 以供他人使用。 +现在我们创建了一个账号，保存了 API token，为 crate 选择了一个名字，并指定了所需的元数据，你已经准备好发布了！发布 crate 会上传特定版本的 crate 到 [crates.io](https://crates.io) 以供他人使用。 -发布 crate 时请多加小心，因为发布是 **永久性的**（*permanent*）。对应版本不可能被覆盖，其代码也不可能被删除。Crates.io 的一个主要目标是作为一个代码的永久文档服务器，这样所有依赖 Crates.io 中 crate 的项目都能一直正常工作。允许删除版本将不可能满足这个目标。然而，可以被发布的版本号却没有限制。 +发布 crate 时请多加小心，因为发布是 **永久性的**（*permanent*）。对应版本不可能被覆盖，其代码也不可能被删除。[crates.io](https://crates.io) 的一个主要目标是作为一个代码的永久文档服务器，这样所有依赖 [crates.io](https://crates.io) 中 crate 的项目都能一直正常工作。允许删除版本将不可能满足这个目标。然而，可以被发布的版本号却没有限制。 -让我们再次运行`cargo publish`命令。这次它应该会成功： +再次运行 `cargo publish` 命令。这次它应该会成功： ```text $ cargo publish @@ -327,7 +331,6 @@ $ cargo yank --vers 1.0.1 也可以撤销撤回操作，并允许项目可以再次开始依赖某个版本，通过在命令上增加 `--undo`： - ```text $ cargo yank --vers 1.0.1 --undo ``` diff --git a/src/ch14-03-cargo-workspaces.md b/src/ch14-03-cargo-workspaces.md index e5c3c20..b9d1c54 100644 --- a/src/ch14-03-cargo-workspaces.md +++ b/src/ch14-03-cargo-workspaces.md @@ -2,38 +2,146 @@ > [ch14-03-cargo-workspaces.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch14-03-cargo-workspaces.md) >
-> commit 6e53771a409794d9933c2a31310d78149b7e0534 +> commit a59537604248f2970e0831d5ead9f6fac2cdef84 -第十二章中，我们构建一个包含二进制 crate 和库 crate 的包。你可能会发现，随着项目开发的深入，库 crate 持续增大，而你希望将其进一步拆分成多个库 crate。对于这种情况，Cargo 提供了一个叫 **工作空间**（*workspaces*）的功能，它可以帮助我们管理多个相关的并行开发的包。 +第十二章中，我们构建一个包含二进制 crate 和库 crate 的包。你可能会发现，随着项目开发的深入，库 crate 持续增大，而你希望将其进一步拆分成多个库 crate。对于这种情况，Cargo 提供了一个叫 **工作空间**（*workspaces*）的功能，它可以帮助我们管理多个相关的协同开发的包。 -**工作空间** 是一系列共享同样的 *Cargo.lock* 和输出目录的包。让我们使用工作空间创建一个项目，这里采用常见的代码这样就可以关注工作空间的结构了。这里有一个使用了两个库的二进制项目：一个库会提供 `add_one` 方法而第二个会提供 `add_two` 方法。让我们以为这个二进制项目创建一个新 crate 作为开始： +**工作空间** 是一系列共享同样的 *Cargo.lock* 和输出目录的包。让我们使用工作空间创建一个项目，这里采用常见的代码这样就可以关注工作空间的结构了。有多种组织工作空间的方式；我们将展示一个常用方法。我们的工作空间有一个二进制项目和两个库。二进制项目会提供作为命令行工具的主要功能，它会依赖另两个库。一个库会提供 `add_one` 方法而第二个会提供 `add_two` 方法。这三个 crate 将会是相同工作空间的一部分。让我们以新建工作空间目录开始： + +```text +$ mkdir add +$ cd add +``` + +在 add* 目录中，创建 *Cargo.toml* 文件。这个 *Cargo.toml* 文件配置了整个工作空间。它不会包含 `[package]` 或其他我们在 *Cargo.toml* 中见过的元信息。相反，它以 `[workspace]` 部分作为开始，并通过指定 *adder* 的路径来为工作空间增加成员，如下会加入二进制 crate： + +文件名: Cargo.toml + +```toml +[workspace] + +members = [ + "adder", +] +``` + +接下来，在 *add* 目录运行 `cargo new` 新建 `adder` 二进制 crate： ```text $ cargo new --bin adder Created binary (application) `adder` project -$ cd adder ``` -我们需要修改二进制包的 *Cargo.toml* 并增加一个 `[workspace]` 部分来告诉 Cargo 包 `adder` 是一个工作空间。在文件末尾增加如下内容： +到此为止，可以运行 `cargo build` 来构建工作空间。*add* 目录中的文件应该看起来像这样： + +```text +├── Cargo.lock +├── Cargo.toml +├── adder +│ ├── Cargo.toml +│ └── src +│ └── main.rs +└── target +``` + +工作空间在顶级目录有一个 *target* 目录；`adder` 并没有自己的 *target* 目录。即使进入 *adder* 目录运行 `cargo build`，构建结果也位于 *add/target* 而不是 *add/adder/target*。工作空间中的 crate 之间相互依赖。如果每个 crate 有其自己的 *target* 目录，为了在自己的 *target* 目录中生成构建结果，工作空间中的每一个 crate 都不得不相互重新编译其他 crate。通过共享一个 *target* 目录，工作空间可以避免其他 crate 多余的重复构建。 + +### 在工作空间中创建第二个 crate + +接下来，让我们在工作空间中指定另一个成员 crate。这个 crate 位于 *add-one* 目录中，所以修改顶级 *Cargo.toml* 为也包含 *add-one* 路径： + +文件名: Cargo.toml ```toml [workspace] + +members = [ + "adder", + "add-one", +] ``` -类似于很多 Cargo 的功能，工作空间支持配置惯例：只要遵循这些惯例就无需在 *Cargo.toml* 中增加更多的配置来定义工作空间了。 +接着新生成一个叫做 `add-one` 的库： -### 指定工作空间的依赖 +```text +$ cargo new add-one + Created library `add-one` project +``` -工作空间惯例表明任何顶级 crate 依赖的位于任意子目录的 crate 都是工作空间的一部分。任何 crate，无论是否在工作空间中，可以在 *Cargo.toml* 中使用 `path` 属性来指定它拥有本地目录中的 crate 作为依赖。如果 crate 拥有 `[workspace]` 部分并指定了路径依赖，而这些路径是 crate 的子目录，则这些相关的 crate 被认为是工作空间的一部分。让我们在顶级的 `adder` crate 的 *Cargo.toml* 中为其指定位于 `add-one` 子目录的 `add-one` crate 作为依赖，通过这样修改 *Cargo.toml*： +现在 *add* 目录应该有如下目录和文件： + +```text +├── Cargo.lock +├── Cargo.toml +├── add-one +│ ├── Cargo.toml +│ └── src +│ └── lib.rs +├── adder +│ ├── Cargo.toml +│ └── src +│ └── main.rs +└── target +``` + +在 *add-one/src/lib.rs* 文件中，增加一个 `add_one` 函数： + +文件名: add-one/src/lib.rs + +```rust +pub fn add_one(x: i32) -> i32 { + x + 1 +} +``` + +现在工作空间中有了一个库 crate，让 `adder` 依赖库 crate `add-one`。首先需要在 *adder/Cargo.toml* 文件中增加 `add-one` 作为路径依赖： + +文件名: adder/Cargo.toml ```toml [dependencies] -add-one = { path = "add-one" } + +add-one = { path = "../add-one" } ``` -如果在 *Cargo.toml* 中增加依赖但没有指定对应 `path`，则这些将是不属于工作空间的假设来自于 Crates.io 的常规依赖。 +工作空间中的 crate 不必相互依赖，所以仍需显示的表明工作空间中 crate 的依赖关系。 + +接下来，在 `adder` crate 中使用 `add-one` crate 的函数 `add_one`。打开 *adder/src/main.rs* 在顶部增加一行 `extern crate` 将新 `add-one` 库 crate 引入作用域。接着修改 `main` 函数来调用 `add_one` 函数，如示例 14-7 所示： + +文件名: adder/src/main.rs + +```rust,ignore +extern crate add_one; + +fn main() { + let num = 10; + println!("Hello, world! {} plus one is {}!", num, add_one::add_one(num)); +} +``` + +示例 14-7：在 `adder` crate 中使用 `add-one` 库 crate + +在 *add* 目录中运行 `cargo build` 来构建工作空间！ + +```text +$ cargo build + Compiling add-one v0.1.0 (file:///projects/add/add-one) + Compiling adder v0.1.0 (file:///projects/add/adder) + Finished dev [unoptimized + debuginfo] target(s) in 0.68 secs +``` + +为了在顶层 *add* 目录运行二进制 crate，需要通过 `-p` 参数和包名称来运行 `cargo run` 指定工作空间中我们希望使用的包： + +```text +$ cargo run -p adder + Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs + Running `target/debug/adder` +Hello, world! 10 plus one is 11! +``` + +这会运行 *adder/src/main.rs* 中的代码，其依赖 `add-one` crate + -### 在工作空间中创建第二个 crate 接下来，在 `adder` 目录中生成 `add-one` crate： @@ -101,13 +209,9 @@ $ cargo build └── target ``` -工作空间在顶级目录有一个 *target* 目录；*add-one* 并没有自己的 *target* 目录。即使进入 `add-one` 目录运行 `cargo build`，构建结果也位于 *adder/target* 而不是 *adder/add-one/target*。因为工作空间中的 crate 之间相互依赖。如果每个 crate 有其自己的 *target* 目录，为了在自己的 *target* 目录中生成构建结果，工作空间中的每一个 crate 都不得不相互重新编译其他 crate。通过共享一个 *target* 目录，工作空间可以避免其他 crate 多余的重复构建。 - #### 在工作空间中依赖外部 crate -还需注意的是工作空间只有一个 *Cargo.lock*，而不是拥有一个顶级的 *Cargo.lock* 和一个 *add-one/Cargo.lock*。这确保了所有的 crate 都使用完全相同版本的依赖。如果在 *Cargo.toml* 和 *add-one/Cargo.toml* 中都增加 `rand` crate，则 Cargo 会将其都解析为同一版本并记录到唯一的 *Cargo.lock* 中。使得工作空间中的所有 crate 都使用相同的依赖意味着其中的 crate 都是相互减重的。现在就让我们来试一试。 - -让我们在 *add-one/Cargo.toml* 中的 `[dependencies]` 部分增加 `rand` crate 以便能够在 `add-one` crate 中使用 `rand` crate： +还需注意的是工作空间只在根目录有一个 *Cargo.lock*，而不是在每一个 crate 目录都有 *Cargo.lock*。这确保了所有的 crate 都使用完全相同版本的依赖。如果在 *Cargo.toml* 和 *add-one/Cargo.toml* 中都增加 `rand` crate，则 Cargo 会将其都解析为同一版本并记录到唯一的 *Cargo.lock* 中。使得工作空间中的所有 crate 都使用相同的依赖意味着其中的 crate 都是相互兼容的。让我们在 *add-one/Cargo.toml* 中的 `[dependencies]` 部分增加 `rand` crate 以便能够在 `add-one` crate 中使用 `rand` crate： 文件名: add-one/Cargo.toml @@ -117,29 +221,29 @@ $ cargo build rand = "0.3.14" ``` -现在就可以在 *add-one/src/lib.rs* 中增加 `extern crate rand;` 了，接着在 *adder* 目录运行 `cargo build` 构建整个工作空间就会引入并编译 `rand` crate： +现在就可以在 *add-one/src/lib.rs* 中增加 `extern crate rand;` 了，接着在 *add* 目录运行 `cargo build` 构建整个工作空间就会引入并编译 `rand` crate： ```text $ cargo build Updating registry `https://github.com/rust-lang/crates.io-index` Downloading rand v0.3.14 - ...snip... + --snip-- Compiling rand v0.3.14 - Compiling add-one v0.1.0 (file:///projects/adder/add-one) - Compiling adder v0.1.0 (file:///projects/adder) + Compiling add-one v0.1.0 (file:///projects/add/add-one) + Compiling adder v0.1.0 (file:///projects/add/adder) Finished dev [unoptimized + debuginfo] target(s) in 10.18 secs ``` -现在顶级的 *Cargo.lock* 包含了 `add-one` 的 `rand` 依赖的信息。然而，即使 `rand` 被用于工作空间的某处，也不能在其他 crate 中使用它，除非也在他们的 *Cargo.toml* 中加入 `rand`。例如，如果在顶级的 `adder` crate 的 *src/main.rs* 中增加 `extern crate rand;`，则会得到一个错误： +现在顶级的 *Cargo.lock* 包含了 `add-one` 的 `rand` 依赖的信息。然而，即使 `rand` 被用于工作空间的某处，也不能在其他 crate 中使用它，除非也在他们的 *Cargo.toml* 中加入 `rand`。例如，如果在顶级的 `adder` crate 的 *adder/src/main.rs* 中增加 `extern crate rand;`，会得到一个错误： ```text $ cargo build - Compiling adder v0.1.0 (file:///projects/adder) -error[E0463]: can't find crate for `rand` - --> src/main.rs:1:1 + Compiling adder v0.1.0 (file:///projects/add/adder) +error: use of unstable library feature 'rand': use `rand` from crates.io (see +issue #27703) + --> adder/src/main.rs:1:1 | 1 | extern crate rand; - | ^^^^^^^^^^^^^^^^^^^ can't find crate ``` 为了修复这个错误，修改顶级 `adder` crate 的 *Cargo.toml* 来表明 `rand` 也是这个 crate 的依赖。构建 `adder` crate 会将 `rand` 加入到 *Cargo.lock* 中 `adder` 的依赖列表中，但是这并不会下载 `rand` 的额外拷贝。Cargo 确保了工作空间中任何使用 `rand` 的 crate 都采用相同的版本。在整个工作空间中使用相同版本的 `rand` 节省了空间，因为这样就无需多个拷贝并确保了工作空间中的 crate 将是相互兼容的。 @@ -166,32 +270,21 @@ mod tests { } ``` -在顶级 *adder* 目录运行 `cargo test`： +在顶级 *add* 目录运行 `cargo test`： ```text $ cargo test - Compiling adder v0.1.0 (file:///projects/adder) + Compiling add-one v0.1.0 (file:///projects/add/add-one) + Compiling adder v0.1.0 (file:///projects/add/adder) Finished dev [unoptimized + debuginfo] target(s) in 0.27 secs - Running target/debug/adder-f0253159197f7841 - -running 0 tests - -test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured -``` - -等等，零个测试？我们刚刚增加了一个测试！如果我们观察输出，就不难发现在工作空间中的 `cargo test` 只运行顶级 crate 的测试。为了运行工作空间中所有 crate 的测试，需要使用 `--all` 参数： - -```text -$ cargo test --all - Finished dev [unoptimized + debuginfo] target(s) in 0.37 secs - Running target/debug/deps/add_one-abcabcabc + Running target/debug/deps/add_one-f0253159197f7841 running 1 test test tests::it_works ... ok test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out - Running target/debug/deps/adder-abcabcabc + Running target/debug/deps/adder-f88af9d2cc175a5e running 0 tests @@ -204,7 +297,9 @@ running 0 tests test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out ``` -当传递了 `--all` 时，`cargo test` 会运行工作空间中所有 crate 的测试。也可以选择在顶级目录运行工作空间中特定 crate 的测试，通过使用 `-p` 参数并指定希望测试的 crate 的名称： +输出的第一部分显示 `add-one` crate 的 `it_works` 测试通过了。下一个部分显示 `adder` crate 中找到了 0 个测试，最后一部分显示 `add-one` crate 中有 0 个文档测试。在像这样的工作空间结构中运行 `cargo test` 会运行工作空间中所有 crate 的测试。 + +也可以选择运行工作空间中特定 crate 的测试，通过在根目录使用 `-p` 参数并指定希望测试的 crate 名称： ```text $ cargo test -p add-one @@ -225,8 +320,8 @@ test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out 输出显示了 `cargo test` 只运行了 `add-one` crate 的测试而没有运行 `adder` crate 的测试。 -如果你选择向 crates.io 发布工作空间中的 crate，每一个工作空间中的 crate 将会单独发布。`cargo publish` 命令并没有 `--all` 或者 `-p` 参数，所以必须进入每一个 crate 的目录并运行 `cargo publish` 来发布工作空间中的每一个 crate。 +如果你选择向 *https://crates.io/* 发布工作空间中的 crate，每一个工作空间中的 crate 将会单独发布。`cargo publish` 命令并没有 `--all` 或者 `-p` 参数，所以必须进入每一个 crate 的目录并运行 `cargo publish` 来发布工作空间中的每一个 crate。 现在尝试以类似 `add-one` crate 的方式向工作空间增加 `add-two` crate 来作为更多的练习！ -随着项目增长，考虑使用工作空间：每一个更小的组件比一大块代码要容易理解。将 crate 保持在工作空间中易于协调他们的改变，如果他们一起运行并经常需要同时被修改的话。 \ No newline at end of file +随着项目增长，考虑使用工作空间：每一个更小的组件比一大块代码要容易理解。将 crate 保持在工作空间中更易于协调他们的改变，如果他们一起运行并经常需要同时被修改的话。 \ No newline at end of file diff --git a/src/img/trpl14-01.png b/src/img/trpl14-01.png new file mode 100644 index 0000000000000000000000000000000000000000..5fc59898ceb3c08368c0030cbe1da4b8b36ed1af GIT binary patch literal 65437 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%0AfslbAShU8X}>u|K0PCHy7eX6zpHyjC&QEO8AHk4 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 literal 0 HcmV?d00001 diff --git a/src/img/trpl14-02.png b/src/img/trpl14-02.png new file mode 100644 index 0000000000000000000000000000000000000000..78e7e7ba747bf1a8839c6decbb5f12ab28e50497 GIT binary patch literal 175642 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

@^fAzfZS7q18afg%x(%UhDX#n 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�bB>L0t-JAyC$_O-Beep=)H>6gdk>_Sst@2GUL$VNQnbv!FP4Io%g zyvW!u`Ceq=NxNLDFlHk5Zhe*_CkPR=H@oN*(Ve@lJR^GgD3neYHUrC3|@qTr`O1t{%Zzhwd`x;yP zVsv9`%X}l_@whg74q#8kI<6VVlsRexQjp1`PKqL3l&9-=@);ezX(beP(0ixWDf>Is zJ_~WIs9q+Y8UUKAVsUr8r+oV4Aqp1mfDg3-UU>#xx#Xp_5;>E2ydpa(4C*MLgub0d z7A}Y#KDgSx2-<0@=rh&c_47S0yu$gl?1XeigBNgXjC77eUs$oXsBt9_27aJ7CL#LU zC`+Gb?WeN~a{ce8B3tp!X6U;)u`|1-+M6z5Pq9VLcL;GsCo~n&uIL+bB%+}KGQ#!- zlM5=AP~+$TYxPvJIh&)H(;avfdnwiL5od%sd*qc(Fwm-DS!LQ@1!ZMT@jhG-$hZn( z%-Zeeqq{)g*IQ>dV>CCUwbcF^ESV@vJ-oP=x)300fi6K7Ji$QkmQBTdmiGUlxO@7? z;S=fHNF-E`M8O1N-Hx#b#aF!`qPr#Tq+0uNVm&WCffhLqH5+$G7v3YtFE%Be00=GS z#2GpF!r{g+6AbEpe{JT3{rY;OaPCN#LGKRD2vfYSFJED)wHo173?9NkR4ZHe%P;n8 zopP-ozhrP2{UgF}yDf_+?toLm&Zgs7hQAr*_zQ+J!$>6({Vlm{vvaWVVB(ZK?DZtV~*N?N#MAC*qba}*JVrM=>w)rDZt?MEogEWM` z#qPX?ptIv6K97}6(IfAh(qz4$2Npr4;hcuh_h$SyW>p_C%%Mes|irz(XqmqLw)}zyt(@6z%|aX`ixWo zS#>|ekFQxtBB`JD3k|!m0Ri&BF zi!Y{^Xf#8n$}8J@Wq2_kRfNqMJMU!%BiDYg&3M_S7|&lWYK!OXg$nN#5v6)0Q{+=@ zZ@?+{y3&Gxfug;+qouI=tWeAOHR!;U^?1dL^e)!L5JwxbbHp`CfY~U>(X@BIAHzL5 zT^LYW4NimIiAc4z?75O1Z6t-4}q4noVoJmgl0sEV49FyzvPE>NhX33Cf z#u$4U=>=;i)sjwQyOYji2rs83LI-=vP0{8bC4mwELGZ3H-&xF|A5$Hoa(SrIgEwP% zO^{`0BgMyK#uepx!FjA^6`@zkz4>9N*;`dXK@u+6mm;0^!Feis&kMy zaA*C>A~a~7-|$1d4gloSwepnTj$G!iz1Lr`hN&w_B4(~hugL#ALf(=f^ha$6e-AtM zpQs7to@6xh zY(K?q|IFlucrd8g6>}?UK%_@aJ%W>m{lT#DP%RxKnQao4@cl53pLUU?_Dj7(;4auS z!Ss0Yf8>6HTih;wI2%9^0aGKS7}7vxV?^y+lM7t?P2U8SOhjVjm7Bk#io zqrvN&sG@zFx!6ptw!;5Sd5sVQ2 zxij&JpPV(hSf9!2eAM?8WiZ$~{lq^Wqs-ou{)GI08Hof5^DeCseB$?yDB)`hnF-Nfss6{Xn~mO6a(m^sRS$19BUKggBCtv_nmAT%D2{KBk%8BTp0>(x6g?Pzbi zSi$f{LQ-I94_<1y-WRPM`O3=r{6vs<-49IPRkLfq|4vu^fO+?yu;d?E*w>^iEc?9l z5cQv;%<12IRQUeZh7~w0{ZpFSN)2M(Vf0_{E(1zg!iX^e{x3!Y{>23>p=AbKH3m?gEHt zd&iD7umWgWE2CfX%%F~Zi3!KU_WNJc>rY{~JiSQjV-fe_pRTbbpPpOANyp4t`WJlh zub%vES3tV`1h#mktAGFUfAg0i>3PV?_rLbzmu~(1^%*ruNsufR*8iIa{Kty)NjH@U z-Tvon{JGixbx4;+9*`=m7~j$UC2s!j?+exo<^~Ejr37{tof+)fo16b E05`}JQ2+n{ literal 0 HcmV?d00001 diff --git a/src/img/trpl14-03.png b/src/img/trpl14-03.png index 5fc59898ceb3c08368c0030cbe1da4b8b36ed1af..ef8414507ac1e3cfec292f31be2b056d1b16aad1 100644 GIT binary patch literal 43085 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 diff --git a/src/img/trpl14-07.png b/src/img/trpl14-07.png deleted file mode 100644 index ef8414507ac1e3cfec292f31be2b056d1b16aad1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 43085 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

rc;i4T5tezuTZ+>#R`ot3upYCJ6U8Zb$W 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 a%4Bn$wPGkR;nf51eBYi!LENuT{rC^^ Date: Wed, 24 Jan 2018 09:39:02 +0800 Subject: [PATCH 121/150] :joy: remove DS_Store --- .DS_Store | Bin 8196 -> 0 bytes .gitignore | 2 ++ 2 files changed, 2 insertions(+) delete mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index f37fa75e0de78293b6f1382b2e5e3fb25d3eb724..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8196 zcmeHLPiz!b82`R)ftjJ$X(_Y=E?p@#r4(qFLcvho?iNBrmCE)n1-G+1V>>#XS$Af4 z`^RDvF9y+r2@0P4caU(CcrZ~D7!g>-g}bsz{b z5M&_8K#+kT13?D<4;i36n-yW5eV=QCI>>!M?7=D z7{{OvG7w~7Z3fuSrwkm(K_*>XettI%$8BxBgQ2qW4I4KJq9}-4gbT?DyO?xUH}AyN z+^E+xG(GLN`)%7?YOCo%LocS}nuKk+s$uE5W#;FH3`?_%aXW8mjyF!9>Q0caH&IHi zot>;xrMTB;c;7>ft-^g9$UA7a0BP?R09|9M(d?i!Wa1z8gZOf{{WT+|^Q z6Xet4P=SZdh1F80AP#5j$w>;v;j)+#7vu%u88&gR>bPgJx4!Z+|O+=B055q^SS;5YaK z{)E5aZ`_ELC}TBl#R%@jX55Dz7{e}1U^n*QSxn*p4&o?ksN*!m+>;b zhOgsW_zu2{@8bt}6Fr6pXoYRlQ<5r#9uV@in$-qNk4AFZ{rW2Y1z zAVTR=tEpcix4elFUtr8o>LcN>%xJ^Adm5=5B3kqA-sZ3*ml0`2&-lPWDJ*Xwesb-h zc1e=UiNIWY^cZP35>>gjb0=xR*L5}0Kq!c-iMKB8uER(01$<3}TZA9sXZRIDI7x;pF@*qXJZzpiFR{% z5nsYr@DjdC1iV7@yNcKFZ6e@@tLS#BL^O_g{Vv@K$(&`{);LK@ma diff --git a/.gitignore b/.gitignore index 146ccaf..4d6ce87 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,4 @@ _book/ mdbook/ + +.DS_Store \ No newline at end of file From d50fb8b05872ee5b554c99afbd767481b28ee91c Mon Sep 17 00:00:00 2001 From: KaiserY Date: Wed, 24 Jan 2018 16:56:28 +0800 Subject: [PATCH 122/150] check to ch15-02 --- src/SUMMARY.md | 2 +- src/ch14-04-installing-binaries.md | 8 +- src/ch14-05-extending-cargo.md | 6 +- src/ch15-00-smart-pointers.md | 59 +++++- src/ch15-01-box.md | 75 ++++++- src/ch15-02-deref.md | 329 ++++++++++++++++++++++++----- 6 files changed, 399 insertions(+), 80 deletions(-) diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 2803635..449d2f4 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -82,7 +82,7 @@ - [智能指针](ch15-00-smart-pointers.md) - [`Box` 在堆上存储数据，并且可确定大小](ch15-01-box.md) - - [`Deref` Trait 允许通过引用访问数据](ch15-02-deref.md) + - [通过 `Deref` trait 将智能指针当作常规引用处理](ch15-02-deref.md) - [`Drop` Trait 运行清理代码](ch15-03-drop.md) - [`Rc` 引用计数智能指针](ch15-04-rc.md) - [`RefCell` 和内部可变性模式](ch15-05-interior-mutability.md) diff --git a/src/ch14-04-installing-binaries.md b/src/ch14-04-installing-binaries.md index 1e04b1e..9f956fe 100644 --- a/src/ch14-04-installing-binaries.md +++ b/src/ch14-04-installing-binaries.md @@ -2,11 +2,11 @@ > [ch14-04-installing-binaries.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch14-04-installing-binaries.md) >
-> commit 6e53771a409794d9933c2a31310d78149b7e0534 +> commit ff93f82ff63ade5a352d9ccc430945d4ec804cdf -`cargo install` 命令用于在本地安装和使用二进制 crate。它并不打算替换系统中的包；它意在作为一个方便 Rust 开发者们安装其他人已经在 crates.io 上共享的工具的手段。只有拥有二进制目标文件的包能够被安装。二进制目标文件是在 crate 有 *src/main.rs* 或者其他指定为二进制文件时所创建的可执行程序，这不同于自身不能执行但适合包含在其他程序中的库目标。通常 crate 的 *README* 文件中有该 crate 是库、二进制目标还是两者都是的信息。 +`cargo install` 命令用于在本地安装和使用二进制 crate。它并不打算替换系统中的包；它意在作为一个方便 Rust 开发者们安装其他人已经在 [crates.io](https://crates.io) 上共享的工具的手段。只有拥有二进制目标文件的包能够被安装。二进制目标文件是在 crate 有 *src/main.rs* 或者其他指定为二进制文件时所创建的可执行程序，这不同于自身不能执行但适合包含在其他程序中的库目标文件。通常 crate 的 *README* 文件中有该 crate 是库、二进制目标还是两者都是的信息。 -所有来自 `cargo install` 的二进制文件都安装到 Rust 安装根目录的 *bin* 文件夹中。如果你使用 *rustup.rs* 安装的 Rust 且没有自定义任何配置，这将是 `$HOME/.cargo/bin`。将这个目录添加到 `$PATH` 环境变量中就能够运行通过 `cargo install` 安装的程序了。 +所有来自 `cargo install` 的二进制文件都安装到 Rust 安装根目录的 *bin* 文件夹中。如果你使用 *rustup.rs* 安装的 Rust 且没有自定义任何配置，这将是 `$HOME/.cargo/bin`。确保将这个目录添加到 `$PATH` 环境变量中就能够运行通过 `cargo install` 安装的程序了。 例如，第十二章提到的叫做 `ripgrep` 的用于搜索文件的 `grep` 的 Rust 实现。如果想要安装 `ripgrep`，可以运行如下： @@ -14,7 +14,7 @@ $ cargo install ripgrep Updating registry `https://github.com/rust-lang/crates.io-index` Downloading ripgrep v0.3.2 - ...snip... + --snip-- Compiling ripgrep v0.3.2 Finished release [optimized + debuginfo] target(s) in 97.91 secs Installing ~/.cargo/bin/rg diff --git a/src/ch14-05-extending-cargo.md b/src/ch14-05-extending-cargo.md index d1ab126..26946b8 100644 --- a/src/ch14-05-extending-cargo.md +++ b/src/ch14-05-extending-cargo.md @@ -2,10 +2,10 @@ > [ch14-05-extending-cargo.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch14-05-extending-cargo.md) >
-> commit 6e53771a409794d9933c2a31310d78149b7e0534 +> commit ff93f82ff63ade5a352d9ccc430945d4ec804cdf -Cargo 被设计为可扩展的，通过新的子命令而无须修改 Cargo 自身。如果 `$PATH` 中有类似 `cargo-something` 的二进制文件，就可以通过 `cargo something` 来像 Cargo 子命令一样运行它。像这样的自定义命令也可以运行 `cargo --list` 来展示出来。能够通过 `cargo install` 向 Cargo 安装扩展并可以如内建 Cargo 工具那样运行他们是 Cargo 设计上的一个非常方便的优点！ +Cargo 被设计为可以通过新的子命令而无须修改 Cargo 自身来进行扩展。如果 `$PATH` 中有类似 `cargo-something` 的二进制文件，就可以通过 `cargo something` 来像 Cargo 子命令一样运行它。像这样的自定义命令也可以运行 `cargo --list` 来展示出来。能够通过 `cargo install` 向 Cargo 安装扩展并可以如内建 Cargo 工具那样运行他们是 Cargo 设计上的一个非常方便的优点！ ## 总结 -通过 Cargo 和 crates.io 来分享代码是使得 Rust 生态环境可以用于许多不同的任务的重要组成部分。Rust 的标准库是小而稳定的，不过 crate 易于分享和使用，并采用一个不同语言自身的时间线来提供改进。不要羞于在 crates.io 上共享对你有用的代码；因为它很有可能对别人也很有用！ \ No newline at end of file +通过 Cargo 和 [crates.io](https://crates.io) 来分享代码是使得 Rust 生态环境可以用于许多不同的任务的重要组成部分。Rust 的标准库是小而稳定的，不过 crate 易于分享和使用，并采用一个不同语言自身的时间线来提供改进。不要羞于在 [crates.io](https://crates.io) 上共享对你有用的代码；因为它很有可能对别人也很有用！ \ No newline at end of file diff --git a/src/ch15-00-smart-pointers.md b/src/ch15-00-smart-pointers.md index 6d53dd5..cb11eb4 100644 --- a/src/ch15-00-smart-pointers.md +++ b/src/ch15-00-smart-pointers.md @@ -2,21 +2,64 @@ > [ch15-00-smart-pointers.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-00-smart-pointers.md) >
-> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 +> commit 68267b982a226fa252e9afa1a5029396ccf5fa03 -**指针** （*pointer*）是一个常见的编程概念，它代表一个指向储存其他数据的位置。第四章学习了 Rust 的引用；他们是一类很平常的指针，以 `&` 符号为标志并借用了他们所指向的值。**智能指针**（*smart pointers*）是一类数据结构，他们的表现类似指针，但是也拥有额外的元数据和功能，比如说引用计数。智能指针模式起源于 C++。在 Rust 中，普通引用和智能指针的一个额外的区别是引用是一类只借用数据的指针；相反大部分情况，智能指针 **拥有** 他们指向的数据。 +**指针** （*pointer*）是一个包含内存地址的变量的通用概念。这个地址引用，或 “指向”（points at）一些其他数据。Rust 中最常见的指针是第四章介绍的 **引用**（*reference*）。引用以 `&` 符号为标志并借用了他们所指向的值。除了引用数据它们没有任何其他特殊功能。它们也没有任何额外开销，所以应用的最多。 -本书中已经出现过一些智能指针，虽然当时我们并不这么称呼他们。例如在某种意义上说，第八章的 `String` 和 `Vec` 都是智能指针。他们拥有一些数据并允许你修改他们，并带有元数据（比如他们的容量）和额外的功能或保证（`String` 的数据总是有效的 UTF-8 编码）。智能指针区别于常规结构体的显著特性在于他们实现了 `Deref` 和 `Drop` trait，而本章会讨论这些 trait 以及为什么对于智能指针来说他们很重要。 +另一方面，**智能指针**（*smart pointers*）是一类数据结构，他们的表现类似指针，但是也拥有额外的元数据和功能。智能指针的概念并不为 Rust 所独有；其起源于 C++ 并存在于其他语言中。Rust 标准库中不同的智能指针提供了多于引用的额外功能。本章将会探索的一个例子便是 **引用计数** （*reference counting*）智能指针类型，其允许数据有多个所有者。引用计数智能指针记录总共有多少个所有者，并当没有任何所有者时负责清理数据。 -考虑到智能指针是一个在 Rust 经常被使用的通用设计模式，本章并不会覆盖所有现存的智能指针。很多库都有自己的智能指针而你也可以编写属于你自己的。这里将会讲到的是来自标准库中最常用的一些： + + + + + + +在 Rust 中，普通引用和智能指针的一个额外的区别是引用是一类只借用数据的指针；相反大部分情况，智能指针 **拥有** 他们指向的数据。 + +实际上本书中已经出现过一些智能指针，比如第八章的 `String` 和 `Vec`，虽然当时我们并不这么称呼它们。这些类型都属于智能指针因为它们拥有一些数据并允许你修改它们。它们也带有元数据（比如他们的容量）和额外的功能或保证（`String` 的数据总是有效的 UTF-8 编码）。 + + + + +智能指针通常使用结构体实现。智能指针区别于常规结构体的显著特性在于其实现了 `Deref` 和 `Drop` trait。`Deref` trait 允许智能指针结构体实例表现的像引用一样，这样就可以编写既用于引用又用于智能指针的代码。`Drop` trait 允许我们自定义当智能指针离开作用域时运行的代码。本章会讨论这些 trait 以及为什么对于智能指针来说他们很重要。 + +考虑到智能指针是一个在 Rust 经常被使用的通用设计模式，本章并不会覆盖所有现存的智能指针。很多库都有自己的智能指针而你也可以编写属于你自己的智能指针。这里将会讲到的是来自标准库中最常用的一些： + + + * `Box`，用于在堆上分配值 * `Rc`，一个引用计数类型，其数据可以有多个所有者 -* `RefCell`，其本身并不是智能指针，不过它管理智能指针 `Ref` 和 `RefMut` 的访问，在运行时而不是在编译时执行借用规则。 +* `Ref` 和 `RefMut`，通过 `RefCell` 访问，一个在运行时而不是在编译时执行借用规则的类型。 -同时我们还将涉及： + + -* **内部可变性**（*interior mutability*）模式，当一个不可变类型暴露出改变其内部值的 API，这时借用规则适用于运行时而不是编译时。 -* 引用循环，它如何会泄露内存，以及如何避免他们 +同时我们会涉及 **内部可变性**（*interior mutability*）模式，这时不可变类型暴露出改变其内部值的 API。我们也会讨论 **引用循环**（*reference cycles*）会如何泄露内存，以及如何避免。 让我们开始吧！ diff --git a/src/ch15-01-box.md b/src/ch15-01-box.md index e7ecd8d..0c5703d 100644 --- a/src/ch15-01-box.md +++ b/src/ch15-01-box.md @@ -2,13 +2,18 @@ > [ch15-01-box.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-01-box.md) >
-> commit 68267b982a226fa252e9afa1a5029396ccf5fa03 +> commit 0905e41f7387b60865e6eac744e31a7f7b46edf5 -最简单直接的智能指针是 *box*，它的类型是 `Box`。 box 允许你将一个值放在堆上而不是栈上。留在栈上的则是指向堆数据的指针。如果你想回顾一下栈与堆的区别请参考第四章。 +最简单直接的智能指针是 *box*，其类型是 `Box`。 box 允许你将一个值放在堆上而不是栈上。留在栈上的则是指向堆数据的指针。如果你想回顾一下栈与堆的区别请参考第四章。 + + + 除了数据被储存在堆上而不是栈上之外，box 没有性能损失，不过也没有很多额外的功能。他们多用于如下场景： -- 当有一个在编译时未知大小的类型，而又想要在需要确切大小的上下文中使用这个类型的值的时候 +- 当有一个在编译时未知大小的类型，而又想要在需要确切大小的上下文中使用这个类型值的时候 - 当有大量数据并希望在确保数据不被拷贝的情况下转移所有权的时候 - 当希望拥有一个值并只关心它的类型是否实现了特定 trait 而不是其具体类型的时候 @@ -31,16 +36,40 @@ fn main() { 示例 15-1：使用 box 在堆上储存一个 `i32` 值 -这里定义了变量 `b`，其值是一个指向被分配在堆上的值 `5` 的 `Box`。这个程序会打印出 `b = 5`。在这个例子中，我们可以像数据是储存在栈上的那样访问 box 中的数据。正如任何拥有数据所有权的值那样，当像 `b` 这样的 box 在 `main` 的末尾离开作用域时，它将被释放。这个释放过程作用于 box 本身（位于栈上）和它所指向的数据（位于堆上）。 +这里定义了变量 `b`，其值是一个指向被分配在堆上的值 `5` 的 `Box`。这个程序会打印出 `b = 5`；在这个例子中，我们可以像数据是储存在栈上的那样访问 box 中的数据。正如任何拥有数据所有权的值那样，当像 `b` 这样的 box 在 `main` 的末尾离开作用域时，它将被释放。这个释放过程作用于 box 本身（位于栈上）和它所指向的数据（位于堆上）。 -将一个单独的值存放在堆上并不是很有意义，所以像示例 15-1 这样单独使用 box 并不常见。将像单个 `i32` 这样的值储存在栈上，也就是其默认存放的地方在大部分使用场景中更为合适。让我们看看一个 box 定义一个不使用 box 时无法定义的类型的例子。 +将一个单独的值存放在堆上并不是很有意义，所以像示例 15-1 这样单独使用 box 并不常见。将像单个 `i32` 这样的值储存在栈上，也就是其默认存放的地方在大部分使用场景中更为合适。让我们看看一个不使用 box 时无法定义的类型的例子。 + + + ### box 允许创建递归类型 + + + + + Rust 需要在编译时知道类型占用多少空间。一种无法在编译时知道大小的类型是 **递归类型**（*recursive type*），其值的一部分可以是相同类型的另一个值。这种值的嵌套理论上可以无限的进行下去，所以 Rust 不知道递归类型需要多少空间。不过 box 有一个已知的大小，所以通过在循环类型定义中插入 box，就可以创建递归类型了。 让我们探索一下 *cons list*，一个函数式编程语言中的常见类型，来展示这个（递归类型）概念。除了递归之外，我们将要定义的 cons list 类型是很直白的，所以这个例子中的概念在任何遇到更为复杂的涉及到递归类型的场景时都很实用。 + + + cons list 是一个每一项都包含两个部分的列表：当前项的值和下一项。其最后一项值包含一个叫做 `Nil` 的值并没有下一项。 > #### cons list 的更多内容 @@ -53,6 +82,15 @@ cons list 是一个每一项都包含两个部分的列表：当前项的值和 注意虽然函数式编程语言经常使用 cons list，但是它并不是一个 Rust 中常见的类型。大部分在 Rust 中需要列表的时候，`Vec` 是一个更好的选择。其他更为复杂的递归数据类型 **确实** 在 Rust 的很多场景中很有用，不过通过以 cons list 作为开始，我们可以探索如何使用 box 毫不费力的定义一个递归数据类型。 + + + 示例 15-2 包含一个 cons list 的枚举定义。注意这还不能编译因为这个类型没有已知的大小，之后我们会展示： 文件名: src/main.rs @@ -66,7 +104,13 @@ enum List { 示例 15-2：第一次尝试定义一个代表 `i32` 值的 cons list 数据结构的枚举 -> 注意：出于示例的我们选择实现一个只存放 `i32` 值的 cons list。也可以用泛型实现它，正如第十章讲到的，来定义一个可以存放任何类型值的 cons list 类型。 +> 注意：出于示例的需要我们选择实现一个只存放 `i32` 值的 cons list。也可以用泛型实现它，正如第十章讲到的，来定义一个可以存放任何类型值的 cons list 类型。 + + + 使用这个 cons list 来储存列表 `1, 2, 3` 将看起来如示例 15-3 所示： @@ -93,7 +137,7 @@ error[E0072]: recursive type `List` has infinite size 1 | enum List { | ^^^^^^^^^ recursive type has infinite size 2 | Cons(i32, List), - | --------------- recursive without indirection + | ----- recursive without indirection | = help: insert indirection (e.g., a `Box`, `Rc`, or `&`) at some point to make `List` representable @@ -101,6 +145,14 @@ error[E0072]: recursive type `List` has infinite size 示例 15-4：尝试定义一个递归枚举时得到的错误 + + + 这个错误表明这个类型 “有无限的大小”。其原因是 `List` 的一个成员被定义为是递归的：它直接存放了另一个相同类型的值。这意味着 Rust 无法计算为了存放 `List` 值到底需要多少空间。让我们一点一点来看：首先了解一下 Rust 如何决定需要多少空间来存放一个非递归类型。 ### 计算非递归类型的大小 @@ -159,7 +211,7 @@ fn main() { } ``` -示例 15-6：为了已知大小而使用 `Box` 的 `List` 定义 +示例 15-6：为了拥有已知大小而使用 `Box` 的 `List` 定义 `Cons` 成员将会需要一个 `i32` 的大小加上储存 box 指针数据的空间。`Nil` 成员不储存值，所以它比 `Cons` 成员需要更少的空间。现在我们知道了任何 `List` 值最多需要一个 `i32` 加上 box 指针数据的大小。通过使用 box ，打破了这无限递归的连锁，这样编译器就能够计算出储存 `List` 值需要的大小了。图 15-7 展示了现在 `Cons` 成员看起来像什么： @@ -170,3 +222,10 @@ fn main() { box 只提供了间接存储和堆分配；他们并没有任何其他特殊的功能，比如我们将会见到的其他智能指针。他们也没有这些特殊功能带来的性能损失，所以他们可以用于像 cons list 这样间接存储是唯一所需功能的场景。我们还将在第十七章看到 box 的更多应用场景。 `Box` 类型是一个智能指针，因为它实现了 `Deref` trait，它允许 `Box` 值被当作引用对待。当 `Box` 值离开作用域时，由于 `Box` 类型 `Drop` trait 的实现，box 所指向的堆数据也会被清除。让我们更详细的探索一下这两个 trait；这些 trait 在本章余下讨论的其他智能指针所提供的功能中将会更为重要。 + + + diff --git a/src/ch15-02-deref.md b/src/ch15-02-deref.md index b405616..c0e0ef3 100644 --- a/src/ch15-02-deref.md +++ b/src/ch15-02-deref.md @@ -1,113 +1,330 @@ -## `Deref` Trait 允许通过引用访问数据 +## 通过 `Deref` trait 将智能指针当作常规引用处理 > [ch15-02-deref.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-02-deref.md) >
> commit d06a6a181fd61704cbf7feb55bc61d518c6469f9 -第一个智能指针相关的重要 trait 是 `Deref`，它允许我们重载 `*`，解引用运算符（不同于乘法运算符或全局引用运算符）。重载智能指针的 `*` 能使访问其持有的数据更为方便，在本章结束前谈到解引用强制多态（deref coercions）时我们会说明方便意味着什么。 +实现 `Deref` trait 允许我们重载 **解引用运算符**（*dereference operator*）`*`（与乘法运算符或 glob 运算符相区别）。通过这种方式实现 `Deref` trait 可以被当作常规引用来对待，可以编写操作引用的代码并用于智能指针。 -第八章的哈希 map 的 “根据旧值更新一个值” 部分简要的提到了解引用运算符。当时有一个可变引用，而我们希望改变这个引用所指向的值。为此，首先我们必须解引用。这是另一个使用 `i32` 值引用的例子： + + + + + + +让我们首先看看 `*` 如何处理引用，接着尝试定义我们自己的类 `Box` 类型并看看为何 `*` 不能像引用一样工作。我们会探索如何实现 `Deref` trait 使得智能指针以类似引用的方式工作变为可能。最后，我们会讨论 Rust 的 **解引用强制多态**（*deref coercions*）功能和它是如何一同处理引用或智能指针的。 + +### 通过 `*` 追钟指针的值 + + + + + + + +常规引用是一个指针类型，一种理解指针的方式是将其看成指向储存在其他某处值的箭头。在示例 15-8 中，创建了一个 `i32` 值的引用接着使用解引用运算符来跟踪所引用的数据： + + + + + + + +文件名: src/main.rs ```rust -let mut x = 5; -{ - let y = &mut x; +fn main() { + let x = 5; + let y = &x; - *y += 1 + assert_eq!(5, x); + assert_eq!(5, *y); } - -assert_eq!(6, x); ``` -我们使用 `*y` 来访问可变引用 `y` 所指向的数据，而不是可变引用本身。接着可以修改它的数据，在这里是对其加一。 +示例 15-8：使用解引用运算符来跟踪 `i32` 值的引用 -引用并不是智能指针，他们只是引用指向的一个值，所以这个解引用操作是很直接的。智能指针还会储存指针或数据的元数据。当解引用一个智能指针时，我们只想要数据，而不需要元数据，因为解引用一个常规的引用只能给我们数据而不是元数据。我们希望能在使用常规引用的地方也能使用智能指针。为此，可以通过实现 `Deref` trait 来重载 `*` 运算符的行为。 +变量 `x` 存放了一个 `i32` 值 `5`。`y` 等于 `x` 的一个引用。可以断言 `x` 等于 `5`。然而，如果希望对 `y` 的值做出断言，必须使用 `*y` 来追踪引用所指向的值（也就是 **解引用**）。一旦解引用了 `y`，就可以访问 `y` 所指向的整型值并可以与 `5` 做比较。 -示例 15-7 展示了一个定义为储存 mp3 数据和元数据的结构体通过 `Deref` trait 来重载 `*` 的例子。`Mp3`，在某种意义上是一个智能指针：它拥有包含音频的 `Vec` 数据。另外，它储存了一些可选的元数据，在这个例子中是音频数据中艺术家和歌曲的名称。我们希望能够方便的访问音频数据而不是元数据，所以需要实现 `Deref` trait 来返回音频数据。实现 `Deref` trait 需要一个叫做 `deref` 的方法，它借用 `self` 并返回其内部数据： +相反如果尝试编写 `assert_eq!(5, y);`，则会得到如下编译错误： + +```text +error[E0277]: the trait bound `{integer}: std::cmp::PartialEq<&{integer}>` is +not satisfied + --> src/main.rs:6:5 + | +6 | assert_eq!(5, y); + | ^^^^^^^^^^^^^^^^^ can't compare `{integer}` with `&{integer}` + | + = help: the trait `std::cmp::PartialEq<&{integer}>` is not implemented for + `{integer}` +``` + +不允许比较数字的引用与数字，因为它们是不同的类型。必须使用 `*` 追踪引用所指向的值。 + +### 像引用一样使用 `Box` + +可以重写示例 15-8 中的代码来使用 `Box` 而不是引用，同时借引用运算符也一样能工作，如示例 15-9 所示： + +文件名: src/main.rs + +```rust +fn main() { + let x = 5; + let y = Box::new(x); + + assert_eq!(5, x); + assert_eq!(5, *y); +} +``` + +示例 15-9：在 `Box` 上使用解引用运算符 + +相比示例 15-8 唯一修改的地方就是将 `y` 设置为一个指向 `x` 值的 box 实例，而不是指向 `x` 值的引用。在最后的断言中，可以使用解引用运算符以 `y` 为引用时相同的方式追踪 box 的指针。让我们通过实现自己的 box 类型来探索 `Box` 能这么做有何特殊之处。 + +### 自定义智能指针 + +为了体会默认智能指针的行为不同于引用，让我们创建一个类似于标准库提供的 `Box` 类型的只能指针。接着会学习如何增加使用解引用运算符的功能。 + +从根本上说，`Box` 被定义为包含一个元素的元组结构体，所以示例 15-10 以相同的方式定义了 `MyBox` 类型。我们还定义了 `new` 函数来对应定义于 `Box` 的 `new` 函数： + +文件名: src/main.rs + +```rust +struct MyBox(T); + +impl MyBox { + fn new(x: T) -> MyBox { + MyBox(x) + } +} +``` + +示例 15-10：定义 `MyBox` 类型 + +这里定义了一个结构体 `MyBox` 并声明了一个泛型 `T`，因为我们希望其可以存放任何类型的值。`MyBox` 是一个包含 `T` 类型元素的元组结构体。`MyBox::new` 函数获取一个 `T` 类型的参数并返回一个存放传入值的 `MyBox` 实例。 + +尝试将示例 15-9 中的代码加入示例 15-10 中并修改 `main` 使用我们定义的 `MyBox` 类型代替 `Box`。示例 15-11 中的代码不能编译，因为 Rust 不知道如何解引用 `MyBox`： + +文件名: src/main.rs + +```rust,ignore +fn main() { + let x = 5; + let y = MyBox::new(x); + + assert_eq!(5, x); + assert_eq!(5, *y); +} +``` + +示例 15-11：尝试以使用引用和 `Box` 相同的方式使用 `MyBox` + +得到的编译错误是： + +```text +error: type `MyBox<{integer}>` cannot be dereferenced + --> src/main.rs:14:19 + | +14 | assert_eq!(5, *y); + | ^^ +``` + +`MyBox` 类型不能解引用我们并没有为其实现这个功能。为了启用 `*` 运算符的解引用功能，可以实现 `Deref` trait。 + +### 实现 `Deref` trait 定义如何像引用一样对待某类型 + +如第十章所讨论的，为了实现 trait，需要提供 trait 所需的方法实现。`Deref` trait，由标准库提供，要求实现名为 `deref` 的方法，其借用 `self` 并返回一个内部数据的引用。示例 15-12 包含定义于 `MyBox` 之上的 `Deref` 实现： 文件名: src/main.rs ```rust use std::ops::Deref; -struct Mp3 { - audio: Vec, - artist: Option, - title: Option, -} +# struct MyBox(T); +impl Deref for MyBox { + type Target = T; -impl Deref for Mp3 { - type Target = Vec; - - fn deref(&self) -> &Vec { - &self.audio + fn deref(&self) -> &T { + &self.0 } } - -fn main() { - let my_favorite_song = Mp3 { - // we would read the actual audio data from an mp3 file - audio: vec![1, 2, 3], - artist: Some(String::from("Nirvana")), - title: Some(String::from("Smells Like Teen Spirit")), - }; - - assert_eq!(vec![1, 2, 3], *my_favorite_song); -} ``` -示例 15-7：一个存放 mp3 文件数据和元数据的结构体上的 `Deref` trait 实现 +示例 15-12：`MyBox` 上的 `Deref` 实现 -大部分代码看起来都比较熟悉：一个结构体、一个 trait 实现、和一个创建了结构体实例的 main 函数。其中有一部分我们还未全面的讲解：类似于第十三章学习迭代器 trait 时出现的 `type Item`，`type Target = T;` 语法用于定义关联类型，第十九章会更详细的介绍。不必过分担心例子中的这一部分；它只是一个稍显不同的定义泛型参数的方式。 +`type Target = T;` 语法定义了用于此 trait 的关联类型。关联类型是一个稍有不同的定义泛型参数的方式，现在还无需过多的担心它；第十九章会详细介绍。 -在 `assert_eq!` 中，我们验证 `vec![1, 2, 3]` 是否为 `Mp3` 实例 `*my_favorite_song` 解引用的值，结果正是如此，因为我们实现了 `deref` 方法来返回音频数据。如果没有为 `Mp3` 实现 `Deref` trait，Rust 将不会编译 `*my_favorite_song`：会出现错误说 `Mp3` 类型不能被解引用。 + + -没有 `Deref` trait 的话，编译器只能解引用 `&` 引用，而 `my_favorite_song` 并不是（它是一个 `Mp3` 结构体）。通过 `Deref` trait，编译器知道实现了 `Deref` trait 的类型有一个返回引用的 `deref` 方法（在这个例子中，是 `&self.audio` 因为示例 15-7 中的 `deref` 的定义）。所以为了得到一个 `*` 可以解引用的 `&` 引用，编译器将 `*my_favorite_song` 展开为如下： +`deref` 方法体中写入了 `&self.0`，这样 `deref` 返回了我希望通过 `*` 运算符访问的值的引用。示例 15-11 中的 `main` 函数中对 `MyBox` 值的 `*` 调用现在可以编译并能通过断言了！ + +没有 `Deref` trait 的话，编译器只能解引用 `&` 引用。`Deref` trait 的 `deref` 方法为编译器提供了获取任何实现了 `Deref` 的类型值的能力，为了获取其知道如何解引用的 `&` 引用编译器可以调用 `deref` 方法。 + +当我们在示例 15-11 中输入 `*y` 时，Rust 事实上在底层运行了如下代码： ```rust,ignore -*(my_favorite_song.deref()) +*(y.deref()) ``` -其结果就是 `self.audio` 中的值。`deref` 返回一个引用并接下来必需解引用而不是直接返回值的原因是所有权：如果 `deref` 方法直接返回值而不是引用，其值将被移动出 `self`。和大部分使用解引用运算符的地方相同，这里并不想获取 `my_favorite_song.audio` 的所有权。 + + + +Rust 将 `*` 运算符替换为 `deref` 方法调用和一个普通解引用，如此我们便无需担心是否需要调用 `deref` 方法。Rust 的这个功能让我们可以编写同时处理常规引用或实现了 `Deref` 的类型的代码。 + +`deref` 方法返回值的引用，以及 `*(y.deref())` 括号外边的普通解引用仍为必须的原因在于所有权。如果 `deref` 方法直接返回值而不是值的引用，其值（的所有权）将被移出 `self`。在这里以及大部分使用解引用运算符的情况下我们并不希望获取 `MyBox` 内部值的所有权。 + +注意将 `*` 替换为 `deref` 调用和 `*` 调用的过程在每次使用 `*` 的时候都会发生一次。`*` 的替换并不会无限递归进行。最终的数据类型是 `i32`，它与示例 15-11 中 `assert_eq!` 的 `5` 相匹配。 -注意将 `*` 替换为 `deref` 调用和 `*` 调用的过程在每次使用 `*` 的时候都会发生一次。`*` 的替换并不会无限递归进行。最终的数据类型是 `Vec`，它与示例 15-7 中 `assert_eq!` 的 `vec![1, 2, 3]` 相匹配。 ### 函数和方法的隐式解引用强制多态 -Rust 倾向于偏爱明确而不是隐晦，不过一个情况下这并不成立，就是函数和方法的参数的 **解引用强制多态**（*deref coercions*）。解引用强制多态会自动的将指针或智能指针的引用转换为指针内容的引用。解引用强制多态发生于当传递给函数的参数类型不同于函数签名中定义参数类型的时候。解引用强制多态的加入使得 Rust 调用函数或方法时无需很多显式使用 `&` 和 `*` 的引用和解引用。 + + -使用示例 15-7 中的 `Mp3` 结构体，如下是一个获取 `u8` slice 并压缩 mp3 音频数据的函数签名： +**解引用强制多态**（*deref coercions*）是 Rust 出于方便的考虑作用于函数或方法的参数的。其将实现了 `Deref` 的类型的引用转换为 `Deref` 所能够将原始类型转换的类型的引用。解引用强制多态发生于当作为参数传递给函数或方法的特定类型的引用不同于函数或方法签名中定义参数类型的时候，这时会有一系列的 `deref` 方法调用会将提供的类型转换为参数所需的类型。 -```rust,ignore -fn compress_mp3(audio: &[u8]) -> Vec { - // the actual implementation would go here +解引用强制多态的加入使得 Rust 程序员编写函数和方法调用时无需增加过多显式使用 `&` 和 `*` 的引用和解引用。这个功能也使得我们可以编写更多同时作用于引用或智能指针的代码。 + +作为展示解引用强制多态的实例，让我们使用示例 15-10 中定义的 `MyBox`，以及示例 15-12 中增加的 `Deref` 实现。示例 15-13 展示了一个有着字符串 slice 参数的函数定义： + +文件名: src/main.rs + +```rust +fn hello(name: &str) { + println!("Hello, {}!", name); } ``` -如果 Rust 没有解引用强制多态，为了使用 `my_favorite_song` 中的音频数据调用此函数，必须写成： +示例 15-13：`hello` 函数有着 `&str` 类型的参数 `name` -```rust,ignore -compress_mp3(my_favorite_song.audio.as_slice()) +可以使用字符串 slice 作为参数调用 `hello` 函数，比如 `hello("Rust");`。解引用强制多态使得用 `MyBox` 类型值的引用调用 `hello` 称为可能，如示例 15-14 所示： + +文件名: src/main.rs + +```rust +# use std::ops::Deref; +# +# struct MyBox(T); +# +# impl MyBox { +# fn new(x: T) -> MyBox { +# MyBox(x) +# } +# } +# +# impl Deref for MyBox { +# type Target = T; +# +# fn deref(&self) -> &T { +# &self.0 +# } +# } +# +# fn hello(name: &str) { +# println!("Hello, {}!", name); +# } +# +fn main() { + let m = MyBox::new(String::from("Rust")); + hello(&m); +} ``` -也就是说，必须明确表明需要 `my_favorite_song` 中的 `audio` 字段而且我们希望有一个 slice 来引用这整个 `Vec`。如果有很多地方需要用相同的方式处理 `audio` 数据，那么 `.audio.as_slice()` 就显得冗长重复了。 +示例 15-14：因为解引用强制多态，使用 `MyBox` 的引用调用 `hello` 是可行的 -然而，因为解引用强制多态和 `Mp3` 的 `Deref` trait 实现，我们可以使用如下代码使用 `my_favorite_song` 中的数据调用这个函数： +这里使用 `&m` 调用 `hello` 函数，其为 `MyBox` 值的引用。因为示例 15-12 中在 `MyBox` 上实现了 `Deref` trait，Rust 可以通过 `deref` 调用将 `&MyBox` 变为 `&String`。标准库中提供了 `String` 上的 `Deref` 实现，其会返回字符串 slice，这可以在 `Deref` 的 API 文档中看到。Rust 再次调用 `deref` 将 `&String` 变为 `&str`，这就符合 `hello` 函数的定义了。 -```rust,ignore -let result = compress_mp3(&my_favorite_song); +如果 Rust 没有实现解引用强制多态，为了使用 `&MyBox` 类型的值调用 `hello`，则不得不编写示例 15-15 中的代码来代替示例 15-14： + +文件名: src/main.rs + +```rust +# use std::ops::Deref; +# +# struct MyBox(T); +# +# impl MyBox { +# fn new(x: T) -> MyBox { +# MyBox(x) +# } +# } +# +# impl Deref for MyBox { +# type Target = T; +# +# fn deref(&self) -> &T { +# &self.0 +# } +# } +# +# fn hello(name: &str) { +# println!("Hello, {}!", name); +# } +# +fn main() { + let m = MyBox::new(String::from("Rust")); + hello(&(*m)[..]); +} ``` -只有 `&` 和实例，好的！我们可以把智能指针当成普通的引用那样使用。也就是说解引用强制多态意味着 Rust 利用了 `Deref` 实现的优势：Rust 知道 `Mp3` 实现了 `Deref` trait 并从 `deref` 方法返回 `&Vec`。它也知道标准库实现了 `Vec`的 `Deref` trait，其 `deref` 方法返回 `&[T]`（我们也可以通过查阅 `Vec` 的 API 文档来发现这一点）。所以，在编译时，Rust 会发现它可以调用两次 `Deref::deref` 来将 `&Mp3` 变成 `&Vec` 再变成 `&[T]` 来满足 `compress_mp3` 的签名。这意味着我们可以少写一些代码！Rust 会多次分析 `Deref::deref` 的返回值类型直到它满足参数的类型，只要相关类型实现了 `Deref` trait。这些间接转换在编译时进行，所以利用解引用强制多态并没有运行时惩罚！ +示例 15-15：如果 Rust 没有解引用强制多态则必须编写的代码 -类似于如何使用 `Deref` trait 重载 `&T` 的 `*` 运算符，`DerefMut` trait 用于重载 `&mut T` 的 `*` 运算符。 +`(*m)` 将 `MyBox` 解引用为 `String`。接着 `&` 和 `[..]` 获取了整个 `String` 的字符串 slice 来匹配 `hello` 的签名。没有解引用强制多态所有这些符号混在一起将更难以读写和理解。解引用强制多态使得 Rust 自动的帮我们处理这些转换。 + +当所涉及到的类型定义了 `Deref` trait，Rust 会分析这些类型并使用任意多次 `Deref::deref` 调用以获得匹配参数的类型。这写解析都发生在编译时，所以利用解引用强制多态并没有运行时惩罚！ + +### 解引用强制多态如何与可变性交互 + + + + +类似于如何使用 `Deref` trait 重载不可变引用的 `*` 运算符，Rust 提供了 `DerefMut` trait 用于重载可变引用的 `*` 运算符。 Rust 在发现类型和 trait 实现满足三种情况时会进行解引用强制多态： + + + * 当 `T: Deref` 时从 `&T` 到 `&U`。 * 当 `T: DerefMut` 时从 `&mut T` 到 `&mut U`。 * 当 `T: Deref` 时从 `&mut T` 到 `&U`。 -头两个情况除了可变性之外是相同的：如果有一个 `&T`，而 `T` 实现了返回 `U` 类型的 `Deref`，则可以直接得到 `&U`。对于可变引用也是一样。最后一个有些微妙：如果有一个可变引用，它也可以强转为一个不可变引用。反之则是 **不可能** 的：不可变引用永远也不能强转为可变引用。 +头两个情况除了可变性之外是相同的：第一种情况表明如果有一个 `&T`，而 `T` 实现了返回 `U` 类型的 `Deref`，则可以直接得到 `&U`。第二种情况表明对于可变引用也有着相同的行为。 -`Deref` trait 对于智能指针模式十分重要的原因在于智能指针可以被看作普通引用并被用于期望使用普通引用的地方。例如，无需重新定义方法和函数来直接获取智能指针。 \ No newline at end of file +最后一个情况有些微妙：Rust 也会将可变引用强转为不可变引用。但是反之是 **不可能** 的：不可变引用永远也不能强转为可变引用。因为根据借用规则，如果有一个可变引用，其必须是这些数据的唯一引用（否则程序将无法编译）。将一个可变引用转换为不可变引用永远也不会打破借用规则。将不可变引用转换为可变引用则需要数据只能有一个不可变引用，而借用规则无法保证这一点。因此，Rust 无法假设将不可变引用转换为可变引用是可能的。 + + + From 5d99450d89aea899302c4d0c2685f3f79a5dc17d Mon Sep 17 00:00:00 2001 From: KaiserY Date: Fri, 26 Jan 2018 14:11:33 +0800 Subject: [PATCH 123/150] check to ch15-05 --- src/ch15-03-drop.md | 161 +++++++++--- src/ch15-04-rc.md | 107 +++++--- src/ch15-05-interior-mutability.md | 377 +++++++++++++++++++++-------- 3 files changed, 478 insertions(+), 167 deletions(-) diff --git a/src/ch15-03-drop.md b/src/ch15-03-drop.md index ad41544..884b5a2 100644 --- a/src/ch15-03-drop.md +++ b/src/ch15-03-drop.md @@ -2,15 +2,38 @@ > [ch15-03-drop.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-03-drop.md) >
-> commit 3f2a1bd8dbb19cc48b210fc4fb35c305c8d81b56 +> commit 721553e3a7b5ee9430cb548c8699b67be197b3f6 -对于智能指针模式来说另一个重要的 trait 是`Drop`。`Drop`运行我们在值要离开作用域时执行一些代码。智能指针在被丢弃时会执行一些重要的清理工作，比如释放内存或减少引用计数。更一般的来讲，数据类型可以管理多于内存的资源，比如文件或网络连接，而使用`Drop`在代码处理完他们之后释放这些资源。我们在智能指针上下文中讨论`Drop`是因为其功能几乎总是用于实现智能指针。 +对于智能指针模式来说另一个重要的 trait 是 `Drop`。`Drop` 允许我们在值要离开作用域时执行一些代码。可以为任何类型提供 `Drop` trait 的实现，同时所指定的代码被用于释放类似于文件或网络连接的资源。我们在智能指针上下文中讨论 `Drop` 是因为其功能几乎总是用于实现智能指针。例如，`Box` 自定义了 `Drop` 用来释放 box 所指向的堆空间。 -在其他一些语言中，我们不得不记住在每次使用完智能指针实例后调用清理内存或资源的代码。如果忘记的话，运行代码的系统可能会因为负荷过重而崩溃。在 Rust 中，可以指定一些代码应该在值离开作用域时被执行，而编译器会自动插入这些代码。这意味着无需记住在所有处理完这些类型实例后调用清理代码，而仍然不会泄露资源！ +在其他一些语言中，我们不得不记住在每次使用完智能指针实例后调用清理内存或资源的代码。如果忘记的话，运行代码的系统可能会因为负荷过重而崩溃。在 Rust 中，可以指定一些代码应该在值离开作用域时被执行，而编译器会自动插入这些代码。 -指定在值离开作用域时应该执行的代码的方式是实现`Drop` trait。`Drop` trait 要求我们实现一个叫做`drop`的方法，它获取一个`self`的可变引用。 + + + +这意味着无需记住在所有处理完这些类型实例后调用清理代码，而仍然不会泄露资源！ + +指定在值离开作用域时应该执行的代码的方式是实现 `Drop` trait。`Drop` trait 要求实现一个叫做 `drop` 的方法，它获取一个 `self` 的可变引用。为了能够看出 Rust 何时调用 `drop`，让我们暂时使用 `println!` 语句实现 `drop`。 + + + + +示例 15-16 展示了唯一定制功能就是当其实例离开作用域时打印出 `Dropping CustomSmartPointer!` 的结构体 `CustomSmartPointer`。这会演示 Rust 何时运行 `drop` 函数： + + + -示例 15-8 展示了并没有实际功能的结构体`CustomSmartPointer`，不过我们会在创建实例之后打印出`CustomSmartPointer created.`，而在实例离开作用域时打印出`Dropping CustomSmartPointer!`，这样就能看出每一段代码是何时被执行的。实际的项目中，我们应该在`drop`中清理任何智能指针运行所需要的资源，而不是这个例子中的`println!`语句： 文件名: src/main.rs @@ -21,32 +44,57 @@ struct CustomSmartPointer { impl Drop for CustomSmartPointer { fn drop(&mut self) { - println!("Dropping CustomSmartPointer!"); + println!("Dropping CustomSmartPointer with data `{}`!", self.data); } } fn main() { - let c = CustomSmartPointer { data: String::from("some data") }; - println!("CustomSmartPointer created."); - println!("Wait for it..."); + let c = CustomSmartPointer { data: String::from("my stuff") }; + let d = CustomSmartPointer { data: String::from("other stuff") }; + println!("CustomSmartPointers created."); } ``` -示例 15-8: 结构体 `CustomSmartPointer` 实现了 `Drop` trait, 我们能够放入代码以便在 `CustomSmartPointer` 离开作用域后进行清理 +示例 15-16：结构体 `CustomSmartPointer`，其实现了放置清理代码的 `Drop` trait -`Drop` trait 位于 prelude 中，所以无需导入它。`drop`方法的实现调用了`println!`；这里是你需要放入实际关闭套接字代码的地方。在`main`函数中，我们创建一个`CustomSmartPointer`的新实例并打印出`CustomSmartPointer created.`以便在运行时知道代码运行到此处。在`main`的结尾，`CustomSmartPointer`的实例会离开作用域。注意我们没有显式调用`drop`方法： +`Drop` trait 包含在 prelude 中，所以无需导入它。我们在 `CustomSmartPointer` 上实现了 `Drop` trait，并提供了一个调用 `println!` 的 `drop` 方法实现。`drop` 函数体是放置任何当类型实例离开作用域时期望运行的逻辑的地方。这里选择打印一些文本以展示 Rust 合适调用 `drop`。 -当运行这个程序，我们会看到： + + -``` -CustomSmartPointer created. -Wait for it... -Dropping CustomSmartPointer! +在 `main` 中，新建了一个 `CustomSmartPointer` 实例并打印出了 `CustomSmartPointer created.`。在 `main` 的结尾，`CustomSmartPointer` 的实例会离开作用域，而 Rust 会调用放置于 `drop` 方法中的代码，打印出最后的信息。注意无需显示调用 `drop` 方法： + +当运行这个程序，会出现如下输出： + +```text +CustomSmartPointers created. +Dropping CustomSmartPointer with data `other stuff`! +Dropping CustomSmartPointer with data `my stuff`! ``` -被打印到屏幕上，它展示了 Rust 在实例离开作用域时自动调用了`drop`。 +当实例离开作用域 Rust 会自动调用 `drop`，并调用我们指定的代码。变量以被创创建时相反的顺序被丢弃，所以 `d` 在 `c` 之前被丢弃。这刚好给了我们一个 drop 方法如何工作的可视化指导，不过通常需要指定类型所需执行的清理代码而不是打印信息。 -可以使用`std::mem::drop`函数来在值离开作用域之前丢弃它。这通常是不必要的；整个`Drop` trait 的要点在于它自动的帮我们处理清理工作。在第十六章讲到并发时我们会看到一个需要在离开作用域之前丢弃值的例子。现在知道这是可能的即可，`std::mem::drop`位于 prelude 中所以可以如示例 15-9 所示直接调用`drop`： + + + +#### 通过 `std::mem::drop` 提早丢弃值 + + + + +Rust 当值离开作用域时自动插入 `drop` 调用，不能直接禁用这个功能。 + + + +被打印到屏幕上，它展示了 Rust 在实例离开作用域时自动调用了`drop`。通常也不需要禁用 `drop`；整个 `Drop` trait 存在的意义在于其是自动处理的。有时可能需要提早清理某个值。一个例子是当使用智能指针管理锁时；你可能希望强制运行 `drop` 方法来释放锁以便作用域中的其他代码可以获取锁。首先。让我们看看自己调用 `Drop` trait 的 `drop` 方法会发生什么，如示例 15-17 修改示例 15-16 中的 `main` 函数： + + + 文件名: src/main.rs @@ -54,33 +102,80 @@ Dropping CustomSmartPointer! fn main() { let c = CustomSmartPointer { data: String::from("some data") }; println!("CustomSmartPointer created."); - drop(c); - println!("Wait for it..."); + c.drop(); + println!("CustomSmartPointer dropped before the end of main."); } ``` -示例 15-9: 在一个值离开作用域之前，调用 `std::mem::drop` 显式进行回收 +示例 15-17：尝试手动调用 `Drop` trait 的 `drop` 方法提早清理 -运行这段代码会打印出如下内容，因为`Dropping CustomSmartPointer!`在`CustomSmartPointer created.`和`Wait for it...`之间被打印出来，表明析构代码被执行了： +如果尝试编译代码会得到如下错误： -``` -CustomSmartPointer created. -Dropping CustomSmartPointer! -Wait for it... +```text +error[E0040]: explicit use of destructor method + --> src/main.rs:15:7 + | +15 | c.drop(); + | ^^^^ explicit destructor calls not allowed ``` -注意不允许直接调用我们定义的`drop`方法：如果将示例 15-9 中的`drop(c)`替换为`c.drop()`，会得到一个编译错误表明`explicit destructor calls not allowed`。不允许直接调用`Drop::drop`的原因是 Rust 在值离开作用域时会自动插入`Drop::drop`，这样就会丢弃值两次。丢弃一个值两次可能会造成错误或破坏内存，所以 Rust 就不允许这么做。相应的可以调用`std::mem::drop`，它的定义是： +错误信息表明不允许显式调用 `drop`。错误信息使用了术语 **析构函数**（*destructor*），这是一个清理实例的函数的通用编程概念。**析构函数** 对应创建实例的 **构造函数**。Rust 中的 `drop` 函数就是这么一个析构函数。 + +Rust 不允许我们显式调用 `drop` 因为 Rust 仍然会在 `main` 的结尾对值自动调用 `drop`，这会导致一个 **double free** 错误，因为 Rust 会尝试清理相同的值两次。 + +因为不能禁用当值离开作用域时自动插入的 `drop`，并且不能显示调用 `drop`，如果我们需要提早清理值，可以使用 `std::mem::drop` 函数。 + +`std::mem::drop` 函数不同于 `Drop` trait 中的 `drop` 方法。可以通过传递希望提早强制丢弃的值作为参数。`std::mem::drop` 位于 prelude，所以我们可以修改示例 15-16 中的 `main` 来调用 `drop` 函数如示例 15-18 所示： + +文件名: src/main.rs ```rust -pub mod std { - pub mod mem { - pub fn drop(x: T) { } - } +# struct CustomSmartPointer { +# data: String, +# } +# +# impl Drop for CustomSmartPointer { +# fn drop(&mut self) { +# println!("Dropping CustomSmartPointer!"); +# } +# } +# +fn main() { + let c = CustomSmartPointer { data: String::from("some data") }; + println!("CustomSmartPointer created."); + drop(c); + println!("CustomSmartPointer dropped before the end of main."); } ``` -这个函数对于`T`是泛型的，所以可以传递任何值。这个函数的函数体并没有任何实际内容，所以它也不会利用其参数。这个空函数的作用在于`drop`获取其参数的所有权，它意味着在这个函数结尾`x`离开作用域时`x`会被丢弃。 +示例 15-18: 在值离开作用域之前调用 `std::mem::drop` 显式清理 + +运行这段代码会打印出如下： + +```text +CustomSmartPointer created. +Dropping CustomSmartPointer with data `some data`! +CustomSmartPointer dropped before the end of main. +``` + + + + +```Dropping CustomSmartPointer with data `some data`!``` 出现在 `CustomSmartPointer created.` 和 `CustomSmartPointer dropped before the end of main.` 之间，表明了 `drop` 方法被调用了并在此丢弃了 `c`。 + + + + +`Drop` trait 实现中指定的代码可以用于许多方面来使得清理变得方便和安全：比如可以用其创建我们自己的内存分配器！通过 `Drop` trait 和 Rust 所有权系统，你无需担心之后清理代码，Rust 会自动考虑这些问题。 + +我们也无需担心意外的清理掉仍在使用的值，这会造成编译器错误：所有权系统确保引用总是有效的，也会确保 `drop` 只会在值不再被使用时被调用一次。 + + 使用`Drop` trait 实现指定的代码在很多方面都使得清理值变得方便和安全：比如可以使用它来创建我们自己的内存分配器！通过`Drop` trait 和 Rust 所有权系统，就无需担心之后清理代码，因为 Rust 会自动考虑这些问题。如果代码在值仍被使用时就清理它会出现编译错误，因为所有权系统确保了引用总是有效的，这也就保证了`drop`只会在值不再被使用时被调用一次。 -现在我们学习了`Box`和一些智能指针的特性，让我们聊聊一些其他标准库中定义的拥有各种实用功能的智能指针。 \ No newline at end of file +现在我们学习了 `Box` 和一些智能指针的特性，让我们聊聊一些其他标准库中定义的智能指针。 \ No newline at end of file diff --git a/src/ch15-04-rc.md b/src/ch15-04-rc.md index 861f77a..49caed7 100644 --- a/src/ch15-04-rc.md +++ b/src/ch15-04-rc.md @@ -2,27 +2,35 @@ > [ch15-04-rc.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-04-rc.md) >
-> commit 3f2a1bd8dbb19cc48b210fc4fb35c305c8d81b56 +> commit 071b97540bca12fd416d2ea7a2daa5d3e9c74400 -大部分情况下所有权是非常明确的：可以准确的知道哪个变量拥有某个值。然而并不总是如此；有时确实可能需要多个所有者。为此，Rust 有一个叫做`Rc`的类型。它的名字是**引用计数**（*reference counting*）的缩写。引用计数意味着它记录一个值引用的数量来知晓这个值是否仍在被使用。如果这个值有零个引用，就知道可以在没有有效引用的前提下清理这个值。 +大部分情况下所有权是非常明确的：可以准确的知道哪个变量拥有某个值。然而，有些情况单个值可能会有多个所有者。例如，在图数据结构中，多个边可能指向相同的结点，而这个结点从概念上讲为所有指向它的边所拥有。结点直到没有任何边指向它之前都不应该被清理。 -根据现实生活场景来想象的话，它就像一个客厅的电视。当一个人进来看电视时，他打开电视。其他人也会进来看电视。当最后一个人离开房间时，他关掉电视因为它不再被使用了。如果某人在其他人还在看的时候关掉了电视，正在看电视人肯定会抓狂的！ + + -`Rc`用于当我们希望在堆上分配一些内存供程序的多个部分读取，而且无法在编译时确定程序的那一部分会最后结束使用它。如果我们知道的话那么常规的所有权规则会在编译时强制起作用。 +为了启用多所有权，Rust 有一个叫做 `Rc` 的类型。其名称为 **引用计数**（*reference counting*）的缩写。引用计数意味着记录一个值引用的数量来知晓这个值是否仍在被使用。如果某个值有零个引用，就代表没有任何有效引用并可以被清理。 -注意`Rc`只能用于单线程场景；下一章并发会涉及到如何在多线程程序中进行引用计数。如果尝试在多线程中使用`Rc`则会得到一个编译错误。 +可以将其想象为客厅中的电视。当一个人进来看电视时，他打开电视。其他人也可以进来看电视。当最后一个人离开房间时，他关掉电视因为它不再被使用了。如果某人在其他人还在看的时候就关掉了电视，正在看电视的人肯定会抓狂的！ -### 使用`Rc`分享数据 +`Rc` 用于当我们希望在堆上分配一些内存供程序的多个部分读取，而且无法在编译时确定程序的那一部分会最后结束使用它的时候。如果确实知道哪部分会结束使用的话，就可以令其成为数据的所有者同时正常的所有权规则就可以在编译时生效。 -让我们回到示例 15-5 中的 cons list 例子。在示例 15-11 中尝试使用`Box`定义的`List`。首先创建了一个包含 5 接着是 10 的列表实例。之后我们想要创建另外两个列表：一个以 3 开始并后接第一个包含 5 和 10 的列表，另一个以 4 开始其后**也**是第一个列表。换句话说，我们希望这两个列表共享第三个列表的所有权，概念上类似于图 15-10： +注意 `Rc` 只能用于单线程场景；第十六章并发会涉及到如何在多线程程序中进行引用计数。 + +### 使用 `Rc` 共享数据 + +让我们回到示例 15-6 中使用 `Box` 定义 cons list 的例子。这一次，我们希望创建两个共享第三个列表所有权的列表，其概念将会看起来如图 15-19 所示： Two lists that share ownership of a third list -图 15-10: 两个列表, `b` 和 `c`, 共享第三个列表 `a` 的所有权 +图 15-19: 两个列表, `b` 和 `c`, 共享第三个列表 `a` 的所有权 -尝试使用`Box`定义的`List`并不能工作，如示例 15-11 所示： +列表 `a` 包含 5 之后是 10，之后是另两个列表：`b` 从 3 开始而 `c` 从 4 开始。`b` 和 `c` 会接上包含 5 和 10 的列表 `a`。换句话说，这两个列表会尝试共享第一个列表所包含的 5 和 10。 -文件: src/main.rs +尝试使用 `Box` 定义的 `List` 并实现不能工作，如示例 15-20 所示： + +文件名: src/main.rs ```rust,ignore enum List { @@ -41,11 +49,11 @@ fn main() { } ``` -示例 15-11: 具有两个使用 `Box` 的列表，试图共享第三个列表的所有权，是不能正常运行的/span> +示例 15-20: 展示不能用两个 `Box` 的列表尝试共享第三个列表的所有权/span> 编译会得出如下错误： -``` +```text error[E0382]: use of moved value: `a` --> src/main.rs:13:30 | @@ -58,11 +66,17 @@ error[E0382]: use of moved value: `a` implement the `Copy` trait ``` -`Cons`成员拥有其储存的数据，所以当创建`b`列表时将`a`的所有权移动到了`b`。接着当再次尝使用`a`创建`c`时，这不被允许因为`a`的所有权已经被移动。 +`Cons` 成员拥有其储存的数据，所以当创建 `b` 列表时，`a` 被移动进了 `b` 这样 `b` 就拥有了 `a`。接着当再次尝使用 `a` 创建 `c` 时，这不被允许因为 `a` 的所有权已经被移动。 -相反可以改变`Cons`的定义来存放一个引用，不过接着必须指定生命周期参数，而且在构造列表时，也必须使列表中的每一个元素都至少与列表本身存在的一样久。否则借用检查器甚至都不会允许我们编译代码。 +可以改变 `Cons` 的定义来存放一个引用，不过接着必须指定生命周期参数。通过指定生命周期参数，表明列表中的每一个元素都至少与列表本身存在的一样久。例如，借用检查器不会允许 `let a = Cons(10, &Nil);` 编译，因为临时值 `Nil` 会在 `a` 获取其引用之前就被丢弃了。 -如示例 15-12 所示，可以将`List`的定义从`Box`改为`Rc`： +相反，我们修改 `List` 的定义为使用 `Rc` 代替 `Box`，如列表 15-21 所示。现在每一个 `Cons` 变量都包含一个值和一个指向 `List` 的 `Rc`。当创建 `b` 时，不同于获取 `a` 的所有权，这里会克隆 `a` 所包含的 `Rc`，这会将引用计数从 1 增加到 2 并允许 `a` 和 `b` 共享 `Rc` 中数据的所有权。创建 `c` 时也会克隆 `a`，这会将引用计数从 2 增加为 3。每次调用 `Rc::clone`，`Rc` 中数据的引用计数都会增加，直到有零个引用之前其数据都不会被清理： + + + 文件名: src/main.rs @@ -77,18 +91,35 @@ use std::rc::Rc; fn main() { let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); - let b = Cons(3, a.clone()); - let c = Cons(4, a.clone()); + let b = Cons(3, Rc::clone(&a)); + let c = Cons(4, Rc::clone(&a)); } ``` -示例 15-12: 使用 `Rc` 定义的 `List` +示例 15-21: 使用 `Rc` 定义的 `List` -注意必须为`Rc`增加`use`语句因为它不在 prelude 中。在`main`中创建了存放 5 和 10 的列表并将其存放在一个叫做`a`的新的`Rc`中。接着当创建`b`和`c`时，我们对`a`调用了`clone`方法。 +需要为 `Rc` 增加`use`语句因为它不在 prelude 中。在 `main` 中创建了存放 5 和 10 的列表并将其存放在 `a` 的新的 `Rc` 中。接着当创建 `b` 和 `c` 时，调用 `Rc::clone` 函数并传递 `a` 中 `Rc` 的引用作为参数。 -### 克隆`Rc`会增加引用计数 +也可以调用 `a.clone()` 而不是 `Rc::clone(&a)`，不过在这里 Rust 的习惯是使用 `Rc::clone`。`Rc::clone` 的实现并不像大部分类型的 `clone` 实现那样对所有数据进行深拷贝。`Rc::clone` 只会增加引用计数，这并不会花费多少时间。深拷贝可能会花费很长时间，所以通过使用 `Rc::clone` 进行引用计数，可以明显的区别可能会对运行时性能有巨大影响的深拷贝和不分配内存的对运行时性能影响相对较小的增加引用计数拷贝。 -之前我们见过`clone`方法，当时使用它来创建某些数据的完整拷贝。但是对于`Rc`来说，它并不创建一个完整的拷贝。`Rc`存放了**引用计数**，也就是说，一个存在多少个克隆的计数器。让我们像示例 15-13 那样在创建`c`时增加一个内部作用域，并在不同的位置打印出关联函数`Rc::strong_count`的结果。`Rc::strong_count`返回传递给它的`Rc`值的引用计数，而在本章的稍后部分介绍避免引用循环时讲到它为什么叫做`strong_count`。 +### 克隆 `Rc` 会增加引用计数 + +让我们修改示例 15-21 的代码以便观察创建和丢弃 `a` 中 `Rc` 的引用时引用计数的变化。 + + + + +在示例 15-22 中，修改了 `main` 以便将列表 `c` 置于内部作用域中，这样就可以观察当 `c` 离开作用域时引用计数如何变化。在程序中每个引用计数变化的点，会打印出引用计数，其值可以通过调用 `Rc::strong_count` 函数获得。在本章稍后的部分讨论避免引用循环时会解释为何这个函数叫做 `strong_count` 而不是 `count`。 + + + 文件名: src/main.rs @@ -103,28 +134,34 @@ fn main() { # fn main() { let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil))))); - println!("rc = {}", Rc::strong_count(&a)); - let b = Cons(3, a.clone()); - println!("rc after creating b = {}", Rc::strong_count(&a)); + println!("count after creating a = {}", Rc::strong_count(&a)); + let b = Cons(3, Rc::clone(&a)); + println!("count after creating b = {}", Rc::strong_count(&a)); { - let c = Cons(4, a.clone()); - println!("rc after creating c = {}", Rc::strong_count(&a)); + let c = Cons(4, Rc::clone(&a)); + println!("count after creating c = {}", Rc::strong_count(&a)); } - println!("rc after c goes out of scope = {}", Rc::strong_count(&a)); + println!("count after c goes out of scope = {}", Rc::strong_count(&a)); } ``` -示例 15-13: 打印输出引用计数 +示例 15-22：打印出引用计数 这会打印出： -``` -rc = 1 -rc after creating b = 2 -rc after creating c = 3 -rc after c goes out of scope = 2 +```text +count after creating a = 1 +count after creating b = 2 +count after creating c = 3 +count after c goes out of scope = 2 ``` -不难看出`a`的初始引用计数是一。接着每次调用`clone`，计数会加一。当`c`离开作用域时，计数减一，这发生在`Rc`的`Drop` trait 实现中。这个例子中不能看到的是当`b`接着是`a`在`main`函数的结尾离开作用域时，包含 5 和 10 的列表的引用计数会是 0，这时列表将被丢弃。这个策略允许拥有多个所有者，而引用计数会确保任何所有者存在时这个值保持有效。 + + -在本部分的开始，我们说`Rc`只允许程序的多个部分读取`Rc`中`T`的不可变引用。如果`Rc`允许一个可变引用，我们将遇到第四章讨论的借用规则所不允许的问题：两个指向同一位置的可变借用会导致数据竞争和不一致。不过可变数据是非常有用的！在下一部分，我们将讨论内部可变性模式和`RefCell`类型，它可以与`Rc`结合使用来处理不可变性的限制。 +我们能够看到 `a` 中 `Rc` 的初始引用计数为一，接着每次调用 `clone`，计数会增加一。当 `c` 离开作用域时，计数减一。不必像调用 `Rc::clone` 增加引用计数那样调用一个函数来减少计数；`Drop` trait 的实现当 `Rc` 值离开作用域时自动减少引用计数。 + +从这个例子我们所不能看到的是在 `main` 的结尾当 `b` 然后是 `a` 离开作用域时，此处计数会是 0，同时 `Rc` 被完全清理。使用 `Rc` 允许一个值有多个所有者，引用计数则确保只要任何所有者依然存在其值也保持有效。 + +`Rc` 允许通过不可变引用来只读的在程序的多个部分共享数据。如果 `Rc` 也允许多个可变引用，则会违反第四章讨论的借用规则之一：相同位置的多个可变借用可能造成数据竞争和不一致。不过可以修改数据是非常有用的！在下一部分，我们将讨论内部可变性模式和 `RefCell` 类型，它可以与 `Rc` 结合使用来处理不可变性的限制。 diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index d2fcda3..68c0909 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -1,126 +1,300 @@ -## `RefCell`和内部可变性模式 +## `RefCell` 和内部可变性模式 > [ch15-05-interior-mutability.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-05-interior-mutability.md) >
-> commit 3f2a1bd8dbb19cc48b210fc4fb35c305c8d81b56 +> commit 54169ef43f57847913ebec7e021c1267663a5d12 -**内部可变性**（*Interior mutability*）是 Rust 中的一个设计模式，它允许你即使在有不可变引用时改变数据，这通常是借用规则所不允许。内部可变性模式涉及到在数据结构中使用`unsafe`代码来模糊 Rust 通常的可变性和借用规则。我们还未讲到不安全代码；第十九章会学习他们。内部可变性模式用于当你可以确保代码在运行时也会遵守借用规则，哪怕编译器也不能保证的情况。引入的`unsafe`代码将被封装进安全的 API 中，而外部类型仍然是不可变的。 + + -让我们通过遵循内部可变性模式的`RefCell`类型来开始探索。 + + -### `RefCell`拥有内部可变性 +**内部可变性**（*Interior mutability*）是 Rust 中的一个设计模式，它允许你即使在有不可变引用时改变数据，这通常是借用规则所不允许的。为此，该模式在数据结构中使用 `unsafe` 代码来模糊 Rust 通常的可变性和借用规则。我们还未讲到不安全代码；第十九章会学习它们。当可以确保代码在运行时会遵守借用规则，即使编译器不能保证的情况，可以选择使用那些运用内部可变性模式的类型。所涉及的 `unsafe` 代码将被封装进安全的 API 中，而外部类型仍然是不可变的。 -不同于`Rc`，`RefCell`代表其数据的唯一的所有权。那么是什么让`RefCell`不同于像`Box`这样的类型呢？回忆一下第四章所学的借用规则： +让我们通过遵循内部可变性模式的 `RefCell` 类型来开始探索。 -1. 在任意给定时间，**只能**拥有如下中的一个： +### 通过 `RefCell` 在运行时检查借用规则 + +不同于 `Rc`，`RefCell` 代表其数据的唯一的所有权。那么是什么让 `RefCell` 不同于像 `Box` 这样的类型呢？回忆一下第四章所学的借用规则： + +1. 在任意给定时间，**只能** 拥有如下中的一个： * 一个可变引用。 * 任意数量的不可变引用。 2. 引用必须总是有效的。 -对于引用和`Box`，借用规则的不可变性作用于编译时。对于`RefCell`，这些不可变性作用于**运行时**。对于引用，如果违反这些规则，会得到一个编译错误。而对于`RefCell`，违反这些规则会`panic!`。 +对于引用和 `Box`，借用规则的不可变性作用于编译时。对于 `RefCell`，这些不可变性作用于 **运行时**。对于引用，如果违反这些规则，会得到一个编译错误。而对于`RefCell`，违反这些规则会 `panic!`。 -Rust 编译器执行的静态分析天生是保守的。代码的一些属性则不可能通过分析代码发现：其中最著名的就是[停机问题（Halting Problem）](https://zh.wikipedia.org/wiki/%E5%81%9C%E6%9C%BA%E9%97%AE%E9%A2%98)，这超出了本书的范畴，不过如果你感兴趣的话这是一个值得研究的有趣主题。 + + -因为一些分析是不可能的，Rust 编译器在其不确定的时候甚至都不尝试猜测，所以说它是保守的而且有时会拒绝事实上不会违反 Rust 保证的正确的程序。换句话说，如果 Rust 接受不正确的程序，那么人们也就不会相信 Rust 所做的保证了。如果 Rust 拒绝正确的程序，会给程序员带来不便，但不会带来灾难。`RefCell`正是用于当你知道代码遵守借用规则，而编译器不能理解的时候。 +在编译时检查借用规则的好处是这些错误将在开发过程的早期被捕获同时对没有运行时性能影响，因为所有的分析都提前完成了。为此，在编译时检查借用规则是大部分情况的最佳选择，这也正是其为何是 Rust 的默认行为。 -类似于`Rc`，`RefCell`只能用于单线程场景。在并发章节会介绍如何在多线程程序中使用`RefCell`的功能。现在所有你需要知道的就是如果尝试在多线程上下文中使用`RefCell`，会得到一个编译错误。 +相反在运行时检查借用规则的好处是特定内存安全的场景是允许的，而它们在编译时检查中是不允许的。静态分析，正如 Rust 编译器，是天生保守的。代码的一些属性则不可能通过分析代码发现：其中最著名的就是 [停机问题（Halting Problem）](https://zh.wikipedia.org/wiki/%E5%81%9C%E6%9C%BA%E9%97%AE%E9%A2%98)，这超出了本书的范畴，不过如果你感兴趣的话这是一个值得研究的有趣主题。 -对于引用，可以使用`&`和`&mut`语法来分别创建不可变和可变的引用。不过对于`RefCell`，我们使用`borrow`和`borrow_mut`方法，它是`RefCell`拥有的安全 API 的一部分。`borrow`返回`Ref`类型的智能指针，而`borrow_mut`返回`RefMut`类型的智能指针。这两个类型实现了`Deref`所以可以被当作常规引用处理。`Ref`和`RefMut`动态的借用所有权，而他们的`Drop`实现也动态的释放借用。 + + -示例 15-14 展示了如何使用`RefCell`来使函数不可变的和可变的借用它的参数。注意`data`变量使用`let data`而不是`let mut data`来声明为不可变的，而`a_fn_that_mutably_borrows`则允许可变的借用数据并修改它！ +因为一些分析是不可能的，如果 Rust 编译器不能通过所有权规则编译，它可能会拒绝一个正确的程序；从这种角度考虑它是保守的。如果 Rust 接受不正确的程序，那么人们也就不会相信 Rust 所做的保证了。然而，如果 Rust 拒绝正确的程序，会给程序员带来不便，但不会带来灾难。`RefCell` 正是用于当你确信代码遵守借用规则，而编译器不能理解和确定的时候。 -文件名: src/main.rs +类似于 `Rc`，`RefCell` 只能用于单线程场景。如果尝试在多线程上下文中使用`RefCell`，会得到一个编译错误。第十六章会介绍如何在多线程程序中使用 `RefCell` 的功能。 -```rust -use std::cell::RefCell; + + -fn a_fn_that_immutably_borrows(a: &i32) { - println!("a is {}", a); -} +如下为选择 `Box`，`Rc` 或 `RefCell` 的理由： -fn a_fn_that_mutably_borrows(b: &mut i32) { - *b += 1; -} +- `Rc` 允许相同数据有多个所有者；`Box` 和 `RefCell` 有单一所有者。 +- `Box` 允许在编译时检查的不可变或可变借用；`RefCell` 允许在运行时价差的不可变或可变借用 +- 因为 `RefCell` 允许在运行时检查的可变借用，可以在即便 `RefCell` 自身是不可变的情况下修改其内部的值。 -fn demo(r: &RefCell) { - a_fn_that_immutably_borrows(&r.borrow()); - a_fn_that_mutably_borrows(&mut r.borrow_mut()); - a_fn_that_immutably_borrows(&r.borrow()); -} +最有一个理由便是指 **内部可变性** 模式。让我们看看何时内部可变性是有用的，并讨论这是如何成为可能的。 -fn main() { - let data = RefCell::new(5); - demo(&data); -} -``` +### 内部可变性：不可变值的可变借用 -示例 15-14: 使用 `RefCell`, `borrow` 和 -`borrow_mut` - -这个例子打印出： - -``` -a is 5 -a is 6 -``` - -在`main`函数中，我们新声明了一个包含值 5 的`RefCell`，并储存在变量`data`中，声明时并没有使用`mut`关键字。接着使用`data`的一个不可变引用来调用`demo`函数：对于`main`函数而言`data`是不可变的！ - -在`demo`函数中，通过调用`borrow`方法来获取到`RefCell`中值的不可变引用，并使用这个不可变引用调用了`a_fn_that_immutably_borrows`函数。更为有趣的是，可以通过`borrow_mut`方法来获取`RefCell`中值的**可变**引用，而`a_fn_that_mutably_borrows`函数就允许修改这个值。可以看到下一次调用`a_fn_that_immutably_borrows`时打印出的值是 6 而不是 5。 - -### `RefCell`在运行时检查借用规则 - -回忆一下第四章因为借用规则，尝试使用常规引用在同一作用域中创建两个可变引用的代码无法编译： +借用规则的一个推论是当有一个不可变值时，不能可变的借用它。例如，如下代码不能编译： ```rust,ignore -let mut s = String::from("hello"); - -let r1 = &mut s; -let r2 = &mut s; -``` - -这会得到一个编译错误： - -``` -error[E0499]: cannot borrow `s` as mutable more than once at a time - --> - | -5 | let r1 = &mut s; - | - first mutable borrow occurs here -6 | let r2 = &mut s; - | ^ second mutable borrow occurs here -7 | } - | - first borrow ends here -``` - -与此相反，使用`RefCell`并在同一作用域调用两次`borrow_mut`的代码是**可以**编译的，不过它会在运行时 panic。如下代码： - -```rust,should_panic -use std::cell::RefCell; - fn main() { - let s = RefCell::new(String::from("hello")); - - let r1 = s.borrow_mut(); - let r2 = s.borrow_mut(); + let x = 5; + let y = &mut x; } ``` -能够编译不过在`cargo run`运行时会出现如下错误： +如果尝试编译，会得到如下错误： +```text +error[E0596]: cannot borrow immutable local variable `x` as mutable + --> src/main.rs:3:18 + | +2 | let x = 5; + | - consider changing this to `mut x` +3 | let y = &mut x; + | ^ cannot borrow mutably ``` - Finished dev [unoptimized + debuginfo] target(s) in 0.83 secs - Running `target/debug/refcell` -thread 'main' panicked at 'already borrowed: BorrowMutError', -/stable-dist-rustc/build/src/libcore/result.rs:868 + +然而，特定情况下在值的方法内部能够修改自身是很有用的；而不是在其他代码中，此时值仍然是不可变。值方法外部的代码不能修改其值。`RefCell` 是一个获得内部可变性的方法。`RefCell` 并没有完全绕开借用规则，编译器中的借用检查器允许内部可变性并相应的在运行时检查借用规则。如果违反了这些规则，会得到 `panic!` 而不是编译错误。 + +让我们通过一个实际的例子来探索何处可以使用 `RefCell` 来修改不可变值并看看为何这么做是有意义的。 + +#### 内部可变性的用例：mock 对象 + +**测试替身**（*test double*）是一个通用编程概念，它代表一个在测试中替代某个类型的类型。**mock 对象** 是特定类型的测试替身，它们记录测试过程中发生了什么以便可以断言操作是正确的。 + +虽然 Rust 没有与其他语言中的对象完全相同的对象，Rust 也没有像其他语言那样在标准库中内建 mock 对象功能，不过我们确实可以创建一个与 mock 对象有着相同功能的结构体。 + +如下是一个我们想要测试的场景：我们在编写一个记录某个值与最大值的差距的库，并根据当前值与最大值的差距来发送消息。例如，这个库可以用于记录用户所允许的 API 调用数量限额。 + +该库只提供记录与最大值的差距，以及何种情况发送什么消息的功能。使用此库的程序则期望提供实际发送消息的机制：程序可以选择记录一条消息、发送 email、发送短信等等。库本身无需知道这些细节；只需实现其提供的 `Messenger` trait 即可。示例 15-23 展示了库代码： + +文件名: src/lib.rs + +```rust +pub trait Messenger { + fn send(&self, msg: &str); +} + +pub struct LimitTracker<'a, T: 'a + Messenger> { + messenger: &'a T, + value: usize, + max: usize, +} + +impl<'a, T> LimitTracker<'a, T> + where T: Messenger { + pub fn new(messenger: &T, max: usize) -> LimitTracker { + LimitTracker { + messenger, + value: 0, + max, + } + } + + pub fn set_value(&mut self, value: usize) { + self.value = value; + + let percentage_of_max = self.value as f64 / self.max as f64; + + if percentage_of_max >= 0.75 && percentage_of_max < 0.9 { + self.messenger.send("Warning: You've used up over 75% of your quota!"); + } else if percentage_of_max >= 0.9 && percentage_of_max < 1.0 { + self.messenger.send("Urgent warning: You've used up over 90% of your quota!"); + } else if percentage_of_max >= 1.0 { + self.messenger.send("Error: You are over your quota!"); + } + } +} +``` + +示例 15-23：一个记录某个值与最大值差距的库，并根据此值的特定级别发出警告 + +这些代码中一个重要部分是拥有一个方法 `send` 的 `Messenger` trait，其获取一个 `self` 的可变引用和文本信息。这是我们的 mock 对象所需要拥有的接口。另一个重要的部分是我们需要测试 `LimitTracker` 的 `set_value` 方法的行为。可以改变传递的 `value` 参数的值，不过 `set_value` 并没有返回任何可供断言的值。也就是说，如果使用某个实现了 `Messenger` trait 的值和特定的 `max` 创建 `LimitTracker`，当传递不同 `value` 值时，消息发送者应被告知发送合适的消息。 + +我们所需的 mock 对象是，调用 `send` 不同于实际发送 email 或短息，其只记录信息被通知要发送了。可以新建一个 mock 对象示例，用其创建 `LimitTracker`，调用 `LimitTracker` 的 `set_value` 方法，然后检查 mock 对象是否有我们期望的消息。示例 15-24 展示了一个如此尝试的 mock 对象实现，不过借用检查器并不允许： + +文件名: src/lib.rs + +```rust +#[cfg(test)] +mod tests { + use super::*; + + struct MockMessenger { + sent_messages: Vec, + } + + impl MockMessenger { + fn new() -> MockMessenger { + MockMessenger { sent_messages: vec![] } + } + } + + impl Messenger for MockMessenger { + fn send(&self, message: &str) { + self.sent_messages.push(String::from(message)); + } + } + + #[test] + fn it_sends_an_over_75_percent_warning_message() { + let mock_messenger = MockMessenger::new(); + let mut limit_tracker = LimitTracker::new(&mock_messenger, 100); + + limit_tracker.set_value(80); + + assert_eq!(mock_messenger.sent_messages.len(), 1); + } +} +``` + +示例 15-24：尝试实现 `MockMessenger`，借用检查器并不允许 + +测试代码定义了一个 `MockMessenger` 结构体，其 `sent_messages` 字段为一个 `String` 值的 `Vec` 用来记录被告知发送的消息。我们还定义了一个关联函数 `new` 以便于新建从空消息列表开始的 `MockMessenger` 值。接着为 `MockMessenger` 实现 `Messenger` trait 这样就可以为 `LimitTracker` 提供一个 `MockMessenger`。在 `send` 方法的定义中，获取传入的消息作为参数并储存在 `MockMessenger` 的 `sent_messages` 列表中。 + +在测试中，我们测试了当 `LimitTracker` 被告知将 `value` 设置为超过 `max` 值 75% 的某个值。首先新建一个 `MockMessenger`，其从空消息列表开始。接着新建一个 `LimitTracker` 并传递新建 `MockMessenger` 的引用和 `max` 值 100。我们使用值 80 调用 `LimitTracker` 的 `set_value` 方法，这超过了 100 的 75%。接着断言 `MockMessenger` 中记录的消息列表应该有一条消息。 + +然而，这个测试是有问题的： + +```text +error[E0596]: cannot borrow immutable field `self.sent_messages` as mutable + --> src/lib.rs:46:13 + | +45 | fn send(&self, message: &str) { + | ----- use `&mut self` here to make mutable +46 | self.sent_messages.push(String::from(message)); + | ^^^^^^^^^^^^^^^^^^ cannot mutably borrow immutable field +``` + +不能修改 `MockMessenger` 来记录消息，因为 `send` 方法获取 `self` 的不可变引用。我们也不能参考错误文本的建议使用 `&mut self` 替代，因为这样 `send` 的签名就不符合 `Messenger` trait 定义中的签名了（请随意尝试如此修改并看看会出现什么错误信息）。 + +这正是内部可变性的用武之地！我们将通过 `RefCell` 来储存 `sent_messages`，然而 `send` 将能够修改 `sent_messages` 并储存消息。示例 15-25 展示了代码： + +文件名: src/lib.rs + +```rust +#[cfg(test)] +mod tests { + use super::*; + use std::cell::RefCell; + + struct MockMessenger { + sent_messages: RefCell>, + } + + impl MockMessenger { + fn new() -> MockMessenger { + MockMessenger { sent_messages: RefCell::new(vec![]) } + } + } + + impl Messenger for MockMessenger { + fn send(&self, message: &str) { + self.sent_messages.borrow_mut().push(String::from(message)); + } + } + + #[test] + fn it_sends_an_over_75_percent_warning_message() { + // --snip-- +# let mock_messenger = MockMessenger::new(); +# let mut limit_tracker = LimitTracker::new(&mock_messenger, 100); +# limit_tracker.set_value(75); + + assert_eq!(mock_messenger.sent_messages.borrow().len(), 1); + } +} +``` + +示例 15-25：使用 `RefCell` 能够在外部值被认为是不可变的情况下修改内部值 + +现在 `sent_messages` 字段的类型是 `RefCell>` 而不是 `Vec`。在 `new` 函数中新建了一个 `RefCell` 示例替代空 vector。 + +对于 `send` 方法的实现，第一个参数仍为 `self` 的不可变借用，这是符合方法定义的。我们调用 `self.sent_messages` 中 `RefCell` 的 `borrow_mut` 方法来获取 `RefCell` 中值的可变引用，这是一个 vector。接着可以对 vector 的可变引用调用 `push` 以便记录测试过程中看到的消息。 + +最后必须做出的修改位于断言中：为了看到其内部 vector 中有多少个项，需要调用 `RefCell` 的 `borrow` 以获取 vector 的不可变引用。 + +现在我们见识了如何使用 `RefCell`，让我们研究一下它怎样工作的！ + +### `RefCell` 在运行时检查借用规则 + +当创建不可变和可变引用时，我们分别使用 `&` 和 `&mut` 语法。对于 `RefCell` 来说，则是 `borrow` 和 `borrow_mut` 方法，这属于 `RefCell` 安全 API 的一部分。`borrow` 方法返回 `Ref` 类型的智能指针，`borrow_mut` 方法返回 `RefMut` 类型的智能指针。这两个类型都实现了 `Deref` 所以可以当作常规引用对待。 + + + + +`RefCell` 记录当前有多少个活动的 `Ref` 和 `RefMut` 智能指针。每次调用 `borrow`，`RefCell` 将活动的不可变借用计数加一。当 `Ref` 值离开作用域时，不可变借用计数减一。就像编译时借用规则一样，`RefCell` 在任何时候只允许有多个不可变借用或一个可变借用。 + +如果我们尝试违反这些规则，相比引用时的编译时错误，`RefCell` 的实现会在运行时 `panic!`。示例 15-26 展示了对示例 15-25 中 `send` 实现的修改，这里我们故意尝试在相同作用域创建两个可变借用以便演示 `RefCell` 不允许我们在运行时这么做： + +文件名: src/lib.rs + +```rust,ignore +impl Messenger for MockMessenger { + fn send(&self, message: &str) { + let mut one_borrow = self.sent_messages.borrow_mut(); + let mut two_borrow = self.sent_messages.borrow_mut(); + + one_borrow.push(String::from(message)); + two_borrow.push(String::from(message)); + } +} +``` + +示例 15-26：在同一作用域中创建连个可变引用并观察 `RefCell` panic + +这里为 `borrow_mut` 返回的 `RefMut` 智能指针创建了 `one_borrow` 变量。接着用相同的方式在变量 `two_borrow` 创建了另一个可变借用。这会在相同作用域中创建一个可变引用，这是不允许的，如果运行库的测试，编译时不会有任何错误，不过测试会失败： + +```text +---- tests::it_sends_an_over_75_percent_warning_message stdout ---- + thread 'tests::it_sends_an_over_75_percent_warning_message' panicked at + 'already borrowed: BorrowMutError', src/libcore/result.rs:906:4 note: Run with `RUST_BACKTRACE=1` for a backtrace. ``` -这个运行时`BorrowMutError`类似于编译错误：它表明我们已经可变得借用过一次`s`了，所以不允许再次借用它。我们并没有绕过借用规则，只是选择让 Rust 在运行时而不是编译时执行他们。你可以选择在任何时候任何地方使用`RefCell`，不过除了不得不编写很多`RefCell`之外，最终还是可能会发现其中的问题（可能是在生产环境而不是开发环境）。另外，在运行时检查借用规则有性能惩罚。 +可以看到代码 panic 和信息`already borrowed: BorrowMutError`。这也就是 `RefCell` 如何在运行时处理违反借用规则的情况。 -### 结合`Rc`和`RefCell`来拥有多个可变数据所有者 +在运行时捕获借用错误而不是编译时意味着将会在开发过程的后期才会发现错误 ———— 甚至有可能发布到生产环境才发现。还会因为在运行时而不是编译时记录借用而导致少量的运行时性能惩罚。然而，使用 `RefCell` 使得在只允许不可变值的上下文中编写修改自身以记录消息的 mock 对象成为可能。虽然有取舍，但是我们可以选择使用 `RefCell` 来获得比常规引用所能提供的更多的功能。 -那么为什么要权衡考虑选择引入`RefCell`呢？好吧，还记得我们说过`Rc`只能拥有一个`T`的不可变引用吗？考虑到`RefCell`是不可变的，但是拥有内部可变性，可以将`Rc`与`RefCell`结合来创造一个既有引用计数又可变的类型。示例 15-15 展示了一个这么做的例子，再次回到示例 15-5 中的 cons list。在这个例子中，不同于在 cons list 中储存`i32`值，我们储存一个`Rc>`值。希望储存这个类型是因为其可以拥有不属于列表一部分的这个值的所有者（`Rc`提供的多个所有者功能），而且还可以改变内部的`i32`值（`RefCell`提供的内部可变性功能）： +### 结合 `Rc` 和 `RefCell` 来拥有多个可变数据所有者 + +`RefCell` 的一个常见用法是与 `Rc` 结合。回忆一下 `Rc` 允许对相同数据有多个所有者，不过只能提供数据的不可变访问。如果有一个储存了 `RefCell` 的 `Rc` 的话，就可以得到有多个所有者 **并且** 可以修改的值了！ + + + + +例如，回忆示例 15-13 的 cons list 的例子中使用 `Rc` 使得多个列表共享另一个列表的所有权。因为 `Rc` 只存放不可变值，所以一旦创建了这些列表值后就不能修改。让我们加入 `RefCell` 来获得修改列表中值的能力。示例 15-27 展示了通过在 `Cons` 定义中使用 `RefCell`，我们就允许修改所有列表中的值了： 文件名: src/main.rs @@ -138,34 +312,39 @@ use std::cell::RefCell; fn main() { let value = Rc::new(RefCell::new(5)); - let a = Cons(value.clone(), Rc::new(Nil)); - let shared_list = Rc::new(a); + let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil))); - let b = Cons(Rc::new(RefCell::new(6)), shared_list.clone()); - let c = Cons(Rc::new(RefCell::new(10)), shared_list.clone()); + let b = Cons(Rc::new(RefCell::new(6)), Rc::clone(&a)); + let c = Cons(Rc::new(RefCell::new(10)), Rc::clone(&a)); *value.borrow_mut() += 10; - println!("shared_list after = {:?}", shared_list); + println!("a after = {:?}", a); println!("b after = {:?}", b); println!("c after = {:?}", c); } ``` -示例 15-15: 使用 `Rc>` 创建能够修改的 `List` +示例 15-27：使用 `Rc>` 创建可以修改的 `List` -我们创建了一个值，它是`Rc>`的实例。将其储存在变量`value`中因为我们希望之后能直接访问它。接着在`a`中创建了一个拥有存放了`value`值的`Cons`成员的`List`，而且`value`需要被克隆因为我们希望除了`a`之外还拥有`value`的所有权。接着将`a`封装进`Rc`中这样就可以创建都引用`a`的有着不同开头的列表`b`和`c`，类似示例 15-12 中所做的那样。 +这里创建了一个 `Rc` 实例并储存在变量 `value` 中以便之后直接访问。接着在 `a` 中用包含 `value` 的 `Cons` 成员创建了一个 `List`。需要克隆 `value` 以便 `a` 和 `value` 都能拥有其内部值 `5` 的所有权，而不是将所有权从 `value` 移动到 `a` 或者让 `a` 借用 `value`。 -一旦创建了`shared_list`、`b`和`c`，接下来就可以通过解引用`Rc`和对`RefCell`调用`borrow_mut`来将 10 与 5 相加了。 + + -当打印出`shared_list`、`b`和`c`时，可以看到他们都拥有被修改的值 15： +我们将列表 `a` 封装进了 `Rc` 这样当创建列表 `b` 和 `c` 时，他们都可以引用 `a`，正如示例 15-13 一样。 -``` -shared_list after = Cons(RefCell { value: 15 }, Nil) +一旦创建了列表 `a`、`b` 和 `c`，我们将 `value` 的值加 10。为此对 `value` 调用了 `borrow_mut`，这里使用了第五章讨论的自定解引用功能（“`->`运算符到哪去了？”）来解引用 `Rc` 以获取其内部的 `RefCell` 值。`borrow_mut` 方法返回 `RefMut` 智能指针，可以对其使用解引用运算符并修改其内部值。 + +当我们打印出 `a`、`b` 和 `c` 时，可以看到他们都拥有修改后的值 15 而不是 5： + +```text +a after = Cons(RefCell { value: 15 }, Nil) b after = Cons(RefCell { value: 6 }, Cons(RefCell { value: 15 }, Nil)) c after = Cons(RefCell { value: 10 }, Cons(RefCell { value: 15 }, Nil)) ``` -这是非常巧妙的！通过使用`RefCell`，我们可以拥有一个表面上不可变的`List`，不过可以使用`RefCell`中提供内部可变性的方法来在需要时修改数据。`RefCell`的运行时借用规则检查也确实保护我们免于出现数据竞争，而且我们也决定牺牲一些速度来换取数据结构的灵活性。 +这是非常巧妙的！通过使用 `RefCell`，我们可以拥有一个表面上不可变的 `List`，不过可以使用 `RefCell` 中提供内部可变性的方法来在需要时修改数据。`RefCell` 的运行时借用规则检查也确实保护我们免于出现数据竞争，而且我们也决定牺牲一些速度来换取数据结构的灵活性。 -`RefCell`并不是标准库中唯一提供内部可变性的类型。`Cell`有点类似，不过不同于`RefCell`那样提供内部值的引用，其值被拷贝进和拷贝出`Cell`。`Mutex`提供线程间安全的内部可变性，下一章并发会讨论它的应用。请查看标准库来获取更多细节和不同类型的区别。 +标准库中也有其他提供内部可变性的类型，比如 `Cell`，它有些类似（`RefCell`）除了相比提供内部值的引用，其值被拷贝进和拷贝出 `Cell`。还有 `Mutex`，其提供线程间安全的内部可变性，下一章并发会讨论它的应用。请查看标准库来获取更多细节和不同类型之间的区别。 From 984edcae090131f31771c0896340e6d8ed481e5c Mon Sep 17 00:00:00 2001 From: lyrachord Date: Sun, 28 Jan 2018 19:43:13 +0800 Subject: [PATCH 124/150] =?UTF-8?q?=E4=BF=AE=E6=94=B9=20=E9=80=9A=E7=94=A8?= =?UTF-8?q?=20=E4=B8=BA=20=E5=B8=B8=E8=A7=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 仅仅是建议修改通用。很多语言的概念已经严重过时。比如keyword，在精确语法中（context-sensitive）根本就没有keyword这一说。建议不要局限在老东西上，工作更有价值 --- src/ch03-00-common-programming-concepts.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch03-00-common-programming-concepts.md b/src/ch03-00-common-programming-concepts.md index 5b6cd65..bfd145a 100644 --- a/src/ch03-00-common-programming-concepts.md +++ b/src/ch03-00-common-programming-concepts.md @@ -1,4 +1,4 @@ -# 通用编程概念 +# 常见编程概念 > [ch03-00-common-programming-concepts.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch03-00-common-programming-concepts.md) >
From e9186fb9bbd27c4a9856605adc0fe89b469b9a77 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Sun, 28 Jan 2018 20:01:27 +0800 Subject: [PATCH 125/150] check to ch15-06 --- src/SUMMARY.md | 2 +- src/ch15-06-reference-cycles.md | 271 +++++++++++++++++++++++++------- 2 files changed, 216 insertions(+), 57 deletions(-) diff --git a/src/SUMMARY.md b/src/SUMMARY.md index 449d2f4..2bb99c4 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -86,7 +86,7 @@ - [`Drop` Trait 运行清理代码](ch15-03-drop.md) - [`Rc` 引用计数智能指针](ch15-04-rc.md) - [`RefCell` 和内部可变性模式](ch15-05-interior-mutability.md) - - [引用循环和内存泄漏是安全的](ch15-06-reference-cycles.md) + - [引用循环与内存泄漏](ch15-06-reference-cycles.md) - [无畏并发](ch16-00-concurrency.md) - [线程](ch16-01-threads.md) diff --git a/src/ch15-06-reference-cycles.md b/src/ch15-06-reference-cycles.md index 39587d4..3d49d89 100644 --- a/src/ch15-06-reference-cycles.md +++ b/src/ch15-06-reference-cycles.md @@ -1,18 +1,22 @@ -## 引用循环和内存泄漏是安全的 +## 引用循环与内存泄漏 > [ch15-06-reference-cycles.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch15-06-reference-cycles.md) >
-> commit 9430a3d28a2121a938d704ce48b15d21062f880e +> commit cd7d9bcfb099c224439db0ba3b02956d9843864d -我们讨论过 Rust 做出的一些保证，例如永远也不会遇到一个空值，而且数据竞争也会在编译时被阻止。Rust 的内存安全保证也使其更难以制造从不被清理的内存，这被称为**内存泄露**。然而 Rust 并不是**不可能**出现内存泄漏，避免内存泄露**并**不是 Rust 的保证之一。换句话说，内存泄露是安全的。 +Rust 的内存安全保证使其 **难以** 意外的制造永远也不会被清理的内存（被称为 **内存泄露**（*memory leak*）），但并不是不可能。完全的避免内存泄露并不是同在编译时拒绝数据竞争一样为 Rust 的保证之一，这意味着内存泄露在 Rust 被认为是内存安全的。这一点可以通过 `Rc` 和 `RefCell` 看出：有可能会创建个个项之间相互引用的引用。这会造成内存泄露，因为每一项的引用计数将永远也到不了 0，其值也永远也不会被丢弃。 -在使用`Rc`和`RefCell`时，有可能创建循环引用，这时各个项相互引用并形成环。这是不好的因为每一项的引用计数将永远也到不了 0，其值也永远也不会被丢弃。让我们看看这是如何发生的以及如何避免它。 +### 制造引用循环 -在示例 15-16 中，我们将使用示例 15-5 中`List`定义的另一个变体。我们将回到储存`i32`值作为`Cons`成员的第一个元素。现在`Cons`成员的第二个元素是`RefCell>`：这时就不能修改`i32`值了，但是能够修改`Cons`成员指向的那个`List`。还需要增加一个`tail`方法来方便我们在拥有一个`Cons`成员时访问第二个项： +让我们看看引用循环是如何发生的以及如何避免它。以示例 15-28 中的 `List` 枚举和 `tail` 方法的定义开始： 文件名: src/main.rs ```rust,ignore +use std::rc::Rc; +use std::cell::RefCell; +use List::{Cons, Nil}; + #[derive(Debug)] enum List { Cons(i32, RefCell>), @@ -29,13 +33,32 @@ impl List { } ``` -示例 15-16: 持有 `RefCell` 的 cons 列表定义，我们不能修改 `Cons` 变体引用的内容/span> +示例：一个存放 `RefCell` 的 cons list 定义，这样可以修改 `Cons` 成员所引用的数据 -接下来，在示例 15-17 中，我们将在变量`a`中创建一个`List`值，其内部是一个`5, Nil`的列表。接着在变量`b`创建一个值 10 和指向`a`中列表的`List`值。最后修改`a`指向`b`而不是`Nil`，这会创建一个循环： +这里采用了示例 15-6 中 `List` 定义的另一种变体。现在 `Cons` 成员的第二个元素是 `RefCell>`，这意味着不同于像示例 15-19 那样能够修改 `i32` 的值，我们希望能够修改 `Cons` 成员所指向的 `List`。这里还增加了一个 `tail` 方法来方便我们在有 `Cons` 成员的时候访问其第二项。 -文件名: src/main.rs + + + +在示例 15-29 中增加了一个 `main` 函数，其使用了示例 15-28 中的定义。这些代码在 `a` 中创建了一个列表，一个指向 `a` 中列表的 `b` 列表，接着修改 `b` 中的列表指向 `a` 中的列表，这会创建一个引用循环。在这个过程的多个位置有 `println!` 语句展示引用计数。 + + + + +Filename: src/main.rs ```rust +# use List::{Cons, Nil}; +# use std::rc::Rc; +# use std::cell::RefCell; # #[derive(Debug)] # enum List { # Cons(i32, RefCell>), @@ -51,25 +74,20 @@ impl List { # } # } # -use List::{Cons, Nil}; -use std::rc::Rc; -use std::cell::RefCell; - fn main() { - let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil)))); println!("a initial rc count = {}", Rc::strong_count(&a)); println!("a next item = {:?}", a.tail()); - let b = Rc::new(Cons(10, RefCell::new(a.clone()))); + let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a)))); println!("a rc count after b creation = {}", Rc::strong_count(&a)); println!("b initial rc count = {}", Rc::strong_count(&b)); println!("b next item = {:?}", b.tail()); - if let Some(ref link) = a.tail() { - *link.borrow_mut() = b.clone(); + if let Some(link) = a.tail() { + *link.borrow_mut() = Rc::clone(&b); } println!("b rc count after changing a = {}", Rc::strong_count(&b)); @@ -81,29 +99,101 @@ fn main() { } ``` -示例 15-17: 创建一个引用循环：两个`List` 的值互相指向彼此 +示例 15-29：创建一个引用循环：两个`List` 值互相指向彼此 -使用`tail`方法来获取`a`中`RefCell`的引用，并将其放入变量`link`中。接着对`RefCell`使用`borrow_mut`方法将其中的值从存放`Nil`值的`Rc`改为`b`中的`Rc`。这创建了一个看起来像图 15-18 所示的引用循环： +这里在变量 `a` 中创建了一个 `Rc` 实例来存放初值为 `5, Nil` 的 `List` 值。接着在变量 `b` 中创建了存放包含值 10 和指向列表 `a` 的 `List` 的另一个 `Rc` 实例。 -Reference cycle of lists +最后，修改 `a` 使其指向 `b` 而不是 `Nil`，这就创建了一个循环。为此需要使用 `tail` 方法获取 `a` 中 `RefCell` 的引用，并放入变量 `link` 中。接着使用 `RefCell` 的 `borrow_mut` 方法将其值从存放 `Nil` 的 `Rc` 修改为 `b` 中的 `Rc`。 -图 15-18: 列表 `a` 和 `b` 彼此互相指向形成引用循环 -如果你注释掉最后的`println!`，Rust 会尝试打印出`a`指向`b`指向`a`这样的循环直到栈溢出。 +如果保持最后的 `println!` 行注释并运行代码，会得到如下输出： -观察最后一个`println!`之前的打印结果，就会发现在将`a`改变为指向`b`之后`a`和`b`的引用计数都是 2。在`main`的结尾，Rust 首先会尝试丢弃`b`，这会使`Rc`的引用计数减一，但是这个计数是 1 而不是 0，所以`Rc`在堆上的内存不会被丢弃。它只是会永远的停留在 1 上。这个特定例子中，程序立马就结束了，所以并不是一个问题，不过如果是一个更加复杂的程序，它在这个循环中分配了很多内存并占有很长时间，这就是个问题了。这个程序会使用多于它所需要的内存，并有可能压垮系统并造成没有内存可供使用。 +```text +a initial rc count = 1 +a next item = Some(RefCell { value: Nil }) +a rc count after b creation = 2 +b initial rc count = 1 +b next item = Some(RefCell { value: Cons(5, RefCell { value: Nil }) }) +b rc count after changing a = 2 +a rc count after changing a = 2 +``` -现在，如你所见，在 Rust 中创建引用循环是困难和繁琐的。但并不是不可能：避免引用循环这种形式的内存泄漏并不是 Rust 的保证之一。如果你有包含`Rc`的`RefCell`值或类似的嵌套结合了内部可变性和引用计数的类型，请务必小心确保你没有形成一个引用循环。在示例 15-14 的例子中，可能解决方式就是不要编写像这样可能造成引用循环的代码，因为我们希望`Cons`成员拥有他们指向的列表。 +可以看到将 `a` 修改为指向 `b` 之后，`a` 和 `b` 中都有的 `Rc` 实例的引用计数为 2。在 `main` 的结尾，Rust 会尝试首先丢弃 `b`，这会使 `a` 和 `b` 中 `Rc` 实例的引用计数减一。 -举例来说，对于像图这样的数据结构，为了创建父节点指向子节点的边和以相反方向从子节点指向父节点的边，有时需要创建这样的引用循环。如果一个方向拥有所有权而另一个方向没有，对于模拟这种数据关系的一种不会创建引用循环和内存泄露的方式是使用`Weak`。接下来让我们探索一下！ + + -### 避免引用循环：将`Rc`变为`Weak` + + -Rust 标准库中提供了`Weak`，一个用于存在引用循环但只有一个方向有所有权的智能指针。我们已经展示过如何克隆`Rc`来增加引用的`strong_count`；`Weak`是一种引用`Rc`但不增加`strong_count`的方式：相反它增加`Rc`引用的`weak_count`。当`Rc`离开作用域，其内部值会在`strong_count`为 0 的时候被丢弃，即便`weak_count`不为 0 。为了能够从`Weak`中获取值，首先需要使用`upgrade`方法将其升级为`Option>`。升级`Weak`的结果在`Rc`还未被丢弃时是`Some`，而在`Rc`被丢弃时是`None`。因为`upgrade`返回一个`Option`，我们知道 Rust 会确保`Some`和`None`的情况都被处理并不会尝试使用一个无效的指针。 +然而，因为 `a` 仍然引用 `b` 中的 `Rc`，`Rc` 的引用计数是 1 而不是 0，所以 `Rc` 在堆上的内存不会被丢弃。其内存会因为引用计数为 1 而永远停留。 -不同于示例 15-17 中每个项只知道它的下一项，假如我们需要一个树，它的项知道它的子项**和**父项。 +为了更形象的展示，我们创建了一个如图 15-30 所示的引用循环： -让我们从一个叫做`Node`的存放拥有所有权的`i32`值和其子`Node`值的引用的结构体开始： +Reference cycle of lists + +图 15-30: 列表 `a` 和 `b` 彼此互相指向形成引用循环 + +如果取消最后 `println!` 的注释并运行程序，Rust 会尝试打印出 `a` 指向 `b` 指向 `a` 这样的循环直到栈溢出。 + + + + +这个特定的例子中，创建了引用循环之后程序立刻就结束了。这个循环的结果并不可怕。如果在更为复杂的程序中并在循环里分配了很多内存并占有很长时间，这个程序会使用多于它所需要的内存，并有可能压垮系统并造成没有内存可供使用。 + +创建引用循环并不容易，但也不是不可能。如果你有包含`Rc`的`RefCell`值或类似的嵌套结合了内部可变性和引用计数的类型，请务必小心确保你没有形成一个引用循环；你无法指望 Rust 帮你捕获它们。创建引用循环是一个程序上的逻辑 bug，你应该使用自动化测试、代码评审和其他软件开发最佳实践来使其最小化。 + + + + +另一个解决方案是重新组织数据结构使得一些引用有所有权而另一些则没有。如此，循环将由一些有所有权的关系和一些没有所有权的关系，而只有所有权关系才影响值是否被丢弃。在示例 15-28 中，我们总是希望 `Cons` 成员拥有其列表，所以重新组织数据结构是不可能的。让我们看看一个由服结点和结点够长的图的例子，观察何时无所有权关系是一个好的避免引用循环的方法。 + +### 避免引用循环：将 `Rc` 变为 `Weak` + +到目前为止，我们已经展示了调用 `Rc::clone` 会增加 `Rc` 实例的 `strong_count`，和 `Rc` 实例只在其 `strong_count` 为 0 时才会被清理。也可以通过调用 `Rc::downgrade` 并传递 `Rc` 实例的引用来创建其值的 **弱引用**（*weak reference*）。调用 `Rc::downgrade` 时会得到 `Weak` 类型的智能指针。不同于将 `Rc` 实例的 `strong_count` 加一，调用 `Rc::downgrade` 会将 `weak_count` 加一。`Rc` 类型使用 `weak_count` 来记录其存在多少个 `Weak` 引用，类似于 `strong_count`。其区别在于 `weak_count` 无需计数为 0 就能使 `Rc` 实例被清理。 + + + + +强引用代表如何共享 `Rc` 实例的引用。弱引用并不代表所有权关系。他们不会造成引用循环，因为任何引入了弱引用的循环一旦所涉及的强引用计数为 0 就会被打破。 + + + + +因为 `Weak` 引用的值可能已经被丢弃了，为了使用 `Weak` 所指向的值，我们必须确保其值仍然有效。为此可以调用 `Weak` 实例的 `upgrade` 方法，这会返回 `Option>`。如果 `Rc` 值还未被丢弃则结果是 `Some`，如果 `Rc` 已经被丢弃则结果是 `None`。因为 `upgrade` 返回一个 `Option`，我们确信 Rust 会处理 `Some` 和 `None`的情况，并且不会有一个无效的指针。 + +作为一个例子，不同于使用一个某项只知道其下一项的列表，我们会创建一个某项知道其子项 **和** 父项的树形结构。 + +#### 创建树形数据结构：带有子结点的 `Node` + +让我们从一个叫做 `Node` 的存放拥有所有权的 `i32` 值和其子 `Node` 值引用的结构体开始： + +文件名: src/main.rs ```rust use std::rc::Rc; @@ -116,12 +206,22 @@ struct Node { } ``` -我们希望能够`Node`拥有其子节点，同时也希望变量可以拥有每个节点以便可以直接访问他们。这就是为什么`Vec`中的项是`Rc`值。我们也希望能够修改其他节点的子节点，这就是为什么`children`中`Vec`被放进了`RefCell`的原因。在示例 15-19 中创建了一个叫做`leaf`的带有值 3 并没有子节点的`Node`实例，和另一个带有值 5 和以`leaf`作为子节点的实例`branch`： +我们希望能够 `Node` 拥有其子结点，同时也希望变量可以拥有每个结点以便可以直接访问他们。为此 `Vec` 的项的类型被定义为 `Rc`。我们还希望能改其他结点的子结点，所以 `children` 中 `Vec` 被放进了 `RefCell`。 +接下来，使用此结构体定义来创建一个叫做 `leaf` 的带有值 3 且没有子结点的 `Node` 实例，和另一个带有值 5 并以 `leaf` 作为子结点的实例 `branch`，如示例 15-31 所示： 文件名: src/main.rs -```rust,ignore +```rust +# use std::rc::Rc; +# use std::cell::RefCell; +# +# #[derive(Debug)] +# struct Node { +# value: i32, +# children: RefCell>>, +# } +# fn main() { let leaf = Rc::new(Node { value: 3, @@ -130,18 +230,27 @@ fn main() { let branch = Rc::new(Node { value: 5, - children: RefCell::new(vec![leaf.clone()]), + children: RefCell::new(vec![Rc::clone(&leaf)]), }); } ``` -示例 15-19: 创建一个 `leaf` 节点 和一个 `branch` 节点，使 `leaf` 作为 `branch` 的一个孩子之一，但是`leaf` 没有持有 `branch` 的引用 +示例 15-31：创建没有子结点的 `leaf` 结点和以 `leaf` 作为子结点的 `branch` 结点 -`leaf`中的`Node`现在有两个所有者：`leaf`和`branch`，因为我们克隆了`leaf`中的`Rc`并储存在了`branch`中。`branch`中的`Node`知道它与`leaf`相关联因为`branch`在`branch.children`中有`leaf`的引用。然而，`leaf`并不知道它与`branch`相关联，而我们希望`leaf`知道`branch`是其父节点。 +这里克隆了 `leaf` 中的 `Rc` 并储存在了 `branch` 中，这意味着 `leaf` 中的 `Node` 现在有两个所有者：`leaf`和`branch`。可以通过 `branch.children` 从 `branch` 中获得 `leaf`，不过无法从 `leaf` 到 `branch`。`leaf` 没有到 `branch` 的引用且并不知道他们相互关联。我们希望 `leaf` 知道 `branch` 是其父结点。 -为了做到这一点，需要在`Node`结构体定义中增加一个`parent`字段，不过`parent`的类型应该是什么呢？我们知道它不能包含`Rc`，因为这样`leaf.parent`将会指向`branch`而`branch.children`会包含`leaf`的指针，这会形成引用循环。`leaf`和`branch`不会被丢弃因为他们总是引用对方且引用计数永远也不会是零。 +#### 增加从子到父的引用 -所以在`parent`的类型中是使用`Weak`而不是`Rc`，具体来说是`RefCell>`： +为了使子结点知道其父结点，需要在 `Node` 结构体定义中增加一个 `parent` 字段。问题是 `parent` 的类型应该是什么。我们知道其不能包含 `Rc`，因为这样 `leaf.parent` 将会指向 `branch` 而 `branch.children` 会包含 `leaf` 的指针，这会形成引用循环，会造成其 `strong_count` 永远也不会为 0. + +现在换一种方式思考这个关系，父结点应该拥有其子结点：如果父结点被丢弃了，其子结点也应该别丢弃。然而子结点不应该拥有其父结点：如果丢弃子结点，其父结点应该依然存在。这正是弱引用的例子！ + +所以 `parent` 使用 `Weak` 类型而不是 `Rc`，具体来说是 `RefCell>`。现在 `Node` 结构体定义看起来像这样： + + + 文件名: src/main.rs @@ -157,11 +266,33 @@ struct Node { } ``` -这样，一个节点就能够在拥有父节点时指向它，而并不拥有其父节点。一个父节点哪怕在拥有指向它的子节点也会被丢弃，只要是其自身也没有一个父节点就行。现在将`main`函数更新为如示例 15-20 所示： + + + +这样，一个结点就能够引用其父结点，但不拥有其父结点。在示例 15-32 中，我们更新 `main` 来使用新定义以便 `leaf` 结点可以引用其父结点： + + + 文件名: src/main.rs -```rust,ignore +```rust +# use std::rc::{Rc, Weak}; +# use std::cell::RefCell; +# +# #[derive(Debug)] +# struct Node { +# value: i32, +# parent: RefCell>, +# children: RefCell>>, +# } +# fn main() { let leaf = Rc::new(Node { value: 3, @@ -174,7 +305,7 @@ fn main() { let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()), - children: RefCell::new(vec![leaf.clone()]), + children: RefCell::new(vec![Rc::clone(&leaf)]), }); *leaf.parent.borrow_mut() = Rc::downgrade(&branch); @@ -183,26 +314,44 @@ fn main() { } ``` -示例 15-20: 一个 `leaf` 节点和一个 `branch` 节点， -`leaf` 节点具有一个指向其父节点 `branch` 的 `Weak` 引用 +示例 15-32：一个 `leaf` 结点，其拥有指向其父结点 `branch` 的 `Weak` 引用 -创建`leaf`节点是类似的；因为它作为开始并没有父节点，这里创建了一个新的`Weak`引用实例。当尝试通过`upgrade`方法获取`leaf`父节点的引用时，会得到一个`None`值，如第一个`println!`输出所示： -```= + + +创建 `leaf` 结点类似于示例 15-31 中如何创建 `leaf` 结点的，除了 `parent` 字段有所不同：`leaf` 开始时没有父结点，所以我们新建了一个空的 `Weak` 引用实例。 + +此时，当尝试使用 `upgrade` 方法获取 `leaf` 的父结点引用时，会得到一个 `None` 值。如第一个 `println!` 输出所示： + +```text leaf parent = None ``` -类似的，`branch`也有一个新的`Weak`引用，因为也没有父节点。`leaf`仍然作为`branch`的一个子节点。一旦在`branch`中有了一个新的`Node`实例，就可以修改`leaf`将一个`branch`的`Weak`引用作为其父节点。这里使用了`leaf`中`parent`字段里的`RefCell`的`borrow_mut`方法，接着使用了`Rc::downgrade`函数来从`branch`中的`Rc`值创建了一个指向`branch`的`Weak`引用。 + + -当再次打印出`leaf`的父节点时，这一次将会得到存放了`branch`的`Some`值。另外需要注意到这里并没有打印出类似示例 15-14 中那样最终导致栈溢出的循环：`Weak`引用仅仅打印出`(Weak)`： +当创建 `branch` 结点时，其也会新建一个 `Weak` 引用，因为 `branch` 并没有父结点。`leaf` 仍然作为 `branch` 的一个子结点。一旦在 `branch` 中有了 `Node` 实例，就可以修改 `leaf` 使其拥有指向父结点的 `Weak` 引用。这里使用了 `leaf` 中 `parent` 字段里的 `RefCell` 的 `borrow_mut` 方法，接着使用了 `Rc::downgrade` 函数来从 `branch` 中的 `Rc` 值创建了一个指向 `branch` 的 `Weak` 引用。 -``` + + + +当再次打印出 `leaf` 的父结点时，这一次将会得到存放了 `branch` 的 `Some` 值：现在 `leaf` 可以访问其父结点了！当打印出 `leaf` 时，我们也避免了如示例 15-29 中最终会导致栈溢出的循环：`Weak` 引用被打印为 `(Weak)`： + +```text leaf parent = Some(Node { value: 5, parent: RefCell { value: (Weak) }, children: RefCell { value: [Node { value: 3, parent: RefCell { value: (Weak) }, children: RefCell { value: [] } }] } }) ``` -没有无限的输出（或直到栈溢出）的事实表明这里并没有引用循环。另一种证明的方式时观察调用`Rc::strong_count`和`Rc::weak_count`的值。在示例 15-21 中，创建了一个新的内部作用域并将`branch`的创建放入其中，这样可以观察`branch`被创建时和离开作用域被丢弃时发生了什么： +没有无限的输出表明这段代码并没有造成引用循环。这一点也可以从观察 `Rc::strong_count` 和 `Rc::weak_count` 调用的结果看出。 + +#### 可视化 `strong_count` 和 `weak_count` 的改变 + +让我们通过创建了一个新的内部作用域并将 `branch` 的创建放入其中，来观察 `Rc` 实例的 `strong_count` 和 `weak_count` 值的变化。这会展示当 `branch` 创建和离开作用域被丢弃时会发生什么。这些修改如示例 15-33 所示： 文件名: src/main.rs @@ -224,7 +373,7 @@ fn main() { let branch = Rc::new(Node { value: 5, parent: RefCell::new(Weak::new()), - children: RefCell::new(vec![leaf.clone()]), + children: RefCell::new(vec![Rc::clone(&leaf)]), }); *leaf.parent.borrow_mut() = Rc::downgrade(&branch); @@ -250,24 +399,34 @@ fn main() { } ``` -示例 15-21: 在内部范围创建一个 `branch` 节点，并检查 `leaf` 和 `branch` 的强弱引用计数 +示例 15-33：在内部作用域创建 `branch` 并检查其强弱引用计数 -创建`leaf`之后，强引用计数是 1 （用于`leaf`自身）而弱引用计数是 0。在内部作用域中，在创建`branch`和关联`leaf`和`branch`之后，`branch`的强引用计数为 1（用于`branch`自身）而弱引用计数为 1（因为`leaf.parent`通过一个`Weak`指向`branch`）。`leaf`的强引用计数为 2，因为`branch`现在有一个`leaf`克隆的`Rc`储存在`branch.children`中。`leaf`的弱引用计数仍然为 0。 +一旦创建了 `leaf`，其 `Rc` 的强引用计数为 1，弱引用计数为 0。在内部作用域中创建了 `branch` 并与 `leaf` 相关联，此时 `branch` 中 `Rc` 的强引用计数为 1，弱引用计数为 1（因为 `leaf.parent` 通过 `Weak` 指向 `branch`）。这里 `leaf` 的强引用计数为 2，因为现在 `branch` 的 `branch.children` 中储存了 `leaf` 的 `Rc` 的拷贝，不过弱引用计数仍然为 0。 -当内部作用域结束，`branch`离开作用域，其强引用计数减少为 0，所以其`Node`被丢弃。来自`leaf.parent`的弱引用计数 1 与`Node`是否被丢弃无关，所以并没有产生内存泄露！ +当内部作用域结束时，`branch` 离开作用域，其强引用计数减少为 0，所以其 `Node` 被丢弃。来自 `leaf.parent` 的弱引用计数 1 与 `Node` 是否被丢弃无关，所以并没有产生任何内存泄露！ -如果在内部作用域结束后尝试访问`leaf`的父节点，会像`leaf`拥有父节点之前一样得到`None`值。在程序的末尾，`leaf`的强引用计数为 1 而弱引用计数为 0，因为现在`leaf`又是唯一指向其自己的值了。 +如果在内部作用域结束后尝试访问 `leaf` 的父结点，会再次得到 `None`。在程序的结尾，`leaf` 中 `Rc` 的强引用计数为 1，弱引用计数为 0，因为因为现在 `leaf` 又是 `Rc` 唯一的引用了。 -所有这些管理计数和值是否应该被丢弃的逻辑都通过`Rc`和`Weak`和他们的`Drop` trait 实现来控制。通过在定义中指定从子节点到父节点的关系为一个`Weak`引用，就能够拥有父节点和子节点之间的双向引用而不会造成引用循环和内存泄露。 + + + +所有这些管理计数和值的逻辑都内建于 `Rc` 和 `Weak` 以及它们的 `Drop` trait 实现中。通过在 `Node` 定义中指定从子结点到父结点的关系为一个`Weak`引用，就能够拥有父结点和子结点之间的双向引用而不会造成引用循环和内存泄露。 + + + ## 总结 -现在我们学习了如何选择不同类型的智能指针来选择不同的保证并与 Rust 的常规引用向取舍。`Box`有一个已知的大小并指向分配在堆上的数据。`Rc`记录了堆上数据的引用数量这样就可以拥有多个所有者。`RefCell`和其内部可变性使其可以用于需要不可变类型，但希望在运行时而不是编译时检查借用规则的场景。 +这一章涵盖了如何使用智能指针来做出不同于 Rust 常规引用默认所提供的保证与取舍。`Box` 有一个已知的大小并指向分配在堆上的数据。`Rc` 记录了堆上数据的引用数量以便可以拥有多个所有者。`RefCell` 和其内部可变性提供了一个可以用于当需要不可变类型但是需要改变其内部值能力的类型，并在运行时而不是编译时检查借用规则。 -我们还介绍了提供了很多智能指针功能的 trait `Deref`和`Drop`。同时探索了形成引用循环和造成内存泄漏的可能性，以及如何使用`Weak`避免引用循环。 +我们还介绍了提供了很多智能指针功能的 trait `Deref` 和 `Drop`。同时探索了会造成内存泄露的引用虚幻，以及如何使用 `Weak` 来避免它们。 -如果本章内容引起了你的兴趣并希望现在就实现你自己的智能指针的话，请阅读 [The Nomicon] 来获取更多有用的信息。 +如果本章内容引起了你的兴趣并希望现在就实现你自己的智能指针的话，请阅读 [“The Nomicon”] 来获取更多有用的信息。 -[The Nomicon]: https://doc.rust-lang.org/stable/nomicon/ +[“The Nomicon”]: https://doc.rust-lang.org/stable/nomicon/ 接下来，让我们谈谈 Rust 的并发。我们还会学习到一些新的对并发有帮助的智能指针。 From 1b37e6c2f8afa1fb2e69bc4c5768a6ace67fa68a Mon Sep 17 00:00:00 2001 From: KaiserY Date: Tue, 30 Jan 2018 13:31:23 +0800 Subject: [PATCH 126/150] check to ch16-01 --- src/ch13-01-closures.md | 2 +- src/ch16-00-concurrency.md | 17 ++--- src/ch16-01-threads.md | 132 +++++++++++++++++++-------------- src/ch16-02-message-passing.md | 2 +- 4 files changed, 87 insertions(+), 66 deletions(-) diff --git a/src/ch13-01-closures.md b/src/ch13-01-closures.md index 9be96af..a40b5c1 100644 --- a/src/ch13-01-closures.md +++ b/src/ch13-01-closures.md @@ -537,7 +537,7 @@ error[E0434]: can't capture dynamic environment in a fn item; use the || { ... 当创建一个闭包时，Rust 根据其如何使用环境中变量来推断我们希望如何引用环境。在示例 13-12 中，`equal_to_x` 闭包不可变的借用了 `x`（所以 `equal_to_x` 使用 `Fn` trait），因为闭包体只需要读取 `x` 的值。 -如果我们希望强制闭包获取其使用的环境值的所有权，可以在参数列表前使用 `move` 关键字。这在将闭包传递给新线程以便将数据移动到新线程中时最为实用。 +如果我们希望强制闭包获取其使用的环境值的所有权，可以在参数列表前使用 `move` 关键字。这个技巧在将闭包传递给新线程以便将数据移动到新线程中时最为实用。 第十六章讨论并发时会展示更多 `move` 闭包的例子，不过现在这里修改了示例 13-12 中的代码（作为演示），在闭包定义中增加 `move` 关键字并使用 vector 代替整型，因为整型可以被拷贝而不是移动；注意这些代码还不能编译： diff --git a/src/ch16-00-concurrency.md b/src/ch16-00-concurrency.md index 9c12ebd..db2e12c 100644 --- a/src/ch16-00-concurrency.md +++ b/src/ch16-00-concurrency.md @@ -2,20 +2,19 @@ > [ch16-00-concurrency.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch16-00-concurrency.md) >
-> commit da15de39eaabd50100d6fa662c653169254d9175 +> commit 90406bd5a4cd4447b46cd7e03d33f34a651e9bb7 -确保内存安全并不是 Rust 的唯一目标：更好的处理并发和并行编程一直是 Rust 的另一个主要目标。 -**并发编程**（concurrent programming）代表程序的不同部分相互独立的执行，而**并行编程**代表程序不同部分同时执行，这两个概念在计算机拥有更多处理器可供程序利用时变得更加重要。由于历史的原因，在此类上下文中编程一直是困难且容易出错的：Rust 希望能改变这一点。 +安全并高效的处理并发编程是 Rust 的另一个主要目标。**并发编程**（*Concurrent programming*），代表程序的不同部分相互独立的执行，而 **并行编程**（*parallel programming*）代表程序不同部分于同时执行，这两个概念随着计算机越来越多的利用多处理器的优势时显得愈发重要。由于历史原因，在此类上下文中编程一直是困难且容易出错的：Rust 希望能改变这一点。 -最开始，我们认为内存安全和防止并发问题是需要通过两个不同的方法解决的两个相互独立的挑战。然而，随着时间的推移，我们发现所有权和类型系统是一系列解决内存安全**和**并发问题的强用力的工具！通过改进所有权和类型检查，很多并发错误在 Rust 中都是**编译时**错误，而不是运行时错误。我们给 Rust 的这一部分起了一个绰号**无畏并发**（*fearless concurrency*）。无畏并发意味着 Rust 不光允许你自信代码不会出现诡异的错误，也让你可以轻易重构这种代码而无需担心会引入新的 bug。 +起初，Rust 团队认为确保内存安全和防止并发问题是两个分别需要不同方法应对的挑战。随着时间的推移，团队发现所有权和类型系统是一系列解决内存安全 **和** 并发问题的强用力的工具！通过改进所有权和类型检查，Rust 很多并发错误都是 **编译时** 错误，而非运行时错误。因此，相比花费大量时间尝试重现运行时并发 bug 出现的特定情况，Rust 会拒绝编译不正确的代码并提供解释问题的错误信息。因此，你可以在开发时而不是不慎部署到生产环境后修复代码。我们给 Rust 的这一部分起了一个绰号 **无畏并发**（*fearless concurrency*）。无畏并发令你的代码免于出现诡异的 bug 并可以轻松重构且无需担心会引入新的 bug。 -> 注意：对于 Rust 的口号**无畏并发**，这里用**并发**指代很多问题而不是更精确的区分**并发和（或）并行**，是出于简化问题的原因。如果这是一本专注于并发和/或并行的书，我们肯定会更精确的。对于本章，当我们谈到**并发**时，请自行替换为**并发和（或）并行**。 +> 注意：出于简洁的考虑，我们将很多问题归为并发，而不是更准确的区分并发和（或）并行。如果这是一本专注于并发和/或并行的书，我们肯定会更加精确的。对于本章，当我们谈到并发时，请自行脑内替换为并发和（或）并行。 -很多语言所提供的处理并发问题的解决方法都非常有特色，尤其是对于更高级的语言，这是一个非常合理的策略。然而对于底层语言则没有奢侈的选择。在任何给定的情况下，我们都期望底层语言可以提供最高的性能，并且对硬件有更薄的抽象。因此，Rust 给了我们多种工具，并以适合实际情况和需求的方式来为问题建模。 +很多语言所提供的处理并发问题的解决方法都非常有特色。例如，Erlang 有着优雅的消息传递并发功能，但只有模糊不清的在线程间共享状态的方法。对于高级语言来说，只实现可能解决方案的子集是一个合理的策略，因为高级语言所许诺的价值来源于牺牲一些控制来换取抽象。然而对于底层语言则期望提供在任何给定的情况下有着最高的性能且对硬件有更少的抽象。因此，Rust 提供了多种工具，以符合实际情况和需求的方式来为问题建模。 如下是本章将要涉及到的内容： * 如何创建线程来同时运行多段代码。 -* 并发**消息传递**（*Message passing*），其中通道（channel）被用来在线程间传递消息。 -* 并发**共享状态**（*Shared state*），其中多个线程可以访问同一片数据。 -* `Sync`和`Send` trait，他们允许 Rust 的并发保证能被扩展到用户定义的和标准库中提供的类型中。 \ No newline at end of file +* **消息传递**（*Message passing*）并发，其中通道（channel）被用来在线程间传递消息。 +* **共享状态**（*Shared state*）并发，其中多个线程可以访问同一片数据。 +* `Sync` 和 `Send` trait，他们允许 Rust 的并发保证能被扩展到用户定义的和标准库中提供的类型中。 \ No newline at end of file diff --git a/src/ch16-01-threads.md b/src/ch16-01-threads.md index 0381ab8..7fd815f 100644 --- a/src/ch16-01-threads.md +++ b/src/ch16-01-threads.md @@ -2,48 +2,58 @@ > [ch16-01-threads.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch16-01-threads.md) >
-> commit 55b294f20fc846a13a9be623bf322d8b364cee77 +> commit 90406bd5a4cd4447b46cd7e03d33f34a651e9bb7 -在今天使用的大部分操作系统中，当程序执行时，操作系统运行代码的上下文称为**进程**（*process*）。操作系统可以运行很多进程，而操作系统也管理这些进程使得多个程序可以在电脑上同时运行。 +在大部分现代操作系统中，执行中程序的代码运行于一个 **进程**（*process*）中，操作系统则负责管理多个进程。在程序内部，也可以拥有多个同时运行的独立部分。这个运行这些独立部分的功能被称为 **线程**（*threads*）。 -我们可以将每个进程运行一个程序的概念再往下抽象一层：程序也可以在其上下文中同时运行独立的部分。这个功能叫做**线程**（*thread*）。 +将程序中的计算拆分进多个线程可以改善性能，因为程序可以同时进行多个任务，不过这也会增加复杂性。因为线程是同时运行的，所以无法预先保证不同线程中的代码的执行顺序。这会导致诸如此类的问题： -将程序需要执行的计算拆分到多个线程中可以提高性能，因为程序可以在同时进行很多工作。不过使用线程会增加程序复杂性。因为线程是同时运行的，所以无法预先保证不同线程中的代码的执行顺序。这可能会由于线程以不一致的顺序访问数据或资源而导致竞争状态，或由于两个线程相互阻止对方继续运行而造成死锁，以及仅仅出现于特定场景并难以稳定重现的 bug。Rust 减少了这些或那些使用线程的负面影响，不过在多线程上下文中编程，相比只期望在单个线程中运行的程序，仍然要采用不同的思考方式和代码结构。 +* 竞争状态（Race conditions），多个线程以不一致的顺序访问数据或资源 +* 死锁（Deadlocks），两个线程相互等待对方停止使用其所拥有的资源，这会阻止它们继续运行 +* 只会发生在特定情况且难以稳定重现和修复的 bug -编程语言有一些不同的方法来实现线程。很多操作系统提供了创建新线程的 API。另外，很多编程语言提供了自己的特殊的线程实现。编程语言提供的线程有时被称作**轻量级**（*lightweight*）或**绿色**（*green*）线程。这些语言将一系列绿色线程放入不同数量的操作系统线程中执行。因为这个原因，语言调用操作系统 API 创建线程的模型有时被称为 *1:1*，一个 OS 线程对应一个语言线程。绿色线程模型被称为 *M:N* 模型，`M`个绿色线程对应`N`个 OS 线程，这里`M`和`N`不必相同。 +Rust 尝试缓和使用线程的负面影响。不过在多线程上下文中编程仍需格外小心，同时其所要求的代码结构也不同于运行于单线程的程序。 -每一个模型都有其自己的优势和取舍。对于 Rust 来说最重要的取舍是运行时支持。**运行时**是一个令人迷惑的概念；在不同上下文中它可能有不同的含义。这里其代表二进制文件中包含的语言自身的代码。对于一些语言，这些代码是庞大的，另一些则很小。通俗的说，“没有运行时”通常被人们用来指代“小运行时”，因为任何非汇编语言都存在一定数量的运行时。更小的运行时拥有更少的功能不过其优势在于更小的二进制输出。更小的二进制文件更容易在更多上下文中与其他语言结合。虽然很多语言觉得增加运行时来换取更多功能没有什么问题，但是 Rust 需要做到几乎没有运行时，同时为了保持高性能必需能够调用 C 语言，这点也是不能妥协的。 +编程语言有一些不同的方法来实现线程。很多操作系统提供了创建新线程的 API。这种由编程语言调用操作系统 API 创建线程的模模型有时被称为 *1:1*，一个 OS 线程对应一个语言线程。 -绿色线程模型功能要求更大的运行时来管理这些线程。为此，Rust 标准库只提供了 1:1 线程模型实现。因为 Rust 是这么一个底层语言，所以有相应的 crate 实现了 M:N 线程模型，如果你宁愿牺牲性能来换取例如更好的线程运行控制和更低的上下文切换成本。 +很多编程语言提供了自己特殊的线程实现。编程语言提供的线程被称为 **绿色**（*green*）线程，使用绿色线程的语言会在不同数量的 OS 线程中执行它们。为此，绿色线程模式被称为 *M:N* 模型：`M` 个绿色线程对应 `N` 个 OS 线程，这里 `M` 和 `N` 不必相同。 -现在我们明白了 Rust 中的线程是如何定义的，让我们开始探索如何使用标准库提供的线程相关的 API吧。 +每一个模型都有其优势和取舍。对于 Rust 来说最重要的取舍是运行时支持。运行时是一个令人迷惑的概念，其在不同上下文中可能有不同的含义。 -### 使用`spawn`创建新线程 +在当前上下文中，**运行时** 代表进制文件中包含的由语言自身提供的代码。这些代码根据语言的不同可大可小，不过任何非汇编语言都会有一定数量的运行时代码。为此，通常人们说一个语言 “没有运行时”，一般意味着 “小运行时”。更小的运行时拥有更少的功能不过其优势在于更小的二进制输出，这使其易于在更多上下文中与其他语言向结合。虽然很多语言觉得增加运行时来换取更多功能没有什么问题，但是 Rust 需要做到几乎没有运行时，同时为了保持高性能必需能够调用 C 语言，这点也是不能妥协的。 -为了创建一个新线程，调用`thread::spawn`函数并传递一个闭包（第十三章学习了闭包），它包含希望在新线程运行的代码。示例 16-1 中的例子在新线程中打印了一些文本而其余的文本在主线程中打印： +绿色线程的 M:N 模型更大的语言运行时来管理这些线程。为此，Rust 标准库只提供了 1:1 线程模型实现。因为 Rust 是如此底层的语言，所以有相应的 crate 实现了 M:N 线程模型，如果你宁愿牺牲性能来换取例如更好的线程运行控制和更低的上下文切换成本。 + +现在我们明白了 Rust 中的线程是如何定义的，让我们开始探索如何使用标准库提供的线程相关的 API 吧。 + +### 使用 `spawn` 创建新线程 + +为了创建一个新线程，需要调用 `thread::spawn` 函数并传递一个闭包（第十三章学习了闭包），其包含希望在新线程运行的代码。示例 16-1 中的例子在主线程打印了一些文本而另一些文本则由新线程打印： 文件名: src/main.rs ```rust use std::thread; +use std::time::Duration; fn main() { thread::spawn(|| { for i in 1..10 { println!("hi number {} from the spawned thread!", i); + thread::sleep(Duration::from_millis(1)); } }); for i in 1..5 { println!("hi number {} from the main thread!", i); + thread::sleep(Duration::from_millis(1)); } } ``` 示例 16-1: 创建一个打印某些内容的新线程，但是主线程打印其它内容 - -注意这个函数编写的方式，当主线程结束时，它也会停止新线程。这个程序的输出每次可能都略微不同，不过它大体上看起来像这样： +注意这个函数编写的方式，当主线程结束时，新线程也会结束，而不管其是否执行完毕。这个程序的输出可能每次都略有不同，不过它大体上看起来像这样： ```text hi number 1 from the main thread! @@ -57,38 +67,44 @@ hi number 4 from the spawned thread! hi number 5 from the spawned thread! ``` -这些线程可能会轮流运行，不过并不保证如此。在这里，主线程先行打印，即便新创建线程的打印语句位于程序的开头。甚至即便我们告诉新建的线程打印直到`i`等于 9 ，它在主线程结束之前也只打印到了 5。如果你只看到了一个线程，或没有出现重叠打印的现象，尝试增加 range 的数值来增加线程暂停并切换到其他线程运行的机会。 +`thread::sleep` 调用强制线程停止执行一小段时间，这会允许其他不同的线程运行。这些线程可能会轮流运行，不过并不保证如此：这依赖操作系统如何调度线程。在这里，主线程首先打印，即便新创建线程的打印语句位于程序的开头。甚至即便我们告诉新建的线程打印直到 `i` 等于 9 ，它在主线程结束之前也只打印到了 5。 -#### 使用`join`等待所有线程结束 +如果你只看到了主线程的输出，或没有出现重叠打印的现象，尝试增加 range 的数值来增加操作系统切换线程的机会。 -由于主线程先于新建线程结束，不仅示例 16-1 中的代码大部分时候不能保证新建线程执行完毕，甚至不能实际保证新建线程会被执行！可以通过保存`thread::spawn`的返回值来解决这个问题，这是一个`JoinHandle`。这看起来如示例 16-2 所示： +#### 使用 `join` 等待所有线程结束 + +由于主线程结束，示例 16-1 中的代码大部分时候不光会提早结束新建线程，甚至不能实际保证新建线程会被执行。其原因在于无法保证线程运行的顺序！ + +可以通过将 `thread::spawn` 的返回值储存在变量中来修复新建线程部分没有执行或者完全没有执行的问题。`thread::spawn` 的返回值类型是 `JoinHandle`。`JoinHandle` 是一个拥有所有权的值，当对其调用 `join` 方法时，它会等待其线程结束。示例 16-2 展示了如何使用示例 16-1 这个中创建的线程的 `JoinHandle` 并调用 `join` 来确保新建线程在 `main` 退出前结束运行： 文件名: src/main.rs ```rust use std::thread; +use std::time::Duration; fn main() { let handle = thread::spawn(|| { for i in 1..10 { println!("hi number {} from the spawned thread!", i); + thread::sleep(Duration::from_millis(1)); } }); for i in 1..5 { println!("hi number {} from the main thread!", i); + thread::sleep(Duration::from_millis(1)); } - handle.join(); + handle.join().unwrap(); } ``` -示例 16-2: 从 `thread::spawn` 保存一个 `JoinHandle`， -以确保该线程能够运行至结束 +示例 16-2: 从 `thread::spawn` 保存一个 `JoinHandle` 以确保该线程能够运行至结束 -`JoinHandle`是一个拥有所有权的值，它可以等待一个线程结束，这也正是`join`方法所做的。通过调用这个句柄的`join`，当前线程会阻塞直到句柄所代表的线程结束。因为我们将`join`调用放在了主线程的`for`循环之后，运行这个例子将产生类似这样的输出： +通过调用 handle 的 `join` 会阻塞当前线程直到 handle 所代表的线程结束。**阻塞**（*Blocking*） 线程意味着阻止该线程执行工作或退出。因为我们将 `join` 调用放在了主线程的 `for` 循环之后，运行示例 16-2 应该会产生类似这样的输出： -``` +```text hi number 1 from the main thread! hi number 2 from the main thread! hi number 1 from the spawned thread! @@ -104,33 +120,36 @@ hi number 8 from the spawned thread! hi number 9 from the spawned thread! ``` -这两个线程仍然会交替执行，不过主线程会由于`handle.join()`调用会等待直到新建线程执行完毕。 +这两个线程仍然会交替执行，不过主线程会由于 `handle.join()` 调用会等待直到新建线程执行完毕。 -如果将`handle.join()`放在主线程的`for`循环之前，像这样： +不过让我们看看将 `handle.join()` 移动到 `main` 中 `for` 循环之前会发生什么，如下： 文件名: src/main.rs ```rust use std::thread; +use std::time::Duration; fn main() { let handle = thread::spawn(|| { for i in 1..10 { println!("hi number {} from the spawned thread!", i); + thread::sleep(Duration::from_millis(1)); } }); - handle.join(); + handle.join().unwrap(); for i in 1..5 { println!("hi number {} from the main thread!", i); + thread::sleep(Duration::from_millis(1)); } } ``` -主线程会等待直到新建线程执行完毕之后才开始执行`for`循环，所以输出将不会交替出现： +主线程会等待直到新建线程执行完毕之后才开始执行 `for` 循环，所以输出将不会交替出现，如下所示： -``` +```text hi number 1 from the spawned thread! hi number 2 from the spawned thread! hi number 3 from the spawned thread! @@ -146,17 +165,17 @@ hi number 3 from the main thread! hi number 4 from the main thread! ``` -稍微考虑一下将`join`放置于何处会影响线程是否同时运行。 +稍微考虑一下将 `join` 放置于何处这样一个细节会影响线程是否同时运行。 -### 线程和`move`闭包 +### 线程与 `move` 闭包 -第十三章有一个我们没有讲到的闭包功能，它经常用于`thread::spawn`：`move`闭包。第十三章中讲到： +`move` 闭包，我们曾在第十三章简要的提到过，其经常与 `thread::spawn` 一起使用，因为它允许我们在一个线程中使用另一个线程的数据。 -> 获取他们环境中值的闭包主要用于开始新线程的场景 +第十三章讲到 “如果我们希望强制闭包获取其使用的环境值的所有权，可以在参数列表前使用 `move` 关键字。这个技巧在将闭包传递给新线程以便将数据移动到新线程中时最为实用。” -现在我们正在创建新线程，所以让我们讨论一下获取环境值的闭包吧！ +现在我们正在创建新线程，所以让我们讨论一下在闭包中获取环境值吧。 -注意示例 16-1 中传递给`thread::spawn`的闭包并没有任何参数：并没有在新建线程代码中使用任何主线程的数据。为了在新建线程中使用来自于主线程的数据，需要新建线程的闭包获取它需要的值。示例 16-3 展示了一个尝试在主线程中创建一个 vector 并用于新建线程的例子，不过这么写还不能工作： +注意示例 16-1 中传递给 `thread::spawn` 的闭包并没有任何参数：并没有在新建线程代码中使用任何主线程的数据。为了在新建线程中使用来自于主线程的数据，需要新建线程的闭包获取它需要的值。示例 16-3 展示了一个尝试在主线程中创建一个 vector 并用于新建线程的例子，不过这么写还不能工作，如下所示： 文件名: src/main.rs @@ -170,20 +189,18 @@ fn main() { println!("Here's a vector: {:?}", v); }); - handle.join(); + handle.join().unwrap(); } ``` -示例 16-3: 在主线程中创建一个 vector，尝试在其它线程中使用它 +示例 16-3: 尝试在另一个线程使用主线程创建的 vector -闭包使用了`v`，所以闭包会获取`v`并使其成为闭包环境的一部分。因为`thread::spawn`在一个新线程中运行这个闭包，所以可以在新线程中访问`v`。 +闭包使用了 `v`，所以闭包会捕获 `v` 并使其成为闭包环境的一部分。因为 `thread::spawn` 在一个新线程中运行这个闭包，所以可以在新线程中访问 `v`。然而当编译这个例子时，会得到如下错误： -然而当编译这个例子时，会得到如下错误： - -``` +```text error[E0373]: closure may outlive the current function, but it borrows `v`, which is owned by the current function - --> + --> src/main.rs:6:32 | 6 | let handle = thread::spawn(|| { | ^^ may outlive borrowed value `v` @@ -191,13 +208,15 @@ which is owned by the current function | - `v` is borrowed here | help: to force the closure to take ownership of `v` (and any other referenced -variables), use the `move` keyword, as shown: - | let handle = thread::spawn(move || { +variables), use the `move` keyword + | +6 | let handle = thread::spawn(move || { + | ^^^^^^^ ``` -当在闭包环境中获取某些值时，Rust 会尝试推断如何获取它。`println!`只需要`v`的一个引用，所以闭包尝试借用`v`。但是这有一个问题：我们并不知道新建线程会运行多久，所以无法知道`v`是否一直时有效的。 +Rust 会 **推断** 如何捕获 `v`，因为 `println!` 只需要 `v` 的引用，闭包尝试借用 `v`。然而这有一个问题：Rust 不知道这个新建线程会执行多久，所以无法知晓 `v` 的引用是否一直有效。 -考虑一下示例 16-4 中的代码，它展示了一个`v`的引用很有可能不再有效的场景： +示例 16-4 展示了一个 `v` 的引用很有可能不再有效的场景： 文件名: src/main.rs @@ -213,23 +232,26 @@ fn main() { drop(v); // oh no! - handle.join(); + handle.join().unwrap(); } ``` 示例 16-4: 一个具有闭包的线程，尝试使用一个在主线程中被回收的引用 `v` -这些代码可以运行，而新建线程则可能直接就出错了并完全没有机会运行。新建线程内部有一个`v`的引用，不过主线程仍在执行：它立刻丢弃了`v`，使用了第十五章提到的显式丢弃其参数的`drop`函数。接着，新建线程开始执行，现在`v`是无效的了，所以它的引用也就是无效的。噢，这太糟了！ +这段代码可以运行，而新建线程则可能会立刻被转移到后台并完全没有机会运行。新建线程内部有一个 `v` 的引用，不过主线程立刻就使用第十五章讨论的 `drop` 丢弃了 `v`。接着当新建线程开始执行，`v` 已不再有效，所以其引用也是无效的。噢，这太糟了！ -为了修复这个问题，我们可以听取错误信息的建议： -``` +为了修复示例 16-3 的编译错误，我们可以听取错误信息的建议： + +```text help: to force the closure to take ownership of `v` (and any other referenced -variables), use the `move` keyword, as shown: - | let handle = thread::spawn(move || { +variables), use the `move` keyword + | +6 | let handle = thread::spawn(move || { + | ^^^^^^^ ``` -通过在闭包之前增加`move`关键字，我们强制闭包获取它使用的值的所有权，而不是引用借用。示例 16-5 中展示的对示例 16-3 代码的修改可以按照我们的预期编译并运行： +通过在闭包之前增加 `move` 关键字，我们强制闭包获取其使用的值的所有权，而不是任由 Rust 推断它应该借用值。示例 16-5 中展示的对示例 16-3 代码的修改，这可以按照我们的预期编译并运行： 文件名: src/main.rs @@ -243,17 +265,17 @@ fn main() { println!("Here's a vector: {:?}", v); }); - handle.join(); + handle.join().unwrap(); } ``` 示例 16-5: 使用 `move` 关键字强制获取它使用的值的所有权 -那么示例 16-4 中那个主线程调用了`drop`的代码该怎么办呢？如果在闭包上增加了`move`，就将`v`移动到了闭包的环境中，我们将不能对其调用`drop`了。相反会出现这个编译时错误： +那么如何使用了 `move` 闭包，示例 16-4 中主线程调用了 `drop` 的代码会发生什么呢？不幸的是，我们会因为示例 16-4 尝试进行由于不同的原因所不允许的操作而得到不同的错误。如果为闭包增加 `move`，将会把 `v` 移动进闭包的环境中，如此将不能在主线程中对其调用 `drop` 了。我们会得到如下不同的编译错误： -``` +```text error[E0382]: use of moved value: `v` - --> + --> src/main.rs:10:10 | 6 | let handle = thread::spawn(move || { | ------- value moved (into closure) here @@ -265,6 +287,6 @@ error[E0382]: use of moved value: `v` not implement the `Copy` trait ``` -Rust 的所有权规则又一次帮助了我们！ +Rust 的所有权规则又一次帮助了我们！示例 16-3 中的错误是因为 Rust 是保守的并只会为线程借用 `v`，这意味着主线程理论上可能使新建线程的引用无效。通过告诉 Rust 将 `v` 的所有权移动到新建线程，我们向 Rust 保证主线程不会再使用 `v`。如果对示例 16-4 也做出如此修改，那么当在主线程中使用 `v` 时就会违反所有权规则。 `move` 关键字覆盖了 Rust 默认保守的借用：其也不允许我们违反所有权规则。 -现在我们有一个线程和线程 API 的基本了解，让我们讨论一下使用线程实际可以**做**什么吧。 +现在我们有一个线程和线程 API 的基本了解，让我们讨论一下使用线程实际可以 **做** 什么吧。 diff --git a/src/ch16-02-message-passing.md b/src/ch16-02-message-passing.md index b9ffa91..f79f1c6 100644 --- a/src/ch16-02-message-passing.md +++ b/src/ch16-02-message-passing.md @@ -2,7 +2,7 @@ > [ch16-02-message-passing.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch16-02-message-passing.md) >
-> commit da15de39eaabd50100d6fa662c653169254d9175 +> commit 90406bd5a4cd4447b46cd7e03d33f34a651e9bb7 最近人气正在上升的一个并发方式是**消息传递**（*message passing*），这里线程或 actor 通过发送包含数据的消息来沟通。这个思想来源于口号： From 185a7d7be42cabeacaf7e47a46d530f84fc62be9 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Wed, 31 Jan 2018 21:02:04 +0800 Subject: [PATCH 127/150] check to ch16-03 --- src/ch16-02-message-passing.md | 108 +++++++++++++++++++-------------- src/ch16-03-shared-state.md | 11 ++-- 2 files changed, 68 insertions(+), 51 deletions(-) diff --git a/src/ch16-02-message-passing.md b/src/ch16-02-message-passing.md index f79f1c6..731f668 100644 --- a/src/ch16-02-message-passing.md +++ b/src/ch16-02-message-passing.md @@ -4,7 +4,7 @@ >
> commit 90406bd5a4cd4447b46cd7e03d33f34a651e9bb7 -最近人气正在上升的一个并发方式是**消息传递**（*message passing*），这里线程或 actor 通过发送包含数据的消息来沟通。这个思想来源于口号： +一个人气正在上升的确保安全并发的方式是 **消息传递**（*message passing*），这里线程或 actor 通过发送包含数据的消息来相互沟通。这个思想来源于 Go 编程语言文档中的口号： > Do not communicate by sharing memory; instead, share memory by > communicating. @@ -13,11 +13,15 @@ > > --[Effective Go](http://golang.org/doc/effective_go.html) -实现这个目标的主要工具是**通道**（*channel*）。通道有两部分组成，一个发送者（transmitter）和一个接收者（receiver）。代码的一部分可以调用发送者和想要发送的数据，而另一部分代码可以在接收的那一端收取消息。 +Rust 中一个实现消息传递并发的主要工具是 **通道**（*channel*），一个 Rust 标准库提供了其实现的编程概念。你可以将其想象为一个水流的通道，比如河流或小溪。如果你将诸如橡皮鸭或小船之类的东西放入其中，它们会顺流而下到达下游。 -我们将编写一个例子使用一个线程生成值并向通道发送他们。主线程会接收这些值并打印出来。 -首先，如示例 16-6 所示，先创建一个通道但不做任何事： +编程中的通道有两部分组成，一个发送者（transmitter）和一个接收者（receiver）。发送者一端位于上游位置，在这里可以将橡皮鸭放入河中，接收者部分则位于下游，橡皮鸭最终会漂流至此。代码中的一部分调用发送者的方法以及希望发送的数据，另一部分则检查接收端收到到达的消息。当发送者或接收者任一被丢弃时可以认为通道被 **关闭**（*closed*）了 + +这里，我们将开发一个程序，它会在一个线程生成值向通道发送，而在另一个线程会接收值并打印出来。这里会通过通道在线程间发送简单值来演示这个功能。一旦你熟悉了这项技术，就能使用通道来实现聊天系统或利用很多线程进行分布式计算并将部分计算结果发送给一个线程进行聚合。 + +首先，在示例 16-6 中，创建了一个通道但没有做任何事。注意这还不能编译，因为 Rust 不知道我们想要在通道中发送什么类型： + 文件名: src/main.rs @@ -30,13 +34,16 @@ fn main() { } ``` -示例 16-6: 创建一个通道，并指派一个包含 `tx` 和 `rx` 的元组 +示例 16-6: 创建一个通道，并将其两端赋值给 `tx` 和 `rx` -`mpsc::channel`函数创建一个新的通道。`mpsc`是**多个生产者，单个消费者**（*multiple producer, single consumer*）的缩写。简而言之，可以有多个产生值的**发送端**，但只能有一个消费这些值的**接收端**。现在我们以一个单独的生产者开始，不过一旦例子可以工作了就会增加多个生产者。 +这里使用 `mpsc::channel` 函数创建一个新的通道；`mpsc` 是 **多个生产者，单个消费者**（*multiple producer, single consumer*）的缩写。简而言之，Rust 标准库实现通道的方式意味着一个通道可以有多个产生值的 **发送**（*sending*）端，但只能有一个消费这些值的 **接收**（*receiving*）端。想象一下多条小河小溪最终汇聚成大河：所有通过这些小河发出的东西最后都会来到大河的下游。目前我们以单个生产者开始，但是当示例可以工作后会增加多个生产者。 -`mpsc::channel`返回一个元组：第一个元素是发送端，而第二个元素是接收端。由于历史原因，很多人使用`tx`和`rx`作为**发送者**和**接收者**的缩写，所以这就是我们将用来绑定这两端变量的名字。这里使用了一个`let`语句和模式来解构了元组。第十八章会讨论`let`语句中的模式和解构。 -让我们将发送端移动到一个新建线程中并发送一个字符串，如示例 16-7 所示： + + +`mpsc::channel` 函数返回一个元组：第一个元素是发送端，而第二个元素是接收端。由于历史原因，`tx` 和 `rx` 通常作为 **发送者**（*transmitter*）和 **接收者**（*receiver*）的缩写，所以这就是我们将用来绑定这两端变量的名字。这里使用了一个 `let` 语句和模式来解构了此元组；第十八章会讨论 `let` 语句中的模式和解构。如此使用 `let` 语句是一个方便提取 `mpsc::channel` 返回的元组中一部分的手段。 + +让我们将发送端移动到一个新建线程中并发送一个字符串，这样新建线程就可以和主线程通讯了，如示例 16-7 所示。这类似与在和的上游扔下一只橡皮鸭或从一个线程向另一个线程发送聊天信息： 文件名: src/main.rs @@ -54,13 +61,13 @@ fn main() { } ``` -示例 16-7: 将 `tx` 移动到一个新建的线程中并发送内容 "hi" +示例 16-7: 将 `tx` 移动到一个新建的线程中并发送 “hi” -正如上一部分那样使用`thread::spawn`来创建一个新线程。并使用一个`move`闭包来将`tx`移动进闭包这样新建线程就是其所有者。 +这里再次使用 `thread::spawn` 来创建一个新线程并使用 `move` 将 `tx` 移动到闭包中这样新建线程就拥有 `tx` 了。新建线程需要拥有通道的发送端以便能向通道发送消息。 -通道的发送端有一个`send`方法用来获取需要放入通道的值。`send`方法返回一个`Result`类型，因为如果接收端被丢弃了，将没有发送值的目标，所以发送操作会出错。在这个例子中，我们简单的调用`unwrap`来忽略错误，不过对于一个真实程序，需要合理的处理它。第九章是你复习正确错误处理策略的好地方。 +通道的发送端有一个 `send` 方法用来获取需要放入通道的值。`send` 方法返回一个 `Result` 类型，所以如果接收端已经被丢弃了，将没有发送值的目标，所以发送操作会返回错误。在这个例子中，出错的时候调用 `unwrap` 产生 panic。过对于一个真实程序，需要合理的处理它：回到第九章复习正确处理错误的策略。 -在示例 16-8 中，让我们在主线程中从通道的接收端获取值： +在示例 16-8 中，我们在主线程中从通道的接收端获取值。这类似于在河的下游捞起橡皮鸭或接收聊天信息： 文件名: src/main.rs @@ -81,19 +88,27 @@ fn main() { } ``` -示例 16-8: 在主线程中接收并打印内容 "hi" +示例 16-8: 在主线程中接收并打印内容 “hi” -通道的接收端有两个有用的方法：`recv`和`try_recv`。这里，我们使用了`recv`，它是 *receive* 的缩写。这个方法会阻塞执行直到从通道中接收一个值。一旦发送了一个值，`recv`会在一个`Result`中返回它。当通道发送端关闭，`recv`会返回一个错误。`try_recv`不会阻塞；相反它立刻返回一个`Result`。 +通道的接收端有两个有用的方法：`recv` 和 `try_recv`。这里，我们使用了 `recv`，它是 *receive* 的缩写。这个方法会阻塞主线程执行直到从通道中接收一个值。一旦发送了一个值，`recv` 会在一个 `Result` 中返回它。当通道发送端关闭，`recv` 会返回一个错误表明不会再有新的值到来了。 + +`try_recv` 不会阻塞，相反它立刻返回一个 `Result`：`Ok` 值包含可用的信息，而 `Err` 值代表此时没有任何消息。如果线程在等待消息过程中还有其他工作时使用 `try_recv` 很有用：可以编写一个循环来频繁调用 `try_recv`，再有可用消息时进行处理，其余时候则处理一会其他工作知道再次检查。 + +处于简单的考虑，这个例子使用了 `recv`；主线程中除了等待消息之外没有任何其他工作，所以阻塞主线程是合适的。 如果运行示例 16-8 中的代码，我们将会看到主线程打印出这个值： -``` +```text Got: hi ``` -### 通道与所有权如何交互 +完美！ -现在让我们做一个试验来看看通道与所有权如何在一起工作：我们将尝试在新建线程中的通道中发送完`val`之后再使用它。尝试编译示例 16-9 中的代码： +### 通道与所有权转移 + +所有权规则在消息传递中扮演了重要角色，其有助于我们编写安全的并发代码。在并发编程中避免错误是在整个 Rust 程序中必须思考所有权所换来的一大优势。 + +现在让我们做一个试验来看看通道与所有权如何一同协作以避免产生问题：我们将尝试在新建线程中的通道中发送完 `val` 值 **之后** 再使用它。尝试编译示例 16-9 中的代码： 文件名: src/main.rs @@ -117,11 +132,11 @@ fn main() { 示例 16-9: 在我们已经发送到通道中后，尝试使用 `val` 引用 -这里尝试在通过`tx.send`发送`val`到通道中之后将其打印出来。这是一个坏主意：一旦将值发送到另一个线程后，那个线程可能会在我们在此使用它之前就修改或者丢弃它。这会由于不一致或不存在的数据而导致错误或意外的结果。 +这里尝试在通过 `tx.send` 发送 `val` 到通道中之后将其打印出来。允许这么做是一个坏主意：一旦将值发送到另一个线程后，那个线程可能会在我们再次使用它之前就将其修改或者丢弃。这会由于不一致或不存在的数据而导致错误或意外的结果。 -尝试编译这些代码，Rust 会报错： +这是一个坏主意：一旦将值发送到另一个线程后，那个线程可能会在我们再次使用它之前就将其修改或者丢弃。其他线程对值可能的修改会由于不一致或不存在的数据而导致错误或意外的结果。然而，尝试编译示例 16-9 的代码时，Rust 会给出一个错误： -``` +```text error[E0382]: use of moved value: `val` --> src/main.rs:10:31 | @@ -131,16 +146,14 @@ error[E0382]: use of moved value: `val` | ^^^ value used here after move | = note: move occurs because `val` has type `std::string::String`, which does - not implement the `Copy` trait +not implement the `Copy` trait ``` -我们的并发错误会造成一个编译时错误！`send`获取其参数的所有权并移动这个值归接收者所有。这个意味着不可能意外的在发送后再次使用这个值；所有权系统检查一切是否合乎规则。 - -在这一点上，消息传递非常类似于 Rust 的单所有权系统。消息传递的拥护者出于相似的原因支持消息传递，就像 Rustacean 们欣赏 Rust 的所有权一样：单所有权意味着特定类型问题的消失。如果一次只有一个线程可以使用某些内存，就没有出现数据竞争的机会。 +我们的并发错误会造成一个编译时错误。`send` 函数获取其参数的所有权并移动这个值归接收者所有。这个意味着不可能意外的在发送后再次使用这个值；所有权系统检查一切是否合乎规则。 ### 发送多个值并观察接收者的等待 -示例 16-8 中的代码可以编译和运行，不过这并不是很有趣：通过它难以看出两个独立的线程在一个通道上相互通讯。示例 16-10 则有一些改进会证明这些代码是并发执行的：新建线程现在会发送多个消息并在每个消息之间暂停一段时间。 +示例 16-8 中的代码可以编译和运行，不过它并没有明前的告诉我们两个独立的线程通过通道相互通讯。示例 16-10 则有一些改进会证明示例 16-8 中的代码是并发执行的：新建线程现在会发送多个消息并在每个消息之间暂停一秒钟。 文件名: src/main.rs @@ -162,7 +175,7 @@ fn main() { for val in vals { tx.send(val).unwrap(); - thread::sleep(Duration::new(1, 0)); + thread::sleep(Duration::from_secs(1)); } }); @@ -174,37 +187,39 @@ fn main() { 示例 16-10: 发送多个消息，并在每次发送后暂停一段时间 -这一次，在新建线程中有一个字符串 vector 希望发送到主线程。我们遍历他们，单独的发送每一个字符串并通过一个`Duration`值调用`thread::sleep`函数来暂停一秒。 +这一次，在新建线程中有一个字符串 vector 希望发送到主线程。我们遍历他们，单独的发送每一个字符串并通过一个 `Duration` 值调用 `thread::sleep` 函数来暂停一秒。 -在主线程中，不再显式的调用`recv`函数：而是将`rx`当作一个迭代器。对于每一个接收到的值，我们将其打印出来。当通道被关闭时，迭代器也将结束。 +在主线程中，不再显式调用 `recv` 函数：而是将 `rx` 当作一个迭代器。对于每一个接收到的值，我们将其打印出来。当通道被关闭时，迭代器也将结束。 当运行示例 16-10 中的代码时，将看到如下输出，每一行都会暂停一秒： -``` +```text Got: hi Got: from Got: the Got: thread ``` -在主线程中并没有任何暂停或位于`for`循环中用于等待的代码，所以可以说主线程是在等待从新建线程中接收值。 +因为在主线程中并没有任何暂停或位于 `for` 循环中用于等待的代码，所以可以说主线程是在等待从新建线程中接收值。 ### 通过克隆发送者来创建多个生产者 -差不多在本部分的开头，我们提到了`mpsc`是 *multiple producer, single consumer* 的缩写。可以扩展示例 16-11 中的代码来创建都向同一接收者发送值的多个线程。这可以通过克隆通道的发送端在来做到，如示例 16-11 所示： +之前我们提到了`mpsc`是 *multiple producer, single consumer* 的缩写。可以运用 `mpsc` 来扩展示例 16-11 中的代码来以创建都向同一接收者发送值的多个线程。这可以通过克隆通道的发送端在来做到，如示例 16-11 所示： 文件名: src/main.rs + ```rust # use std::thread; # use std::sync::mpsc; # use std::time::Duration; # # fn main() { -// ...snip... +// --snip-- + let (tx, rx) = mpsc::channel(); -let tx1 = tx.clone(); +let tx1 = mpsc::Sender::clone(&tx); thread::spawn(move || { let vals = vec![ String::from("hi"), @@ -215,7 +230,7 @@ thread::spawn(move || { for val in vals { tx1.send(val).unwrap(); - thread::sleep(Duration::new(1, 0)); + thread::sleep(Duration::from_secs(1)); } }); @@ -229,24 +244,25 @@ thread::spawn(move || { for val in vals { tx.send(val).unwrap(); - thread::sleep(Duration::new(1, 0)); + thread::sleep(Duration::from_secs(1)); } }); -// ...snip... -# -# for received in rx { -# println!("Got: {}", received); -# } + +for received in rx { + println!("Got: {}", received); +} + +// --snip-- # } ``` -示例 16-11: 发送多个消息，并在每次发送后暂停一段时间 +示例 16-11: 从多个生产者发送多个消息 -这一次，在创建新线程之前，我们对通道的发送端调用了`clone`方法。这会给我们一个可以传递给第一个新建线程的发送端句柄。我们会将原始的通道发送端传递给第二个新建线程，这样每个线程将向通道的接收端发送不同的消息。 +这一次，在创建新线程之前，我们对通道的发送端调用了 `clone` 方法。这会给我们一个可以传递给第一个新建线程的发送端句柄。我们会将原始的通道发送端传递给第二个新建线程。这样就会有两个线程，每个线程将向通道的接收端发送不同的消息。 -如果运行这些代码，你**可能**会看到这样的输出： +如果运行这些代码，你 **可能** 会看到这样的输出： -``` +```text Got: hi Got: more Got: from @@ -257,6 +273,6 @@ Got: thread Got: you ``` -虽然你可能会看到这些以不同的顺序出现。这依赖于你的系统！这也就是并发既有趣又困难的原因。如果你拿`thread::sleep`做实验，在不同的线程中提供不同的值，就会发现他们的运行更加不确定并每次都会产生不同的输出。 +虽然你可能会看到这些值以不同的顺序出现；这依赖于你的系统。这也就是并发既有趣又困难的原因。如果通过 `thread::sleep` 做实验，在不同的线程中提供不同的值，就会发现他们的运行更加不确定并每次都会产生不同的输出。 -现在我们见识过了通道如何工作，再看看共享内存并发吧。 \ No newline at end of file +现在我们见识过了通道如何工作，再看看另一种不同的并发方式吧。 \ No newline at end of file diff --git a/src/ch16-03-shared-state.md b/src/ch16-03-shared-state.md index 653b463..7ae0dbe 100644 --- a/src/ch16-03-shared-state.md +++ b/src/ch16-03-shared-state.md @@ -2,14 +2,15 @@ > [ch16-03-shared-state.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch16-03-shared-state.md) >
-> commit 9df612e93e038b05fc959db393c15a5402033f47 +> commit 90406bd5a4cd4447b46cd7e03d33f34a651e9bb7 -虽然消息传递是一个很好的处理并发的方式，但并不是唯一的一个。再次考虑一下它的口号： +虽然消息传递是一个很好的处理并发的方式，但并不是唯一一个。再一次思考一下 Go 编程语言文档中口号的这一部分：“通过共享内存通讯”： -> Do not communicate by sharing memory; instead, share memory by -> communicating. +> What would communicating by sharing memory look like? In addition, why would message passing enthusiasts not use it and do the opposite instead? > -> 不要共享内存来通讯；而是要通讯来共享内存。 +> 通过共享内存通讯看起来如何？除此之外，为何消息传递的拥护者并不使用它并反其道而行之呢？ + +在某种程度上 那么“共享内存来通讯”是怎样的呢？共享内存并发有点像多所有权：多个线程可以同时访问相同的内存位置。第十五章介绍了智能指针如何使得多所有权成为可能，然而这会增加额外的复杂性，因为需要以某种方式管理这些不同的所有者。 From e83d020d5969dfa287d7379ea2ca6bba2ddbf36d Mon Sep 17 00:00:00 2001 From: Deshi Xiao Date: Thu, 1 Feb 2018 13:48:29 +0800 Subject: [PATCH 128/150] fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit s/只能/智能/ --- src/ch15-02-deref.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch15-02-deref.md b/src/ch15-02-deref.md index c0e0ef3..56a27d4 100644 --- a/src/ch15-02-deref.md +++ b/src/ch15-02-deref.md @@ -99,7 +99,7 @@ fn main() { ### 自定义智能指针 -为了体会默认智能指针的行为不同于引用，让我们创建一个类似于标准库提供的 `Box` 类型的只能指针。接着会学习如何增加使用解引用运算符的功能。 +为了体会默认智能指针的行为不同于引用，让我们创建一个类似于标准库提供的 `Box` 类型的智能指针。接着会学习如何增加使用解引用运算符的功能。 从根本上说，`Box` 被定义为包含一个元素的元组结构体，所以示例 15-10 以相同的方式定义了 `MyBox` 类型。我们还定义了 `new` 函数来对应定义于 `Box` 的 `new` 函数： From 538b49620a8c93abdfc088e0214bb72e21afea02 Mon Sep 17 00:00:00 2001 From: Deshi Xiao Date: Thu, 1 Feb 2018 15:27:03 +0800 Subject: [PATCH 129/150] =?UTF-8?q?=E6=8E=AA=E8=BE=9E=E9=9A=BE=E4=BB=A5?= =?UTF-8?q?=E7=90=86=E8=A7=A3=EF=BC=8C=E6=B6=A6=E8=89=B2=E5=AE=8C=E5=8F=AF?= =?UTF-8?q?=E4=BB=A5=E7=90=86=E8=A7=A3=E6=9B=B4=E4=BD=B3=E3=80=82?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 其中，修正一个typo, s/价差的/检查的/ --- src/ch15-05-interior-mutability.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index 68c0909..d827cc0 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -56,8 +56,8 @@ RefCell is, perhaps a succinct round up would help? --> 如下为选择 `Box`，`Rc` 或 `RefCell` 的理由： - `Rc` 允许相同数据有多个所有者；`Box` 和 `RefCell` 有单一所有者。 -- `Box` 允许在编译时检查的不可变或可变借用；`RefCell` 允许在运行时价差的不可变或可变借用 -- 因为 `RefCell` 允许在运行时检查的可变借用，可以在即便 `RefCell` 自身是不可变的情况下修改其内部的值。 +- `Box` 允许在编译时执行不可变（或可变）借用检查；`Rc`仅允许在编译时执行不可变借用检查；`RefCell` 允许在运行时执行不可变（或可变）借用检查。 +- 因为 `RefCell` 允许在运行时执行可变借用检查，所以我们可以在即便 `RefCell` 自身是不可变的情况下修改其内部的值。 最有一个理由便是指 **内部可变性** 模式。让我们看看何时内部可变性是有用的，并讨论这是如何成为可能的。 From d349c5a1346fda18ac6484a016bc8ce15030a463 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Thu, 1 Feb 2018 17:34:11 +0800 Subject: [PATCH 130/150] check to ch17-00 --- src/ch16-03-shared-state.md | 129 ++++++++---------- ...04-extensible-concurrency-sync-and-send.md | 34 ++--- src/ch17-00-oop.md | 4 +- 3 files changed, 74 insertions(+), 93 deletions(-) diff --git a/src/ch16-03-shared-state.md b/src/ch16-03-shared-state.md index 7ae0dbe..f83cdd4 100644 --- a/src/ch16-03-shared-state.md +++ b/src/ch16-03-shared-state.md @@ -10,26 +10,24 @@ > > 通过共享内存通讯看起来如何？除此之外，为何消息传递的拥护者并不使用它并反其道而行之呢？ -在某种程度上 - -那么“共享内存来通讯”是怎样的呢？共享内存并发有点像多所有权：多个线程可以同时访问相同的内存位置。第十五章介绍了智能指针如何使得多所有权成为可能，然而这会增加额外的复杂性，因为需要以某种方式管理这些不同的所有者。 - -不过 Rust 的类型系统和所有权可以很好的帮助我们，正确的管理它们。以共享内存中更常见的并发原语：互斥器（mutexes）为例，让我们看看具体的情况。 +在某种程度上，任何编程语言中的通道都类似于单所有权，因为一旦将一个值传送到通道中，将无法再使用这个值。共享内存类似于多所有权：多个线程可以同时访问相同的内存位置。第十五章介绍了智能指针如何使得多所有权成为可能，然而这会增加额外的复杂性，因为需要以某种方式管理这些不同的所有者。作为一个例子，让我们看看互斥器，一个更为常见的共享内存并发原语。 ### 互斥器一次只允许一个线程访问数据 -**互斥器**（*mutex*）是一种用于共享内存的并发原语。它是“mutual exclusion”的缩写，也就是说，任意时间，它只允许一个线程访问某些数据。互斥器以难以使用著称，因为你不得不记住： +**互斥器**（*mutex*）是 “mutual exclusion” 的缩写，也就是说，任意时刻，其只允许一个线程访问某些数据。为了访问互斥器中的数据，线程首先需要通过获取互斥器的 **锁**（*lock*）来表明其希望访问数据。锁是一个作为互斥器一部分的数据结构，它记录谁有数据的排他访问权。因此，我们描述互斥器为通过锁系统 **保护**（*guarding*）其数据。 + +互斥器以难以使用著称，因为你不得不记住： 1. 在使用数据之前尝试获取锁。 2. 处理完被互斥器所保护的数据之后，必须解锁数据，这样其他线程才能够获取锁。 -现实中也有互斥器的例子，想象一下在一个会议中，只有一个麦克风。如果一个成员要发言，他必须请求使用麦克风。一旦得到了麦克风，他可以畅所欲言，然后将麦克风交给下一个希望讲话的成员。如果成员在没有麦克风的时候就开始叫喊，或者在其他成员发言结束之前就拿走麦克风，是很不合适的。如果这个共享的麦克风因为此类原因而出现问题，会议将无法正常进行。 +作为一个现实中互斥器的例子，想象一下在某个会议的一次小组座谈会中，只有一个麦克风。如果一位成员要发言，他必须请求或表示希望使用麦克风。一旦得到了麦克风，他可以畅所欲言，然后将麦克风交给下一位希望讲话的成员。如果一位成员结束发言后忘记将麦克风交还，其他人将无法发言。如果对共享麦克风的管理出现了问题，座谈会将无法如期进行！ 正确的管理互斥器异常复杂，这也是许多人之所以热衷于通道的原因。然而，在 Rust 中，得益于类型系统和所有权，我们不会在锁和解锁上出错。 ### `Mutex`的 API -让我们看看示例 16-12 中使用互斥器的例子，现在不涉及多线程： +作为展示如何使用互斥器的例子，让我们从在单线程上下文使用互斥器开始，如示例 16-12 所示： 文件名: src/main.rs @@ -48,20 +46,22 @@ fn main() { } ``` -示例 16-12: 为简单，在一个单线程中探索 `Mutex` 的 API +示例 16-12: 出于简单的考虑，在一个单线程上下文中探索 `Mutex` 的 API -像很多类型一样，我们使用关联函数 `new` 来创建一个 `Mutex`。使用`lock`方法获取锁，以访问互斥器中的数据。这个调用会阻塞，直到我们拥有锁为止。如果另一个线程拥有锁，并且那个线程 panic 了，则这个调用会失败。类似于示例 16-6 那样，我们暂时使用 `unwrap()` 进行错误处理，或者使用第九章中提及的更好的工具。 +像很多类型一样，我们使用关联函数 `new` 来创建一个 `Mutex`。使用 `lock` 方法获取锁，以访问互斥器中的数据。这个调用会阻塞当前线程，直到我们拥有锁为止。 + +如果另一个线程拥有锁，并且那个线程 panic 了，则 `lock` 调用会失败。在这种情况下，没人能够再获取锁，所以这里选择 `unwrap` 并在遇到这种情况时使线程 panic。 -一旦获取了锁，就可以将返回值（在这里是`num`）作为一个数据的可变引用使用了。观察 Rust 类型系统如何保证使用值之前必须获取锁：`Mutex`并不是一个`i32`，所以**必须**获取锁才能使用这个`i32`值。我们是不会忘记这么做的，因为类型系统不允许。 +一旦获取了锁，就可以将返回值（在这里是`num`）视为一个其内部数据的可变引用了。类型系统确保了我们在使用 `m` 中的值之前获取锁：`Mutex` 并不是一个 `i32`，所以 **必须** 获取锁才能使用这个 `i32` 值。我们是不会忘记这么做的，因为反之类型系统不允许访问内部的 `i32` 值。 +正如你所怀疑的，`Mutex` 是一个智能指针。更准确的说，`lock` 调用 **返回** 一个叫做 `MutexGuard` 的智能指针。这个智能指针实现了 `Deref` 来指向其内部数据；其也提供了一个 `Drop` 实现当 `MutexGuard` 离开作用域时自动释放锁，这正发生于示例 16-12 内部作用域的结尾。为此，我们不会冒忘记释放锁并阻塞互斥器为其它线程所用的风险，因为锁的释放是自动发生的。 -你也许会怀疑，`Mutex`是一个智能指针？是的！更准确的说，`lock`调用返回一个叫做`MutexGuard`的智能指针。类似我们在第十五章见过的智能指针，它实现了`Deref`来指向其内部数据。另外`MutexGuard`有一个用来释放锁的`Drop`实现。这样就不会忘记释放锁了。这在`MutexGuard`离开作用域时会自动发生，例如它发生于示例 16-12 中内部作用域的结尾。接着可以打印出互斥器的值并发现能够将其内部的`i32`改为 6。 +丢弃了锁之后，可以打印出互斥器的值，并发现能够将其内部的 `i32` 改为 6。 -#### 在线程间共享`Mutex` +#### 在线程间共享 `Mutex` -现在让我们尝试使用`Mutex`在多个线程间共享值。我们将启动十个线程，并在各个线程中对同一个计数器值加一，这样计数器将从 0 变为 10。注意，接下来的几个例子会出现编译错误，而我们将通过这些错误来学习如何使用 -`Mutex`，以及 Rust 又是如何辅助我们以确保正确。示例 16-13 是最开始的例子： +现在让我们尝试使用 `Mutex` 在多个线程间共享值。我们将启动十个线程，并在各个线程中对同一个计数器值加一，这样计数器将从 0 变为 10。注意，接下来的几个例子会出现编译错误，而我们将通过这些错误来学习如何使用 `Mutex`，以及 Rust 又是如何帮助我们正确正确使用的。示例 16-13 是最开始的例子： 文件名: src/main.rs @@ -74,7 +74,7 @@ fn main() { let mut handles = vec![]; for _ in 0..10 { - let handle = thread::spawn(|| { + let handle = thread::spawn(move || { let mut num = counter.lock().unwrap(); *num += 1; @@ -92,38 +92,16 @@ fn main() { 示例 16-13: 程序启动了 10 个线程，每个线程都通过 `Mutex` 来增加计数器的值 -这里创建了一个 `counter` 变量来存放内含 `i32` 的 `Mutex`，类似示例 16-12 那样。接下来使用 range 创建了 10 个线程。使用了 `thread::spawn` 并对所有线程使用了相同的闭包：他们每一个都将调用 `lock` 方法来获取 `Mutex` 上的锁，接着将互斥器中的值加一。当一个线程结束执行，`num` 会离开闭包作用域并释放锁，这样另一个线程就可以获取它了。 +这里创建了一个 `counter` 变量来存放内含 `i32` 的 `Mutex`，类似示例 16-12 那样。接下来遍历 range 创建了 10 个线程。使用了 `thread::spawn` 并对所有线程使用了相同的闭包：他们每一个都将调用 `lock` 方法来获取 `Mutex` 上的锁，接着将互斥器中的值加一。当一个线程结束执行，`num` 会离开闭包作用域并释放锁，这样另一个线程就可以获取它了。 在主线程中，我们像示例 16-2 那样收集了所有的 join 句柄，调用它们的 `join` 方法来确保所有线程都会结束。之后，主线程会获取锁并打印出程序的结果。 之前提示过这个例子不能编译，让我们看看为什么！ -``` -error[E0373]: closure may outlive the current function, but it borrows -`counter`, which is owned by the current function - --> - | -9 | let handle = thread::spawn(|| { - | ^^ may outlive borrowed value `counter` -10 | let mut num = counter.lock().unwrap(); - | ------- `counter` is borrowed here - | -help: to force the closure to take ownership of `counter` (and any other -referenced variables), use the `move` keyword, as shown: - | let handle = thread::spawn(move || { -``` -这类似于示例 16-5 中解决了的问题。考虑到启动了多个线程，Rust 无法知道这些线程会运行多久，而在每一个线程尝试借用 `counter` 时它是否仍然有效。帮助信息提醒了我们如何解决它：可以使用 `move` 来给予每个线程其所有权。尝试在闭包上做一点改动： - -```rust,ignore -thread::spawn(move || { -``` - -再次编译。这回出现了一个不同的错误！ - -``` +```text error[E0382]: capture of moved value: `counter` - --> + --> src/main.rs:10:27 | 9 | let handle = thread::spawn(move || { | ------- value moved (into closure) here @@ -134,7 +112,7 @@ error[E0382]: capture of moved value: `counter` which does not implement the `Copy` trait error[E0382]: use of moved value: `counter` - --> + --> src/main.rs:21:29 | 9 | let handle = thread::spawn(move || { | ------- value moved (into closure) here @@ -148,9 +126,9 @@ error[E0382]: use of moved value: `counter` error: aborting due to 2 previous errors ``` -`move` 并没有像示例 16-5 中那样解决问题。为什么呢？错误信息有点难懂，因为它表明 `counter` 被移动进了闭包，接着它在调用 `lock` 时被捕获。这似乎是我们希望的，然而不被允许。 +错误信息表明 `counter` 值被移动进了闭包并当调用 `lock` 时被捕获。这听起来正是我们需要的，但是这是不允许的！ -让我们推理一下。这次不再使用 `for` 循环创建 10 个线程，只创建两个线程，看看会发生什么。将示例 16-13 中第一个`for`循环替换为如下代码： +让我们简化程序来进行分析。不同于在 `for` 循环中创建 10 个线程，仅仅创建两个线程来观察发生了什么。将示例 16-13 中第一个 `for` 循环替换为如下代码： ```rust,ignore let handle = thread::spawn(move || { @@ -168,23 +146,23 @@ let handle2 = thread::spawn(move || { handles.push(handle2); ``` -这里创建了两个线程，并将第二个线程所用的变量改名为 `handle2` 和 `num2`。我们简化了例子，看是否能理解错误信息。此次编译给出如下信息： +这里创建了两个线程并将用于第二个线程的变量名改为 `handle2` 和 `num2`。这一次当运行代码时，编译会给出如下错误： ```text error[E0382]: capture of moved value: `counter` - --> + --> src/main.rs:16:24 | 8 | let handle = thread::spawn(move || { | ------- value moved (into closure) here ... -16 | let mut num = counter.lock().unwrap(); - | ^^^^^^^ value captured here after move +16 | let mut num2 = counter.lock().unwrap(); + | ^^^^^^^ value captured here after move | = note: move occurs because `counter` has type `std::sync::Mutex`, which does not implement the `Copy` trait error[E0382]: use of moved value: `counter` - --> + --> src/main.rs:26:29 | 8 | let handle = thread::spawn(move || { | ------- value moved (into closure) here @@ -198,15 +176,15 @@ error[E0382]: use of moved value: `counter` error: aborting due to 2 previous errors ``` -啊哈！第一个错误信息中说，`counter` 被移动进了 `handle` 所代表线程的闭包中。因此我们无法在第二个线程中对其调用 `lock`，并将结果储存在 `num2` 中时捕获`counter`！所以 Rust 告诉我们不能将 `counter` 的所有权移动到多个线程中。这在之前很难看出，因为我们在循环中创建了多个线程，而 Rust 无法在每次迭代中指明不同的线程（没有临时变量 `num2`）。 +啊哈！第一个错误信息中说，`counter` 被移动进了 `handle` 所代表线程的闭包中。因此我们无法在第二个线程中对其调用 `lock`，并将结果储存在 `num2` 中时捕获`counter`！所以 Rust 告诉我们不能将 `counter` 的所有权移动到多个线程中。这在之前很难看出，因为我们在循环中创建了多个线程，而 Rust 无法在每次迭代中指明不同的线程。让我们通过一个第十五章讨论过的多所有权手段来修复这个编译错误。 #### 多线程和多所有权 -在第十五章中，我们通过使用智能指针 `Rc` 来创建引用计数的值，以便拥有多所有权。同时第十五章提到了 `Rc` 只能在单线程环境中使用，不过还是在这里试用 `Rc` 看看会发生什么。示例 16-14 将 `Mutex` 装进了 `Rc` 中，并在移入线程之前克隆了 `Rc`。再用循环来创建线程，保留闭包中的 `move` 关键字： +在第十五章中，通过使用智能指针 `Rc` 来创建引用计数的值，以便拥有多所有者。让我们在这也这么做看看会发生什么。将示例 16-14 中的 `Mutex` 封装进 `Rc` 中并在将所有权移入线程之前克隆了 `Rc`。现在我们理解了所发生的错误，同时也将代码改回使用 `for` 循环，并保留闭包的 `move` 关键字： 文件名: src/main.rs -```rust +```rust,ignore use std::rc::Rc; use std::sync::Mutex; use std::thread; @@ -216,7 +194,7 @@ fn main() { let mut handles = vec![]; for _ in 0..10 { - let counter = counter.clone(); + let counter = Rc::clone(&counter); let handle = thread::spawn(move || { let mut num = counter.lock().unwrap(); @@ -237,34 +215,37 @@ fn main() { 再一次编译并...出现了不同的错误！编译器真是教会了我们很多！ -``` +```text error[E0277]: the trait bound `std::rc::Rc>: -std::marker::Send` is not satisfied - --> +std::marker::Send` is not satisfied in `[closure@src/main.rs:11:36: +15:10 +counter:std::rc::Rc>]` + --> src/main.rs:11:22 | 11 | let handle = thread::spawn(move || { - | ^^^^^^^^^^^^^ the trait `std::marker::Send` is not - implemented for `std::rc::Rc>` + | ^^^^^^^^^^^^^ `std::rc::Rc>` +cannot be sent between threads safely | - = note: `std::rc::Rc>` cannot be sent between threads - safely + = help: within `[closure@src/main.rs:11:36: 15:10 +counter:std::rc::Rc>]`, the trait `std::marker::Send` is +not implemented for `std::rc::Rc>` = note: required because it appears within the type - `[closure@src/main.rs:11:36: 15:10 - counter:std::rc::Rc>]` +`[closure@src/main.rs:11:36: 15:10 +counter:std::rc::Rc>]` = note: required by `std::thread::spawn` ``` -哇哦，太长不看！说重点：第一个提示表明 `Rc>` 不能安全的在线程间传递。理由也在错误信息中，“不满足 `Send` trait bound”（`the trait bound Send is not satisfied`）。下一部分将会讨论 `Send`，它是确保许多用在多线程中的类型，能够适合并发环境的 trait 之一。 +哇哦，错误信息太长不看！这里是一些需要注意的重要部分：第一行错误表明 `` `std::rc::Rc>` cannot be sent between threads safely ``。其原因是另一个值得注意的部分，经过提炼的错误信息表明 `` the trait bound `Send` is not satisfied ``。下一部分会讲到 `Send`：这是确保所使用的类型意在用于并发环境的 trait 之一。 -不幸的是，`Rc` 并不能安全的在线程间共享。当 `Rc` 管理引用计数时，它必须在每一个 `clone` 调用时增加计数，并在每一个克隆被丢弃时减少计数。`Rc` 并没有使用任何并发原语，来确保改变计数的操作不会被其他线程打断。在计数出错时可能会导致诡异的 bug，比如可能会造成内存泄漏，或在使用结束之前就丢弃一个值。如果有一个类型与 `Rc` 相似，又以一种线程安全的方式改变引用计数，会怎么样呢？ +不幸的是，`Rc` 并不能安全的在线程间共享。当 `Rc` 管理引用计数时，它必须在每一个 `clone` 调用时增加计数，并在每一个克隆被丢弃时减少计数。`Rc` 并没有使用任何并发原语，来确保改变计数的操作不会被其他线程打断。在计数出错时可能会导致诡异的 bug，比如可能会造成内存泄漏，或在使用结束之前就丢弃一个值。我们所需要的是一个完全类似 `Rc`，又以一种线程安全的方式改变引用计数的类型。 #### 原子引用计数 `Arc` -答案是肯定的，确实有一个类似`Rc`并可以安全的用于并发环境的类型：`Arc`。字母“a”代表**原子性**（*atomic*），所以这是一个**原子引用计数**（*atomically reference counted*）类型。原子性是另一类这里还未涉及到的并发原语；请查看标准库中`std::sync::atomic`的文档来获取更多细节。其中的要点就是：原子性类型工作起来类似原始类型，不过可以安全的在线程间共享。 +所幸 `Arc` **正是** 这么一个类似 `Rc` 并可以安全的用于并发环境的类型。字母 “a” 代表 **原子性**（*atomic*），所以这是一个**原子引用计数**（*atomically reference counted*）类型。原子性是另一类这里还未涉及到的并发原语：请查看标准库中 `std::sync::atomic` 的文档来获取更多细节。其中的要点就是：原子性类型工作起来类似原始类型，不过可以安全的在线程间共享。 -为什么不是所有的原始类型都是原子性的？为什么不是所有标准库中的类型都默认使用`Arc`实现？线程安全带来性能惩罚，我们希望只在必要时才为此买单。如果只是在单线程中对值进行操作，原子性提供的保证并无必要，代码可以因此运行的更快。 +你可能会好奇为什么不是所有的原始类型都是原子性的？为什么不是所有标准库中的类型都默认使用 `Arc` 实现？原因在于线程安全带有性能惩罚，我们希望只在必要时才为此买单。如果只是在单线程中对值进行操作，原子性提供的保证并无必要，代码可以因此运行的更快。 -回到之前的例子：`Arc`和`Rc`除了`Arc`内部的原子性之外没有区别。其 API 也相同，所以可以修改`use`行和`new`调用。示例 16-15 中的代码最终可以编译和运行： +回到之前的例子：`Arc` 和 `Rc` 有着相同的 API，所以修改程序修改 `use` 行和 `new` 调用。示例 16-15 中的代码最终可以编译和运行： 文件名: src/main.rs @@ -277,7 +258,7 @@ fn main() { let mut handles = vec![]; for _ in 0..10 { - let counter = counter.clone(); + let counter = Arc::clone(&counter); let handle = thread::spawn(move || { let mut num = counter.lock().unwrap(); @@ -298,16 +279,16 @@ fn main() { 这会打印出： -``` +```text Result: 10 ``` -成功了！我们从 0 数到了 10，这可能并不是很显眼，不过一路上我们学习了很多关于`Mutex`和线程安全的内容！这个例子中构建的结构可以用于比增加计数更为复杂的操作。能够被分解为独立部分的计算可以像这样被分散到多个线程中，并可以使用`Mutex`来允许每个线程在他们自己的部分更新最终的结果。 +成功了！我们从 0 数到了 10，这可能并不是很显眼，不过一路上我们确实学习了很多关于 `Mutex` 和线程安全的内容！这个例子中构建的结构可以用于比增加计数更为复杂的操作。使用这个策略，可将计算分成独立的部分，分散到多个线程中，接着使用 `Mutex` 使用各自的结算结果更新最终的结果。 -你可能注意到了，因为`counter`是不可变的，不过可以获取其内部值的可变引用，这意味着`Mutex`提供了内部可变性，就像`Cell`系列类型那样。正如第十五章中使用`RefCell`可以改变`Rc`中的内容那样，同样的可以使用`Mutex`来改变`Arc`中的内容。 +### `RefCell`/`Rc` 与 `Mutex`/`Arc` 的相似性 -回忆一下`Rc`并没有避免所有可能的问题：我们也讨论了当两个`Rc`相互引用时的引用循环的可能性，这可能造成内存泄露。`Mutex`有一个类似的 Rust 同样也不能避免的问题：死锁。**死锁**（*deadlock*）是一个场景中操作需要锁定两个资源，而两个线程分别拥有一个锁并永远相互等待的问题。如果你对这个主题感兴趣，尝试编写一个带有死锁的 Rust 程序，接着研究任何其他语言中使用互斥器的死锁规避策略并尝试在 Rust 中实现他们。标准库中`Mutex`和`MutexGuard`的 API 文档会提供有用的信息。 +你可能注意到了，因为 `counter` 是不可变的，不过可以获取其内部值的可变引用；这意味着 `Mutex` 提供了内部可变性，就像 `Cell` 系列类型那样。正如第十五章中使用 `RefCell` 可以改变 `Rc` 中的内容那样，同样的可以使用 `Mutex` 来改变 `Arc` 中的内容。 -Rust 的类型系统和所有权规则，确保了线程在更新共享值时拥有独占的访问权限，所以线程不会以不可预测的方式覆盖彼此的操作。虽然为了使一切正确运行而在编译器上花了一些时间，但是我们节省了未来的时间，尤其是线程以特定顺序执行才会出现的诡异错误难以重现。 +另一个值得注意的细节是 Rust 不能避免使用 `Mutex` 的全部逻辑错误。回忆一下第十五章使用 `Rc` 就有造成引用循环的风险，这时两个 `Rc` 值相互引用，造成内存泄露。同理，`Mutex` 也有造成 **死锁**（*deadlock*） 的风险。这发生于当一个操作需要锁住两个资源而两个线程各持一个锁，这会造成它们永远相互等待。如果你对这个主题感兴趣，尝试编写一个带有死锁的 Rust 程序，接着研究任何其他语言中使用互斥器的死锁规避策略并尝试在 Rust 中实现他们。标准库中 `Mutex` 和 `MutexGuard` 的 API 文档会提供有用的信息。 -接下来，为了丰富本章的内容，让我们讨论一下`Send`和`Sync` trait 以及如何对自定义类型使用他们。 \ No newline at end of file +接下来，为了丰富本章的内容，让我们讨论一下 `Send`和 `Sync` trait 以及如何对自定义类型使用他们。 \ No newline at end of file diff --git a/src/ch16-04-extensible-concurrency-sync-and-send.md b/src/ch16-04-extensible-concurrency-sync-and-send.md index c72d4f7..a03773d 100644 --- a/src/ch16-04-extensible-concurrency-sync-and-send.md +++ b/src/ch16-04-extensible-concurrency-sync-and-send.md @@ -1,41 +1,41 @@ -## 使用`Sync`和`Send` trait 的可扩展并发 +## 使用 `Sync` 和 `Send` trait 的可扩展并发 > [ch16-04-extensible-concurrency-sync-and-send.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch16-04-extensible-concurrency-sync-and-send.md) >
-> commit 9430a3d28a2121a938d704ce48b15d21062f880e +> commit 90406bd5a4cd4447b46cd7e03d33f34a651e9bb7 -Rust 的并发模型中一个有趣的方面是：语言本身对并发知之**甚少**。我们之前讨论的几乎所有内容，都属于标准库，而不是语言本身的内容。由于不需要语言提供并发相关的基础设施，并发方案不受标准库或语言所限：我们可以编写自己的或使用别人编写的。 +Rust 的并发模型中一个有趣的方面是：语言本身对并发知之 **甚少**。我们之前讨论的几乎所有内容，都属于标准库，而不是语言本身的内容。由于不需要语言提供并发相关的基础设施，并发方案不受标准库或语言所限：我们可以编写自己的或使用别人编写的并发功能。 -我们说“**几乎**所有内容都不属于语言本身”，那么属于语言本身的是什么呢？是两个 trait，都位于`std::marker`： `Sync`和`Send`。 +然而有两个并发概念是内嵌于语言中的：`std::marker` 中的 `Sync` 和 `Send` trait。 -### `Send`用于表明所有权可能被传送给其他线程 +### 通过 `Send` 允许在线程间转移所有权 -`Send`标记 trait 表明类型的所有权可能被在线程间传递。几乎所有的 Rust 类型都是`Send`的，不过有一些例外。比如标准库中提供的 `Rc`：如果克隆`Rc`值，并尝试将克隆的所有权传递给另一个线程，这两个线程可能会同时更新引用计数。正如上一部分提到的，`Rc`被实现为用于单线程场景，这时不需要为拥有线程安全的引用计数而付出性能代价。 +`Send` 标记 trait 表明类型的所有权可以在线程间传递。几乎所有的 Rust 类型都是`Send` 的，不过有一些例外，包括 `Rc`：这是不能 `Send` 的，因为如果克隆了 `Rc` 的值并尝试将克隆的所有权转移到另一个线程，这两个线程都可能同时更新引用计数。为此，`Rc` 被实现为用于单线程场景，这时不需要为拥有线程安全的引用计数而付出性能代价。 -因为 `Rc` 没有标记为 `Send`，Rust 的类型系统和 trait bound 会确保我们不会错误的把一个 `Rc` 值不安全的在线程间传递。列表 16-14 曾尝试这么做，不过得到了一个错误，`the trait Send is not implemented for Rc>`。而使用标记为 `Send` 的 `Arc` 时，就没有问题了。 +因此，Rust 类型系统和 trait bound 确保永远也不会意外的将不安全的 `Rc` 在线程间发送。当尝试在示例 16-14 中这么做的时候，会得到错误 `the trait Send is not implemented for Rc>`。而使用标记为 `Send` 的 `Arc` 时，就没有问题了。 -任何完全由 `Send` 的类型组成的类型也会自动被标记为 `Send`：几乎所有基本类型都是 `Send` 的，大部分标准库类型是`Send`的，除了`Rc`，以及第十九章将会讨论的裸指针（raw pointer）。 +任何完全由 `Send` 的类型组成的类型也会自动被标记为 `Send`。几乎所有基本类型都是 `Send` 的，除了第十九章将会讨论的裸指针（raw pointer）。 -### `Sync` 表明多线程访问是安全的 +### `Sync` 允许多线程访问 -`Sync` 标记 trait 表明一个类型可以安全的在多个线程中拥有其值的引用。换一种方式来说，对于任意类型 `T`，如果`&T`（`T`的引用）是`Send`的话`T`就是`Sync`的，这样其引用就可以安全的发送到另一个线程。类似于 `Send` 的情况，基本类型是 `Sync` 的，完全由 `Sync` 的类型组成的类型也是 `Sync` 的。 +`Sync` 标记 trait 表明一个实现了 `Sync` 的类型可以安全的在多个线程中拥有其值的引用。换一种方式来说，对于任意类型 `T`，如果 `&T`（`T` 的引用）是 `Send` 的话 `T` 就是 `Sync` 的，这意味着其引用就可以安全的发送到另一个线程。类似于 `Send` 的情况，基本类型是 `Sync` 的，完全由 `Sync` 的类型组成的类型也是 `Sync` 的。 -`Rc` 也不是 `Sync` 的，出于其不是`Send`的相同的原因。`RefCell`（第十五章讨论过）和`Cell`系列类型不是`Sync`的。`RefCell`在运行时所进行的借用检查也不是线程安全的。`Mutex`是`Sync`的，正如上一部分所讲的它可以被用来在多线程中共享访问。 +智能指针 `Rc` 也不是 `Sync` 的，出于其不是 `Send` 相同的原因。`RefCell`（第十五章讨论过）和 `Cell` 系列类型不是 `Sync` 的。`RefCell` 在运行时所进行的借用检查也不是线程安全的。`Mutex` 是 `Sync` 的，正如 “在线程间共享 `Mutex`” 部分所讲的它可以被用来在多线程中共享访问。 -### 手动实现`Send`和`Sync`是不安全的 +### 手动实现 `Send` 和 `Sync` 是不安全的 -通常并不需要实现`Send`和`Sync` trait，由属于`Send`和`Sync`的类型组成的类型，自动就是`Send`和`Sync`的。因为他们是标记 trait，甚至都不需要实现任何方法。他们只是用来加强并发相关的不可变性的。 +通常并不需要手动实现 `Send` 和 `Sync` trait，因为由 `Send` 和 `Sync` 的类型组成的类型，自动就是 `Send` 和 `Sync` 的。因为他们是标记 trait，甚至都不需要实现任何方法。他们只是用来加强并发相关的不可变性的。 -实现这些标记 trait 涉及到编写不安全的 Rust 代码，第十九章将会讲述具体的方法；当前重要的是，在创建新的由不是`Send`和`Sync`的部分构成的并发类型时需要多加小心，以确保维持其安全保证。[The Nomicon] 中有更多关于这些保证以及如何维持他们的信息。 +手动实现这些标记 trait 涉及到编写不安全的 Rust 代码，第十九章将会讲述具体的方法；当前重要的是，在创建新的由不是 `Send` 和 `Sync` 的部分构成的并发类型时需要多加小心，以确保维持其安全保证。[The Nomicon] 中有更多关于这些保证以及如何维持他们的信息。 [The Nomicon]: https://doc.rust-lang.org/stable/nomicon/ ## 总结 -这不会是本书最后一个出现并发的章节；第二十章的项目会在更现实的场景中使用这些概念，而不像本章中讨论的这些小例子。 +这不会是本书最后一个出现并发的章节：第二十章的项目会在更现实的场景中使用这些概念，而不像本章中讨论的这些小例子。 -正如我们提到的，因为 Rust 本身很少有处理并发的部分内容，有很多的并发方案都由 crate 实现。他们比标准库要发展的更快；请在网上搜索当前最新的用于多线程场景的 crate。 +正如之前提到的，因为 Rust 本身很少有处理并发的部分内容，有很多的并发方案都由 crate 实现。他们比标准库要发展的更快；请在网上搜索当前最新的用于多线程场景的 crate。 -Rust 提供了用于消息传递的通道，和像`Mutex`和`Arc`这样可以安全的用于并发上下文的智能指针。类型系统和借用检查器会确保这些场景中的代码，不会出现数据竞争和无效的引用。一旦代码可以编译了，我们就可以坚信这些代码可以正确的运行于多线程环境，而不会出现其他语言中经常出现的那些难以追踪的 bug。并发编程不再是什么可怕的概念：无所畏惧地并发吧！ +Rust 提供了用于消息传递的通道，和像 `Mutex` 和 `Arc` 这样可以安全的用于并发上下文的智能指针。类型系统和借用检查器会确保这些场景中的代码，不会出现数据竞争和无效的引用。一旦代码可以编译了，我们就可以坚信这些代码可以正确的运行于多线程环境，而不会出现其他语言中经常出现的那些难以追踪的 bug。并发编程不再是什么可怕的概念：无所畏惧地并发吧！ 接下来，让我们讨论一下当 Rust 程序变得更大时，有哪些符合语言习惯的问题建模方法和结构化解决方案，以及 Rust 的风格是如何与面向对象编程（Object Oriented Programming）中那些你所熟悉的概念相联系的。 \ No newline at end of file diff --git a/src/ch17-00-oop.md b/src/ch17-00-oop.md index 355b887..68c6c99 100644 --- a/src/ch17-00-oop.md +++ b/src/ch17-00-oop.md @@ -2,6 +2,6 @@ > [ch17-00-oop.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch17-00-oop.md) >
-> commit 759801361bde74b47e81755fff545c66020e6e63 +> commit 28d0efb644d18e8d104c2e813c8cdce50d040d3d -面向对象编程（Object-Oriented Programming）是一种起源于 20 世纪 60 年代的 Simula 编程语言的模式化编程方式，然后在 90 年代随着 C++ 语言开始流行。关于 OOP 是什么有很多相互矛盾的定义：在一些定义下，Rust 是面向对象的；在其他定义下，Rust 不是。在本章节中，我们会探索一些被普遍认为是面向对象的特性和这些特性是如何体现在 Rust 语言习惯中的。 \ No newline at end of file +面向对象编程（Object-Oriented Programming）是一种起源于 20 世纪 60 年代的 Simula 编程语言的模式化编程方式，然后在 90 年代随着 C++ 语言开始流行。关于 OOP 是什么有很多相互矛盾的定义，在一些定义下，Rust 是面向对象的；在其他定义下，Rust 不是。在本章节中，我们会探索一些被普遍认为是面向对象的特性和这些特性是如何体现在 Rust 语言习惯中的。接着会展示如何在 Rust 中实现面向对象设计模式，并讨论这么做与利用 Rust 自身的一些优势实现的方案相比有什么取舍。 \ No newline at end of file From bf638f3fc9bc607277d5e60290ba1f0c1b0b43e4 Mon Sep 17 00:00:00 2001 From: pearzl <302669696@qq.com> Date: Mon, 19 Feb 2018 22:14:54 +0800 Subject: [PATCH 131/150] Update ch15-05-interior-mutability.md --- src/ch15-05-interior-mutability.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch15-05-interior-mutability.md b/src/ch15-05-interior-mutability.md index d827cc0..f2ee789 100644 --- a/src/ch15-05-interior-mutability.md +++ b/src/ch15-05-interior-mutability.md @@ -139,7 +139,7 @@ impl<'a, T> LimitTracker<'a, T> 示例 15-23：一个记录某个值与最大值差距的库，并根据此值的特定级别发出警告 -这些代码中一个重要部分是拥有一个方法 `send` 的 `Messenger` trait，其获取一个 `self` 的可变引用和文本信息。这是我们的 mock 对象所需要拥有的接口。另一个重要的部分是我们需要测试 `LimitTracker` 的 `set_value` 方法的行为。可以改变传递的 `value` 参数的值，不过 `set_value` 并没有返回任何可供断言的值。也就是说，如果使用某个实现了 `Messenger` trait 的值和特定的 `max` 创建 `LimitTracker`，当传递不同 `value` 值时，消息发送者应被告知发送合适的消息。 +这些代码中一个重要部分是拥有一个方法 `send` 的 `Messenger` trait，其获取一个 `self` 的不可变引用和文本信息。这是我们的 mock 对象所需要拥有的接口。另一个重要的部分是我们需要测试 `LimitTracker` 的 `set_value` 方法的行为。可以改变传递的 `value` 参数的值，不过 `set_value` 并没有返回任何可供断言的值。也就是说，如果使用某个实现了 `Messenger` trait 的值和特定的 `max` 创建 `LimitTracker`，当传递不同 `value` 值时，消息发送者应被告知发送合适的消息。 我们所需的 mock 对象是，调用 `send` 不同于实际发送 email 或短息，其只记录信息被通知要发送了。可以新建一个 mock 对象示例，用其创建 `LimitTracker`，调用 `LimitTracker` 的 `set_value` 方法，然后检查 mock 对象是否有我们期望的消息。示例 15-24 展示了一个如此尝试的 mock 对象实现，不过借用检查器并不允许： From 164149c269604ecd22ed9c42db5d68c487619bb9 Mon Sep 17 00:00:00 2001 From: rhgb Date: Thu, 22 Feb 2018 13:38:33 +0800 Subject: [PATCH 132/150] typo --- src/ch15-02-deref.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch15-02-deref.md b/src/ch15-02-deref.md index 56a27d4..a6d2025 100644 --- a/src/ch15-02-deref.md +++ b/src/ch15-02-deref.md @@ -17,7 +17,7 @@ different way in the below paragraph /Carol --> 让我们首先看看 `*` 如何处理引用，接着尝试定义我们自己的类 `Box` 类型并看看为何 `*` 不能像引用一样工作。我们会探索如何实现 `Deref` trait 使得智能指针以类似引用的方式工作变为可能。最后，我们会讨论 Rust 的 **解引用强制多态**（*deref coercions*）功能和它是如何一同处理引用或智能指针的。 -### 通过 `*` 追钟指针的值 +### 通过 `*` 追踪指针的值 From d2d3fd24e3af0f9f4774890b393dd4db594699da Mon Sep 17 00:00:00 2001 From: rhgb Date: Thu, 22 Feb 2018 13:44:16 +0800 Subject: [PATCH 133/150] Update ch15-02-deref.md --- src/ch15-02-deref.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch15-02-deref.md b/src/ch15-02-deref.md index a6d2025..5374b40 100644 --- a/src/ch15-02-deref.md +++ b/src/ch15-02-deref.md @@ -294,7 +294,7 @@ fn main() { `(*m)` 将 `MyBox` 解引用为 `String`。接着 `&` 和 `[..]` 获取了整个 `String` 的字符串 slice 来匹配 `hello` 的签名。没有解引用强制多态所有这些符号混在一起将更难以读写和理解。解引用强制多态使得 Rust 自动的帮我们处理这些转换。 -当所涉及到的类型定义了 `Deref` trait，Rust 会分析这些类型并使用任意多次 `Deref::deref` 调用以获得匹配参数的类型。这写解析都发生在编译时，所以利用解引用强制多态并没有运行时惩罚！ +当所涉及到的类型定义了 `Deref` trait，Rust 会分析这些类型并使用任意多次 `Deref::deref` 调用以获得匹配参数的类型。这些解析都发生在编译时，所以利用解引用强制多态并没有运行时惩罚！ ### 解引用强制多态如何与可变性交互 From e5da938983bad4fa1c6693bb0fca2a5c0709dcd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=BB=84=E8=9E=8D?= Date: Sun, 25 Feb 2018 17:40:20 +0800 Subject: [PATCH 134/150] Update ch14-03-cargo-workspaces.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 显示的->显式地 --- src/ch14-03-cargo-workspaces.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ch14-03-cargo-workspaces.md b/src/ch14-03-cargo-workspaces.md index b9d1c54..06490b8 100644 --- a/src/ch14-03-cargo-workspaces.md +++ b/src/ch14-03-cargo-workspaces.md @@ -104,7 +104,7 @@ pub fn add_one(x: i32) -> i32 { add-one = { path = "../add-one" } ``` -工作空间中的 crate 不必相互依赖，所以仍需显示的表明工作空间中 crate 的依赖关系。 +工作空间中的 crate 不必相互依赖，所以仍需显式地表明工作空间中 crate 的依赖关系。 接下来，在 `adder` crate 中使用 `add-one` crate 的函数 `add_one`。打开 *adder/src/main.rs* 在顶部增加一行 `extern crate` 将新 `add-one` 库 crate 引入作用域。接着修改 `main` 函数来调用 `add_one` 函数，如示例 14-7 所示： @@ -324,4 +324,4 @@ test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out 现在尝试以类似 `add-one` crate 的方式向工作空间增加 `add-two` crate 来作为更多的练习！ -随着项目增长，考虑使用工作空间：每一个更小的组件比一大块代码要容易理解。将 crate 保持在工作空间中更易于协调他们的改变，如果他们一起运行并经常需要同时被修改的话。 \ No newline at end of file +随着项目增长，考虑使用工作空间：每一个更小的组件比一大块代码要容易理解。将 crate 保持在工作空间中更易于协调他们的改变，如果他们一起运行并经常需要同时被修改的话。 From 53aca5cc3d5286f7204429286faf4f6d71d91635 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Sun, 25 Feb 2018 20:43:24 +0800 Subject: [PATCH 135/150] check to ch17-01 --- src/ch17-01-what-is-oo.md | 62 ++++++++++++++++++++++++--------------- 1 file changed, 38 insertions(+), 24 deletions(-) diff --git a/src/ch17-01-what-is-oo.md b/src/ch17-01-what-is-oo.md index 1e0d687..2594626 100644 --- a/src/ch17-01-what-is-oo.md +++ b/src/ch17-01-what-is-oo.md @@ -2,27 +2,35 @@ > [ch17-01-what-is-oo.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch17-01-what-is-oo.md) >
-> commit 2a9b2a1b019ad6d4832ff3e56fbcba5be68b250e +> commit e7df3050309924827ff828ddc668a8667652d2fe -关于一个语言被称为面向对象所需的功能，在编程社区内并未达成一致意见。Rust 被很多不同的编程范式影响；我们探索了十三章提到的来自函数式编程的特性。面向对象编程语言所共享的一些特性往往是对象、封装和继承。让我们看一下这每一个概念的含义以及 Rust 是否支持他们。 +关于一个语言被称为面向对象所需的功能，在编程社区内并未达成一致意见。Rust 被很多不同的编程范式影响，包括面向对象编程；比如第十三章提到了来自函数式编程的特性。面向对象编程语言所共享的一些特性往往是对象、封装和继承。让我们看一下这每一个概念的含义以及 Rust 是否支持他们。 ### 对象包含数据和行为 -`Design Patterns: Elements of Reusable Object-Oriented Software`这本书被俗称为`The Gang of Four book`，是面向对象编程模式的目录。它这样定义面向对象编程： + + + +`Design Patterns: Elements of Reusable Object-Oriented Software` 这本书被俗称为 `The Gang of Four book`，是面向对象编程模式的目录。它这样定义面向对象编程： > Object-oriented programs are made up of objects. An *object* packages both > data and the procedures that operate on that data. The procedures are > typically called *methods* or *operations*. > -> 面向对象的程序是由对象组成的。一个**对象**包含数据和操作这些数据的过程。这些过程通常被称为**方法**或**操作**。 +> 面向对象的程序是由对象组成的。一个 **对象** 包含数据和操作这些数据的过程。这些过程通常被称为 **方法** 或 **操作**。 -在这个定义下，Rust 是面向对象的：结构体和枚举包含数据而 impl 块提供了在结构体和枚举之上的方法。虽然带有方法的结构体和枚举并不被**称为**对象，但是他们提供了与对象相同的功能，参考 Gang of Four 中对象的定义。 +在这个定义下，Rust 是面向对象的：结构体和枚举包含数据而 impl 块提供了在结构体和枚举之上的方法。虽然带有方法的结构体和枚举并不被 **称为** 对象，但是他们提供了与对象相同的功能，参考 Gang of Four 中对象的定义。 -### 隐藏了实现细节的封装 +### 封装隐藏了实现细节 -另一个通常与面向对象编程相关的方面是**封装**（*encapsulation*）的思想：对象的实现细节不能被使用对象的代码获取到。唯一与对象交互的方式是通过对象提供的公有 API；使用对象的代码无法深入到对象内部并直接改变数据或者行为。封装使得改变和重构对象的内部时无需改变使用对象的代码。 +另一个通常与面向对象编程相关的方面是 **封装**（*encapsulation*）的思想：对象的实现细节不能被使用对象的代码获取到。唯一与对象交互的方式是通过对象提供的公有 API；使用对象的代码无法深入到对象内部并直接改变数据或者行为。封装使得改变和重构对象的内部时无需改变使用对象的代码。 -就像我们在第七章讨论的那样，可以使用`pub`关键字来决定模块、类型函数和方法是公有的，而默认情况下一切都是私有的。比如，我们可以定义一个包含一个`i32`类型的 vector 的结构体`AveragedCollection `。结构体也可以有一个字段，该字段保存了 vector 中所有值的平均值。这样，希望知道结构体中的 vector 的平均值的人可以随时获取它，而无需自己计算。`AveragedCollection`会为我们缓存平均值结果。列表 17-1 有`AveragedCollection`结构体的定义： +就像我们在第七章讨论的那样：可以使用 `pub` 关键字来决定模块、类型、函数和方法是公有的，而默认情况下其他一切都是私有的。比如，我们可以定义一个包含一个 `i32` 类型 vector 的结构体 `AveragedCollection `。结构体也可以有一个字段，该字段保存了 vector 中所有值的平均值。这样，希望知道结构体中的 vector 的平均值的人可以随时获取它，而无需自己计算。换句话说，`AveragedCollection` 会为我们缓存平均值结果。示例 17-1 有 `AveragedCollection` 结构体的定义： 文件名: src/lib.rs @@ -33,9 +41,9 @@ pub struct AveragedCollection { } ``` -列表 17-1: `AveragedCollection`结构体维护了一个整型列表和集合中所有元素的平均值。 +示例 17-1: `AveragedCollection` 结构体维护了一个整型列表和集合中所有元素的平均值。 -注意，结构体自身被标记为`pub`，这样其他代码可以使用这个结构体，但是在结构体内部的字段仍然是私有的。这是非常重要的，因为我们希望保证变量被增加到列表或者被从列表删除时，也会同时更新平均值。可以通过在结构体上实现`add`、`remove`和`average`方法来做到这一点，如列表 17-2 所示： +注意，结构体自身被标记为 `pub`，这样其他代码就可以使用这个结构体，但是在结构体内部的字段仍然是私有的。这是非常重要的，因为我们希望保证变量被增加到列表或者被从列表删除时，也会同时更新平均值。可以通过在结构体上实现 `add`、`remove` 和 `average` 方法来做到这一点，如示例 17-2 所示： 文件名: src/lib.rs @@ -72,32 +80,38 @@ impl AveragedCollection { } ``` -列表 17-2: 在`AveragedCollection`结构体上实现了`add`、`remove`和`average`公有方法 +示例 17-2: 在`AveragedCollection` 结构体上实现了`add`、`remove` 和 `average` 公有方法 -公有方法`add`、`remove`和`average`是修改`AveragedCollection`实例的唯一方式。当使用`add`方法把一个元素加入到`list`或者使用`remove`方法来删除它时，这些方法的实现同时会调用私有的`update_average`方法来更新`average`字段。因为`list`和`average`是私有的，没有其他方式来使得外部的代码直接向`list`增加或者删除元素，直接操作`list`可能会引发`average`字段不同步。`average`方法返回`average`字段的值，这使得外部的代码只能读取`average`而不能修改它。 +公有方法 `add`、`remove` 和 `average` 是修改 `AveragedCollection` 实例的唯一方式。当使用 `add` 方法把一个元素加入到 `list` 或者使用 `remove` 方法来删除时，这些方法的实现同时会调用私有的 `update_average` 方法来更新 `average` 字段。 -因为我们已经封装好了`AveragedCollection`的实现细节，将来可以轻松改变类似数据结构这些方面的内容。例如，可以使用`HashSet`代替`Vec`作为`list`字段的类型。只要`add`、`remove`和`average`公有函数的签名保持不变，使用`AveragedCollection`的代码就无需改变。如果将`List`暴露给外部代码时，未必都是这样，因为`HashSet`和`Vec`使用不同的方法增加或移除项，所以如果要想直接修改`list`的话，外部的代码可能不得不修改。 +`list` 和 `average` 是私有的，所以没有其他方式来使得外部的代码直接向 `list` 增加或者删除元素，否则 `list` 改变时可能会导致 `average` 字段不同步。`average` 方法返回 `average` 字段的值，这使得外部的代码只能读取 `average` 而不能修改它。 -如果封装是一个语言被认为是面向对象语言所必要的方面的话，那么 Rust 就满足这个要求。在代码中不同的部分使用或者不使用`pub`决定了实现细节的封装。 +因为我们已经封装好了 `AveragedCollection` 的实现细节，将来可以轻松改变类似数据结构这些方面的内容。例如，可以使用 `HashSet` 代替 `Vec` 作为 `list` 字段的类型。只要 `add`、`remove` 和 `average` 公有函数的签名保持不变，使用 `AveragedCollection` 的代码就无需改变。相反如果使得 `list` 为公有，就未必都会如此了： `HashSet` 和 `Vec` 使用不同的方法增加或移除项，所以如果要想直接修改 `list` 的话，外部的代码可能不得不做出修改。 -## 作为类型系统的继承和作为代码共享的继承 +如果封装是一个语言被认为是面向对象语言所必要的方面的话，那么 Rust 满足这个要求。在代码中不同的部分使用 `pub` 与否可以封装其实现细节。 -**继承**（*Inheritance*）是一个很多编程语言都提供的机制，一个对象可以定义为继承另一个对象的定义，这使其可以获得父对象的数据和行为，而不用重新定义。一些人定义面向对象语言时，认为继承是一个特色。 +## 继承，作为类型系统与代码共享 -如果一个语言必须有继承才能被称为面向对象语言的话，那么 Rust 就不是面向对象的。无法定义一个结构体继承自另外一个结构体，从而获得父结构体的成员和方法。然而，如果你过去常常在你的编程工具箱使用继承，根据你希望使用继承的原因，Rust 也提供了其他的解决方案。 +**继承**（*Inheritance*）是一个很多编程语言都提供的机制，一个对象可以定义为继承另一个对象的定义，这使其可以获得父对象的数据和行为，而无需重新定义。 -使用继承有两个主要的原因。第一个是为了重用代码：一旦为一个类型实现了特定行为，继承可以对一个不同的类型重用这个实现。相反 Rust 代码可以使用默认 trait 方法实现来进行共享，在列表 10-14 中我们见过在`Summarizable` trait 上增加的`summary`方法的默认实现。任何实现了`Summarizable` trait 的类型都可以使用`summary`方法而无须进一步实现。这类似于父类有一个方法的实现，而通过继承子类也拥有这个方法的实现。当实现`Summarizable` trait 时也可以选择覆盖`summary`的默认实现，这类似于子类覆盖从父类继承的方法实现。 +如果一个语言必须有继承才能被称为面向对象语言的话，那么 Rust 就不是面向对象的。无法定义一个结构体继承父结构体的成员和方法。然而，如果你过去常常在你的编程工具箱使用继承，根据你最初考虑继承的原因，Rust 也提供了其他的解决方案。 -第二个使用继承的原因与类型系统有关：用来表现子类型可以在父类型被使用的地方使用。这也被称为**多态**（*polymorphism*），意味着如果多种对象有一个相同的形态大小，它们可以替代使用。 +选择继承有两个主要的原因。第一个是为了重用代码：一旦为一个类型实现了特定行为，继承可以对一个不同的类型重用这个实现。相反 Rust 代码可以使用默认 trait 方法实现来进行共享，在示例 10-15 中我们见过在 `Summarizable` trait 上增加的 `summary` 方法的默认实现。任何实现了 `Summarizable` trait 的类型都可以使用 `summary` 方法而无须进一步实现。这类似于父类有一个方法的实现，而通过继承子类也拥有这个方法的实现。当实现 `Summarizable` trait 时也可以选择覆盖 `summary` 的默认实现，这类似于子类覆盖从父类继承的方法实现。 + +第二个使用继承的原因与类型系统有关：表现为子类型可以用于父类型被使用的地方。这也被称为 **多态**（*polymorphism*），这意味着如果多种对象共享特定的属性，则可以相互替代使用。 + + + -> 虽然很多人使用“多态”（"polymorphism"）来描述继承，但是它实际上是一种特殊的多态，称为“子类型多态”（"sub-type polymorphism"）。也有很多种其他形式的多态，在 Rust 中带有泛型参数的 trait bound 也是多态，更具体的说是“参数多态”（"parametric polymorphism"）。不同类型多态的确切细节在这里并不关键，所以不要过于担心细节，只需要知道 Rust 有多种多态相关的特色就好，不同于很多其他 OOP 语言。 +> 多态（Polymorphism） +> +> 很多人将多态描述为继承的同义词。不过它是一个有关可以用于多种类型的代码的更广泛的概念。对于继承来说，这些类型通常是子类。Rust 则通过泛型来使得对多个不同类型的抽象成为可能，并通过 trait bounds 加强对这些类型所必须提供的内容的限制。这有时被称为 *bounded parametric polymorphism*。 -为了支持这种模式，Rust 有 **trait 对象**（*trait objects*），这样就可以使用任意类型的值，只要这个值实现了指定的 trait。 +近来继承作为一种语言设计的解决方案在很多语言中失宠了，因为其时常带有共享多于所需的代码的风险。子类不应总是共享其父类的多有特征，但是继承却始终如此。如此会使程序设计更为不灵活，并引入无意义的子类方法调用，或由于方法实际并不适用于子类而造成错误的可能性。某些语言还只允许子类继承一个父类，进一步限制了程序设计的灵活性。 -继承最近在很多编程语言的设计方案中失宠了。使用继承来实现代码重用，会共享更多非必需的代码。子类不应该总是共享其父类的所有特性，然而继承意味着子类得到了其父类全部的数据和行为。这使得程序的设计更不灵活，并产生了无意义的方法调用或子类，以及由于方法并不适用于子类，却必需从父类继承而可能造成的错误。另外，某些语言只允许子类继承一个父类，进一步限制了程序设计的灵活性。 - -因为这些原因，Rust 选择了一个另外的途径，使用 trait 对象替代继承。让我们看一下在 Rust 中 trait 对象是如何实现多态的。 +因为这些原因，Rust 选择了一个不同的途径，使用 trait 对象替代继承。让我们看一下 Rust 中的 trait 对象是如何实现多态的。 From befecd54a9cb5318b0bd897d7f7421588c43c415 Mon Sep 17 00:00:00 2001 From: KaiserY Date: Mon, 26 Feb 2018 16:52:45 +0800 Subject: [PATCH 136/150] check to ch17-03 --- src/ch17-02-trait-objects.md | 168 +++++++++++++-------------- src/ch17-03-oo-design-patterns.md | 184 +++++++++++++++++++----------- 2 files changed, 200 insertions(+), 152 deletions(-) diff --git a/src/ch17-02-trait-objects.md b/src/ch17-02-trait-objects.md index fc09d6a..78d1385 100644 --- a/src/ch17-02-trait-objects.md +++ b/src/ch17-02-trait-objects.md @@ -2,28 +2,27 @@ > [ch17-02-trait-objects.md](https://github.com/rust-lang/book/blob/master/second-edition/src/ch17-02-trait-objects.md) >
-> commit 67876e3ef5323ce9d394f3ea6b08cb3d173d9ba9 +> commit ccdd9ca7aacea4cefeb6a96e7ffb9ea91a923abd - 在第八章中，我们谈到了 vector 只能存储同种类型元素的局限。在列表 8-1 中有一个例子，其中定义了一个拥有分别存放整型、浮点型和文本型成员的枚举类型 `SpreadsheetCell`，使用这个枚举的 vector 可以在每一个单元格（cell）中储存不同类型的数据，并使得 vector 整体仍然代表一行（row）单元格。这当编译代码时就知道希望可以交替使用的类型为固定集合的情况下是可行的。 + 在第八章中，我们谈到了 vector 只能存储同种类型元素的局限。示例 8-10 中提供了一个定义 `SpreadsheetCell` 枚举来储存整型，浮点型和文本成员的替代方案。这意味着可以在每个单元中储存不同类型的数据，并仍能拥有一个代表一排单元的 vector。这在当编译代码时就知道希望可以交替使用的类型为固定集合的情况下是完全可行的。 + +然而有时，我们希望库用户在特定情况下能够扩展有效的类型集合。为了展示如何实现这一点，这里将创建一个图形用户接口（Graphical User Interface， GUI）工具的例子，其它通过遍历列表并调用每一个项目的 `draw` 方法来将其绘制到屏幕上；此乃一个 GUI 工具的常见技术。我们将要创建一个叫做 `rust_gui` 的库 crate，它含一个 GUI 库的结构。这个 GUI 库包含一些可供开发者使用的类型，比如 `Button` 或 `TextField`。在此之上，`rust_gui` 的用户希望创建自定义的可以绘制于屏幕上的类型：比如，一个程序员可能会增加 `Image`，另一个可能会增加 `SelectBox`。 - +这个例子中并不会实现一个功能完善的 GUI 库，不过会展示其中各个部分是如何结合在一起的。编写库的时候，我们不可能知晓并定义所有其他程序员希望创建的类型。我们所知晓的是 `rust_gui` 需要记录一系列不同类型的值，并需要能够对其中每一个值调用 `draw` 方法。这里无需知道调用 `draw` 方法时具体会发生什么，只需提供可供这些值调用的方法即可。 -有时，我们希望使用的类型的集合对于使用库的程序员来说是可扩展的。例如，很多图形用户接口（GUI）工具有一个项目列表的概念，它通过遍历列表并调用每一个项目的 `draw` 方法来将其绘制到屏幕上。我们将要创建一个叫做 `rust_gui` 的库 crate，它含一个 GUI 库的结构。这个 GUI 库包含一些可供开发者使用的类型，比如 `Button` 或 `TextField`。使用 `rust_gui` 的程序员会想要创建更多可以绘制在屏幕上的类型：其中一些可能会增加一个 `Image`，而另一些可能会增加一个 `SelectBox`。本章节并不准备实现一个功能完善的 GUI 库，不过会展示其中各个部分是如何结合在一起的。 - -编写 `rust_gui` 库时，我们并不知道其他程序员想要创建的全部类型，所以无法定义一个 `enum` 来包含所有这些类型。我们所要做的是使 `rust_gui` 能够记录一系列不同类型的值，并能够对其中每一个值调用 `draw` 方法。 GUI 库不需要知道当调用 `draw` 方法时具体会发生什么，只需提供这些值可供调用的方法即可。 - -在拥有继承的语言中，我们可能定义一个名为 `Component` 的类，该类上有一个 `draw` 方法。其他的类比如 `Button`、`Image` 和 `SelectBox` 会从 `Component` 派生并因此继承 `draw` 方法。它们各自都可以覆盖 `draw` 方法来定义自己的行为，但是框架会把所有这些类型当作是 `Component` 的实例，并在其上调用 `draw`。 +在拥有继承的语言中，可以定义一个名为 `Component` 的类，该类上有一个 `draw` 方法。其他的类比如 `Button`、`Image` 和 `SelectBox` 会从 `Component` 派生并因此继承 `draw` 方法。它们各自都可以覆盖 `draw` 方法来定义自己的行为，但是框架会把所有这些类型当作是 `Component` 的实例，并在其上调用 `draw`。不过 Rust 并没有继承，我们得另寻出路。 ### 定义通用行为的 trait -不过，在 Rust 中，我们可以定义一个 `Draw` trait，包含名为 `draw` 的方法。接着可以定义一个存放**trait 对象**（*trait -object*）的 vector，trait 对象是一个位于某些指针，比如 `&` 引用或 `Box` 智能指针，之后的 trait。第十九章会讲到为何 trait 对象必须位于指针之后的原因。 +为了实现 `rust_gui` 所期望拥有的行为，定义一个 `Draw` trait，其包含名为 `draw` 的方法。接着可以定义一个存放 **trait 对象**（*trait object*） 的 vector。trait 对象指向一个实现了我们指定 trait 的类型实例。我们通过指定某些指针，比如 `&` 引用或 `Box` 智能指针，接着指定相关的 trait（第十九章动态大小类型部分会介绍 trait 对象必须使用指针的原因）。我们可以使用 trait 对象代替泛型或具体类型。任何使用 trait 对象的位置，Rust 的类型系统会在编译时确保任何在此上下文中使用的值会实现其 trait 对象的 trait。如此便无需在编译时就知晓所有可能的类型。 -之前提到过，我们并不将结构体与枚举称之为“对象”，以便与其他语言中的对象相区别。结构体与枚举和 `impl` 块中的行为是分开的，不同于其他语言中将数据和行为组合进一个称为对象的概念中。trait 对象将由指向具体对象的指针构成的数据和定义于 trait 中方法的行为结合在一起，从这种意义上说它**则**更类似其他语言中的对象。不过 trait 对象与其他语言中的对象是不同的，因为不能向 trait 对象增加数据。trait 对象并不像其他语言中的对象那么通用：他们（trait 对象）的作用是允许对通用行为的抽象。 + + -trait 对象定义了在给定情况下所需的行为。接着就可以在要使用具体类型或泛型的地方使用 trait 来作为 trait 对象。Rust 的类型系统会确保任何我们替换为 trait 对象的值都会实现了 trait 的方法。这样就无需在编译时就知道所有可能的类型，就能够用同样的方法处理所有的实例。列表 17-3 展示了如何定义一个带有 `draw` 方法的 trait `Draw`： +之前提到过，Rust 刻意不将结构体与枚举称为 “对象”，以便与其他语言中的对象相区别。在结构体或枚举中，结构体字段中的数据和 `impl` 块中的行为是分开的，不同于其他语言中将数据和行为组合进一个称为对象的概念中。trait 对象将数据和行为两者相结合，从这种意义上说 **则** 其更类似其他语言中的对象。不过 trait 对象不同于传统的对象，因为不能向 trait 对象增加数据。trait 对象并不像其他语言中的对象那么通用：其（trait 对象）具体的作用是允许对通用行为的抽象。 + +示例 17-3 展示了如何定义一个带有 `draw` 方法的 trait `Draw`： 文件名: src/lib.rs @@ -33,13 +32,15 @@ pub trait Draw { } ``` -列表 17-3:`Draw` trait 的定义 +示例 17-3：`Draw` trait 的定义 - +因为第十章已经讨论过如何定义 trait，这看起来应该比较眼熟。接下来就是新内容了：实例 17-4 定义了一个存放了名叫 `components` 的 vector 的结构体 `Screen`。这个 vector 的类型是 `Box`，此为一个 trait 对象：它是 `Box` 中任何实现了 `Draw` trait 的类型的替身。 - - -因为第十章已经讨论过如何定义 trait，这看起来应该比较眼熟。接下来就是新内容了：列表 17-4 有一个名为 `Screen` 的结构体定义，它存放了一个叫做 `components` 的 `Box` 类型的 vector 。`Box` 是一个 trait 对象：它是 `Box` 中任何实现了 `Draw` trait 的类型的替身。 + + 文件名: src/lib.rs @@ -53,9 +54,9 @@ pub struct Screen { } ``` -列表 17-4: 一个 `Screen` 结构体的定义，它带有一个字段`components`，其包含实现了 `Draw` trait 的 trait 对象的 vector +示例 17-4: 一个 `Screen` 结构体的定义，它带有一个字段`components`，其包含实现了 `Draw` trait 的 trait 对象的 vector -在 `Screen` 结构体上，我们将定义一个 `run` 方法，该方法会对其 `components` 上的每一个元素调用 `draw` 方法，如列表 17-5 所示： +在 `Screen` 结构体上，我们将定义一个 `run` 方法，该方法会对其 `components` 上的每一个组件调用 `draw` 方法，如示例 17-5 所示： 文件名: src/lib.rs @@ -77,9 +78,9 @@ impl Screen { } ``` -列表 17-5:在 `Screen` 上实现一个 `run` 方法，该方法在每个 component 上调用 `draw` 方法 +示例 17-5：在 `Screen` 上实现一个 `run` 方法，该方法在每个 component 上调用 `draw` 方法 -这与定义使用了带有 trait bound 的泛型类型参数的结构体不同。泛型类型参数一次只能替代一个具体的类型，而 trait 对象则允许在运行时替代多种具体类型。例如，可以像列表 17-6 那样定义使用泛型和 trait bound 的结构体 `Screen`： +这与定义使用了带有 trait bound 的泛型类型参数的结构体不同。泛型类型参数一次只能替代一个具体类型，而 trait 对象则允许在运行时替代多种具体类型。例如，可以定义 `Screen` 结构体来使用泛型和 trait bound，如示例 17-6 所示： 文件名: src/lib.rs @@ -102,15 +103,15 @@ impl Screen } ``` -列表 17-6: 一种 `Screen` 结构体的替代实现，它的 `run` 方法使用泛型和 trait bound +示例 17-6: 一种 `Screen` 结构体的替代实现，其 `run` 方法使用泛型和 trait bound -这只允许我们拥有一个包含全是 `Button` 类型或者全是 `TextField` 类型的 component 列表的 `Screen` 实例。如果只拥有相同类型的集合，那么使用泛型和 trait bound 是更好的，因为在编译时使用具体类型其定义是单态（monomorphized）的。 +这限制了 `Screen` 实例必须拥有一个全是 `Button` 类型或者全是 `TextField` 类型的组件列表。如果只需要同质（相同类型）集合，则倾向于使用泛型和 trait bound，因为其定义会在编译时采用具体类型进行单态化。 -相反对于存放了 `Vec>` trait 对象的 component 列表的 `Screen` 定义，一个 `Screen` 实例可以存放一个既可以包含 `Box

rc;i4T5tezuTZ+>#R`ot3upYCJ6U8Zb$W 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%0AfslbAShU8X}>u|K0PCHy7eX6zpHyjC&QEO8AHk4 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 diff --git a/src/img/trpl14-10.png b/src/img/trpl14-04.png similarity index 100% rename from src/img/trpl14-10.png rename to src/img/trpl14-04.png diff --git a/src/img/trpl14-05.png b/src/img/trpl14-05.png deleted file mode 100644 index 139011f008a0dac7966d3eb128cc95d2fb5a15f8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 60311 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