@ -73,10 +73,10 @@
< br > < br >
commit e6d6caab41471f7115a621029bd428a812c5260e< / p >
commit e6d6caab41471f7115a621029bd428a812c5260e< / p >
< / blockquote > < / blockquote >
< p > 让我们通过自己动手的方式一起完成一个项目来快速上手 Rust！ 概念，并通过真实的程序来展示如何运用他们 。你将会学到< code > let< / code > 、< code > match< / code > 、方法、关联函数、使用外部 crate 等更多的知识！接下来的章节会 探索这些概念的细节。在这一章，我们将练习基础。< / p > < p > 让我们亲自动手，快速熟悉 Rust！ 概念，并通过真实的程序来展示如何运用。你将会学到更多诸如 < code > let< / code > 、< code > match< / code > 、方法、关联函数、外部 crate 等知识！后继章节会深入 探索这些概念的细节。在这一章，我们将练习基础。< / p >
< p > 我们会实现一个经典的新手编程问题：猜猜看游戏。它是这么工作的：程序将会随机生成一个 1 到 100 之间的随机整数。接着它会提示玩家输入一个猜测。当输入了一个猜测后，它会提示猜测是太大了还是太小了。如果猜对了，它会打印出祝贺并退出 。< / p > < p > 我们会实现一个经典的新手编程问题：猜猜看游戏。它是这么工作的：程序将会随机生成一个 1 到 100 之间的随机整数。接着它会请玩家猜一个数并输入，然后提示猜测是大了还是小了。如果猜对了，它会在退出前祝贺你 。< / p >
< a class = "header" href = "#准备一个新项目" name = "准备一个新项目" > < h2 > 准备一个新项目< / h2 > < / a > < a class = "header" href = "#准备一个新项目" name = "准备一个新项目" > < h2 > 准备一个新项目< / h2 > < / a >
< p > 要创建一个新项目，进入在 第一章创建的< strong > 项目< / strong > 目录，像这样 使用 Cargo 创建它：< / p > < p > 要创建一个新项目，进入第一章创建的< strong > 项目< / strong > 目录，使用 Cargo 创建它：< / p >
< pre > < code > $ cargo new guessing_game --bin< pre > < code > $ cargo new guessing_game --bin
$ cd guessing_game
$ cd guessing_game
< / code > < / pre > < / code > < / pre >
@ -91,22 +91,22 @@ authors = ["Your Name <you@example.com>"]
[dependencies]
[dependencies]
< / code > < / pre > < / code > < / pre >
< p > 如果 Cargo 从环境中获取的开发者信息不正确，修改这个文件并再次保存。< / p > < p > 如果 Cargo 从环境中获取的开发者信息不正确，修改这个文件并再次保存。< / p >
< p > 正如第一章那样，< code > cargo new< / code > 生成了一个“Hello, world!”程序。查看 < em > src/main.rs< / em > 文件：< / p > < p > 正如第一章那样，< code > cargo new< / code > 生成了一个“Hello, world!”程序。查看 < em > src/main.rs< / em > 文件：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust" > fn main() {< pre > < code class = "language-rust" > fn main() {
println!(" Hello, world!" );
println!(" Hello, world!" );
}
}
< / code > < / pre > < / code > < / pre >
< p > 现在让我们使用< code > cargo run< / code > 在相同的步骤编译并运行这个“Hello, world!”程序 ： < / p > < p > 现在让我们使用 < code > cargo run< / code > ，编译运行一步到位 ： < / p >
< pre > < code class = "language-sh" > $ cargo run< pre > < code class = "language-sh" > $ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Running `target/debug/guessing_game`
Running `target/debug/guessing_game`
Hello, world!
Hello, world!
< / code > < / pre > < / code > < / pre >
< p > < code > run< / code > 命令在需要快速迭代项目时就派上用场了 ，而这个游戏就正 是这么一个项目 ：我们需要在进行 下一步之前快速测试每次迭代 。< / p > < p > < code > run< / code > 命令适合用 在需要快速迭代的 项目，而这个游戏就是：我们需要在下一步迭代 之前快速测试。< / p >
< p > 重新打开 < em > src/main.rs< / em > 文件。我们将会在这个文件编写全部的 代码。< / p > < p > 重新打开 < em > src/main.rs< / em > 文件。我们将会在这个文件中 编写全部代码。< / p >
< a class = "header" href = "#处理一次猜测" name = "处理一次猜测" > < h2 > 处理一次猜测< / h2 > < / a > < a class = "header" href = "#处理一次猜测" name = "处理一次猜测" > < h2 > 处理一次猜测< / h2 > < / a >
< p > 程序的第一部分会请求用户输入，处理输入，并检查输入是否为期望的形式。首先，允许玩家输入一个猜测 。在 < em > src/main.rs< / em > 中输入列表 2-1 中的代码。< / p > < p > 程序的第一部分请求和处理用户输入，并检查输入是否符合预期。首先，需要有一个让玩家输入猜测的地方 。在 < em > src/main.rs< / em > 中输入列表 2-1 中的代码。< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust,ignore" > use std::io;< pre > < code class = "language-rust,ignore" > use std::io;
@ -124,59 +124,59 @@ fn main() {
}
}
< / code > < / pre > < / code > < / pre >
< p > < span class = "caption" > Listing 2-1: Code to get a guess from the user and print it out< / span > < / p > < p > < span class = "caption" > Listing 2-1: Code to get a guess from the user and print it out< / span > < / p >
< p > 这些代码包含很多信息，所以让 我们一点一点地过一遍。为了获取用户输入并接着 打印结果作为输出，我们需要将< code > io< / code > （输入/输出）库引入作用域中 。< code > io< / code > 库来自于标准库（也被称为< code > std< / code > ） ： < / p > < p > 这些代码包含很多信息，我们一点一点地过一遍。为了获取用户输入并打印结果作为输出，我们需要将 < code > io< / code > （输入/输出）库引入当前 作用域。< code > io< / code > 库来自于标准库（也被称为< code > std< / code > ） ： < / p >
< pre > < code class = "language-rust,ignore" > use std::io;< pre > < code class = "language-rust,ignore" > use std::io;
< / code > < / pre > < / code > < / pre >
< p > Rust 默认只在每个程序的 < a href = "https://doc.rust-lang.org/std/prelude/index.html" > < em > prelude< / em > < / a > <!-- ignore --> 中引用很少的一些类型。如果想要使用的类型并不在 prelude 中，你必须使用一个 < code > use< / code > 语句显式的将其引入到 作用域中 。使用 < code > std::io< / code > 库将 提供很多< code > io< / code > 相关的功能，接受用户输入的功能 。< / p > < p > Rust 默认只在每个程序的 < a href = "https://doc.rust-lang.org/std/prelude/index.html" > < em > prelude< / em > < / a > <!-- ignore --> 中引入少量类型。如果需要的类型不在 prelude 中，你必须使用一个 < code > use< / code > 语句显式的将其引入作用域。< code > std::io< / code > 库提供很多 < code > io< / code > 相关的功能，比如 接受用户输入。< / p >
< p > 正如第一章所讲 ， < code > main< / code > 函数是程序的入口点：< / p > < p > 如第一章所提及 ， < code > main< / code > 函数是程序的入口点：< / p >
< pre > < code class = "language-rust,ignore" > fn main() {< pre > < code class = "language-rust,ignore" > fn main() {
< / code > < / pre > < / code > < / pre >
< p > < code > fn< / code > 语法声明了一个新函数，< code > ()< / code > 表明没有参数，< code > {< / code > 作为函数体的开始。< / p > < p > < code > fn< / code > 语法声明了一个新函数，< code > ()< / code > 表明没有参数，< code > {< / code > 作为函数体的开始。< / p >
< p > 第一章也讲到了 ， < code > println!< / code > 是一个在屏幕上打印字符串的宏：< / p > < p > 第一章也提及 ， < code > println!< / code > 是一个在屏幕上打印字符串的宏：< / p >
< pre > < code class = "language-rust,ignore" > println!(" Guess the number!" );< pre > < code class = "language-rust,ignore" > println!(" Guess the number!" );
println!(" Please input your guess." );
println!(" Please input your guess." );
< / code > < / pre > < / code > < / pre >
< p > 这些代码仅仅打印一个提示，说明游戏的内容并请求 用户输入。< / p > < p > 这些代码仅仅打印提示，介绍游戏的内容然后请 用户输入。< / p >
< a class = "header" href = "#用变量储存值" name = "用变量储存值" > < h3 > 用变量储存值< / h3 > < / a > < a class = "header" href = "#用变量储存值" name = "用变量储存值" > < h3 > 用变量储存值< / h3 > < / a >
< p > 接下来，创建一个地方储存用户输入，像这样：< / p > < p > 接下来，创建一个地方储存用户输入，像这样：< / p >
< pre > < code class = "language-rust ,ignore "> let mut guess = String::new();< pre > < code class = "language-rust "> let mut guess = String::new();
< / code > < / pre > < / code > < / pre >
< p > 现在程序开始变得有意思了！这一小行代码发生了很多事。注意这是一个< code > let< / code > 语句，用来创建< strong > 变量< / strong > 。这里是另外一个例子：< / p > < p > 现在程序开始变得有意思了！这一小行代码发生了很多事。注意这是一个 < code > let< / code > 语句，用来创建< strong > 变量< / strong > 。这里是另外一个例子：< / p >
< pre > < code class = "language-rust ,ignore "> let foo = bar;< pre > < code class = "language-rust "> let foo = bar;
< / code > < / pre > < / code > < / pre >
< p > 这行代码会创建一个叫做< code > foo< / code > 的新变量并把它绑定到值< code > bar< / code > 上。在 Rust 中，变量默认是不可变的。下面的例子展示了如何在变量名前使用< code > mut< / code > 来使一个变量可变：< / p > < p > 这行代码会创建一个叫做 < code > foo< / code > 的新变量并把它绑定到值 < code > bar< / code > 上。在 Rust 中，变量默认是不可变的。下面的例子展示了如何在变量名前使用 < code > mut< / code > 来使一个变量可变：< / p >
< pre > < code class = "language-rust" > let foo = 5; // immutable< pre > < code class = "language-rust" > let foo = 5; // immutable
let mut bar = 5; // mutable
let mut bar = 5; // mutable
< / code > < / pre > < / code > < / pre >
< blockquote > < blockquote >
< p > 注意：< code > //< / code > 开始一个注释， < / p > < p > 注意：< code > //< / code > 开始一个注释， < / p >
< / blockquote > < / blockquote >
< p > 现在我们知道了< code > let mut guess< / code > 会引入一个叫做< code > guess< / code > 的可变变量。等号（< code > =< / code > ）的另一边是 < code > guess< / code > 所绑定的值，它是< code > String::new< / code > 的结果，这个函数会返回一个< code > String< / code > 的新实例。< a href = "https://doc.rust-lang.org/std/string/struct.String.html" > < code > String< / code > < / a > <!-- ignore --> 是一个标准库提供的字符串类型，它是可增长的、UTF-8 编码的 文本块。< / p > < p > 现在我们知道了 < code > let mut guess< / code > 会引入一个叫做 < code > guess< / code > 的可变变量。等号（< code > =< / code > ）的右边是 < code > guess< / code > 所绑定的值，它是 < code > String::new< / code > 的结果，这个函数会返回一个 < code > String< / code > 的新实例。< a href = "https://doc.rust-lang.org/std/string/struct.String.html" > < code > String< / code > < / a > <!-- ignore --> 是一个标准库提供的字符串类型，它是 UTF-8 编码的可增长 文本块。< / p >
< p > < code > ::new< / code > 那一行的< code > ::< / code > 语法表明< code > new< / code > 是< code > String< / code > 类型的一个< strong > 关联函数< / strong > （ < em > associated function< / em > ）。关联函数是针对类型实现的，在这个例子中是< code > String< / code > ，而不是< code > String< / code > 的某个特定实例。一些语言中把它称为< strong > 静态方法< / strong > （ < em > static method< / em > ）。< / p > < p > < code > ::new< / code > 那一行的 < code > ::< / code > 语法表明 < code > new< / code > 是 < code > String< / code > 类型的一个 < strong > 关联函数< / strong > （ < em > associated function< / em > ）。关联函数是针对类型实现的，在这个例子中是 < code > String< / code > ，而不是 < code > String< / code > 的某个特定实例。一些语言中把它称为< strong > 静态方法< / strong > （ < em > static method< / em > ）。< / p >
< p > < code > new< / code > 函数创建了一个新的空的 < code > String< / code > ，你会在很多类型上发现< code > new< / code > 函数，因为这是创建某个类型新值的常 用函数名。< / p > < p > < code > new< / code > 函数创建了一个新的空 < code > String< / code > ，你会在很多类型上发现< code > new< / code > 函数，这是创建类型实例的惯 用函数名。< / p >
< p > 总结一下，< code > let mut guess = String::new();< / code > 这一行创建了一个可变变量，目前它 绑定到一个< code > String< / code > 新的、空的实例上。哟！ < / p > < p > 总结一下，< code > let mut guess = String::new();< / code > 这一行创建了一个可变变量，绑定到一个新的 < code > String< / code > 空实例上。 < / p >
< p > 回忆一下我们在程序的第一行使用< code > use std::io;< / code > 从标准库中引用输入/输出功能。现在在< code > io< / code > 上调用一个关联函数， < code > stdin< / code > ： < / p > < p > 回忆一下， < code > use std::io;< / code > 从标准库中引入“输入输出”。现在调用 < code > io< / code > 的关联函数 < code > stdin< / code > ： < / p >
< pre > < code class = "language-rust,ignore" > io::stdin().read_line(& mut guess)< pre > < code class = "language-rust,ignore" > io::stdin().read_line(& mut guess)
.expect(" Failed to read line" );
.expect(" Failed to read line" );
< / code > < / pre > < / code > < / pre >
< p > 如果我们在 程序的开头没有< code > use std::io< / code > 这一行，我们可以把函数调用写成< code > std::io::stdin< / code > 这样 。< code > stdin< / code > 函数返回一个 < a href = "https://doc.rust-lang.org/std/io/struct.Stdin.html" > < code > std::io::Stdin< / code > < / a > <!-- ignore --> 的实例，这是一个 代表终端标准输入句柄的类型。< / p > < p > 如果程序的开头没有 < code > use std::io< / code > 这一行，我们可以把函数调用写成 < code > std::io::stdin< / code > 。< code > stdin< / code > 函数返回一个 < a href = "https://doc.rust-lang.org/std/io/struct.Stdin.html" > < code > std::io::Stdin< / code > < / a > <!-- ignore --> 的实例，这代表终端标准输入句柄的类型。< / p >
< p > 代码的下一部分，< code > .read_line(& mut guess)< / code > ，调用 < a href = "https://doc.rust-lang.org/std/io/struct.Stdin.html#method.read_line" > < code > read_line< / code > < / a > <!-- ignore --> 方法从标准输入句柄获取用户输入。我们还向< code > read_line()< / code > 传递了一个参数：< code > & mut guess< / code > 。< / p > < p > 代码的下一部分，< code > .read_line(& mut guess)< / code > ，调用 < a href = "https://doc.rust-lang.org/std/io/struct.Stdin.html#method.read_line" > < code > read_line< / code > < / a > <!-- ignore --> 方法从标准输入句柄获取用户输入。我们还向 < code > read_line()< / code > 传递了一个参数：< code > & mut guess< / code > 。< / p >
< p > < code > read_line< / code > 的工作是把获取任何用户键入到标准输入的字符并放入一个字符串中，所以它获取字符串作为一个参数。这个字符串需要是可变的，这样这个方法就可以通过增加用户的输入来改变字符串的内容 。< / p > < p > < code > read_line< / code > 的工作是，无论用户在标准输入中键入什么内容，都将其存入一个字符串中，因此它需要字符串作为参数。这个字符串参数< code > read_line< / code > 将用户输入附加上去 。< / p >
< p > < code > & < / code > 表明 这个参数是一个< strong > 引用< / strong > （ < em > reference< / em > ），它提供了一个允许多个不同部分的代码访问同一份数据而不需要在内存中多次拷贝的方法。引用是一个复杂的功能，而 Rust 的一大优势就是它是如何安全而优雅操纵引用的。完成这个程序并不需要知道这么 多细节：第四章会更全面的解释引用。现在，我们只需知道它像变量一样，默认是不可变的。因此 ，需要写成< code > & mut guess< / code > 而不是< code > & guess< / code > 来使其可变。< / p > < p > < code > & < / code > 表示 这个参数是一个< strong > 引用< / strong > （ < em > reference< / em > ），它允许多处代码访问同一处数据， ， 多细节：第四章会更全面的解释引用。现在，我们只需知道它像变量一样，默认是不可变的，需要写成 < code > & mut guess< / code > 而不是 < code > & guess< / code > 来使其可变。< / p >
< p > 我们还没有分析完这行代码。虽然这是单独一行代码，但它只 是一个逻辑上代码 行（虽然换行了但仍是一个语句）的第一部分。第二部分是这个方法：< / p > < p > 我们还没有分析完这行代码。虽然这是单独一行代码，但它是一个逻辑行（虽然换行了但仍是一个语句）的第一部分。第二部分是这个方法：< / p >
< pre > < code class = "language-rust ,ignore "> .expect(" Failed to read line" );< pre > < code class = "language-rust "> .expect(" Failed to read line" );
< / code > < / pre > < / code > < / pre >
< p > 当使用< code > .expect()< / code > 语法调用方法时，明智的选择是换行并留出空白（缩进）来把长的代码行拆开。我们可以把代码写成这样 ： < / p > < p > 当使用 < code > .expect()< / code > 语法调用方法时，通过‘换行并缩进’来把长行拆开，是明智的。我们完全可以这样写 ： < / p >
< pre > < code class = "language-rust ,ignore "> io::stdin().read_line(& mut guess).expect(" Failed to read line" );< pre > < code class = "language-rust "> io::stdin().read_line(& mut guess).expect(" Failed to read line" );
< / code > < / pre > < / code > < / pre >
< p > 不过，过长的代码 行难以阅读，所以最好拆开来写，两行代码两个方法调用。现在来看看这行代码干了什么。< / p > < p > 不过，过长的行难以阅读，所以最好拆开来写，两行代码两个方法调用。现在来看看这行代码干了什么。< / p >
< a class = "header" href = "#使用 result类型来处理潜在的错误" name = "使用 result类型来处理潜在的错误"> < h3 > 使用< code > Result< / code > 类型来处理潜在的错误< / h3 > < / a > < a class = "header" href = "#使用 - result- 类型来处理潜在的错误" name = "使用 - result- 类型来处理潜在的错误"> < h3 > 使用 < code > Result< / code > 类型来处理潜在的错误< / h3 > < / a >
< p > 之前提到过 ， < code > read_line< / code > 将用户输入放入到传递给它字符串中，不过它也返回一个值——在这个例子中，一个 < a href = "https://doc.rust-lang.org/std/io/type.Result.html" > < code > io::Result< / code > < / a > <!-- ignore --> 。Rust 标准库中有很多叫做< code > Result< / code > 的类型。一个< a href = "https://doc.rust-lang.org/std/result/enum.Result.html" > < code > Result< / code > < / a > <!-- ignore --> 泛型以及对应子模块的特定版本，比如< code > io::Result< / code > 。< / p > < p > 之前提到，< code > read_line< / code > 将用户输入附加到传递给它字符串中，不过它也返回一个值——在这个例子中是 < a href = "https://doc.rust-lang.org/std/io/type.Result.html" > < code > io::Result< / code > < / a > <!-- ignore --> 。Rust 标准库中有很多叫做 < code > Result< / code > 的类型。一个 < a href = "https://doc.rust-lang.org/std/result/enum.Result.html" > < code > Result< / code > < / a > <!-- ignore --> 泛型以及对应子模块的特定版本，比如 < code > io::Result< / code > 。< / p >
< p > < code > Result< / code > 类型是 < a href = "ch06-00-enums.html" > < em > 枚举< / em > （ < em > enumerations< / em > ） < / a > <!-- ignore --> ，通常也写作 < em > enums< / em > 。枚举拥有固定值集合的类型，而 这些值被称为枚举的< strong > 成员< / strong > （ < em > variants< / em > ）。第六章会更详细的介绍枚举 。< / p > < p > < code > Result< / code > 类型是 < a href = "ch06-00-enums.html" > < em > 枚举< / em > （ < em > enumerations< / em > ） < / a > <!-- ignore --> ，通常也写作 < em > enums< / em > 。枚举类型持有固定集合的值， 这些值被称为枚举的< strong > 成员< / strong > （ < em > variants< / em > ）。第六章将介绍枚举的更多细节 。< / p >
< p > 对于< code > Result< / code > ，它的成员是< code > Ok< / code > 或< code > Err< / code > ， < code > Ok< / code > 表明操作成功了，同时< code > Ok< / code > 成员之中包含成功生成 的值。< code > Err< / code > 意味着操作失败，< code > Err< / code > 之中包含操作是为什么或如何失败的信息 。< / p > < p > 对于 < code > Result< / code > ，它的成员是 < code > Ok< / code > 或 < code > Err< / code > ， < code > Ok< / code > 表示操作成功，内部包含产生 的值。< code > Err< / code > 意味着操作失败，包含失败的前因后果 。< / p >
< p > < code > Result< / code > 类型的作用是编码错误处理信息。< code > Result< / code > 类型的值，正如其他任何类型 ，拥有定义于其上的方法。< code > io::Result< / code > 的实例拥有< a href = "https://doc.rust-lang.org/std/result/enum.Result.html#method.expect" > < code > expect< / code > 方法< / a > <!-- ignore --> 可供调用。如果< code > io::Result< / code > 实例的值是 < code > Err< / code > ， < code > expect< / code > 会导致程序崩溃并显示显示你作为参数传递给< code > expect< / code > 的信息。如果< code > io::Result< / code > 实例的值是 < code > Ok< / code > ， < code > expect< / code > 会获取< code > Ok< / code > 中的值并原原本本的返回给你 。在本例中，这个值是用户输入到标准输入中的字节的数量。< / p > < p > < code > Result< / code > 类型的作用是编码错误处理信息。< code > Result< / code > 类型的值，像其他类型一样 ，拥有定义于其上的方法。< code > io::Result< / code > 的实例拥有< a href = "https://doc.rust-lang.org/std/result/enum.Result.html#method.expect" > < code > expect< / code > 方法< / a > <!-- ignore --> ，如果实例的值是 < code > Err< / code > ， < code > expect< / code > 会导致程序崩溃，并显示当做参数传递给 < code > expect< / code > 的信息;如果实例的值是 < code > Ok< / code > ， < code > expect< / code > 会获取 < code > Ok< / code > 中的值并原样返回 。在本例中，这个值是用户输入到标准输入中的字节的数量。< / p >
< p > 如果不使用< code > expect< / code > ，程序也能编译，不过会出现一个警告：< / p > < p > 如果不使用 < code > expect< / code > ，程序也能编译，不过会出现一个警告：< / p >
< pre > < code > $ cargo build< pre > < code > $ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
src/main.rs:10:5: 10:39 warning: unused result which must be used,
src/main.rs:10:5: 10:39 warning: unused result which must be used,
@ -184,18 +184,18 @@ src/main.rs:10:5: 10:39 warning: unused result which must be used,
src/main.rs:10 io::stdin().read_line(& mut guess);
src/main.rs:10 io::stdin().read_line(& mut guess);
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
< / code > < / pre > < / code > < / pre >
< p > Rust 警告我们没有使用< code > read_line< / code > 返回的 值< code > Result< / code > ， 表明程序没有处理一个可能的错误。消除警告的正确方式是老实编写错误处理，不过因为我们仅仅希望程序出现问题就崩溃，可以直接使用 < code > expect< / code > 。第九章会学习从错误中恢复的内容 。< / p > < p > Rust 警告我们没有使用 < code > read_line< / code > 的 返回值 < code > Result< / code > ， 说明有一个可能的错误没处理。想消除警告，就老实的写错误处理，不过我们就是希望程序在出现问题时立即崩溃，所以直接使用 < code > expect< / code > 。第九章会学习如何 从错误中恢复。< / p >
< a class = "header" href = "#使用 println占位符打印值" name = "使用 println占位符打印值"> < h3 > 使用< code > println!< / code > 占位符打印值< / h3 > < / a > < a class = "header" href = "#使用 - println- 占位符打印值" name = "使用 - println- 占位符打印值"> < h3 > 使用 < code > println!< / code > 占位符打印值< / h3 > < / a >
< p > 除了位于结尾的大括号，目前为止编写的代码 就只有一行代码值得讨论一下了，就是这一行：< / p > < p > 除了位于结尾的大括号，目前为止就只有一行代码值得讨论一下了，就是这一行：< / p >
< pre > < code class = "language-rust ,ignore "> println!(" You guessed: {}" , guess);< pre > < code class = "language-rust "> println!(" You guessed: {}" , guess);
< / code > < / pre > < / code > < / pre >
< p > 这行代码打印出存储了用户输入的字符串。这对< code > {}< / code > 是一个在特定位置预留值的占位符。可以使用< code > {}< / code > 打印多个值：第一个< code > {}< / code > 对应格式化字符串之后列出的第一个值，第二个对应第二个值，以此类推。用一个< code > println!< / code > 调用打印多个值应该 看起来像这样：< / p > < p > 这行代码打印存储用户输入的字符串。第一个参数是格式化字符串，里面的 < code > {}< / code > 是预留在特定位置的占位符。使用占位符也可以打印多个值：格式化字符串中第一个占位符对应第二个参数值，第二个占位符对应第三个参数值，以此类推（第一个参数是格式化字符串本身）。调用一< code > println!< / code > 打印多个值 看起来像这样：< / p >
< pre > < code class = "language-rust" > let x = 5;< pre > < code class = "language-rust" > let x = 5;
let y = 10;
let y = 10;
println!(" x = {} and y = {}" , x, y);
println!(" x = {} and y = {}" , x, y);
< / code > < / pre > < / code > < / pre >
< p > 这行代码会打印出< code > x = 5 and y = 10< / code > 。< / p > < p > 这行代码会打印出 < code > x = 5 and y = 10< / code > 。< / p >
< a class = "header" href = "#测试第一部分代码" name = "测试第一部分代码" > < h3 > 测试第一部分代码< / h3 > < / a > < a class = "header" href = "#测试第一部分代码" name = "测试第一部分代码" > < h3 > 测试第一部分代码< / h3 > < / a >
< p > 让我们来测试下猜猜看游戏的第一部分。使用< code > cargo run< / code > 运行它：< / p > < p > 让我们来测试下猜猜看游戏的第一部分。使用< code > cargo run< / code > 运行它：< / p >
< pre > < code class = "language-sh" > $ cargo run< pre > < code class = "language-sh" > $ cargo run
@ -206,19 +206,19 @@ Please input your guess.
6
6
You guessed: 6
You guessed: 6
< / code > < / pre > < / code > < / pre >
< p > 至此为止，游戏的第一部分已经完成：我们从键盘获取了 输入并打印了出来。< / p > < p > 至此为止，游戏的第一部分已经完成：我们从键盘获取输入并打印了出来。< / p >
< a class = "header" href = "#生成一个秘密数字" name = "生成一个秘密数字" > < h2 > 生成一个秘密数字< / h2 > < / a > < a class = "header" href = "#生成一个秘密数字" name = "生成一个秘密数字" > < h2 > 生成一个秘密数字< / h2 > < / a >
< p > 接下来，需要生成一个秘密数字，用户会尝试猜测它。秘密数字应该每次都不同，这样多玩几次才会有意思。生成一个 1 到 100 之间的随机数这样游戏也不会太难。Rust 标准库中还未包含随机数功能。然而， < a href = "https://crates.io/crates/rand" > < code > rand< / code > crate< / a > 。< / p > < p > 接下来，需要生成一个秘密数字，好让用户来猜。秘密数字应该每次都不同，这样重复玩才不会， ， < a href = "https://crates.io/crates/rand" > < code > rand< / code > crate< / a > 。< / p >
< a class = "header" href = "#使用-crate-来增加更多功能" name = "使用-crate-来增加更多功能" > < h3 > 使用 crate 来增加更多功能< / h3 > < / a > < a class = "header" href = "#使用-crate-来增加更多功能" name = "使用-crate-来增加更多功能" > < h3 > 使用 crate 来增加更多功能< / h3 > < / a >
< p > 记住 < em > crate< / em > 是一个 Rust 代码的包。我们正在构建的项目是一个< strong > 二进制 crate< / strong > ，它生成一个可执行文件。 < code > rand< / code > crate 是一个 < strong > 库 crate< / strong > ， 它包含意在 被其他程序使用的代码。< / p > < p > 记住 < em > crate< / em > 是一个 Rust 代码的包。我们正在构建的项目是一个< strong > 二进制 crate< / strong > ，它生成一个可执行文件。 < code > rand< / code > crate 是一个 < strong > 库 crate< / strong > ， 库 crate 可以包含任意能 被其他程序使用的代码。< / p >
< p > Cargo 对外部 crate 的运用是其真正闪光的地方。在我们可以使用 < code > rand< / code > 编写代码之前，需要编辑 < em > Cargo.toml< / em > 来包含 < code > rand< / code > 作为一个依赖。现在打开这个文件并在< code > [dependencies]< / code > 部分标题（ ： < / p > < p > Cargo 对外部 crate 的运用是亮点。在我们使用 < code > rand< / code > 编写代码之前，需要编辑 < em > Cargo.toml< / em > ，声明 < code > rand< / code > 作为一个依赖。现在打开这个文件并在 < code > [dependencies]< / code > 标题（ ： < / p >
< p > < span class = "filename" > Filename: Cargo.toml< / span > < / p > < p > < span class = "filename" > Filename: Cargo.toml< / span > < / p >
< pre > < code class = "language-toml" > [dependencies]< pre > < code class = "language-toml" > [dependencies]
rand = " 0.3.14"
rand = " 0.3.14"
< / code > < / pre > < / code > < / pre >
< p > 在 < em > Cargo.toml< / em > 文件中，任何标题之后的内容都是属于这个部分的，一直持续到直到另一个部分开始 。< code > [dependencies]< / code > 部分告诉 Cargo 项目依赖了哪个外部 crate 和需要的 crate 版本。在这个例子中，我们使用语义化版本符号 < code > 0.3.14< / code > 来指定< code > rand< / code > crate。Cargo 理解< a href = "http://semver.org" > 语义化版本（ ） < / a > <!-- ignore --> （有时也称为 < em > SemVer< / em > ） ， 这是一个编写版本号的标准。版本号 < code > 0.3.14< / code > 事实上是< code > ^0.3.14< / code > 的缩写，它的意思是 “任何与 0.3.14 版本公有 API 相兼容的版本”。< / p > < p > 在 < em > Cargo.toml< / em > 文件中，标题以及之后的内容属同一个段落，遇到下一个标题则开始新的段落 。< code > [dependencies]< / code > 部分告诉 Cargo 本项目依赖了哪些外部 crate 及其版本。本例中，我们使用语义化版本 < code > 0.3.14< / code > 来指定 < code > rand< / code > crate。Cargo 理解< a href = "http://semver.org" > 语义化版本（ ） < / a > <!-- ignore --> （有时也称为 < em > SemVer< / em > ） ， 是一种定义版本号的标准。 < code > 0.3.14< / code > 事实上是 < code > ^0.3.14< / code > 的简写，它表示 “任何与 0.3.14 版本公有 API 相兼容的版本”。< / p >
< p > 现在，不用 修改任何代码，构建项目，如列表 2-2 所示：< / p > < p > 现在，不修改任何代码，构建项目，如列表 2-2 所示：< / p >
< pre > < code > $ cargo build< pre > < code > $ cargo build
Updating registry `https://github.com/rust-lang/crates.io-index`
Updating registry `https://github.com/rust-lang/crates.io-index`
Downloading rand v0.3.14
Downloading rand v0.3.14
@ -229,40 +229,40 @@ rand = "0.3.14"
< / code > < / pre > < / code > < / pre >
< p > < span class = "caption" > Listing 2-2: The output from running < code > cargo build< / code > after< p > < span class = "caption" > Listing 2-2: The output from running < code > cargo build< / code > after
adding the rand crate as a dependency< / span > < / p >
adding the rand crate as a dependency< / span > < / p >
< p > 可能会出现不同的版本号（不过 多亏了语义化版本，它们与代码是兼容的！），同时显示顺序也可能会有所不同。< / p > < p > 可能会出现不同的版本号（多亏了语义化版本，它们与代码是兼容的！），同时显示顺序也可能会有所不同。< / p >
< p > 现在我们有了一个外部依赖， < em > registry< / em > （ < a href = "https://crates.io" > Crates.io< / a > ）上获取了一份（兼容的）最新版本代码的拷贝 。Crates.io 是 Rust 生态环境中的开发者们向他人贡献他们的开源 Rust 项目的地方。< / p > < p > 现在我们有了一个外部依赖， < em > registry< / em > （ < a href = "https://crates.io" > Crates.io< / a > ）上获取了一份（兼容的）最新版本的 代码。Crates.io 是 Rust 生态环境中的开发者们向他人贡献 Rust 开源 项目的地方。< / p >
< p > 在更新完 registry （ ） ， < code > [dependencies]< / code > 部分并下载还不存在的部分。在这个例子中，虽然只列出了< code > rand< / code > 一个依赖， < code > libc< / code > 的拷贝 ，因为< code > rand< / code > 依赖< code > libc< / code > 来正常工作。在下载他们之后， 使用这些依赖编译项目。< / p > < p > 在更新完 registry （ ） ， < code > [dependencies]< / code > 段落并下载缺失的部分。本例中，只声明了 < code > rand< / code > 一个依赖，然而 Cargo 还是额外获取了 < code > libc< / code > ，因为 < code > rand< / code > 依赖 < code > libc< / code > 来正常工作。下载完成后， 使用这些依赖编译项目。< / p >
< p > 如果不做任何修改就立刻再次运行 < code > cargo build< / code > ， < em > Cargo.toml< / em > 文件中也没有任何相关修改。Cargo 也知道代码没有做任何修改，所以它也 不会重新编译代码。因为无事可做，它简单的退出了。如果打开 < em > src/main.rs< / em > 文件，并 做一些普通的修改，保存并再次构建，只会出现一行输出：< / p > < p > 如果不做任何修改，立刻再次运行 < code > cargo build< / code > ， < em > Cargo.toml< / em > 文件也没有变动，并且代码也没有任何修改，所以它 不会重新编译代码。因为无事可做，它简单的退出了。如果打开 < em > src/main.rs< / em > 文件，做一些普通的修改，保存并再次构建，只会出现一行输出：< / p >
< pre > < code > $ cargo build< pre > < code > $ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
< / code > < / pre > < / code > < / pre >
< p > 这一行表明 Cargo 只构建了 对 < em > src/main.rs< / em > 文件做出的微小修改。依赖没有被修改，所以 Cargo 知道可以 复用已经为此下载并编译的代码。它只是重新构建了部分（项目）代码。< / p > < p > 这一行表示 Cargo 只针 对 < em > src/main.rs< / em > 文件的微小修改而构建。依赖没有变化，所以 Cargo 会 复用已经为此下载并编译的代码。它只是重新构建了部分（项目）代码。< / p >
< a class = "header" href = "#cargolock-文件确保构建是可重现的" name = "cargolock-文件确保构建是可重现的" > < h4 > < em > Cargo.lock< / em > 文件确保构建是可重现的< / h4 > < / a > < a class = "header" href = "#cargolock-文件确保构建是可重现的" name = "cargolock-文件确保构建是可重现的" > < h4 > < em > Cargo.lock< / em > 文件确保构建是可重现的< / h4 > < / a >
< p > Cargo 有一个机制来确保每次 任何人重新构建代码都会生成 相同的结果： < code > rand< / code > crate 的< code > v0.3.15< / code > 版本出来了，而它包含一个重要的 bug 修改并也含有一个会破坏代码运行的缺陷的时候 会发生什么呢？< / p > < p > Cargo 有一个机制来确保任何人在任何时候 重新构建代码， 产 生相同的结果： < code > rand< / code > crate 的 < code > v0.3.15< / code > 版本出来了，它修复了一个重要的 bug， ， ， 会发生什么呢？< / p >
< p > 这个问题的 答案是 < em > Cargo.lock< / em > 文件，它在第一次运行 < code > cargo build< / code > 时被创建并位于 < em > guessing_game< / em > 目录。当第一次构建项目时 ， 接着 写入 < em > Cargo.lock< / em > 文件中。当将来构建项目时， < em > Cargo.lock< / em > 存在就会使用这里指定的版本，而不是重新进行所有版本的计算。这使得你拥有了一个自动的 可重现的构建。换句话说，项目会继续使用< code > 0.3.14< / code > 直到你显式升级，多亏了 < em > Cargo.lock< / em > 文件。我们将会在这个文件编写全部的代码 。< / p > < p > 答案是 < em > Cargo.lock< / em > 文件。它在第一次运行 < code > cargo build< / code > 时创建，并放在 < em > guessing_game< / em > 目录， < em > Cargo.lock< / em > 文件。当将来构建项目时，如果 < em > Cargo.lock< / em > 存在， < code > 0.3.14< / code > 直到你显式升级，感谢 < em > Cargo.lock< / em > 。< / p >
< a class = "header" href = "#更新-crate-到一个新版本" name = "更新-crate-到一个新版本" > < h4 > 更新 crate 到一个新版本< / h4 > < / a > < a class = "header" href = "#更新-crate-到一个新版本" name = "更新-crate-到一个新版本" > < h4 > 更新 crate 到一个新版本< / h4 > < / a >
< p > 当你< strong > 确实< / strong > 需要升级 crate 时， < code > update< / code > ，他会：< / p > < p > 当你< strong > 确实< / strong > 需要升级 crate 时， < code > update< / code > ，他会：< / p >
< ol > < ol >
< li > 忽略 < em > Cargo.lock< / em > 文件并计算出所有符合 < em > Cargo.toml< / em > 中规格 的最新版本。< / li > < li > 忽略 < em > Cargo.lock< / em > 文件， < em > Cargo.toml< / em > 声明 的最新版本。< / li >
< li > 如果成功了， < em > Cargo.lock< / em > 文件。< / li > < li > 如果成功了， < em > Cargo.lock< / em > 文件。< / li >
< / ol > < / ol >
< p > 不过， < code > 0.3.0< / code > 而小于< code > 0.4.0< / code > 的版本。如果< code > rand< / code > crate 发布了两个新版本，< code > 0.3.15< / code > 和< code > 0.4.0< / code > ，在运行< code > cargo update< / code > 时会出现如下内容：< / p > < p > 不过， < code > 0.3.0< / code > 而小于 < code > 0.4.0< / code > 的版本。如果 < code > rand< / code > crate 发布了两个新版本，< code > 0.3.15< / code > 和 < code > 0.4.0< / code > ，在运行 < code > cargo update< / code > 时会出现如下内容：< / p >
< pre > < code > $ cargo update< pre > < code > $ cargo update
Updating registry `https://github.com/rust-lang/crates.io-index`
Updating registry `https://github.com/rust-lang/crates.io-index`
Updating rand v0.3.14 -> v0.3.15
Updating rand v0.3.14 -> v0.3.15
< / code > < / pre > < / code > < / pre >
< p > 这时，值得注意的是 < em > Cargo.lock< / em > 文件中的一个改变，< code > rand< / code > crate 现在使用的版本是< code > 0.3.15< / code > 。< / p > < p > 这时，值得注意的是 < em > Cargo.lock< / em > 文件中的一个改变，< code > rand< / code > crate 现在使用的版本是< code > 0.3.15< / code > 。< / p >
< p > 如果想要使用< code > 0.4.0< / code > 版本的< code > rand< / code > 或是任何< code > 0.4.x< / code > 系列的版本，必须像这样更新 < em > Cargo.toml< / em > 文件：< / p > < p > 如果想要使用 < code > 0.4.0< / code > 版本的 < code > rand< / code > 或是任何 < code > 0.4.x< / code > 系列的版本，必须像这样更新 < em > Cargo.toml< / em > 文件：< / p >
< pre > < code class = "language-toml" > [dependencies]< pre > < code class = "language-toml" > [dependencies]
rand = " 0.4.0"
rand = " 0.4.0"
< / code > < / pre > < / code > < / pre >
< p > 下一次运行< code > cargo build< / code > 时， < code > rand< / code > 的要求 。< / p > < p > 下一次运行 < code > cargo build< / code > 时， 。< / p >
< p > 第十四章会讲到< a href = "http://doc.crates.io" > Cargo< / a > <!-- ignore --> 和 < a href = "http://doc.crates.io/crates-io.html" > 它的 生态系统< / a > <!-- ignore --> 的更多内容，不过目前你只需要了解这么多。Cargo 使得复用库文件变得非常容易，所以 Rustacean 们能够通过组合很多包来编写出 更轻巧的项目。< / p > < p > 第十四章会讲到 < a href = "http://doc.crates.io" > Cargo< / a > <!-- ignore --> 及其 < a href = "http://doc.crates.io/crates-io.html" > 生态系统< / a > <!-- ignore --> 的更多内容，不过目前你只需要了解这么多。通过 Cargo 复用库文件非常容易，因此 Rustacean 能够编写出由很多包组装而成的 更轻巧的项目。< / p >
< a class = "header" href = "#生成一个随机数" name = "生成一个随机数" > < h3 > 生成一个随机数< / h3 > < / a > < a class = "header" href = "#生成一个随机数" name = "生成一个随机数" > < h3 > 生成一个随机数< / h3 > < / a >
< p > 让我们开始< strong > 使用< / strong > < code > rand< / code > 。下一步是更新 < em > src/main.rs< / em > ，如列表 2-3 所示：< / p > < p > 让我们开始< strong > 使用< / strong > < code > rand< / code > 。下一步是更新 < em > src/main.rs< / em > ，如列表 2-3 所示：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust ,ignore "> extern crate rand;< pre > < code class = "language-rust "> extern crate rand;
use std::io;
use std::io;
use rand::Rng;
use rand::Rng;
@ -286,10 +286,10 @@ fn main() {
< / code > < / pre > < / code > < / pre >
< p > < span class = "caption" > Listing 2-3: Code changes needed in order to generate a< p > < span class = "caption" > Listing 2-3: Code changes needed in order to generate a
random number< / span > < / p >
random number< / span > < / p >
< p > 我们在顶部增加一行< code > extern crate rand;< / code > 来让 Rust 知道 我们要使用外部依赖。这也会调用相应的< code > use rand< / code > ，所以现在可以使用< code > rand::< / code > 前缀来调用< code > rand< / code > 中的任何 内容。< / p > < p > 我们在顶部增加一行 < code > extern crate rand;< / code > 通知 Rust 我们要使用外部依赖。这也会调用相应的 < code > use rand< / code > ，所以现在可以使用 < code > rand::< / code > 前缀来调用 < code > rand< / code > 中的内容。< / p >
< p > 接下来，我们增加了另 一行< code > use< / code > ： < code > use rand::Rng< / code > 。< code > Rng< / code > 是一个定义了随机数生成器应实现方法的 trait， trait 必须在作用域中。第十章会详细介绍 trait。< / p > < p > 接下来，我们增加了一行 < code > use< / code > ： < code > use rand::Rng< / code > 。< code > Rng< / code > 是一个 trait， trait 必须在作用域中。第十章会详细介绍 trait。< / p >
< p > 另外，中间还新增加了两行。< code > rand::thread_rng< / code > 函数会提供具体会使用的随机数生成器：它位于当前执行线程本地 并从操作系统获取 seed。接下来， < code > gen_range< / code > 方法。这个方法由我们使用< code > use rand::Rng< / code > 语句引入到作用域的 < code > Rng< / code > trait 定义。< code > gen_range< / code > 方法获取两个数作为参数并生成一个两者之间的随机数。它包含下限但不包含上限，所以需要指定< code > 1< / code > 和< code > 101< / code > 来请求一个< code > 1< / code > 和< code > 100< / code > 之间的数。< / p > < p > 另外，中间还新增加了两行。< code > rand::thread_rng< / code > 函数提供实际使用的随机数生成器：它位于当前执行线程， 并从操作系统获取 seed。接下来， < code > gen_range< / code > 方法。这个方法由刚才引入到作用域的 < code > Rng< / code > trait 定义。< code > gen_range< / code > 方法获取两个数字 作为参数， 范围在 两者之间的随机数。它包含下限但不包含上限，所以需要指定< code > 1< / code > 和< code > 101< / code > 来请求一个< code > 1< / code > 和< code > 100< / code > 之间的数。< / p >
< p > 并不是仅仅能够 < strong > 知道< / strong > 该 use 哪个 trait 和该从 crate 中调用哪个方法。如何使用 crate 的说明位于每个 crate 的文档中。Cargo 另一个很棒的功能是可以运行 < code > cargo doc --open< / code > 命令来构建所有本地依赖提供的文档并在浏览器中打开。例如，如果你对 < code > rand< / code > crate 中的其他功能感兴趣，运行 < code > cargo doc --open< / code > 并点击左侧导航栏中的< code > rand< / code > 。< / p > < p > < strong > 知道< / strong > use 哪个 trait 和该从 crate 中调用哪个方法并不是全部， ， < code > cargo doc --open< / code > 命令来构建所有本地依赖提供的文档，并在浏览器中打开。例如，假设你对 < code > rand< / code > crate 中的其他功能感兴趣，< code > cargo doc --open< / code > 并点击左侧导航栏中的 < code > rand< / code > 。< / p >
< p > 新增加的第二行代码打印出了秘密数字。这在开发程序时很有用，因为我们可以去测试它，不过在最终版本我们会删掉它。游戏一开始就打印出结果就没什么可玩的了！< / p > < p > 新增加的第二行代码打印出了秘密数字。这在开发程序时很有用，因为我们可以去测试它，不过在最终版本我们会删掉它。游戏一开始就打印出结果就没什么可玩的了！< / p >
< p > 尝试运行程序几次：< / p > < p > 尝试运行程序几次：< / p >
< pre > < code > $ cargo run< pre > < code > $ cargo run
@ -312,7 +312,7 @@ You guessed: 5
< a class = "header" href = "#比较猜测与秘密数字" name = "比较猜测与秘密数字" > < h2 > 比较猜测与秘密数字< / h2 > < / a > < a class = "header" href = "#比较猜测与秘密数字" name = "比较猜测与秘密数字" > < h2 > 比较猜测与秘密数字< / h2 > < / a >
< p > 现在有了用户输入和一个随机数，我们可以比较他们。这个步骤如列表 2-4 所示：< / p > < p > 现在有了用户输入和一个随机数，我们可以比较他们。这个步骤如列表 2-4 所示：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust ,ignore "> extern crate rand;< pre > < code class = "language-rust "> extern crate rand;
use std::io;
use std::io;
use std::cmp::Ordering;
use std::cmp::Ordering;
@ -343,17 +343,17 @@ fn main() {
< / code > < / pre > < / code > < / pre >
< p > < span class = "caption" > Listing 2-4: Handling the possible return values of< p > < span class = "caption" > Listing 2-4: Handling the possible return values of
comparing two numbers< / span > < / p >
comparing two numbers< / span > < / p >
< p > 新代码的第一行是另一个< code > use< / code > ，从标准库引入了一个叫做< code > std::cmp::Ordering< / code > 的类型到作用域 。< code > Ordering< / code > 是另 一个枚举， 像< code > Result< / code > 一样，不过< code > Ordering< / code > 的成员是 < code > Less< / code > 、< code > Greater< / code > 和< code > Equal< / code > 。这是你比较两个值 时可能出现三种结果。< / p > < p > 新代码的第一行是另一个 < code > use< / code > ，从标准库引入了一个叫做 < code > std::cmp::Ordering< / code > 的类型。< code > Ordering< / code > 是一个像 < code > Result< / code > 一样的枚举，不过它的成员是 < code > Less< / code > 、< code > Greater< / code > 和 < code > Equal< / code > 。这是你做 比较时可能出现的 三种结果。< / p >
< p > 接着在底部的五行新代码使用了 < code > Ordering< / code > 类型：< / p > < p > 接着，底部的五行新代码使用了 < code > Ordering< / code > 类型：< / p >
< pre > < code class = "language-rust ,ignore "> match guess.cmp(& secret_number) {< pre > < code class = "language-rust "> match guess.cmp(& secret_number) {
Ordering::Less => println!(" Too small!" ),
Ordering::Less => println!(" Too small!" ),
Ordering::Greater => println!(" Too big!" ),
Ordering::Greater => println!(" Too big!" ),
Ordering::Equal => println!(" You win!" ),
Ordering::Equal => println!(" You win!" ),
}
}
< / code > < / pre > < / code > < / pre >
< p > < code > cmp< / code > 方法比较两个值并可以在任何可比较的值上调用。它获取一个任何你想要比较的值的引用：这里是把 < code > guess< / code > 与< code > secret_number< / code > 做比较。< code > cmp< / code > 返回一个使用< code > use< / code > 语句引入作用域的< code > Ordering< / code > 枚举的成员。我们使用一个 < a href = "ch06-02-match.html" > < code > match< / code > < / a > <!-- ignore --> 表达式根据对< code > guess< / code > 和< code > secret_number< / code > 中的值调用< code > cmp< / code > 后返回的哪个< code > Ordering< / code > 枚举成员来决定接下来干什么。< / p > < p > < code > cmp< / code > 方法用来比较两个值。在任何可比较的值上调用，然后获取另一个被比较值的引用：这里是把 < code > guess< / code > 与 < code > secret_number< / code > 做比较，返回一个 < code > Ordering< / code > 枚举的成员。再使用一个 < a href = "ch06-02-match.html" > < code > match< / code > < / a > <!-- ignore --> 表达式， < / p >
< p > 一个< code > match< / code > 表达式由 < strong > 分支（ ） < / strong > 构成。一个分支包含一个 < strong > 模式< / strong > （ < em > pattern< / em > ）和代码，这些代码在< code > match< / code > 表达式开头给出的值符合分支的模式时将被执行。Rust 获取提供给 < code > match< / code > 的值并挨个检查每个分支的模式。< code > match< / code > 结构和模式是 Rust 中非常强大的功能，它帮助你体现代码可能遇到的多种情形并帮助你处理全部的可能 。这些功能将分别在第六章和第十八章详细介绍。< / p > < p > 一个 < code > match< / code > 表达式由 < strong > 分支（ ） < / strong > 构成。一个分支包含一个 < strong > 模式< / strong > （ < em > pattern< / em > ）和动作， < code > match< / code > 的值并挨个检查每个分支的模式。< code > match< / code > 结构和模式是 Rust 的强大功能，它体现了代码可能遇到的多种情形，并帮助你没有遗漏的处理 。这些功能将分别在第六章和第十八章详细介绍。< / p >
< p > 让我们看看一个使用这里的 < code > match< / code > 表达式会发生什么 的例子。假设用户猜了 50， 当代码 比较 50 与 38 时，< code > cmp< / code > 方法会返回< code > Ordering::Greater< / code > ，因为 50 比38 要大。 < code > Ordering::Greater< / code > 是< code > match< / code > 表达式得到的值。它 检查第一个分支的模式，< code > Ordering::Less< / code > ，不过值 < code > Ordering::Greater< / code > 并不匹配< code > Ordering::Less< / code > 。所以它忽略了这个分支的代码并移动到下一个分支。下一个分支的模式，< code > Ordering::Greater< / code > ， < strong > 正确< / strong > 匹配了< code > Ordering::Greater< / code > ！这个分支关联的代码会被执行并在屏幕打印出 < code > Too big!< / code > 。< code > match< / code > 表达式就此终止，因为在这个特定 场景下没有检查最后一个分支的必要。< / p > < p > 让我们看看使用 < code > match< / code > 表达式的例子。假设用户猜了 50， 因为 50 比 38 要大， < code > cmp< / code > 方法会返回 < code > Ordering::Greater< / code > 。< code > match< / code > 表达式得到该值，然后 检查第一个分支的模式，< code > Ordering::Less< / code > 与 < code > Ordering::Greater< / code > 并不匹配，所以它忽略了这个分支的动作并来到下一个分支。下一个分支的模式是 < code > Ordering::Greater< / code > ， < strong > 正确< / strong > 匹配！这个分支关联的动作被执行，在屏幕打印出 < code > Too big!< / code > 。< code > match< / code > 表达式就此终止，因为该 场景下没有检查最后一个分支的必要。< / p >
< p > 然而，列表 2-4 的代码并不能编译，可以尝试一下：< / p > < p > 然而，列表 2-4 的代码并不能编译，可以尝试一下：< / p >
< pre > < code > $ cargo build< pre > < code > $ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
@ -369,10 +369,10 @@ error[E0308]: mismatched types
error: aborting due to previous error
error: aborting due to previous error
Could not compile `guessing_game`.
Could not compile `guessing_game`.
< / code > < / pre > < / code > < / pre >
< p > 错误的核心表明这里有< strong > 不匹配的类型< / strong > （ < em > mismatched types< / em > ） 拥有一个静态强类型系统。不过，它也有类型推断。当我们写出 < code > let guess = String::new()< / code > 时， 能够 推断出< code > guess< / code > 应该是一个< code > String< / code > ， 并 不需要我们写出类型。另一方面，< code > secret_number< / code > ，是一个数字类型。一些数字类型拥有 1 到 100 之间的值：< code > i32< / code > ，一个 32 位的数字；< code > u32< / code > ，一个 32 位无符号数字； < code > i64< / code > ，一个 64 位数字； 等等。Rust 默认使用< code > i32< / code > ，所以< code > secret_number< / code > 的类型就是它 ，除非增加类型信息或任何能让 Rust 推断出不同数值类型的信息。这里错误的原因在于 Rust 不会比较字符串类型和数字类型。< / p > < p > 错误的核心表明这里有< strong > 不匹配的类型< / strong > （ < em > mismatched types< / em > ） 有一个静态强类型系统，同时也有类型推断。当我们写出 < code > let guess = String::new()< / code > 时， < code > guess< / code > 应该是一个< code > String< / code > ，不需要我们写出类型。另一方面，< code > secret_number< / code > ，是一个数字类型。多种数字类型拥有 1 到 100 之间的值： < code > i32< / code > ； < code > u32< / code > ； < code > i64< / code > 等等。Rust 默认使用 < code > i32< / code > ，所以它是 < code > secret_number< / code > 的类型，除非增加类型信息， < / p >
< p > 最终我们想要把程序从输入中读取到的< code > String< / code > 转换为一个真正的数字类型，这样好与秘密数字向比较。可以通过在 < code > main< / code > 函数体中增加如下两行代码来实现：< / p > < p > 所以我们必须把从输入中读取到的 < code > String< / code > 转换为一个真正的数字类型，才好与秘密数字进行比较。可以通过在 < code > main< / code > 函数体中增加如下两行代码来实现：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust ,ignore "> extern crate rand;< pre > < code class = "language-rust "> extern crate rand;
use std::io;
use std::io;
use std::cmp::Ordering;
use std::cmp::Ordering;
@ -405,13 +405,13 @@ fn main() {
}
}
< / code > < / pre > < / code > < / pre >
< p > 这两行代码是：< / p > < p > 这两行代码是：< / p >
< pre > < code class = "language-rust ,ignore "> let guess: u32 = guess.trim().parse()< pre > < code class = "language-rust "> let guess: u32 = guess.trim().parse()
.expect(" Please type a number!" );
.expect(" Please type a number!" );
< / code > < / pre > < / code > < / pre >
< p > 这里创建了一个叫做< code > guess< / code > 的变量。不过等等，难道这个程序 不是已经有了一个叫做< code > guess< / code > 的变量了吗？确实如此，不过 Rust 允许我们通过< strong > 覆 盖< / strong > （ < em > shadow< / em > ） 用一个新值来覆盖< code > guess< / code > 之前的值。这个功能经常用在类似需要把一个值从一种类型转换到另一种类型的场景。shadowing 允许我们复用< code > guess< / code > 变量的名字而不是强迫我们创建两个不同变量，比如 < code > guess_str< / code > 和< code > guess< / code > 。（第三章会介绍 shadowing 的更多细节。）< / p > < p > 这里创建了一个叫做 < code > guess< / code > 的变量。不过等等，不是已经有了一个叫做< code > guess< / code > 的变量了吗？确实如此，不过 Rust 允许< strong > 遮< / strong > （ < em > shadow< / em > ） ，用一个新值来遮盖 < code > guess< / code > 之前的值。这个功能常用在需要转换值类型之类的场景，它允许我们复用 < code > guess< / code > 变量的名字，而不是被迫创建两个不同变量，诸如 < code > guess_str< / code > 和 < code > guess< / code > 之类 。（第三章会介绍 shadowing 的更多细节。）< / p >
< p > < code > guess< / code > 被绑定到< code > guess.trim().parse()< / code > 表达式。表达式中的< code > guess< / code > 对应包含输入的 < code > String< / code > 类型的原始< code > guess< / code > 。< code > String< / code > 实例的< code > trim< / code > 方法会消 除字符串开头和结尾的空白。< code > u32< / code > 只能包含数字字符。不过用户必须输入回车键才能让< code > read_line< / code > 返回。当 用户按下回车键时， （ ） 字 符。例如，如果 用户输入 5 并回车，< code > guess< / code > 看起来像这样：< code > 5\n< / code > 。< code > \n< / code > 代表“换行”，回车键。< code > trim< / code > 方法消除< code > \n< / code > ，只留下< code > 5< / code > 。< / p > < p > < code > guess< / code > 被绑定到 < code > guess.trim().parse()< / code > 表达式。表达式中的 < code > guess< / code > 是包含输入的 < code > String< / code > 类型。< code > String< / code > 实例的 < code > trim< / code > 方法会去 除字符串开头和结尾的空白。< code > u32< / code > 只能由数字字符转换，不过用户必须输入回车键才能让 < code > read_line< / code > 返回，然而 用户按下回车键时， （ ） ， < code > guess< / code > 看起来像这样：< code > 5\n< / code > 。< code > \n< / code > 代表“换行”，回车键。< code > trim< / code > 方法消除 < code > \n< / code > ，只留下< code > 5< / code > 。< / p >
< p > < a href = "https://doc.rust-lang.org/std/primitive.str.html#method.parse" > 字符串的< code > parse< / code > 方法< / a > <!-- ignore --> 解析一个字符串成某个数字。因为这个方法可以解析多种数字类型，需要告诉 Rust 我们需要的具体的数字类型，这里通过 < code > let guess: u32< / code > 指定。< code > guess< / code > 后面的冒号（< code > :< / code > ）告诉 Rust 我们指明 了变量的类型。Rust 有一些内建的数字类型；这里的 < code > u32< / code > 是一个无符号的 32 位整型。它是一个好的较小正整数的默认类型。第三章会讲到其他数字类型。另外，例子程序中的< code > u32< / code > 注解和与 < code > secret_number< / code > 的比较意味着 Rust 会推断< code > secret_number< / code > 应该是也是 < code > u32< / code > 类型。现在可以使用相同类型比较两个值了！< / p > < p > < a href = "https://doc.rust-lang.org/std/primitive.str.html#method.parse" > 字符串的< code > parse< / code > 方法< / a > <!-- ignore --> 将字符串解析成数字。这个方法可以解析多种数字类型，因此需要告诉 Rust 具体的数字类型，这里通过 < code > let guess: u32< / code > 指定。< code > guess< / code > 后面的冒号（< code > :< / code > ）告诉 Rust 我们指定 了变量的类型。Rust 有一些内建的数字类型；< code > u32< / code > 是一个无符号的 32 位整型。对于不大的正整数来说，它是不错的类型，第三章还会讲到其他数字类型。另外，程序中的 < code > u32< / code > 注解以及与 < code > secret_number< / code > 的比较， 出 < code > secret_number< / code > 也是 < code > u32< / code > 类型。现在可以使用相同类型比较两个值了！< / p >
< p > < code > parse< / code > 调用容易产生错误。例如，如果字符串包含 < code > A👍%< / code > ，就无法将其转换为一个数字。因为它可能失败 ， < code > parse< / code > 方法返回一个< code > Result< / code > 类型，非常像之前在“使用< code > Result< / code > 类型来处理潜在的错误”部分讨论的< code > read_line< / code > 方法。这里再次类似的使用< code > expect< / code > 方法处理这个< code > Result< / code > 类型。如果< code > parse< / code > 因为不能从字符串生成一个数字而返回一个< code > Err< / code > 的< code > Result< / code > 成员 时，< code > expect< / code > 会使游戏崩溃并打印提供给它的信息。如果< code > parse< / code > 能 成功地将字符串转换为一个数字，它会返回< code > Result< / code > 的< code > Ok< / code > 成员，同时< code > expect< / code > 会返回< code > Ok< / code > 中我们需要 的数字。< / p > < p > < code > parse< / code > 调用可能产生错误。例如，字符串中包含 < code > A👍%< / code > ，就无法将其转换为一个数字。因此 ， < code > parse< / code > 方法返回一个 < code > Result< / code > 类型。像之前讨论的 < code > read_line< / code > 方法，按部就班的用 < code > expect< / code > 方法处理即可。如果 < code > parse< / code > 不能从字符串生成一个数字，返回一个 < code > Result::Err< / code > 时，< code > expect< / code > 会使游戏崩溃并打印附带的信息。如果 < code > parse< / code > 成功地将字符串转换为一个数字，它会返回 < code > Result::Ok< / code > ，然后 < code > expect< / code > 会返回 < code > Ok< / code > 中的数字。< / p >
< p > 现在让我们运行程序！< / p > < p > 现在让我们运行程序！< / p >
< pre > < code > $ cargo run< pre > < code > $ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
@ -426,9 +426,9 @@ Too big!
< p > 漂亮！即便是在猜测之前添加了空格，程序依然能判断出用户猜测了 76。多运行程序几次来检验不同类型输入的相应行为： ， < / p > < p > 漂亮！即便是在猜测之前添加了空格，程序依然能判断出用户猜测了 76。多运行程序几次来检验不同类型输入的相应行为： ， < / p >
< p > 现在游戏已经大体上能玩了，不过用户只能猜一次。增加一个循环来改变它吧！< / p > < p > 现在游戏已经大体上能玩了，不过用户只能猜一次。增加一个循环来改变它吧！< / p >
< a class = "header" href = "#使用循环来允许多次猜测" name = "使用循环来允许多次猜测" > < h2 > 使用循环来允许多次猜测< / h2 > < / a > < a class = "header" href = "#使用循环来允许多次猜测" name = "使用循环来允许多次猜测" > < h2 > 使用循环来允许多次猜测< / h2 > < / a >
< p > < code > loop< / code > 关键字提供了一个无限循环。增加它后给了用户多次猜测的机会 ： < / p > < p > < code > loop< / code > 关键字提供了一个无限循环。将其加入后，用户可以反复猜测 ： < / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust ,ignore "> extern crate rand;< pre > < code class = "language-rust "> extern crate rand;
use std::io;
use std::io;
use std::cmp::Ordering;
use std::cmp::Ordering;
@ -462,8 +462,8 @@ fn main() {
}
}
}
}
< / code > < / pre > < / code > < / pre >
< p > 如上所示，我们将提示用户猜测之后的所有内容放入了循环。确保这些代码多缩进了四个空格，并再次运行程序。注意这里有一个新问题，因为程序忠实地执行了我们要求它做的：永远地请求另一个猜测！看起来用户没法退出啊 ！ < / p > < p > 如上所示，我们将提示用户猜测之后的所有内容放入了循环。确保这些代码额外缩进了一层，再次运行程序。注意这里有一个新问题，因为程序忠实地执行了我们的要求：永远地请求另一个猜测，用户没法退出 ！ < / p >
< p > 用户总是可以使用< code > Ctrl-C< / code > 快捷键来终止程序。不过这里还有另一个逃离这个贪得无厌的怪物的方法，就是在“比较猜测”部分提到的 < code > parse< / code > ：如果用户输入一个非数字回 答，程序会崩溃。用户可以利用这一点来退出，如下所示：< / p > < p > 用户总能使用 < code > Ctrl-C< / code > 终止程序。不过还有另一个方法跳出无限循环，就是“比较猜测”部分提到的 < code > parse< / code > ：如果用户输入一个非数字答案 ，程序会崩溃。用户可以利用这一点来退出，如下所示：< / p >
< pre > < code > $ cargo run< pre > < code > $ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Running `target/guessing_game`
Running `target/guessing_game`
@ -487,11 +487,11 @@ thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidD
note: Run with `RUST_BACKTRACE=1` for a backtrace.
note: Run with `RUST_BACKTRACE=1` for a backtrace.
error: Process didn't exit successfully: `target/debug/guess` (exit code: 101)
error: Process didn't exit successfully: `target/debug/guess` (exit code: 101)
< / code > < / pre > < / code > < / pre >
< p > 输入< code > quit< / code > 确实退出了程序，同时其他任何非数字输入也一样。然而，毫不夸张的说这是不理想的。 我们想要当猜测正确的数字时游戏能自动退出。< / p > < p > 输入 < code > quit< / code > 确实退出了程序，同时其他任何非数字输入也一样。然而，这并不理想， 我们想要当猜测正确的数字时游戏能自动退出。< / p >
< a class = "header" href = "#猜测正确后退出" name = "猜测正确后退出" > < h3 > 猜测正确后退出< / h3 > < / a > < a class = "header" href = "#猜测正确后退出" name = "猜测正确后退出" > < h3 > 猜测正确后退出< / h3 > < / a >
< p > 让我们增加一个< code > break< / code > 来在用户胜利 时退出游戏：< / p > < p > 让我们增加一个 < code > break< / code > ，在用户猜对 时退出游戏：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust ,ignore "> extern crate rand;< pre > < code class = "language-rust "> extern crate rand;
use std::io;
use std::io;
use std::cmp::Ordering;
use std::cmp::Ordering;
@ -528,18 +528,18 @@ fn main() {
}
}
}
}
< / code > < / pre > < / code > < / pre >
< p > 通过在< code > You win!< / code > 之后增加一行< code > break< / code > ， 程序在 用户猜对了神秘数字后会退出循环。退出循环也就 意味着退出程序，因为循环是< code > main< / code > 的最后一部分。< / p > < p > 通过在 < code > You win!< / code > 之后增加一行 < code > break< / code > ，用户猜对了神秘数字后会退出循环。退出循环也意味着退出程序，因为循环是 < code > main< / code > 的最后一部分。< / p >
< a class = "header" href = "#处理无效输入" name = "处理无效输入" > < h3 > 处理无效输入< / h3 > < / a > < a class = "header" href = "#处理无效输入" name = "处理无效输入" > < h3 > 处理无效输入< / h3 > < / a >
< p > 为了进一步改善游戏性，而不是在用户输入非数字时崩溃，需要让游戏忽略非数字从而用户可以继续猜测。可以通过修改< code > guess< / code > 从 < code > String< / code > 转化为< code > u32< / code > 那部分代码来实现：< / p > < p > 为了进一步改善游戏性，不要在用户输入非数字时崩溃，需要忽略非数字，让用户可以继续猜测。可以通过修改 < code > guess< / code > 将 < code > String< / code > 转化为 < code > u32< / code > 那部分代码来实现：< / p >
< pre > < code class = "language-rust ,ignore "> let guess: u32 = match guess.trim().parse() {< pre > < code class = "language-rust "> let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Ok(num) => num,
Err(_) => continue,
Err(_) => continue,
};
};
< / code > < / pre > < / code > < / pre >
< p > 从< code > expect< / code > 调用切换到< code > match< / code > 语句是如何从遇到错误就崩溃到真正处理错误的常用手段。记住 < code > parse< / code > 返回一个< code > Result< / code > 类型，而< code > Result< / code > 是一个拥有< code > Ok< / code > 或< code > Err< / code > 两个成员的枚举。在这里使用< code > match< / code > 表达式，就像之前处理< code > cmp< / code > 方法返回的 < code > Ordering< / code > 一样。< / p > < p > 将 < code > expect< / code > 调用换成 < code > match< / code > 语句,是从“立即崩溃”转到真正处理错误的惯用方法。须知 < code > parse< / code > 返回一个 < code > Result< / code > 类型，而 < code > Result< / code > 是一个拥有 < code > Ok< / code > 或 < code > Err< / code > 成员的枚举。这里使用的 < code > match< / code > 表达式，和之前处理 < code > cmp< / code > 方法返回 < code > Ordering< / code > 时用的 一样。< / p >
< p > 如果< code > parse< / code > 能够成功的将字符串转换为一个数字，它会返回一个包含结果数字< code > Ok< / code > 值 。这个< code > Ok< / code > 值会匹配第一个分支的模式，这时< code > match< / code > 表达式仅仅返回< code > parse< / code > 产生的 < code > Ok< / code > 值之 中的< code > num< / code > 值。这个数字会最终如期变成新创建的 < code > guess< / code > 变量。< / p > < p > 如果 < code > parse< / code > 能够成功的将字符串转换为一个数字，它会返回一个包含结果数字的 < code > Ok< / code > 。这个 < code > Ok< / code > 值与< code > match< / code > 第一个分支的模式相匹配，该分支对应的动作返回 < code > Ok< / code > 值中的数字 < code > num< / code > ，最后如愿变成新创建的 < code > guess< / code > 变量。< / p >
< p > 如果< code > parse< / code > < em > 不< / em > 能将字符串转换为一个数字，它会返回一个包含更多错误信息的< code > Err< / code > 值 。< code > Err< / code > 值不能匹配第一个< code > match< / code > 分支的< code > Ok(num)< / code > 模式，但是会匹配第二个分支的< code > Err(_)< / code > 模式。< code > _< / code > 是一个包罗万象的值；在这个例子中，我们想要匹配所有 < code > Err< / code > 值，不管其中有何种信息。所以程序会执行第二个分支的代码 ， < code > continue< / code > ，这意味着进入< code > loop< / code > 的下一次循环并请求另一个猜测。这样程序就有效地忽略了 < code > parse< / code > 可能遇到的所有错误！< / p > < p > 如果 < code > parse< / code > < em > 不< / em > 能将字符串转换为一个数字，它会返回一个包含更多错误信息的 < code > Err< / code > 。< code > Err< / code > 值不能匹配第一个 < code > match< / code > 分支的 < code > Ok(num)< / code > 模式，但是会匹配第二个分支的 < code > Err(_)< / code > 模式：< code > _< / code > 是一个兜底值，用来匹配所有 < code > Err< / code > 值，不管其中有何种信息。所以程序会执行第二个分支的动作 ， < code > continue< / code > 意味着进入 < code > loop< / code > 的下一次循环，请求另一个猜测。这样程序就忽略了 < code > parse< / code > 可能遇到的所有错误！< / p >
< p > 现在万事俱备（只欠东风）了。运行 < code > cargo run< / code > 来尝试一下 ： < / p > < p > 现在万事俱备，只需运行 < code > cargo run< / code > ： < / p >
< pre > < code > $ cargo run< pre > < code > $ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Running `target/guessing_game`
Running `target/guessing_game`
@ -560,9 +560,9 @@ Please input your guess.
You guessed: 61
You guessed: 61
You win!
You win!
< / code > < / pre > < / code > < / pre >
< p > 太棒了！再有最后一个小的修改，就能完成猜猜看游戏了：还记得程序依然会打印出秘密数字。这 在测试时还好，但会毁了游戏性 。删掉打印秘密数字的< code > println!< / code > 。列表 2-5 为最终代码：< / p > < p > 太棒了！再有最后一个小的修改，就能完成猜猜看游戏了：还记得程序依然会打印出秘密数字。在测试时还好，但正式发布时 会毁了游戏。删掉打印秘密数字的 < code > println!< / code > 。列表 2-5 为最终代码：< / p >
< p > < span class = "filename" > Filename: src/main.rs< / span > < / p > < p > < span class = "filename" > Filename: src/main.rs< / span > < / p >
< pre > < code class = "language-rust ,ignore "> extern crate rand;< pre > < code class = "language-rust "> extern crate rand;
use std::io;
use std::io;
use std::cmp::Ordering;
use std::cmp::Ordering;
@ -602,7 +602,7 @@ fn main() {
< p > < span class = "caption" > Listing 2-5: Complete code of the guessing game< / span > < / p > < p > < span class = "caption" > Listing 2-5: Complete code of the guessing game< / span > < / p >
< a class = "header" href = "#总结" name = "总结" > < h2 > 总结< / h2 > < / a > < a class = "header" href = "#总结" name = "总结" > < h2 > 总结< / h2 > < / a >
< p > 此时此刻，你顺利完成了猜猜看游戏！恭喜！< / p > < p > 此时此刻，你顺利完成了猜猜看游戏！恭喜！< / p >
< p > 这是一个通过动手实践的方式想你介绍许多 Rust 新知识 的项目：< code > let< / code > 、< code > match< / code > 、方法、关联函数，使用外部 crate， ， 。第三章涉及到大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用他们。第四章探索所有权（ ） ， < / p > < p > 这是一个通过动手实践学习 Rust 新概念 的项目：< code > let< / code > 、< code > match< / code > 、方法、关联函数、使用外部 crate 等等，接下来的几章，我们将会继续深入 。第三章涉及到大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用他们。第四章探索所有权（ ） ， < / p >
< / div >
< / div >
KaiserY
8 years ago