|
|
|
|
@ -251,11 +251,11 @@ $ cargo build
|
|
|
|
|
|
|
|
|
|
可能会出现不同的版本号（多亏了语义化版本，它们与代码是兼容的！），并且显示的行数可能会有所不同（取决于操作系统），行的顺序也可能会不同。
|
|
|
|
|
|
|
|
|
|
现在我们有了一个外部依赖，Cargo 从 _registry_ 上获取所有包的最新版本信息，这是一份来自 [Crates.io][cratesio] 的数据副本。Crates.io 是 Rust 生态系统中，人们发布其开源 Rust 项目的平台，供他人使用。
|
|
|
|
|
当我们加入一个外部依赖时，Cargo 会从 _registry_ 获取该依赖所需内容的最新版本信息；这个 _registry_ 是来自 [Crates.io][cratesio] 数据的一份副本。Crates.io 是 Rust 生态系统中人们发布开源 Rust 项目、供他人使用的平台。
|
|
|
|
|
|
|
|
|
|
在更新完 _registry_ 后，Cargo 检查 `[dependencies]` section 并下载列表中包含但还未下载的 crate。本例中，虽然只声明了 `rand` 一个依赖，然而 Cargo 还是额外获取了 `rand` 所需要的其他 crate，因为 `rand` 依赖它们来正常工作。下载完成后，Rust 编译依赖，然后使用这些依赖编译项目。
|
|
|
|
|
在更新完 _registry_ 之后，Cargo 会检查 `[dependencies]` section，并下载其中列出但尚未下载的 crate。本例中，虽然我们只声明了 `rand` 这一个依赖，Cargo 还是额外获取了 `rand` 正常工作所依赖的其他 crate。下载完成后，Rust 会先编译这些依赖，再在这些依赖可用的情况下编译项目本身。
|
|
|
|
|
|
|
|
|
|
如果不做任何修改，立刻再次运行 `cargo build`，则不会看到任何除了 `Finished` 行之外的输出。Cargo 知道它已经下载并编译了依赖，同时 _Cargo.toml_ 文件也没有变动。Cargo 还知道代码也没有任何修改，所以它不会重新编译代码。因为无事可做，它会简单地退出。
|
|
|
|
|
如果不做任何修改，立刻再次运行 `cargo build`，除了 `Finished` 那一行之外，你不会看到任何输出。Cargo 知道它已经下载并编译了这些依赖，而且 _Cargo.toml_ 文件也没有发生变化。Cargo 还知道你的代码也没有改动，所以它也不会重新编译代码。由于没有事情可做，它就会直接退出。
|
|
|
|
|
|
|
|
|
|
如果打开 _src/main.rs_ 文件，做一些无关紧要的修改，保存并再次构建，你将只会看到两行输出：
|
|
|
|
|
|
|
|
|
|
@ -265,7 +265,7 @@ $ cargo build
|
|
|
|
|
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
这一行表示 Cargo 只针对 _src/main.rs_ 文件的微小修改而更新构建。依赖没有变化，所以 Cargo 知道它可以复用已经为此下载并编译的代码。
|
|
|
|
|
这表明 Cargo 只因为你对 _src/main.rs_ 做了微小修改而更新了构建。依赖并没有变化，所以 Cargo 知道它可以复用之前已经下载并编译好的那些代码。
|
|
|
|
|
|
|
|
|
|
#### _Cargo.lock_ 文件确保可重现构建
|
|
|
|
|
|
|
|
|
|
@ -275,25 +275,25 @@ Cargo 有一个机制，可以确保无论是你还是其他人在任何时候
|
|
|
|
|
|
|
|
|
|
#### 更新 crate 到一个新版本
|
|
|
|
|
|
|
|
|
|
当你 **确实** 需要升级 crate 时，Cargo 提供了这样一个命令，`update`，它会忽略 *Cargo.lock* 文件，并计算出所有符合 *Cargo.toml* 声明的最新版本。Cargo 接下来会把这些版本写入 *Cargo.lock* 文件。不过，Cargo 默认只会寻找大于 `0.8.5` 而小于 `0.9.0` 的版本。如果 `rand` crate 发布了两个新版本，`0.8.6` 和 `0.9.0`，在运行 `cargo update` 时会出现如下内容：
|
|
|
|
|
当你 **确实** 想更新某个 crate 时，Cargo 提供了 `update` 命令，它会忽略 *Cargo.lock* 文件，并重新计算所有符合 *Cargo.toml* 中声明要求的最新版本。然后，Cargo 会把这些版本写回 *Cargo.lock* 文件。不过，默认情况下，Cargo 只会查找大于 `0.8.5` 且小于 `0.9.0` 的版本。如果 `rand` crate 发布了两个新版本：`0.8.6` 和 `0.999.0`，那么运行 `cargo update` 时你会看到如下输出：
|
|
|
|
|
|
|
|
|
|
```console
|
|
|
|
|
$ cargo update
|
|
|
|
|
Updating crates.io index
|
|
|
|
|
Locking 1 package to latest Rust 1.85.0 compatible version
|
|
|
|
|
Updating rand v0.8.5 -> v0.8.6 (available: v0.9.0)
|
|
|
|
|
Updating rand v0.8.5 -> v0.8.6 (available: v0.999.0)
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Cargo 忽略了 `0.9.0` 版本。这时，你也会注意到的 *Cargo.lock* 文件中的变化无外乎现在使用的 `rand` crate 版本是 `0.8.6` 。如果想要使用 `0.9.0` 版本的 `rand` 或是任何 `0.9.x` 系列的版本，必须像这样更新 *Cargo.toml* 文件：
|
|
|
|
|
Cargo 会忽略 `0.999.0` 这个版本。这时，你也会注意到 *Cargo.lock* 文件发生了变化：你现在使用的 `rand` crate 版本变成了 `0.8.6`。如果你想使用 `rand` 的 `0.999.0` 版本，或者 `0.999.x` 系列中的任何版本，就必须像下面这样更新 *Cargo.toml* 文件：
|
|
|
|
|
|
|
|
|
|
```toml
|
|
|
|
|
[dependencies]
|
|
|
|
|
rand = "0.9.0"
|
|
|
|
|
rand = "0.999.0"
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
下一次运行 `cargo build` 时，Cargo 会更新可用 crate 的 registry，并根据你指定的新版本重新评估 `rand` 的要求。
|
|
|
|
|
下一次运行 `cargo build` 时，Cargo 会更新可用 crate 的 registry，并根据你指定的新版本重新评估 `rand` 的版本要求。
|
|
|
|
|
|
|
|
|
|
第十四章会讲到 [Cargo][doccargo]<!-- ignore --> 及其[生态系统][doccratesio]<!-- ignore --> 的更多内容，不过目前你只需要了解这么多。通过 Cargo 复用库文件非常容易，因此 Rustacean 能够编写出由很多包组装而成的更轻巧的项目。
|
|
|
|
|
第十四章会介绍 [Cargo][doccargo]<!-- ignore --> 及其[生态系统][doccratesio]<!-- ignore --> 的更多内容，不过目前知道这些就足够了。Cargo 让复用库变得非常容易，因此 Rustaceans 能够编写出由多个包组合而成、更小巧的项目。
|
|
|
|
|
|
|
|
|
|
### 生成一个随机数
|
|
|
|
|
|
|
|
|
|
@ -313,9 +313,9 @@ rand = "0.9.0"
|
|
|
|
|
|
|
|
|
|
首先，我们新增了一行 `use rand::Rng;`。`Rng` 是一个 trait，它定义了随机数生成器应实现的方法，想使用这些方法的话，此 trait 必须在作用域中。第十章会详细介绍 trait。
|
|
|
|
|
|
|
|
|
|
接下来，我们在中间还新增加了两行。第一行调用了 `rand::thread_rng` 函数提供实际使用的随机数生成器：它位于当前执行线程的本地环境中，并从操作系统获取 seed。接着调用随机数生成器的 `gen_range` 方法。这个方法由 `use rand::Rng` 语句引入到作用域的 `Rng` trait 定义。`gen_range` 方法获取一个范围表达式（range expression）作为参数，并生成一个在此范围之间的随机数。这里使用的这类范围表达式使用了 `start..=end` 这样的形式，它对上下边界均为闭区间，所以需要指定 `1..=100` 来请求一个 1 和 100 之间的数。
|
|
|
|
|
接下来，我们又在中间加了两行。第一行调用 `rand::thread_rng` 函数，得到我们将要使用的那个特定随机数生成器：它与当前执行线程局部相关，并由操作系统提供种子（seed）。然后，我们在这个随机数生成器上调用 `gen_range` 方法。这个方法由通过 `use rand::Rng` 语句引入作用域的 `Rng` trait 定义。`gen_range` 方法接收一个范围表达式（range expression）作为参数，并在该范围内生成一个随机数。这里我们使用的范围表达式形式是 `start..=end`，它在上下边界上都是闭区间，所以我们需要写 `1..=100`，来请求一个 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`。
|
|
|
|
|
|
|
|
|
|
新增加的第二行代码打印出了秘密数字。这在开发程序时很有用，因为可以测试它，不过在最终版本中会删掉它。如果游戏一开始就打印出结果就没什么可玩的了！
|
|
|
|
|
|
|
|
|
|
@ -360,15 +360,15 @@ You guessed: 5
|
|
|
|
|
|
|
|
|
|
</figure>
|
|
|
|
|
|
|
|
|
|
首先我们增加了另一个 `use` 声明，从标准库引入了一个叫做 `std::cmp::Ordering` 的类型到作用域中。 `Ordering` 也是一个枚举，不过它的成员是 `Less`、`Greater` 和 `Equal`。这是比较两个值时可能出现的三种结果。
|
|
|
|
|
首先，我们增加了另一条 `use` 声明，把标准库中的 `std::cmp::Ordering` 类型引入作用域。`Ordering` 也是一个枚举，它的成员分别是 `Less`、`Greater` 和 `Equal`。这正是比较两个值时可能出现的三种结果。
|
|
|
|
|
|
|
|
|
|
接着，底部的五行新代码使用了 `Ordering` 类型，`cmp` 方法用来比较两个值并可以在任何可比较的值上调用。它获取一个被比较值的引用：这里是把 `guess` 与 `secret_number` 做比较。然后它会返回一个刚才通过 `use` 引入作用域的 `Ordering` 枚举的成员。使用一个 [`match`][match]<!-- ignore --> 表达式，根据对 `guess` 和 `secret_number` 调用 `cmp` 返回的 `Ordering` 成员来决定接下来做什么。
|
|
|
|
|
接着，我们在底部添加了五行新代码，用到了 `Ordering` 类型。`cmp` 方法用于比较两个值，并且可以在任何可比较的值上调用。它接收一个对比对象的引用：这里就是把 `guess` 和 `secret_number` 作比较。然后，它会返回一个我们刚刚通过 `use` 引入作用域的 `Ordering` 枚举成员。我们使用 [`match`][match]<!-- ignore --> 表达式，根据对 `guess` 和 `secret_number` 调用 `cmp` 后返回的是哪个 `Ordering` 成员，来决定下一步该做什么。
|
|
|
|
|
|
|
|
|
|
一个 `match` 表达式由 **分支（arms）** 构成。一个分支包含一个 **模式**（*pattern*）和表达式开头的值与分支模式相匹配时应该执行的代码。Rust 获取提供给 `match` 的值并挨个检查每个分支的模式。`match` 结构和模式是 Rust 中强大的功能，它体现了代码可能遇到的多种情形，并确保对所有情况作出处理。这些功能将分别在第六章和第十九章详细介绍。
|
|
|
|
|
|
|
|
|
|
让我们看看使用 `match` 表达式的例子。假设用户猜了 50，这时随机生成的秘密数字是 38。
|
|
|
|
|
|
|
|
|
|
比较 50 与 38 时，因为 50 比 38 要大，`cmp` 方法会返回 `Ordering::Greater`。`Ordering::Greater` 是 `match` 表达式得到的值。它检查第一个分支的模式，`Ordering::Less` 与 `Ordering::Equal`并不匹配，所以它忽略了这个分支的代码并来到下一个分支。下一个分支的模式是 `Ordering::Greater`，**正确** 匹配！这个分支关联的代码被执行，在屏幕打印出 `Too big!`。`match` 表达式会在第一次成功匹配后终止，因此在这种情况下不会查看最后一个分支。
|
|
|
|
|
当代码比较 50 和 38 时，因为 50 大于 38，`cmp` 方法会返回 `Ordering::Greater`。`match` 表达式拿到的就是这个 `Ordering::Greater` 值。它会先检查第一个分支的模式 `Ordering::Less`，发现并不匹配，于是忽略这个分支中的代码并继续看下一个分支。下一个分支的模式是 `Ordering::Greater`，它**确实**匹配！于是该分支关联的代码会被执行，并在屏幕上打印 `Too big!`。由于 `match` 表达式会在第一次成功匹配后结束，所以在这种情况下它不会再去看最后一个分支。
|
|
|
|
|
|
|
|
|
|
然而，示例 2-4 的代码目前并不能编译，可以尝试一下：
|
|
|
|
|
|
|
|
|
|
@ -392,15 +392,15 @@ You guessed: 5
|
|
|
|
|
let guess: u32 = guess.trim().parse().expect("Please type a number!");
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
这里创建了一个叫做 `guess` 的变量。不过等等，不是已经有了一个叫做 `guess` 的变量了吗？确实如此，不过 Rust 允许用一个新值来 **遮蔽** （_Shadowing_） `guess` 之前的值。这个功能允许我们复用 `guess` 变量的名字，而不是被迫创建两个不同变量，诸如 `guess_str` 和 `guess` 之类。[第三章][shadowing]会介绍 shadowing 的更多细节，现在只需知道这个功能经常用于将一个类型的值转换为另一个类型的值。
|
|
|
|
|
这里创建了一个名为 `guess` 的变量。不过等等，不是已经有一个叫做 `guess` 的变量了吗？确实如此，但 Rust 很贴心地允许我们用一个新值来 **遮蔽**（_shadowing_）之前的 `guess`。这样一来，我们就可以继续复用 `guess` 这个变量名，而不必被迫创建两个不同的变量，比如 `guess_str` 和 `guess`。[第三章][shadowing]会更详细地介绍 shadowing；现在你只需要知道，这个特性经常被用来把一个值从一种类型转换为另一种类型。
|
|
|
|
|
|
|
|
|
|
我们将这个新变量绑定到 `guess.trim().parse()` 表达式上。表达式中的 `guess` 指的是包含输入的字符串类型 `guess` 变量。`String` 实例的 `trim` 方法会去除字符串开头和结尾的空白字符，我们必须执行此方法才能将字符串与 `u32` 比较，因为 `u32` 只能包含数值型数据。用户必须输入 <kbd>enter</kbd> 键才能让 `read_line` 返回并输入他们的猜想，这将会在字符串中增加一个换行（newline）符。例如，用户输入 <kbd>5</kbd> 并按下 <kbd>enter</kbd>（在 Windows 上，按下 <kbd>enter</kbd> 键会得到一个回车符和一个换行符，`\r\n`），`guess` 看起来像这样：`5\n` 或者 `5\r\n`。`\n` 代表 “换行”，回车键；`\r` 代表 “回车”，回车键。`trim` 方法会消除 `\n` 或者 `\r\n`，结果只留下 `5`。
|
|
|
|
|
我们把这个新变量绑定到 `guess.trim().parse()` 这个表达式上。表达式里的 `guess` 指向的是原先那个保存用户输入字符串的 `guess` 变量。`String` 实例上的 `trim` 方法会去掉字符串开头和结尾的空白字符；在把字符串转换为 `u32` 之前，我们必须先这么做，因为 `u32` 只能包含数值数据。用户必须按下 <kbd>enter</kbd> 才能让 `read_line` 返回并提交他们的猜测，这会在字符串中附加一个换行符（newline）。例如，如果用户输入 <kbd>5</kbd> 并按下 <kbd>enter</kbd>，`guess` 实际上会变成 `5\n`。（在 Windows 上，按下 <kbd>enter</kbd> 会得到回车加换行，也就是 `\r\n`。）`trim` 方法会去除 `\n` 或 `\r\n`，最后只留下 `5`。
|
|
|
|
|
|
|
|
|
|
[字符串的 `parse` 方法][parse]<!-- ignore --> 将字符串转换成其他类型。这里用它来把字符串转换为数值。我们需要告诉 Rust 具体的数字类型，这里通过 `let guess: u32` 指定。`guess` 后面的冒号（`:`）告诉 Rust 我们指定了变量的类型。Rust 有一些内建的数字类型；`u32` 是一个无符号的 32 位整型。对于不大的正整数来说，它是不错的默认类型，[第三章][integers]还会讲到其他数字类型。
|
|
|
|
|
|
|
|
|
|
另外，程序中的 `u32` 注解以及与 `secret_number` 的比较，意味着 Rust 会推断出 `secret_number` 也是 `u32` 类型。现在可以使用相同类型比较两个值了！
|
|
|
|
|
|
|
|
|
|
`parse` 方法只有在字符逻辑上可以转换为数字的时候才能工作所以非常容易出错。例如，字符串中包含 `A👍%`，就无法将其转换为一个数字。因此，`parse` 方法返回一个 `Result` 类型。像之前 [“使用 `Result` 类型来处理潜在的错误”](#使用-result-类型来处理潜在的错误) 讨论的 `read_line` 方法那样，再次按部就班的用 `expect` 方法处理即可。如果 `parse` 不能从字符串生成一个数字，返回一个 `Result` 的 `Err` 成员时，`expect` 会使游戏崩溃并打印附带的信息。如果 `parse` 成功地将字符串转换为一个数字，它会返回 `Result` 的 `Ok` 成员，然后 `expect` 会返回 `Ok` 值中的数字。
|
|
|
|
|
`parse` 方法只会在字符逻辑上确实可以转换为数字时才成功，因此很容易失败。例如，如果字符串里包含 `A👍%`，那就根本不可能把它转换成数字。正因如此，`parse` 方法会返回一个 `Result` 类型，就像前面在 [“使用 `Result` 类型来处理潜在的错误”](#handling-potential-failure-with-the-result-type) 中讨论过的 `read_line` 方法一样。这里我们再次使用 `expect` 方法来处理它。如果 `parse` 无法从字符串中生成数字，并返回 `Result` 的 `Err` 成员，`expect` 就会让游戏崩溃，并打印我们提供的消息。如果 `parse` 成功把字符串转换为数字，它就会返回 `Result` 的 `Ok` 成员，而 `expect` 会把 `Ok` 里保存的数字返回给我们。
|
|
|
|
|
|
|
|
|
|
现在让我们运行程序！
|
|
|
|
|
|
|
|
|
|
@ -417,7 +417,7 @@ You guessed: 76
|
|
|
|
|
Too big!
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
漂亮！即便是在猜测之前添加了空格，程序依然能判断出用户猜测了 76。多运行程序几次，输入不同的数字来检验不同的行为：猜一个正确的数字，猜一个过大的数字和猜一个过小的数字。
|
|
|
|
|
很好！即使在猜测前面加了空格，程序仍然能判断出用户猜的是 76。你可以多运行几次程序，用不同类型的输入来验证不同的行为：猜中正确数字、猜一个过大的数字，以及猜一个过小的数字。
|
|
|
|
|
|
|
|
|
|
现在游戏已经大体上能玩了，不过用户只能猜一次。增加一个循环来改变它吧！
|
|
|
|
|
|
|
|
|
|
@ -431,9 +431,9 @@ Too big!
|
|
|
|
|
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/no-listing-04-looping/src/main.rs:here}}
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
如上所示，我们将提示用户猜测之后的所有内容移动到了循环中。确保 loop 循环中的代码多缩进四个空格，再次运行程序。注意这里有一个新问题，程序现在会不断地要求用户输入新的猜测。用户好像无法退出啊！
|
|
|
|
|
如你所见，我们把从提示用户输入猜测开始往后的所有内容都移进了循环中。请确保循环中的代码都额外缩进四个空格，然后再次运行程序。程序现在会不断要求用户输入新的猜测，但这也引入了一个新问题。用户似乎没法退出了！
|
|
|
|
|
|
|
|
|
|
用户总能使用 <kbd>ctrl</kbd>-<kbd>c</kbd> 终止程序。不过还有另一个方法跳出无限循环，就是 [“比较猜测与秘密数字”](#比较猜测的数字和秘密数字) 部分提到的 `parse`：如果用户输入的答案不是一个数字，程序会崩溃。我们可以利用这一点来退出，如下所示：
|
|
|
|
|
用户当然总可以用键盘快捷键 <kbd>ctrl</kbd>-<kbd>C</kbd> 中断程序。不过还有另一种办法能逃离这个贪得无厌的怪物，正如我们在 [“比较猜测的数字和秘密数字”](#比较猜测的数字和秘密数字) 一节讨论 `parse` 时提到的那样：如果用户输入的不是数字，程序就会崩溃。我们可以利用这一点来让用户退出，如下所示：
|
|
|
|
|
|
|
|
|
|
```console
|
|
|
|
|
$ cargo run
|
|
|
|
|
@ -462,7 +462,7 @@ Please type a number!: ParseIntError { kind: InvalidDigit }
|
|
|
|
|
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
输入 `quit` 将会退出程序，同时你会注意到其他任何非数字输入也一样。这至少可以说是不理想的，我们想要当猜测正确的数字时游戏停止。
|
|
|
|
|
输入 `quit` 的确会退出游戏，但你也会注意到，输入任何其他非数字内容也一样会退出。这种体验至少可以说并不理想；我们希望游戏在猜中正确数字时也能停止。
|
|
|
|
|
|
|
|
|
|
### 猜测正确后退出
|
|
|
|
|
|
|
|
|
|
@ -474,11 +474,11 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
|
|
|
|
|
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/no-listing-05-quitting/src/main.rs:here}}
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
通过在 `You win!` 之后增加一行 `break`，用户猜对了神秘数字后会退出循环。退出循环也意味着退出程序，因为循环是 `main` 的最后一部分。
|
|
|
|
|
在 `You win!` 之后加上一行 `break`，程序就会在用户正确猜出秘密数字时退出循环。退出循环也就意味着退出程序，因为这个循环就是 `main` 的最后一部分。
|
|
|
|
|
|
|
|
|
|
### 处理无效输入
|
|
|
|
|
|
|
|
|
|
为了进一步改善游戏性，不要在用户输入非数字时崩溃，需要忽略非数字，让用户可以继续猜测。可以通过修改 `guess` 将 `String` 转化为 `u32` 那部分代码来实现，如示例 2-5 所示：
|
|
|
|
|
为了进一步改进游戏体验，我们不希望程序在用户输入非数字时崩溃；相反，我们希望它忽略这些输入，让用户继续猜。我们可以通过修改将 `guess` 从 `String` 转换为 `u32` 的那行代码来做到这一点，如示例 2-5 所示：
|
|
|
|
|
|
|
|
|
|
<figure class="listing">
|
|
|
|
|
|
|
|
|
|
@ -492,11 +492,11 @@ note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
|
|
|
|
|
|
|
|
|
|
</figure>
|
|
|
|
|
|
|
|
|
|
我们将 `expect` 调用换成 `match` 语句，以从遇到错误就崩溃转换为处理错误。须知 `parse` 返回一个 `Result` 类型，而 `Result` 是一个拥有 `Ok` 或 `Err` 成员的枚举。这里使用的 `match` 表达式，和之前处理 `cmp` 方法返回 `Ordering` 时用的一样。
|
|
|
|
|
我们将 `expect` 调用换成 `match` 语句，以从遇到错误就崩溃转换为处理错误。须知 `parse` 返回的是一个 `Result` 类型，而 `Result` 是一个拥有 `Ok` 和 `Err` 成员的枚举。这里使用的 `match` 表达式，和我们之前处理 `cmp` 方法返回的 `Ordering` 时用的是同一种方式。
|
|
|
|
|
|
|
|
|
|
如果 `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` 可能遇到的所有错误！
|
|
|
|
|
|
|
|
|
|
现在程序中的一切都应该如预期般工作了。让我们试试吧：
|
|
|
|
|
|
|
|
|
|
@ -523,7 +523,7 @@ You guessed: 61
|
|
|
|
|
You win!
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
太棒了！再有最后一个小的修改，就能完成猜数字游戏了：还记得程序依然会打印出秘密数字。在测试时还好，但正式发布时会毁了游戏体验。删掉打印秘密数字的 `println!`。示例 2-6 为最终代码：
|
|
|
|
|
太棒了！再做最后一个小改动，猜数字游戏就完成了：别忘了程序现在仍然会打印出秘密数字。测试时这很方便，但正式发布时会破坏游戏体验。把输出秘密数字的 `println!` 删掉吧。示例 2-6 展示了最终代码：
|
|
|
|
|
|
|
|
|
|
<figure class="listing">
|
|
|
|
|
|
|
|
|
|
@ -537,11 +537,11 @@ You win!
|
|
|
|
|
|
|
|
|
|
</figure>
|
|
|
|
|
|
|
|
|
|
此时此刻，你顺利完成了猜数字游戏。恭喜！
|
|
|
|
|
到这里，你已经成功构建出了猜数字游戏。恭喜！
|
|
|
|
|
|
|
|
|
|
## 总结
|
|
|
|
|
|
|
|
|
|
本项目通过动手实践，向你介绍了 Rust 新概念：`let`、`match`、函数、使用外部 crate 等等，接下来的几章，你会继续深入学习这些概念。第三章介绍大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用它们。第四章探索所有权（ownership），这是一个 Rust 同其他语言大不相同的特性。第五章讨论结构体和方法的语法，而第六章解释枚举。
|
|
|
|
|
这个项目通过动手实践的方式，向你介绍了许多 Rust 新概念：`let`、`match`、函数、使用外部 crate，等等。在接下来的几章中，你会更深入地学习这些概念。第三章介绍大多数编程语言共有的概念，例如变量、数据类型和函数，并展示如何在 Rust 中使用它们。第四章将探索所有权（ownership），这是 Rust 区别于其他语言的一项特性。第五章讨论结构体与方法语法，第六章则解释枚举是如何工作的。
|
|
|
|
|
|
|
|
|
|
[prelude]: https://doc.rust-lang.org/std/prelude/index.html
|
|
|
|
|
[variables-and-mutability]: ch03-01-variables-and-mutability.html#变量和可变性
|
|
|
|
|
|
KaiserY
4 days ago