update to ch04-00

src/ch03-03-how-functions-work.md

@@ -1,11 +1,10 @@
 ## 函数
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch03-03-how-functions-work.md -->
-<!-- commit a619cc5f073b1b59c026cf0f92ab061a46716325 -->
+[ch03-03-how-functions-work.md](https://github.com/rust-lang/book/blob/9cc190796f28505c7a9a9cacea42f50d895ff3bd/src/ch03-03-how-functions-work.md)
 
 函数在 Rust 代码中非常普遍。你已经见过语言中最重要的函数之一：`main` 函数，它是很多程序的入口点。你也见过 `fn` 关键字，它用来声明新函数。
 
-Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake case 中，所有字母都是小写并使用下划线分隔单词。这是一个包含函数定义示例的程序：
+Rust 代码中的函数名和变量名通常使用 *snake case* 风格。在 snake case 中，所有字母都使用小写，并用下划线分隔单词。下面是一个包含函数定义示例的程序：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -17,19 +16,19 @@ Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake
 
 可以使用函数名后跟圆括号来调用我们定义过的任意函数。因为程序中已定义 `another_function` 函数，所以可以在 `main` 函数中调用它。注意，源码中 `another_function` 定义在 `main` 函数 **之后**；也可以定义在之前。Rust 不关心函数定义所在的位置，只要函数被调用时出现在调用之处可见的作用域内就行。
 
-让我们新建一个叫做 *functions* 的二进制项目来进一步探索函数。将上面的 `another_function` 例子写入 *src/main.rs* 中并运行。你应该会看到如下输出：
+让我们新建一个叫做 *functions* 的二进制项目，来进一步探索函数。把上面的 `another_function` 示例放到 *src/main.rs* 中并运行。你应该会看到如下输出：
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/no-listing-16-functions/output.txt}}
 ```
 
-`main` 函数中的代码会按顺序执行。首先，打印 “Hello, world!” 信息，然后调用 `another_function` 函数并打印它的信息。
+这些代码行会按照它们在 `main` 函数中出现的顺序执行。首先打印 “Hello, world!”，然后调用 `another_function` 并打印它的消息。
 
 ### 参数
 
-我们可以定义为拥有 **参数**（*parameters*）的函数，参数是特殊变量，是函数签名的一部分。当函数拥有参数（形参）时，可以为这些参数提供具体的值（实参）。技术上讲，这些具体值被称为参数（*arguments*），但是在日常交流中，人们倾向于不区分使用 *parameter* 和 *argument* 来表示函数定义中的变量或调用函数时传入的具体值。
+我们可以定义带有 **参数**（*parameters*）的函数，参数是特殊变量，是函数签名的一部分。当函数带有参数时，你就可以为这些参数提供具体的值。从严格意义上说，这些具体值叫做 *arguments*，不过在日常交流中，人们通常会把 *parameter* 和 *argument* 混用，用来指函数定义中的变量，或调用函数时传入的具体值。
 
-在这版 `another_function` 中，我们增加了一个参数：
+在这个版本的 `another_function` 中，我们增加了一个参数：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -45,7 +44,7 @@ Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake
 
 `another_function` 的声明中有一个命名为 `x` 的参数。`x` 的类型被指定为 `i32`。当我们将 `5` 传给 `another_function` 时，`println!` 宏会把 `5` 放在格式字符串中包含 `x` 的那对花括号的位置。
 
-在函数签名中，**必须** 声明每个参数的类型。这是 Rust 设计中一个经过慎重考虑的决定：要求在函数定义中提供类型注解，意味着编译器再也不需要你在代码的其他地方注明类型来指出你的意图。而且，在知道函数需要什么类型后，编译器就能够给出更有用的错误消息。
+在函数签名中，**必须** 声明每个参数的类型。这是 Rust 设计中经过深思熟虑的一个决定：要求在函数定义里提供类型注解，意味着编译器几乎不再需要你在代码的其他地方额外标明类型来表达意图。而且，如果编译器知道函数期望什么类型，就能给出更有帮助的错误信息。
 
 当定义多个参数时，使用逗号分隔，像这样：
 
@@ -67,7 +66,7 @@ Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake
 
 ### 语句和表达式
 
-函数体由一系列的语句和一个可选的结尾表达式构成。目前为止，我们提到的函数还不包含结尾表达式，不过你已经见过作为语句一部分的表达式。因为 Rust 是一门基于表达式（expression-based）的语言，这是一个需要理解的重要区别。其他语言并没有这样的区别，所以让我们看看语句与表达式有什么区别以及这些区别是如何影响函数体的。
+函数体由一系列语句组成，并且可以选择以一个表达式结束。到目前为止，我们讲过的函数还没有包含结尾表达式，不过你已经见过出现在语句中的表达式了。由于 Rust 是一门基于表达式（expression-based）的语言，理解这一点非常重要。其他语言通常没有这种区分，所以让我们看看语句和表达式分别是什么，以及它们的差异会如何影响函数体。
 
 - **语句**（*Statements*）是执行一些操作但不返回值的指令。
 - **表达式**（*Expressions*）计算并产生一个值。
@@ -84,7 +83,7 @@ Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake
 
 <span class="caption">示例 3-1：包含一个语句的 `main` 函数定义</span>
 
-函数定义也是语句，上面整个例子本身就是一个语句。（不过，如我们将在下面看到，**调用**函数并不是语句。）
+函数定义本身也是语句，因此前面的整个例子本身也是一条语句。（不过，正如我们稍后会看到的，**调用**函数并不是语句。）
 
 语句不返回值。因此，不能把 `let` 语句赋值给另一个变量，比如下面的例子尝试做的，会产生一个错误：
 
@@ -100,7 +99,7 @@ Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake
 {{#include ../listings/ch03-common-programming-concepts/no-listing-19-statements-vs-expressions/output.txt}}
 ```
 
-`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-1 中，语句 `let y = 6;` 中的 `6` 是一个表达式，它计算出的值是 `6`。函数调用是一个表达式。宏调用是一个表达式。用大括号创建的一个新的块作用域也是一个表达式，例如：
 
@@ -123,7 +122,7 @@ Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake
 
 ### 具有返回值的函数
 
-函数可以向调用它的代码返回值。我们并不对返回值命名，但要在箭头（`->`）后声明它的类型。在 Rust 中，函数的返回值等同于函数体最后一个表达式的值。使用 `return` 关键字和指定值，可从函数中提前返回；但大部分函数隐式的返回最后的表达式。这是一个有返回值的函数的例子：
+函数可以把值返回给调用它的代码。我们不会给返回值命名，但必须在箭头（`->`）后面声明它的类型。在 Rust 中，函数的返回值等同于函数体中最后一个表达式的值。你也可以使用 `return` 关键字并指定一个值，从函数中提前返回；不过大多数函数都会隐式返回最后一个表达式的值。下面是一个带有返回值的函数示例：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -131,19 +130,19 @@ Rust 代码中的函数和变量名使用 *snake case* 规范风格。在 snake
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-21-function-return-values/src/main.rs}}
 ```
 
-在 `five` 函数中没有函数调用、宏、甚至没有 `let` 语句 —— 只有数字 `5`。这在 Rust 中是一个完全有效的函数。注意，也指定了函数返回值的类型，就是 `-> i32`。尝试运行代码；输出应该看起来像这样：
+在 `five` 函数中，没有函数调用、没有宏，甚至连 `let` 语句都没有，只有单独一个数字 `5`。这在 Rust 中是一个完全合法的函数。注意，我们也指定了函数返回值的类型，即 `-> i32`。试着运行这段代码；输出应该如下所示：
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/no-listing-21-function-return-values/output.txt}}
 ```
 
-`five` 函数的返回值是 `5`，所以返回值类型是 `i32`。让我们仔细检查一下这段代码。有两个重要的部分：首先，`let x = five();` 这一行表明我们使用函数的返回值初始化一个变量。因为 `five` 函数返回 `5`，这一行与如下代码相同：
+`five` 函数的返回值是 `5`，所以返回类型是 `i32`。让我们更仔细地看看这段代码。有两个重要的点：首先，`let x = five();` 这一行表明我们用函数的返回值来初始化一个变量。因为 `five` 返回的是 `5`，所以这一行与下面的代码等价：
 
 ```rust
 let x = 5;
 ```
 
-其次，`five` 函数没有参数并定义了返回值类型，不过函数体只有单单一个 `5` 也没有分号，因为这是一个表达式，我们想要返回它的值。
+其次，`five` 函数没有参数，但定义了返回值类型，而且函数体里只有单独一个没有分号的 `5`，因为这是一个表达式，而我们想返回它的值。
 
 让我们看看另一个例子：
 
@@ -167,4 +166,4 @@ let x = 5;
 {{#include ../listings/ch03-common-programming-concepts/no-listing-23-statements-dont-return-values/output.txt}}
 ```
 
-主要的错误信息，“mismatched types”（类型不匹配），揭示了代码的核心问题。函数 `plus_one` 的定义说明它要返回一个 `i32` 类型的值，不过语句并不会返回值，使用单位类型 `()` 表示不返回值。因为不返回值与函数定义相矛盾，从而出现一个错误。在输出中，Rust 提供了一条信息，可能有助于纠正这个错误：它建议删除分号，这会修复这个错误。
+主要的错误信息 `mismatched types`（类型不匹配）揭示了这段代码的核心问题。`plus_one` 函数的定义表明它要返回一个 `i32`，但语句不会求值为某个值，语句对应的是单元类型 `()`。因此，函数实际上没有返回值，这就与函数定义相矛盾，从而产生了错误。在这段输出中，Rust 还提供了一条可能有助于修复该问题的提示：它建议删除这个分号，而这么做确实能修复错误。

src/ch03-04-comments.md

@@ -1,9 +1,8 @@
 ## 注释
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch03-04-comments.md -->
-<!-- commit 5d22a358fb2380aa3f270d7b6269b67b8e44849e -->
+[ch03-04-comments.md](https://github.com/rust-lang/book/blob/9cc190796f28505c7a9a9cacea42f50d895ff3bd/src/ch03-04-comments.md)
 
-所有程序员都力求使其代码易于理解，不过有时还需要提供额外的解释。在这种情况下，程序员在源码中留下 **注释**（*comments*），编译器会忽略它们，不过阅读代码的人可能觉得有用。
+所有程序员都努力让自己的代码易于理解，不过有时仍然需要额外的解释。在这种情况下，程序员会在源码中留下 **注释**（*comments*），编译器会忽略它们，但阅读源码的人可能会觉得这些注释很有帮助。
 
 这是一个简单的注释：
 
@@ -11,7 +10,7 @@
 // hello, world
 ```
 
-在 Rust 中，惯用的注释样式是以两个斜杠开始注释，并持续到本行的结尾。对于超过一行的注释，需要在每一行前都加上 `//`，像这样：
+在 Rust 中，惯用的注释风格是用两个斜杠开始一条注释，并让注释持续到该行末尾。对于跨越多行的注释，你需要在每一行前面都加上 `//`，像这样：
 
 ```rust
 // So we’re doing something complicated here, long enough that we need
@@ -27,7 +26,7 @@
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-24-comments-end-of-line/src/main.rs}}
 ```
 
-不过你更经常看到的是以这种格式使用它们，也就是位于它所解释的代码行的上面一行：
+不过，你更常见到的用法是把注释放在它所解释的代码上一行，像这样：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -35,6 +34,6 @@
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-25-comments-above-line/src/main.rs}}
 ```
 
-Rust 还有另一种注释，称为文档注释，我们将在 14 章的 [“将 crate 发布到 Crates.io” ][publishing]部分讨论它。
+Rust 还有另一种注释，叫作文档注释，我们会在第十四章的[“将 crate 发布到 Crates.io”][publishing]部分讨论它。
 
 [publishing]: ch14-02-publishing-to-crates-io.html

src/ch03-05-control-flow.md

@@ -1,15 +1,14 @@
 ## 控制流
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch03-05-control-flow.md -->
-<!-- commit a619cc5f073b1b59c026cf0f92ab061a46716325 -->
+[ch03-05-control-flow.md](https://github.com/rust-lang/book/blob/9cc190796f28505c7a9a9cacea42f50d895ff3bd/src/ch03-05-control-flow.md)
 
-根据条件是否为真来决定是否执行某些代码，以及根据条件是否为真来重复运行一段代码的能力是大部分编程语言的基本组成部分。Rust 代码中最常见的用来控制执行流的结构是 `if` 表达式和循环。
+根据条件是否为 `true` 来决定是否执行某些代码，以及在条件为 `true` 时重复执行某些代码的能力，是大多数编程语言的基本构件。Rust 中最常见的控制执行流的结构是 `if` 表达式和循环。
 
 ### `if` 表达式
 
 `if` 表达式允许根据条件执行不同的代码分支。你提供一个条件并表示 “如果条件满足，运行这段代码；如果条件不满足，不运行这段代码。”
 
-在 *projects* 目录新建一个叫做 *branches* 的项目，来学习 `if` 表达式。在 *src/main.rs* 文件中，输入如下内容：
+在 *projects* 目录中创建一个名为 *branches* 的新项目，来体验 `if` 表达式。在 *src/main.rs* 文件中输入如下内容：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -17,7 +16,7 @@
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-26-if-true/src/main.rs}}
 ```
 
-所有的 `if` 表达式都以 `if` 关键字开头，其后跟一个条件。在这个例子中，条件检查变量 `number` 的值是否小于 5。在条件为 `true` 时希望执行的代码块位于紧跟条件之后的大括号中。`if` 表达式中与条件关联的代码块有时被叫做 *arms*，就像第二章 [“比较猜测的数字和秘密数字”][comparing-the-guess-to-the-secret-number] 部分中讨论到的 `match` 表达式中的分支一样。
+所有 `if` 表达式都以 `if` 关键字开头，后面紧跟一个条件。在这个例子中，条件会检查变量 `number` 的值是否小于 5。如果条件为 `true`，就执行紧跟在条件后面的大括号中的代码块。与 `if` 表达式中各个条件关联的代码块有时也被称为 *arms*，就像我们在第二章[“比较猜测的数字和秘密数字”][comparing-the-guess-to-the-secret-number]一节中讨论过的 `match` 表达式分支一样。
 
 也可以包含一个可选的 `else` 表达式来提供一个在条件为 `false` 时应当执行的代码块，这里我们就这么做了。如果不提供 `else` 表达式并且条件为 `false` 时，程序会直接忽略 `if` 代码块并继续执行下面的代码。
 
@@ -39,7 +38,7 @@
 {{#include ../listings/ch03-common-programming-concepts/no-listing-27-if-false/output.txt}}
 ```
 
-另外值得注意的是代码中的条件**必须**是 `bool` 值。如果条件不是 `bool` 值，我们将得到一个错误。例如，尝试运行以下代码：
+还值得注意的是，条件**必须**是 `bool` 值。如果条件不是 `bool`，我们就会得到一个错误。例如，尝试运行下面这段代码：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -53,7 +52,7 @@
 {{#include ../listings/ch03-common-programming-concepts/no-listing-28-if-condition-must-be-bool/output.txt}}
 ```
 
-这个错误表明 Rust 期望一个 `bool` 却得到了一个整数。不像 Ruby 或 JavaScript 这样的语言，Rust 并不会尝试自动地将非布尔值转换为布尔值。必须总是显式地使用布尔值作为 `if` 的条件。例如，如果想要 `if` 代码块只在一个数字不等于 `0` 时执行，可以把 `if` 表达式修改成下面这样：
+这个错误表明 Rust 期望得到的是一个 `bool`，却收到了一个整数。不同于 Ruby 或 JavaScript 这样的语言，Rust 不会自动尝试把非布尔类型转换成布尔类型。你必须显式地为 `if` 提供一个布尔值作为条件。例如，如果我们希望 `if` 代码块只在某个数字不等于 `0` 时运行，就可以把 `if` 表达式改成下面这样：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -81,7 +80,7 @@
 
 当执行这个程序时，它按顺序检查每个 `if` 表达式并执行第一个条件为 `true` 的代码块。注意即使 6 可以被 2 整除，也不会输出 `number is divisible by 2`，更不会输出 `else` 块中的 `number is not divisible by 4, 3, or 2`。原因是 Rust 只会执行第一个条件为 `true` 的代码块，并且一旦它找到一个以后，甚至都不会检查剩下的条件了。
 
-使用过多的 `else if` 表达式会使代码显得杂乱无章，所以如果有多于一个 `else if` 表达式，最好重构代码。为此，第六章会介绍一个强大的 Rust 分支结构（branching construct），叫做 `match`。
+使用过多的 `else if` 表达式会让代码显得杂乱，所以如果你有不止一个 `else if`，可能就该考虑重构代码了。针对这种情况，第六章会介绍一个强大的 Rust 分支结构（branching construct），叫做 `match`。
 
 #### 在 `let` 语句中使用 `if`
 
@@ -95,13 +94,13 @@
 
 <span class="caption">示例 3-2：将 `if` 表达式的返回值赋给一个变量</span>
 
-`number` 变量将会绑定到表示 `if` 表达式结果的值上。运行这段代码看看会出现什么：
+变量 `number` 会绑定到 `if` 表达式结果所产生的那个值。运行这段代码看看会发生什么：
 
 ```console
 {{#include ../listings/ch03-common-programming-concepts/listing-03-02/output.txt}}
 ```
 
-记住，代码块的值是其最后一个表达式的值，而数字本身就是一个表达式。在这个例子中，整个 `if` 表达式的值取决于哪个代码块被执行。这意味着 `if` 的每个分支的可能的返回值都必须是相同类型；在示例 3-2 中，`if` 分支和 `else` 分支的结果都是 `i32` 整型。如果它们的类型不匹配，如下面这个例子，则会出现一个错误：
+记住，代码块的值就是其中最后一个表达式的值，而数字本身也是表达式。在这个例子中，整个 `if` 表达式的值取决于哪个代码块被执行。这意味着 `if` 的各个分支可能产生的结果值都必须是相同类型；在示例 3-2 中，`if` 分支和 `else` 分支的结果都是 `i32` 整数。如果类型不一致，就会像下面这个例子一样报错：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -115,17 +114,17 @@
 {{#include ../listings/ch03-common-programming-concepts/no-listing-31-arms-must-return-same-type/output.txt}}
 ```
 
-`if` 代码块中的表达式返回一个整数，而 `else` 代码块中的表达式返回一个字符串。这不可行，因为变量必须只有一个类型。Rust 需要在编译时就确切的知道 `number` 变量的类型，这样它就可以在编译时验证在每处使用的 `number` 变量的类型是有效的。如果`number`的类型仅在运行时确定，则 Rust 无法做到这一点；且编译器必须跟踪每一个变量的多种假设类型，那么它就会变得更加复杂，对代码的保证也会减少。
+`if` 代码块中的表达式会求值为一个整数，而 `else` 代码块中的表达式会求值为一个字符串。这是行不通的，因为变量必须只有一个类型。Rust 需要在编译时就明确知道 `number` 的类型，这样它才能在编译阶段验证每一处对 `number` 的使用是否合法。如果 `number` 的类型只能在运行时确定，Rust 就无法做到这一点；而如果编译器必须为每个变量跟踪多种假设类型，它也会变得更加复杂，并且对代码的保证会更少。
 
 ### 使用循环重复执行
 
-多次执行同一段代码是很常用的，Rust 为此提供了多种 **循环**（*loops*）。一个循环执行循环体中的代码直到结尾并紧接着回到开头继续执行。为了实验一下循环，让我们新建一个叫做 *loops* 的项目。
+反复执行同一段代码是一件很常见的事，为此 Rust 提供了多种 **循环**（*loops*）。循环会执行循环体中的代码直到结尾，然后立即回到开头继续执行。为了体验循环，我们来新建一个叫做 *loops* 的项目。
 
 Rust 有三种循环：`loop`、`while` 和 `for`。我们每一个都试试。
 
 #### 使用 `loop` 重复执行代码
 
-`loop` 关键字告诉 Rust 一遍又一遍地执行一段代码直到你明确要求停止。
+`loop` 关键字告诉 Rust 反复执行一段代码，要么永远执行下去，要么直到你明确要求它停止。
 
 作为一个例子，将 *loops* 目录中的 *src/main.rs* 文件修改为如下：
 
@@ -135,7 +134,7 @@ Rust 有三种循环：`loop`、`while` 和 `for`。我们每一个都试试。
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-32-loop/src/main.rs}}
 ```
 
-当运行这个程序时，我们会看到连续的反复打印 `again!`，直到我们手动停止程序。大部分终端都支持键盘快捷键 <kbd>ctrl</kbd>-<kbd>c</kbd> 来终止一个陷入无限循环的程序。尝试一下：
+运行这个程序时，我们会看到 `again!` 被不断重复打印，直到我们手动停止程序。大多数终端都支持使用快捷键 <kbd>ctrl</kbd>-<kbd>C</kbd> 来中断一个陷入无限循环的程序。试试看：
 
 ```console
 $ cargo run
@@ -149,31 +148,33 @@ again!
 ^Cagain!
 ```
 
-符号 `^C` 代表你在这按下了 <kbd>ctrl</kbd>-<kbd>c</kbd>。在 `^C` 之后你可能看到也可能看不到 `again!` ，这取决于在接收到终止信号时代码执行到了循环的何处。
+符号 `^C` 表示你在这里按下了 <kbd>ctrl</kbd>-<kbd>C</kbd>。在 `^C` 后面，你可能会看到，也可能不会看到 `again!`，这取决于代码在收到中断信号时正执行到循环的哪个位置。
 
-幸运的是，Rust 提供了一种从代码中跳出循环的方法。可以使用 `break` 关键字来告诉程序何时停止循环。回忆一下在第二章猜猜看游戏的 [“猜测正确后退出”][quitting-after-a-correct-guess] 部分使用过它来在用户猜对数字赢得游戏后退出程序。
+幸运的是，Rust 也提供了在代码中跳出循环的方法。你可以在循环中放置 `break` 关键字，告诉程序何时停止执行该循环。回忆一下，我们曾在第二章猜数字游戏的[“猜测正确后退出”][quitting-after-a-correct-guess]一节中使用过它，让程序在用户猜中数字后退出。
 
-我们在猜谜游戏中也使用了 `continue`。循环中的 `continue` 关键字告诉程序跳过这个循环迭代中的任何剩余代码，并转到下一个迭代。
+我们在猜数字游戏中也使用过 `continue`。在循环里，`continue` 关键字会告诉程序跳过本次循环迭代剩余的代码，并直接进入下一次迭代。
 
 #### 从循环返回值
 
-`loop` 的一个用例是重试可能会失败的操作，比如检查线程是否完成了任务。然而你可能会需要将操作的结果传递给其它的代码。要实现这一点，可以在用于停止循环的 `break` 表达式后添加你希望返回的值；这个值就会作为循环的返回值返回，这样你就可以使用它，如下所示：
+`loop` 的一个用途是重试那些你知道可能失败的操作，比如检查某个线程是否完成了任务。不过，你也可能希望把这个操作的结果传递给其他代码。为此，你可以在用于停止循环的 `break` 表达式后面加上想要返回的值；这个值会作为循环的返回值返回出来，因而你就可以使用它，如下所示：
 
 ```rust
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-33-return-value-from-loop/src/main.rs}}
 ```
 
-在循环之前，我们声明了一个名为 `counter` 的变量并初始化为 `0`。接着声明了一个名为 `result` 来存放循环的返回值。在循环的每一次迭代中，我们将 `counter` 变量加 `1`，接着检查计数是否等于 `10`。当相等时，使用 `break` 关键字返回值 `counter * 2`。循环之后，我们通过分号结束赋值给 `result` 的语句。最后打印出 `result` 的值，也就是 `20`。
+在循环之前，我们声明了一个名为 `counter` 的变量，并将其初始化为 `0`。然后，又声明了一个名为 `result` 的变量，用来保存循环返回的值。在循环的每次迭代中，我们都会给 `counter` 加 `1`，然后检查它是否等于 `10`。当条件满足时，就用 `break` 关键字返回 `counter * 2` 的值。循环结束后，我们用分号结束把值赋给 `result` 的那条语句。最后，打印出 `result` 的值，也就是 `20`。
+
+如果你在循环内部使用 `return`，也可以从中返回。不过，`break` 只会退出当前循环，而 `return` 总是会退出当前函数。
 
 #### 循环标签：在多个循环之间消除歧义
 
-如果存在嵌套循环，`break` 和 `continue` 应用于此时最内层的循环。你可以选择在一个循环上指定一个 **循环标签**（*loop label*），然后将标签与 `break` 或 `continue` 一起使用，使这些关键字应用于已标记的循环而不是最内层的循环。下面是一个包含两个嵌套循环的示例：
+如果循环中又套了循环，那么 `break` 和 `continue` 默认只作用于当前最内层的那个循环。你可以选择给某个循环加上一个 **循环标签**（*loop label*），然后把这个标签和 `break` 或 `continue` 一起使用，这样这些关键字就会作用于被标记的循环，而不是最内层循环。下面是一个包含两层嵌套循环的例子：
 
 ```rust
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-32-5-loop-labels/src/main.rs}}
 ```
 
-外层循环有一个标签 `counting_up`，它将从 0 数到 2。没有标签的内部循环从 10 向下数到 9。第一个没有指定标签的 `break` 将只退出内层循环。`break 'counting_up;` 语句将退出外层循环。这个代码打印：
+外层循环带有标签 `'counting_up`，它会从 0 数到 2。没有标签的内层循环则从 10 倒数到 9。第一个没有指定标签的 `break` 只会退出内层循环。语句 `break 'counting_up;` 则会退出外层循环。这段代码会打印：
 
 ```console
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-32-5-loop-labels/output.txt}}
@@ -181,7 +182,7 @@ again!
 
 #### `while` 条件循环
 
-在程序中计算循环的条件也很常见。当条件为 `true`，执行循环。当条件不再为 `true`，调用 `break` 停止循环。这个循环类型可以通过组合 `loop`、`if`、`else` 和 `break` 来实现；如果你喜欢的话，现在就可以在程序中试试。然而，这个模式太常用了，Rust 为此内置了一个语言结构，它被称为 `while` 循环。在示例 3-3 中，使用了 `while` 程序循环三次，每次数字都减一。接着，在循环结束后，打印出另一个信息并退出。
+程序经常需要在循环中计算某个条件：只要条件为 `true`，循环就继续；当条件不再为 `true` 时，程序就会调用 `break` 来停止循环。这种循环类型可以通过组合 `loop`、`if`、`else` 和 `break` 来实现；如果你愿意，现在就可以在程序里试试看。不过，这种模式实在太常见了，所以 Rust 为它内置了一个语言结构，叫做 `while` 循环。在示例 3-3 中，我们使用 `while` 让程序循环三次，每次计数都减一；之后，在循环结束后打印另一条消息并退出。
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -191,7 +192,7 @@ again!
 
 <span class="caption">示例 3-3: 当条件为 `true` 时，使用 `while` 循环运行代码</span>
 
-这种结构消除了很多使用 `loop`、`if`、`else` 和 `break` 时所必须的嵌套，这样更加清晰。当条件为 `true` 就执行，否则退出循环。
+这种结构消除了使用 `loop`、`if`、`else` 和 `break` 时原本需要的大量嵌套，因此代码会更清晰。只要条件求值为 `true`，代码就会继续执行；否则就退出循环。
 
 #### 使用 `for` 遍历集合
 
@@ -213,7 +214,7 @@ again!
 
 数组中的所有五个元素都如期出现在终端中。尽管 `index` 在某一时刻会到达值 `5`，不过循环在其尝试从数组获取第六个值（会越界）之前就停止了。
 
-但这个过程很容易出错；如果索引长度或测试条件不正确会导致程序 panic。例如，如果将 `a` 数组的定义改为包含 4 个元素而忘记了更新条件 `while index < 4`，则代码会 panic。这也使程序更慢，因为编译器增加了运行时代码来对每次循环进行条件检查，以确定在循环的每次迭代中索引是否在数组的边界内。
+不过，这种方式很容易出错；如果索引值或测试条件写错了，就会导致程序 panic。例如，如果你把数组 `a` 改成只有 4 个元素，却忘了把条件更新成 `while index < 4`，代码就会 panic。它也会让程序变慢，因为编译器会加入运行时代码，在每次循环迭代时检查索引是否仍然位于数组边界之内。
 
 作为更简洁的替代方案，可以使用 `for` 循环来对一个集合的每个元素执行一些代码。`for` 循环看起来如示例 3-5 所示：
 
@@ -225,13 +226,13 @@ again!
 
 <span class="caption">示例 3-5：使用 `for` 循环遍历集合中的元素</span>
 
-当运行这段代码时，将看到与示例 3-4 一样的输出。更为重要的是，我们增强了代码安全性，并消除了可能由于超出数组的结尾或遍历长度不够而缺少一些元素而导致的 bug。
+运行这段代码时，你会看到和示例 3-4 相同的输出。更重要的是，我们提高了代码的安全性，并消除了那种可能因为越过数组末尾，或遍历不够完整而漏掉某些元素所导致的 bug。
 
-例如，在示例 3-4 的代码中，如果你将 `a` 数组的定义改为有四个元素，但忘记将条件更新为 `while index < 4`，代码将会 panic。使用 `for` 循环的话，就不需要惦记着在改变数组元素个数时修改其他的代码了。
+例如，在示例 3-4 的代码中，如果你把数组 `a` 改成只有 4 个元素，却忘了把条件更新为 `while index < 4`，代码就会 panic。而使用 `for` 循环时，你就不必记着在修改数组元素个数时还要同步修改其他代码了。
 
-`for` 循环的安全性和简洁性使得它成为 Rust 中使用最多的循环结构。即使是在想要循环执行代码特定次数时，例如示例 3-3 中使用 `while` 循环的倒计时例子，大部分 Rustacean 也会使用 `for` 循环。这么做的方式是使用 `Range`，它是标准库提供的类型，用来生成从一个数字开始到另一个数字之前结束的所有数字的序列。
+`for` 循环的安全性和简洁性，使它成为 Rust 中最常用的循环结构。即使是在你只想把某段代码执行特定次数的情况下，比如示例 3-3 里那个使用 `while` 的倒计时例子，大多数 Rustaceans 也会选择使用 `for` 循环。实现这种写法的方式是使用 `Range`，这是标准库提供的一种类型，用来生成从某个数字开始、到另一个数字之前结束的所有数字序列。
 
-下面是一个使用 `for` 循环来倒计时的例子，它还使用了一个我们还未讲到的方法，`rev`，用来反转 range。
+下面是一个使用 `for` 循环来倒计时的例子，它还用到了一个我们尚未讲到的方法 `rev`，用于反转 range。
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -239,19 +240,17 @@ again!
 {{#rustdoc_include ../listings/ch03-common-programming-concepts/no-listing-34-for-range/src/main.rs}}
 ```
 
-这段代码看起来更帅气不是吗？
+这段代码是不是更好一些？
 
 ## 总结
 
-你做到了！这是一个大章节：你学习了变量、标量和复合数据类型、函数、注释、 `if` 表达式和循环！如果你想要实践本章讨论的概念，尝试构建如下程序：
+你做到了！这是内容相当丰富的一章：你学习了变量、标量和复合数据类型、函数、注释、`if` 表达式以及循环！如果你想练习本章讨论的概念，可以尝试构建下面这些程序：
 
-* 相互转换摄氏与华氏温度。
-* 生成第 n 个斐波那契数。
-* 打印圣诞颂歌 “The Twelve Days of Christmas” 的歌词，并利用歌曲中的重复部分（编写循环）。
+- 相互转换摄氏与华氏温度。
+- 生成第 n 个斐波那契数。
+- 打印圣诞颂歌 “The Twelve Days of Christmas” 的歌词，并利用歌曲中的重复部分（通过编写循环）。
 
-当你准备好继续的时候，让我们讨论一个其他语言中**并不**常见的概念：所有权（ownership）。
+当你准备好继续时，我们将讨论一个在其他编程语言中**并不**常见的概念：所有权（ownership）。
 
-[comparing-the-guess-to-the-secret-number]:
-ch02-00-guessing-game-tutorial.html#比较猜测的数字和秘密数字
-[quitting-after-a-correct-guess]:
-ch02-00-guessing-game-tutorial.html#猜测正确后退出
+[comparing-the-guess-to-the-secret-number]: ch02-00-guessing-game-tutorial.html#comparing-the-guess-to-the-secret-number
+[quitting-after-a-correct-guess]: ch02-00-guessing-game-tutorial.html#quitting-after-a-correct-guess

src/ch04-00-understanding-ownership.md

@@ -1,6 +1,5 @@
 # 认识所有权
 
-<!-- https://github.com/rust-lang/book/blob/main/src/ch04-00-understanding-ownership.md -->
-<!-- commit a5e0c5b2c5f9054be3b961aea2c7edfeea591de8 -->
+[ch04-00-understanding-ownership.md](https://github.com/rust-lang/book/blob/a5e0c5b2c5f9054be3b961aea2c7edfeea591de8/src/ch04-00-understanding-ownership.md)
 
-所有权（系统）是 Rust 最为与众不同的特性，对语言的其他部分有着深刻含义。它让 Rust 无需垃圾回收（garbage collector）即可保障内存安全，因此理解 Rust 中所有权如何工作是十分重要的。本章，我们将讲到所有权以及相关功能：借用（borrowing）、slice 以及 Rust 如何在内存中布局数据。
+所有权是 Rust 最独特的特性，也是对语言其余部分影响最深的特性之一。它使 Rust 无需垃圾回收器（garbage collector）也能提供内存安全保证，因此理解所有权在 Rust 中是如何工作的非常重要。在本章中，我们将讨论所有权，以及几个相关特性：借用（borrowing）、slice，以及 Rust 如何在内存中布局数据。