猜谜游戏大全有答案搞笑 猜谜游戏

猜谜游戏

我们的第一个项目，将实现一个典型的初学者编程的问题：猜谜游戏。下面介绍下它是如何工作的：我们的程序将生成一个从一到一百的随机整数。然后它会提示我们输入一个猜测值。依据我们的输入的猜测值，它会告诉我们猜测值是否过低或者过高。一旦我们猜正确，它将祝贺我们。听起来不错吧？

设置

进入你的项目目录，让我们建立一个新项目。还记得我们必须为 hello_world 创建目录结构和 Cargo.toml 吗？Cargo 有一个命令能为我们做这些事。让我们来试一试：

    $ cd ~/projects
    $ cargo new guessing_game --bin
    $ cd guessing_game

我们向命令 cargo new 传递了我们项目的名称，然后添加了标记 --bin ，这是因为我们正在创建一个二进制文件，而不是一个库文件。

查看生成的 Cargo.toml：

    [package]

    name = "guessing_game"
    version = "0.1.0"
    authors = ["Your Name <you@example.com>"]

Cargo 从你的环境中得到这些信息。如果它是不正确的，进入文件并且改正过来。

最后，Cargo 为我们生成一个“Hello，world!”。查看下 src/main.rs：

    fn main() {
        println！("Hello， world！")
    }

让我们尝试编译下 Cargo 给我们的东西：

    $ cargo build
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)

太好了！再次打开你的 src/main.rs。我们将在这个文件中编写所有的代码。

在我们继续之前，让我教你一个 Cargo 的命令： run.cargo run 是有点像 cargo build 的命令，但是它可以在生成的可执行文件后运行此文件。试一试：

    $ cargo run
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
         Running `target/debug/guessing_game`
    Hello, world!

太棒了！当你需要在一个项目中快速迭代时，这个 run 命令可以派上用场。我们游戏就是这样的一个项目，在下一次迭代之前，我们需要快速测试每个迭代。

处理一个猜测值

我们开始做吧！对于我们的猜谜游戏，我们需要做的第一件事就是允许玩家输入一个猜测值。将下面的内容输入到你的 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)
            .ok()
            .expect("Failed to read line");

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

这里面有很多代码啊！让我们一点一点地输入它。

    use std::io;

我们需要获取用户的输入，然后将打印结果作为输出。因此，我们需要标准库中的 io 库。Rust 利用“序部”只要引入少量的东西到每一个项目，。如果在序部中没有的话，那么你必须直接 use 它。

    fn main() {

正如之前你所见过的， main() 函数是程序的入口点。这个 fn 语法声明了一个新函数， ()表明没有参数， {表示函数的主体开始。因为我们不包含一个返回类型，它假定是 ()，一个空元组。

       println!("Guess the number!");

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

我们之前学习到的 println！() 是一个打印字符串到屏幕上的宏。

    let mut guess = String::new();

现在越来越有趣了！有很多东西在这个小行上。首先要注意的是，这是一个let 语句，是用来创建变量绑定的。他们以这种形式存在：

    let foo = bar;

这将创建一个名为 foo 的新绑定，并将其绑定到值 bar 上。在许多语言中，这被称为一个“变量”，但是 Rust 的变量绑定有其成熟的方法。

例如，他们在默认情况下是不可变的。这就是我们的例子中使用 mut 的原因：它使一个绑定是可变，而不是不可改变的。 let 的左边不能添加名称，实际上，它可接受一个“模式”。之后，我们将更多的使用模式。现在它很容易使用：

    let foo = 5; // 不可变的.
    let mut bar = 5; // 可变的

哦， // 之后将开始一个注释，直到行的结束。Rust 编译时，将会忽略所有的注释。

所以现在我们知道了 let mut guess 将引入一个名为 gusss 可变的绑定，但我们必须看 = 另一边的绑定： String::new()。

String 是一个字符串类型，由标准库提供的。 String 是一个可增长，utf-8 编码的文本。

::new() 语法使用 ::因为这是一个特定类型的关联函数。也就是说，它与 String 本身相关，而不是一个特定的实例化的 String。一些语言称之为“静态方法”。

这个函数命名为 new()，因为它创建了一个新的，空的 String。你会在许多类型上发现 new()函数，因为它是创建某类型新值的一个普通的名称。

让我们继续往下看：

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

这又有很多代码！让我们一点一点的看。第一行包含两部分。这是第一部分：

    io::stdin()

还记得我们如何在程序的第一行使用 use std::io 吗?我们现在调用一个与之相关的函数。如果我们不用 use std::io，我们可以这样写这一行 std::io::stdin()。

这个特别的函数返回一个句柄到终端的标准输入。更具体地说，返回一个 std::io::Stdin。

下一部分将使用这个句柄获取来自用户的输入：

    .read_line(&mut guess)

在这里，我们在句柄上调用 read_line() 方法。方法就像联合的方法，但其只能在一个特定的实例类型中使用，而不是在类型本身。我们还传递了一个参数到 read_line()： &mut guess。

还记得我们上面是怎么绑定 guess 的吗?我们认为它是可变的。然而， read_line 不是将一个 String 作为一个参数：它用 &mut String 做参数。Rust 有一个称为“引用”的特性，对一个数据你可以有多个引用，这样可以减少复制。引用是一个复杂的特性。如何安全和容易的使用引用是 Rust 的一个主要卖点。现在我们不需要知道很多这些细节来完成我们的项目。现在我们所需要知道的是像 let 绑定，引用是默认是不可变的之类的事情。因此，我们需要写代码 &mut guess，而不是 &guess。

为什么 read_line() 采用一个可变的字符串引用做参数? 它的工作就是获取用户键入到标准输入的内容，并将转换成一个字符串。因此，以该字符串作为参数，因为要添加输入，所以它需要是可变的。

但是我们不确定这一行代码会执行正确。虽然它仅是一行文本，但是它是第一部分的单一逻辑行代码：

        .ok()
        .expect("Failed to read line");

当你用类似 .foo() 的语法调用一个方法时，你可以用换行和空格来写开启新的一行代码。这能帮助你分开很长的代码行。我们之前的代码是这样写的：

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

但是这样的代码阅读性不好，所以我们将其分隔开。三个方法调用分成三行来写。我们已经讲过 read_line() 了，那么 ok() 和 expect() 是什么呢?嗯，我们之前已经提到了， read_line() 读取了用户输入到 &mut String 中的内容。而且它也返回了一个值：在上面的例子中，返回值是 io::Result。Rust 在其标准库中有很多类型命名为 Result：一个通用的 Result，然后用子库指定具体的版本，比如 io::Result。

使用这些 Result 类型的目的是编码错误处理信息。Result 类型的值，类似于任何类型，其有定义的方法。在上面的例子中，io::Result 就有一个 ok() 方法。这个方法表明，“我们想假定这个值是一个正确值。如果不是，那么就抛出错误的信息。”那么为什么要抛出它？对于一个基本的程序，我们只是想打印出一个通用的错误信息。任何这样的基本问题的发生意味着程序不能继续运行了。ok() 方法返回了一个值，在这个值上定义了另外一个方法： expect()。 expect() 方法调用时，会获取一个值，如果这个值不是正确的值，那么会导致一个应急（panic！）的发生，你要传递一个信息给这个应急。这样的一个应急(panic！)会导致我们的程序崩溃，并且会显示你传递的信息。

如果我们不调用这两个方法，程序能编译成功，但我们会得到一个警告信息：

    $ cargo build
       Compiling guessing_game v0.1.0 (file:///home/you/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);

Rust 警告我们，我们没有使用 Result 值。这个警告来自 io::Result 所有的一个特殊的注释。Rust 试图告诉你，你没有处理一个有可能的错误。避免这个错误的正确方法是写好错误的处理部分的代码。幸运的是，如果程序有问题，而我们只是让程序自己崩溃就好，那么我们可以用这两个方法。但是如果我们想让程序能从错误中恢复，那么我们就要做点其他的事情了。这部分内容我们保留到未来的一个项目里再讲。

第一个例子就剩下这一行代码了：

    println！("You guessed： {}"， guess);
    }

这行代码打印出我们输入的字符串。{} 是一个占位符，所以我们把 guess 作为参数传递给它。如果我们有多个 {} ，那么我们将传递多个参数：

    let x = 5;
    let y = 10;

    println!("x and y: {} and {}", x, y);

容易吧。

不管怎样，这就是我们的学习过程啦。我们可以用我们所拥有的 cargo run 来运行代码了：

    $ cargo run
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
         Running `target/debug/guessing_game`
    Guess the number!
    Please input your guess.
    6
    You guessed: 6

好吧！我们的第一部分已经完成了：我们可以从键盘输入，然后将它打印出来。

生成一个秘密数字

接下来，我们需要生成一个秘密数字。Rust 还未引入有随机数方法的标准库。然而，Rust 的团队提供了一个随机箱 rand crate。一个“箱”是一个 Rust 的代码包。我们已经构建了一个可执行的“二进制箱”。 rand 是一个“箱库”，其中包含的代码可以在其他程序中使用。

使用外部箱是 Cargo 的一个闪光点。在我们使用 rand 写代码之前，我们需要修改 Cargo.toml。打开它，并在文件底部添加这几行：

    [dependencies]

    rand="0.3.0"

Cargo.toml 的 [dependencies] 的部分就像 [package] 部分一样：直到下一个部分开始之前，它下面的内容都是它所包含的。Cargo 通过使用依赖关系部分来知道你所拥有的依赖外部箱，以及你需要的版本。在本例中，我们使用的版本是 0.3.0。Cargo 能理解语义版本(Semantic Versioning)，这是一个编写版本号的标准。如果我们想使用最新的版本，我们可以使用 * ，或者我们也可以使用一个范围的版本。Cargo 的文档包含更多的细节内容。

现在，在不改变我们的任何代码，让我们重新构建我们的项目：

    $ cargo build
        Updating registry `https://github.com/rust-lang/crates.io-index`
     Downloading rand v0.3.8
     Downloading libc v0.1.6
       Compiling libc v0.1.6
       Compiling rand v0.3.8
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)

(你可以看到不同版本)。

有大量的新的内容出现了！现在我们有一个外部依赖，Cargo 从注册表获取所有依赖的最新版本，我们这里的注册表是一个来自 Crates.io 的数据副本。这里的 Crates.io 是 Rust 生态系统中人们发布给他人使用的开源 Rust 项目的地方。

更新注册表，Cargo 会检查我们的 [dependencies] 并下载我们没有的一些依赖。在本例中，尽管我们说我们只想依赖 rand，但是我们也获取了一份 libc 的拷贝。这是因为 rand 是基于 libc 工作的。下载完成后，Cargo 会先编译这些依赖项，然后再编译我们的项目。

如果我们再次运行 cargo build，我们将会得到不同的输出：

    $ cargo build

没有错，这里是没有输出的！Cargo 知道我们的项目已经构建完成，并且项目所有的依赖项也构建完成，因此没有理由将所有这些事情再做一遍。既然无事可做，它就退出了。如果我们再次打开 src/main.rs，做一个微不足道的改变，然后再保存它，再次运行，我们就会看到一行：

    $ cargo build
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)

所以，我们告诉 Cargo 我们想要任何 0.3.x 版本的 rand，因此它会获取当时的最新版本，v0.3.8。但是当下周有重要错误修正的版本 v0.3.9 出现时会发生什么？虽然错误修正是很重要的，但是如果 0.3.9 版本包含会破坏我们代码的一个回归呢？

这个问题的答案是锁文件 Cargo.lock，现在你可以在你的项目目录中找到它。当你第一次构建你的项目时，Cargo 会找出所有的符合你的要求的版本，然后将他们写到 Cargo.lock 文件中。当未来你构建项目时，Cargo将会发现 Cargo.lock 文件的存在，然后使用文件指定的版本，而不是再次做找出版本的工作。这可以让你有一个可重复的自动构建。换句话说，直到我们明确升级之前，我们将待在 0.3.8 版本。所以那些分享我们的代码人，也会感谢锁文件的存在。

那么当我们真的想使用 v0.3.9 版本时，怎么办？Cargo 还有另外一个命令， update，它的意思是“忽略锁文件，找出适合我们指定要求的所有最新版本。如果可行，那么将那些版本信息写到锁文件中。”但是，默认情况下，Cargo 只会比寻找大于 0.3.0 并且小于 0.4.0 的版本。如果我们想升级到 0.4.x 版本，那我们必须直接更新 Cargo.toml 文件。如果我们这么做了，我们下次运行 cargo build 时，Cargo 将更新索引并重新评估我们对 rand 的需求。

这里提到了很多关于 Cargo 和它的生态系统的内容，对现在来说，这就是我们所需要知道关于他们的全部信息。Cargo 使 Rust 很容易重复使用库，所以 Rustaceans 倾向于编写当做子包组装的小项目。

让我们实际使用一下 rand。下面是我们要进行的下一个步骤：

    extern crate rand;

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

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

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

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

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

        let mut guess = String::new();

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

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

我们所做的第一件事就是改变了第一行代码。现在第一行是，extern crate rand。因为我们在我们的 [dependencies] 中声明了 rand，所以我们可以使用 extern crate 让 Rust 知道我们会使用它。这也相当于一个 use rand;，所以我们可以通过加前缀 rand::来利用 rand 箱中的所有东西。

接下来，我们添加了另一个 use 行： use rand::Rng。一会儿我们要用一种方法，它需要 Rng 在作用域内才运行。基本的思路是这样的：方法是定义在一些所谓的“特征”上的，它需要特征在域内，才能使方法工作。更多的细节内容，请阅读特征章节。

在中间，有我们添加的另外两行：

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

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

我们使用 rand::thread_rng() 函数获取随机数产生器的一个副本，这是我们在执行的一个本地线程。我们上面使用 use rand::Rng，它有一个可用的 gen_range() 方法。这个方法有两个参数，生成一个在两个参数范围内的数字。它包括下界值，但不包括上界值，所以我们需要 1 和 101 两个参数，从而来获取一个一到一百之间的数字。

第二行打印出了这个生成的秘密数字。这是在我们开发项目时是非常有用的，我们可以很容易地对其进行测试。但是在最终版本里我们会删除它。如果一开始的时候就打印出来你要猜的数字，显然这不是一个游戏！

尝试运行几次我们的程序：

    $ cargo run
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
         Running `target/debug/guessing_game`
    Guess the number!
    The secret number is: 7
    Please input your guess.
    4
    You guessed: 4
    $ cargo run
         Running `target/debug/guessing_game`
    Guess the number!
    The secret number is: 83
    Please input your guess.
    5
    You guessed: 5

太棒了！下一篇：让我们用我们的猜测值和秘密数字比较一下。

比较猜测值

现在，我们已经得到了用户的输入，让我们将我们猜测值与随机值比较下。下面是我们要进行的下一步，它现在还不能运行：

    extern crate rand;

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

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

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

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

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

        let mut guess = String::new();

        io::stdin().read_line(&mut guess)
            .ok()
            .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!"),
        }
    }

这里的有几个新部分。第一个是另外的一个 use。我们将叫做 std::cmp::Ordering 的类型放到了作用域内。然后是底部新的五行代码：

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

cmp() 方法可以在任何可比较的地方被调用，但是它需要你想要比较东西的一个引用。它将返回我们之前 use 的 Ordering 类型。我们使用一个 match 语句来确定它到底是一个什么样的 Ordering。 Ordering 是一个“枚举”（enum，enumeration 的简称）。枚举看起来像这个样子的：

    enum Foo {
        Bar，
        Baz，
    }

利用这个定义，任何类型是 Foo 的类型，可以是一个 Foo::Bar 或者是一个 Foo::Baz。我们使用 :: 表明一个特定 enum 变量的命名空间。

Ordering 枚举有三个可能的变量： Less， Equal 和 Greater。 match 语句需要有一个类型的值输入，并允许你为每一可能的值创建一个“手臂”。因为我们有三种类型的 Ordering，因此我们要三个：

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

如果它是 Less，我们打印 Too small！，如果是 Greater，打印 Too big！，如果 Equal，打印 You win！。 match 是非常有用的，在 Rust 中经常会使用它。

我之前提到了，项目现在还不能运行。让我们来试一试：

    $ cargo build
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
    src/main.rs:28:21: 28:35 error: mismatched types:
     expected `&collections::string::String`,
        found `&_`
    (expected struct `collections::string::String`,
        found integral variable) [E0308]
    src/main.rs:28     match guess.cmp(&secret_number) {

    error: aborting due to previous error
    Could not compile `guessing_game`.

这是一个很严重的错误。它核心的意思是，我们有不匹配的类型。Rust 有一个强壮的、静态的类型系统。然而，它也有类型推导过程。当我们写了 let guess = String::new()，Rust 能够推断出 guess 应该是一个 String，所以它不用让我们写出 guess 的类型。然而值从 1 到 100 的 secret_number 的类型就有很多了：i32，32 位的数字，u32，32 位无符号数字，或者 i64，一个 64 位的数字，或其的一些类型。Rust 的默认类型是 i32。到目前为止，还没有什么关系。然而在比较代码中，Rust 不知道如何比较 guess 和 secret_number。他们需要是相同的类型。最终，我们把读入的 String 转换成一个数字类型，来进行比较。我们用额外的三行来做这件事情。下面是我们的新程序：

    extern crate rand;

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

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

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

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

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

        let mut guess = String::new();

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

        let guess: u32 = guess.trim().parse()
            .ok()
            .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()
        .ok()
        .expect("Please type a number!");

等一下，我想我们已经有了一个 guess 了吧?对，我们确实有一个，但是 Rust 允许我们用一个新的 guess 来“遮住”前面的那一个。在具体情况中这经常使用。 guess 开始时是一个 String，但我们想把它转换成一个 u32。遮蔽功能能让我们重复使用 guess 这个名字，而不是迫使我们使用两个唯一的名字如 guess_str ，guess，或者其他之类的。

类似于我们之前写的代码那样，我们将 guess 绑定到一个表达式：

    guess.trim().parse()

紧随其后的是一个 ok().expect() 的调用。这里的 guess 指的是旧的那个 guess，也就是我们输入 String 到其中那一个。String 的 trim() 方法是消除 String 前端和后端所有空白字符串的方法。这是很重要的，因为我们必须按“回车”键来结束 read_line() 方法的输入。这意味着，如果我们键入 5 并且敲击回车键，guess 看起来是这样的：5n。n 表示“换行符”，回车键。trim() 方法就是用来去除类似这样的东西的，让我们的字符串只有 5。 字符串的 parse() 方法将字符串解析成某类数字。因为它可以解析各种数据，所以我们需要给 Rust 提示我们想要转化的确切数字类型。因此这样写，let guess： u32。guess 后面的冒号(：) 告诉 Rust 我们要转化的类型。 u32 是一个无符号 32 位整数。Rust 有许多内置数字类型，这里我们选择了 u32。对于一个小的正整数，这是一个很好的默认选择。

就像 read_line()，我们的 parse() 调用可能会导致一个错误。如果我们的字符串包含了 A% 呢？这就没有办法转换成一个数字了。因此，我们会像 read_line() 做的那样：用 ok() 和 expect() 方法去处理崩溃，如果有一个错误发生了的话。

让我们来试试我们的新程序！

    $ cargo run
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
         Running `target/guessing_game`
    Guess the number!
    The secret number is: 58
    Please input your guess.
      76
    You guessed: 76
    Too big!

好了！你可以看到我甚至在猜的数字之前添加了空格，程序仍然发现我猜的数是 76。运行几次程序，再猜一个比较小的数字，验证猜测程序能正常运行。

现在我们已经做了游戏的大部分工作，但我们只能做一个猜测。让我们通过添加循环来改变这一情况！

循环

loop 关键字为我们提供了一个无限循环。让我们添加如下的代码并尝试一下：

    extern crate rand;

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

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

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

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

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

            let mut guess = String::new();

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

            let guess: u32 = guess.trim().parse()
                .ok()
                .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!"),
            }
        }
    }

先等一下，我们只是添加一个无限循环么？是的，没错。还记得我们关于 parse() 的讲解吗？如果我们给出了一个非数字的回答，它将会 return 并且退出。我们来看：

    $ cargo run
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
         Running `target/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!"

像其他非数字的输入一样，quit 确实是退出了。嗯，至少可以说这是一个次优的解决方案。第一个方案：当你赢得比赛时，程序退出：

    extern crate rand;

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

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

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

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

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

            let mut guess = String::new();

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

            let guess: u32 = guess.trim().parse()
                .ok()
                .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!");
                    break;
                }
            }
        }
    }

通过在打印 You win！的代码后面添加一行 break，当我们赢了的时候就会退出循环。退出循环也意味着退出了程序，因为它是 main() 做的最后一件事。这里我们想做一个额外的调整：当有人输入非数字时，我们并不退出，只是忽略它。我们可以这样做：

    extern crate rand;

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

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

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

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

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

            let mut guess = String::new();

            io::stdin().read_line(&mut guess)
                .ok()
                .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;
                }
            }
        }
    }

这些代码改变了：

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

通过将使用 ok().expect() 换做使用一个 match 语句，这可以教会你是如何从“崩溃错误”转变到“处理错误”的。parse() 返回的 Result 是一个像 Ordering 一样的枚举，但在这里，每个变量都有与之相关的一些数据： Ok 是一个 success， Err 是一个 failure。它们每个又包含更多的信息：成功的解析成整数，一个错误的类型。在这种情况下，我们将匹配 match 在 Ok(num)，这里将 Ok 的内部值的名字设置为 num，然后我们在右侧返回它的值。在 Err 的情况下，我们不关心它是什么样的错误，所以这里我们只用一个下划线 ‘_’，而不是一个名字。这样会忽略掉错误，continue 会继续进行下一个循环(loop)的迭代。

现在，问题应该都解决了！让我们试一试：

    $ cargo run
       Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
         Running `target/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!

太棒了！经过最后一个小小的调整，我们已经完成了猜谜游戏。你能想到什么？没错，我们不想打印出秘密数字。打印这个数字对于测试来说是很棒的一件事，但是当运行时，它会毁掉这个游戏的。下面是我们最终的代码：

    extern crate rand;

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

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

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

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

            let mut guess = String::new();

            io::stdin().read_line(&mut guess)
                .ok()
                .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;
                }
            }
        }
    }

完成了！

此时此刻，你已经成功地构建了猜谜游戏！恭喜你！

这第一个项目向你展示了很多内容： let， match，方法，相关函数，使用外部箱等等。我们的下一个项目将展示更多的内容。