对猜谜游戏进行编程

让我们一起完成一个动手项目，进入 Rust！这 本章通过展示如何使用 他们在一个真实的程序中。您将了解 、 、 方法、 关联的 函数、外部 crate 等等！在接下来的章节中，我们将探讨 这些想法更详细。在本章中，您将只练习 基础。letmatch

我们将实现一个经典的初学者编程问题：猜谜游戏。这是 运作方式： 该程序将生成一个介于 1 和 100 之间的随机整数。它 然后会提示玩家输入猜测。输入猜测后， 程序将指示猜测值是太低还是太高。如果猜测是 正确，游戏将打印祝贺消息并退出。

设置新项目

要设置新项目，请转到您在 第 1 章，并使用 Cargo 创建一个新项目，如下所示：

$ cargo new guessing_game
$ cd guessing_game

第一个命令 采用项目的名称 （） 作为第一个参数。第二个命令将更改为新项目的 目录。cargo newguessing_game

查看生成的 Cargo.toml 文件：

文件名： Cargo.toml

[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

正如您在第 1 章中看到的，为 你。查看 src/main.rs 文件：cargo new

文件名： src/main.rs

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

现在让我们编译这个 “Hello， world！” 程序，并以相同的步骤运行它 使用以下命令：cargo run

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.50s
     Running `target/debug/guessing_game`
Hello, world!

当您需要快速迭代项目时，该命令会派上用场。 正如我们在这个游戏中所做的那样，在继续 下一个。run

重新打开 src/main.rs 文件。您将在此文件中编写所有代码。

处理猜测

猜谜游戏程序的第一部分会要求用户输入，处理 该 input，并检查输入是否为预期形式。首先，我们将 允许玩家输入猜测。将示例 2-1 中的代码输入到 src/main.rs 中。

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

这段代码包含了很多信息，所以让我们一行一行地看一遍。自 获取用户输入，然后将结果打印为 output，我们需要将 input/output 库引入 Scope。该库来自标准的 库，称为：ioiostd

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

默认情况下，Rust 在标准库中定义了一组项目，它 带入每个程序的范围。这组称为 prelude，而 您可以在 Standard Library 文档中看到其中的所有内容。

如果要使用的类型不在 prelude 中，则必须引入该类型 into 范围。使用库 为您提供了许多有用的功能，包括接受 用户输入。usestd::io

正如您在第 1 章中看到的，该函数是 程序：main

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

语法声明一个新函数;括号 ， 表示那里 没有参数;大括号 ， 开始函数的主体。fn(){

正如您在第 1 章中学到的那样，是一个宏，它将字符串打印到 屏幕：println!

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

此代码将打印一个提示，说明游戏是什么并请求输入 来自用户。

使用变量存储值

接下来，我们将创建一个变量来存储用户输入，如下所示：

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

现在这个程序越来越有趣了！这个小 线。我们使用该语句创建变量。这是另一个示例：let

let apples = 5;

此行创建一个名为 的新变量，并将其绑定到值 5。在 Rust 中，变量默认是不可变的，这意味着一旦我们给变量一个 值，该值不会更改。我们将在 第 3 章中的“变量和可变性”部分。要使变量可变，我们在 变量名称：applesmut

let apples = 5; // immutable
let mut bananas = 5; // mutable

回到猜谜游戏程序，您现在知道将 引入一个名为 .等号 （） 告诉 Rust 我们 想要现在将某些内容绑定到变量。等号的右侧是 绑定到的值，这是调用 的结果，该函数返回 .String 是标准 库，它是一个可增长的 UTF-8 编码文本位。let mut guessguess=guessString::newString

该行中的语法表示 是关联的 函数。关联的函数是 在 type 上实现，在本例中为 .此函数会创建一个 new 的空字符串。你会发现一个函数有很多类型，因为它是一个 生成某种新值的函数的 common name 。::::newnewStringStringnewnew

总的来说，该行已经创建了一个 mutable 当前绑定到 .呼！let mut guess = String::new();String

接收用户输入

回想一下，我们从标准中包含了输入/输出功能 library 的 。现在我们调用 来自模块的函数，这将允许我们处理 user 输入：use std::io;stdinio

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

如果我们没有在 程序中，我们仍然可以通过将这个函数调用编写为 .该函数返回 std：：io：：Stdin 的实例，该实例是表示 handle 添加到终端的标准输入端。iouse std::io;std::io::stdinstdin

接下来，该行在标准输入句柄上调用 read_line 方法，以获取用户的输入。 我们还将参数作为参数传递给 以告诉它什么 string 来存储用户输入。的全部工作是采取 用户在 Standard Input 中键入的任何内容并将其附加到字符串中 （而不覆盖其内容），因此我们将该字符串作为 论点。string 参数需要是可变的，以便方法可以更改 String 的内容。.read_line(&mut guess)&mut guessread_lineread_line

这表示此参数是一个引用，这为您提供了一种 允许代码的多个部分访问一条数据，而无需 多次将该数据复制到内存中。引用是一个复杂的功能， Rust 的主要优势之一是它的安全性和易用性 引用。您无需了解很多细节即可完成此作 程序。现在，您需要知道的是，与变量一样，引用也是 默认为 immut。因此，您需要编写而不是使其可变。（第 4 章将更多地解释参考资料 彻底。&&mut guess&guess

处理潜在故障的结果

我们仍在处理这行代码。我们现在讨论的是 text 中，但请注意，它仍然是单个逻辑代码行的一部分。下一个 部分是这个方法：

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

我们可以将这段代码编写为：

io::stdin().read_line(&mut guess).expect("Failed to read line");

但是，一条长线很难阅读，因此最好将其分开。它 引入换行符和其他空格来帮助分解长线通常是明智的 行。现在让我们 讨论此行的作用。.method_name()

如前所述，将用户输入的任何内容放入字符串 我们传递给它，但它也返回一个值。Result 是一个枚举，通常称为枚举 该类型可以处于多种可能的状态之一。我们称每个 possible 状态 a 变体。read_lineResult

第 6 章将更详细地介绍枚举。目的 用于对错误处理信息进行编码。Result

Result的变体是 和 。该 variant 表示 作成功，内部是成功生成的值。 变体表示作失败，并包含信息 了解作失败的方式或原因。OkErrOkOkErrErr

该类型的值与任何类型的值一样，在 他们。的实例具有可以调用的 expect 方法。如果此实例 of 是一个值，将导致程序崩溃并显示您作为 参数设置为 .如果该方法返回一个 ，它将 可能是来自底层作系统的错误的结果。 如果此实例 为 值，则将采用 value 并返回该值给你，以便你可以使用它。 在这种情况下，该值是用户输入中的字节数。ResultResultResultErrexpectexpectread_lineErrResultOkexpectOk

如果您不调用 ，程序将编译，但您将收到警告：expect

$ cargo build
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
warning: unused `Result` that must be used
  --> src/main.rs:10:5
   |
10 |     io::stdin().read_line(&mut guess);
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: `#[warn(unused_must_use)]` on by default
help: use `let _ = ...` to ignore the resulting value
   |
10 |     let _ = io::stdin().read_line(&mut guess);
   |     +++++++

warning: `guessing_game` (bin "guessing_game") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.59s

Rust 警告您尚未使用从 、 返回的值 指示程序尚未处理可能的错误。Resultread_line

抑制警告的正确方法是实际编写错误处理代码 但是在我们的例子中，我们只是想在出现问题时使这个程序崩溃，所以我们 可以使用 .您将在 章节 中了解如何从错误中恢复 9.expect

使用 println 打印值！占位符

除了右大括号之外，只剩下一行要讨论 到目前为止的代码：

use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {}", guess);
}

此行打印现在包含用户输入的字符串。的集合 大括号是一个占位符：可以想象成小螃蟹钳 一个值就位。打印变量的值时，变量名称可以 进入大括号内。打印 表达式，请在格式字符串中放置空的大括号，然后按照 format 字符串，其中包含要在每个空函数中打印的以逗号分隔的表达式列表 大括号占位符。打印变量和结果 的表达式将如下所示：{}{}println!

#![allow(unused)]
fn main() {
let x = 5;
let y = 10;

println!("x = {x} and y + 2 = {}", y + 2);
}

此代码将打印 .x = 5 and y + 2 = 12

测试 First Part

让我们测试猜谜游戏的第一部分。使用以下方式运行它：cargo run

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 6.44s
     Running `target/debug/guessing_game`
Guess the number!
Please input your guess.
6
You guessed: 6

此时，游戏的第一部分已经完成：我们从 键盘，然后打印它。

生成密钥编号

接下来，我们需要生成一个用户将尝试猜测的秘密号码。这 每次的秘密号码都应该不同，这样游戏玩起来就更有趣了 一次。我们将使用一个介于 1 和 100 之间的随机数，这样游戏就不会太过分 难。Rust 尚未在其标准中包含随机数功能 图书馆。但是，Rust 团队确实提供了一个带有 说功能。

使用 crate 获得更多功能

请记住，crate 是 Rust 源代码文件的集合。项目 我们一直在构建一个二进制 crate，它是一个可执行文件。crate 是一个库 crate，其中包含打算在 其他程序，不能单独执行。rand

Cargo 对外部板条箱的协调是 Cargo 真正闪耀的地方。在我们之前 可以编写使用的代码，我们需要将 Cargo.toml 文件修改为 将 crate 作为依赖项包含在内。现在打开该文件并添加 以下行到底部，在部分标题下方 为您创建的 Cargo。请务必按照此处的 此版本号或本教程中的代码示例可能不起作用：randrand[dependencies]rand

文件名： Cargo.toml

[dependencies]
rand = "0.8.5"

在 Cargo.toml 文件中，标头后面的所有内容都是该文件的一部分 部分继续，直到另一个部分开始。在你 告诉 Cargo 你的项目依赖于哪些外部 crate 以及哪些版本的 您需要的那些板条箱。在本例中，我们指定带有 语义版本说明符 。Cargo 理解语义 版本控制（有时称为 SemVer），它是一个 编写版本号的标准。说明符实际上是 的简写 ，表示至少为 0.8.5 但 低于 0.9.0。[dependencies]rand0.8.50.8.5^0.8.5

Cargo 认为这些版本具有与版本 0.8.5 版本，此规范可确保您获得最新的补丁版本，该 仍会使用本章中的代码进行编译。任何版本 0.9.0 或更高版本 不保证具有与以下示例使用的 API 相同的 API。

现在，在不更改任何代码的情况下，让我们构建项目，如 示例 2-2.

$ cargo build
    Updating crates.io index
  Downloaded rand v0.8.5
  Downloaded libc v0.2.127
  Downloaded getrandom v0.2.7
  Downloaded cfg-if v1.0.0
  Downloaded ppv-lite86 v0.2.16
  Downloaded rand_chacha v0.3.1
  Downloaded rand_core v0.6.3
   Compiling libc v0.2.127
   Compiling getrandom v0.2.7
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.16
   Compiling rand_core v0.6.3
   Compiling rand_chacha v0.3.1
   Compiling rand v0.8.5
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53s

您可能会看到不同的版本号（但它们都将与 代码，感谢 SemVer！和不同的线路（取决于作 system），并且这些行的顺序可能不同。

当我们包含外部依赖项时，Cargo 会获取最新版本的 依赖项需要从注册表中获得的所有内容，即数据副本 从 Crates.io。Crates.io 是 Rust 生态系统中人们的地方 发布他们的开源 Rust 项目供其他人使用。

更新注册表后，Cargo 会检查 section 和 下载列出的任何尚未下载的 crate。在这种情况下， 虽然我们只列为一个依赖，但 Cargo 也抢走了其他 crate 那要看工作。下载 crate 后，Rust 编译 them，然后使用可用的依赖项编译项目。[dependencies]randrand

如果您立即再次运行而不进行任何更改，则 不会得到除了 line 之外的任何输出。Cargo 知道它已经 下载并编译了依赖项，您没有更改任何内容 关于 Cargo.toml 文件中的 Package。Cargo 也知道您没有更改 任何关于你的代码的信息，所以它也不会重新编译它。无所事事 do，它只是退出。cargo buildFinished

如果你打开 src/main.rs 文件，做一个小小的修改，然后保存它并 build 再次构建，您将只看到两行输出：

$ 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 将仅使用 dependencies 的 trust 选项，直到您另有说明。例如，假设 下周 Crate 的 0.8.6 版本出来了，那个版本 包含一个重要的错误修复，但它也包含一个回归，该回归将 破解你的代码。为了解决这个问题，Rust 首先创建了 Cargo.lock 文件 运行时间，因此我们现在在 guessing_game 目录中有 this。randcargo build

当你第一次构建一个项目时，Cargo 会找出所有版本 ，然后将它们写入 Cargo.lock 文件。当你将来构建项目时，Cargo 将看到 Cargo.lock 文件存在并将使用其中指定的版本 而不是再次做所有弄清楚版本的工作。这让您 自动获得可重现的构建。换句话说，您的项目将 保持 0.8.5 状态，直到您明确升级，这要归功于 Cargo.lock 文件。 由于 Cargo.lock 文件对于可重现的构建非常重要，因此它通常是 签入 源代码管理，并将项目的其余代码包含在 Source Control 中。

更新 crate 以获得新版本

当您确实想要更新 crate 时，Cargo 会提供命令 ， 它将忽略 Cargo.lock 文件并找出所有最新版本 符合 Cargo.toml 中的规范。然后 Cargo 将写入这些 版本添加到 Cargo.lock 文件中。在这种情况下，Cargo 只会查找 大于 0.8.5 且小于 0.9.0 的版本。如果 crate 有 发布了 0.8.6 和 0.9.0 两个新版本，如果 你运行了 ：updaterandcargo update

$ cargo update
    Updating crates.io index
    Updating rand v0.8.5 -> v0.8.6

Cargo 忽略了 0.9.0 版本。此时，您还会注意到一个变化 在你的 Cargo.lock 文件中，注意你所在的 crate 的版本 现在使用的是 IS 0.8.6。要使用版本 0.9.0 或 0.9 中的任何版本。x 系列，则必须更新 Cargo.toml 文件，使其如下所示：randrand

[dependencies]
rand = "0.9.0"

下次运行 时，Cargo 将更新 crate 的注册表 可用，并根据新版本重新评估您的要求 您已指定。cargo buildrand

关于 Cargo 及其 ecosystem，我们将在第 14 章中讨论，但是 现在，这就是您需要了解的全部内容。Cargo 使其非常容易重复使用 库，因此 Rustacean 能够编写组装的较小项目 从多个包中。

生成随机数

让我们开始使用 to generate a number to guess。下一步是 update src/main.rs，如示例 2-3 所示。rand

use std::io;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");
}

首先，我们添加 .trait 定义了 random number generators 实现，并且这个 trait 必须在我们的范围内，以便我们 使用这些方法。第 10 章将详细介绍特征。use rand::Rng;Rng

接下来，我们在中间添加两行。在第一行中，我们调用为我们提供特定随机数的函数 生成器：一个位于当前线程 执行，并由作系统作为种子。然后我们在随机数生成器上调用该方法。此方法由我们使用 statement 引入范围的 trait 定义。该方法将范围表达式作为参数，并生成一个 范围内的随机数。我们在此处使用的范围表达式类型采用 形式 and 在下限和上限上都包含，因此我们 需要指定请求一个介于 1 和 100 之间的数字。rand::thread_rnggen_rangeRnguse rand::Rng;gen_rangestart..=end1..=100

第二个新行打印秘密号码。这在我们 开发程序以便能够对其进行测试，但我们会将其从 final 版本。如果程序立即打印答案，那就不是什么游戏了 当它开始时！

尝试运行该程序几次：

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 2.53s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 7
Please input your guess.
4
You guessed: 4

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 83
Please input your guess.
5
You guessed: 5

您应该得到不同的随机数，它们都应该是介于 1 和 100。太棒了！

将猜测值与秘密数字进行比较

现在我们有了用户输入和随机数，我们可以比较它们。那一步 如示例 2-4 所示。请注意，这段代码还不会编译，因为我们会编译 解释。

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    // --snip--
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

首先，我们添加另一个语句，将 standard 库中调用的类型引入 scope。类型 是另一个枚举，具有变体 、 、 和 。这些是 比较两个值时可能出现的三种结果。usestd::cmp::OrderingOrderingLessGreaterEqual

然后我们在底部添加 5 行使用该类型的新行。该方法比较两个值，并且可以对任何可以 比较。它需要一个对你想要比较的任何内容的引用：这里是 与 相比。然后它返回我们使用 statement 引入作用域的 enum 的变体。我们使用 match 表达式来决定下一步做什么 的哪个变体是从调用 to 返回的，其值为 in 和 .Orderingcmpguesssecret_numberOrderinguseOrderingcmpguesssecret_number

表情由手臂组成。手臂由一个模式组成，以 match st，如果给定的值适合该 Arm 的模式，则应运行该代码。Rust 接受给定的值 and looks 依次通过每个手臂的模式。模式和结构是 强大的 Rust 功能：它们允许您表达代码中的各种情况 可能会遇到，他们确保您处理所有问题。这些功能将是 分别在第 6 章和第 18 章中详细介绍。matchmatchmatchmatch

让我们看一个包含此处使用的表达式的示例。说那个 用户猜出了 50，这次随机生成的秘密号码是 38.match

当代码将 50 与 38 进行比较时，该方法将返回，因为 50 大于 38。表达式获取 值并开始检查每个臂的模式。看起来 在第一个分支的模式 中，看到该值不匹配，因此它会忽略 该手臂并移动到下一个手臂。下一个分支的模式是 ，它确实匹配 ！关联的 该 ARM 中的代码将执行并打印到屏幕上。表达式在第一次成功匹配后结束，因此它不会查看最后一个 ARM 的 S 实例。cmpOrdering::GreatermatchOrdering::GreaterOrdering::LessOrdering::GreaterOrdering::LessOrdering::GreaterOrdering::GreaterToo big!match

但是，示例 2-4 中的代码还不能编译。让我们试一试：

$ cargo build
 Downloading crates ...
  Downloaded rand_core v0.6.2
  Downloaded getrandom v0.2.2
  Downloaded rand_chacha v0.3.0
  Downloaded ppv-lite86 v0.2.10
  Downloaded libc v0.2.86
   Compiling libc v0.2.86
   Compiling getrandom v0.2.2
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.10
   Compiling rand_core v0.6.2
   Compiling rand_chacha v0.3.0
   Compiling rand v0.8.5
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
error[E0308]: mismatched types
  --> src/main.rs:22:21
   |
22 |     match guess.cmp(&secret_number) {
   |                 --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
   |                 |
   |                 arguments to this method are incorrect
   |
   = note: expected reference `&String`
              found reference `&{integer}`
note: method defined here
  --> /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/core/src/cmp.rs:839:8

For more information about this error, try `rustc --explain E0308`.
error: could not compile `guessing_game` (bin "guessing_game") due to 1 previous error

错误的核心是存在不匹配的类型。Rust 有一个 坚固的静态型系统。但是，它也具有类型推断功能。当我们编写 时，Rust 能够推断出应该是 a 的 intent 示例，并且没有让我们编写类型。另一个 ， hand，是一个数字类型。一些 Rust 的数字类型的值可以介于 1 之间 和 100： ，一个 32 位数字;、无符号的 32 位数字;一个 64 位数字;以及其他一些。除非另有说明，否则 Rust 默认为 an ，除非添加 type information 否则会导致 Rust 推断出不同的数值类型。原因 因为错误是 Rust 无法比较字符串和数字类型。let mut guess = String::new()guessStringsecret_numberi32u32i64i32secret_number

最终，我们希望将作为输入的程序读取转换为 number 类型，以便我们可以将其与秘密数字进行数值比较。我们通过以下方式实现 将此行添加到函数体中：Stringmain

文件名： src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    println!("Please input your guess.");

    // --snip--

    let mut guess = String::new();

    io::stdin()
        .read_line(&mut guess)
        .expect("Failed to read line");

    let guess: u32 = guess.trim().parse().expect("Please type a number!");

    println!("You guessed: {guess}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

该行为：

let guess: u32 = guess.trim().parse().expect("Please type a number!");

我们创建一个名为 .但是等等，程序不是已经有了吗 名为 ？确实如此，但有用的是 Rust 允许我们隐藏 previous 值替换为 new 值。隐藏允许我们重用变量名称，而不是强制我们创建两个唯一的变量，例如 和 。我们将在第 3 章中更详细地介绍这一点，但现在，要知道这个功能是 当您想要将值从一种类型转换为另一种类型时，通常会使用。guessguessguessguessguess_strguess

我们将这个新变量绑定到表达式 .表达式中的 The 引用包含 input 作为字符串。实例上的方法将消除任何 whitespace 的开头和结尾，我们必须这样做才能比较 string 设置为 ，它只能包含数值数据。用户必须按下 satisfy 并输入他们的猜测，这会添加一个 换行符添加到字符串中。例如，如果用户键入 按 ，如下所示： 。表示 “换行符。”（在 Windows 上，按 会导致回车 和换行符 .）该方法消除 或 ，结果 在 Just .guess.trim().parse()guessguesstrimStringu32enterread_line5enterguess5\n\nenter\r\ntrim\n\r\n5

字符串的 parse 方法将字符串转换为 另一种类型。在这里，我们使用它从字符串转换为数字。我们需要 使用 告诉 Rust 我们想要的确切数字类型。冒号 （） 后告诉 Rust 我们将注释变量的类型。Rust 有一个 很少有内置数字类型;这里看到的是一个无符号的 32 位整数。 对于较小的正数，这是一个不错的默认选择。您将了解 第 3 章中的其他数字类型。let guess: u32:guessu32

此外，此示例程序中的注释和比较 with 意味着 Rust 也会推断那也应该是 a。所以现在比较将是两个相同的值 类型！u32secret_numbersecret_numberu32

该方法仅适用于逻辑上可以转换的字符 转换为数字，因此很容易导致错误。例如，如果字符串 包含 ，则无法将其转换为数字。因为它 可能会失败，则该方法将返回一个类型，这与该方法非常相似（在前面的“使用 Result 处理潜在故障”中讨论过）。我们将处理 通过再次使用 method 以相同的方式执行此作。If 返回一个变体，因为它无法从 string，则调用将使游戏崩溃并打印我们给它的消息。 如果可以成功地将字符串转换为数字，它将返回 的变体 ，并将返回我们想要的数字 值。parseA👍%parseResultread_lineResultexpectparseErrResultexpectparseOkResultexpectOk

现在让我们运行该程序：

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 0.43s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 58
Please input your guess.
  76
You guessed: 76
Too big!

好！尽管在猜测之前添加了空格，但该程序仍然会 用户猜出了 76。运行程序几次以验证 不同类型输入的不同行为：猜对数字， 猜一个太高的数字，猜一个太低的数字。

我们现在大部分游戏都已正常运行，但用户只能进行一次猜测。 让我们通过添加一个循环来改变它！

允许循环进行多次猜测

关键字将创建一个无限循环。我们将添加一个循环，为用户提供 更多猜数字的机会：loop

文件名： src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    // --snip--

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        // --snip--


        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("Please type a number!");

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => println!("You win!"),
        }
    }
}

如您所见，我们已将 guess input 提示符中的所有内容移至 一个循环。确保循环内的行再缩进四个空格 并再次运行该程序。程序现在将永远要求再次猜测， 这实际上引入了一个新问题。用户似乎无法退出！

用户始终可以使用键盘快捷键 - 中断程序。但还有另一种方法可以摆脱这种贪得无厌 monster，如“将 Guess 与 Secret Number“：如果 用户输入非数字答案，程序将崩溃。我们可以采取 允许用户退出，如下所示：ctrlcparse

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 1.50s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 59
Please input your guess.
45
You guessed: 45
Too small!
Please input your guess.
60
You guessed: 60
Too big!
Please input your guess.
59
You guessed: 59
You win!
Please input your guess.
quit
thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/main.rs:28:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

键入将退出游戏，但正如您会注意到的，输入任何 其他非数字输入。至少可以说，这是次优的;我们想要这场比赛 在猜出正确的数字时也停止。quit

猜对后退出

让我们通过添加一条语句来编程游戏，使其在用户获胜时退出：break

文件名： src/main.rs

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("Please type a number!");

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

在 After 后添加行会使程序退出循环 用户猜对了密钥号码。退出循环也意味着 退出程序，因为循环是 的最后一部分。breakYou win!main

处理无效输入

为了进一步优化游戏的行为，而不是在 用户输入一个非数字，让我们让游戏忽略一个非数字，这样 用户可以继续猜测。我们可以通过将 where 从 a 转换为 a 的行更改为 a 来做到这一点，如示例 2-5 所示。guessStringu32

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    println!("The secret number is: {secret_number}");

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        // --snip--

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        // --snip--

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

我们从调用切换到表达式，以从崩溃 on an error 处理错误。请记住，返回一个类型 and 是一个具有变体 和 的枚举。我们正在使用 一个表达式，就像我们对 method 的 result 所做的那样。expectmatchparseResultResultOkErrmatchOrderingcmp

如果能够成功地将字符串转换为数字，它将 返回包含结果数字的值。该值将 match the first arm's pattern，表达式将只返回 produce 并放入 value 中的 value。那个数字 将出现在我们正在创建的新变量中我们想要的位置。parseOkOkmatchnumparseOkguess

如果 无法将字符串转换为数字，它将返回一个值，其中包含有关错误的更多信息。价值 与第一个臂中的模式不匹配，但它确实 匹配第二个臂中的模式。下划线 ， 是一个 catchall 值;在此示例中，我们表示要匹配所有值，无论它们内部包含什么信息。所以程序将 执行第二个 ARM 的代码 ，该代码告诉程序转到 的 next iteration 并要求再次猜测。因此，实际上， 程序会忽略可能遇到的所有错误！parseErrErrOk(num)matchErr(_)_Errcontinueloopparse

现在，程序中的所有内容都应该按预期工作。让我们试一试：

$ cargo run
   Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    Finished dev [unoptimized + debuginfo] target(s) in 4.45s
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 61
Please input your guess.
10
You guessed: 10
Too small!
Please input your guess.
99
You guessed: 99
Too big!
Please input your guess.
foo
Please input your guess.
61
You guessed: 61
You win!

棒！通过最后的一个小调整，我们将完成猜谜游戏。召回 程序仍在打印密钥号码。这很有效 测试，但它会毁掉游戏。让我们删除输出 秘密号码。示例 2-6 显示了最终的代码。println!

use rand::Rng;
use std::cmp::Ordering;
use std::io;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

        io::stdin()
            .read_line(&mut guess)
            .expect("Failed to read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {guess}");

        match guess.cmp(&secret_number) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            }
        }
    }
}

此时，您已经成功构建了猜谜游戏。祝贺！

总结

这个项目是向你介绍许多新 Rust 概念的实践方式：、、函数、外部 crate 的使用等等。在下一个 在几章中，您将更详细地了解这些概念。第 3 章 涵盖大多数编程语言具有的概念，例如变量、数据 类型和函数，并演示如何在 Rust 中使用它们。第 4 章探讨 所有权，这是 Rust 不同于其他语言的一个特性。第 5 章 讨论结构和方法语法，第 6 章解释了枚举的工作原理。letmatch