mirror of
https://github.com/rust-lang-cn/book-cn.git
synced 2025-01-23 23:50:25 +08:00
Update src/ch02-00-guessing-game-tutorial.md
This commit is contained in:
Aaran Xu
parent
da9d15ea25
commit
aa2e28fc86
@ -2,26 +2,34 @@
|
||||
|
||||
现在我们已经安装好了 Rust，接着我们编写第一个 Rust 程序。按照传统，在学习一门新语言时都会编写一个输出“Hello, world!”（你好，世界）的小程序，本章我们也是如此。
|
||||
|
||||
> 注意：本书假定你已经熟悉基本的命令行。Rust 本身对编辑器、工具或代码存放的位置都没有特别要求。所以要是你更喜欢 IDE 而不是命令行的话，可以随意选用你喜爱的 IDE。
|
||||
> 注意：本书假定你已经熟悉基本的命令行。Rust 本身对编辑器、工具或代码存放的位置都没有特殊要求。所以要是你更喜欢 IDE 而不是命令行的话，可以随意选用你喜爱的 IDE。目前很多 IDE 都提供了一定程度的 Rust 支持。有关详细信息，请查看 IDE 的文档。最近，Rust 团队一直致力于提供出色的 IDE 支持，并且在这方面取得了迅速的进步！
|
||||
|
||||
### 创建项目文件
|
||||
### 创建项目目录
|
||||
|
||||
首先，创建一个文件来存放 Rust 代码。Rust 不关心代码存放的地方，但对于本书，我们建议在系统用户的家目录（home）下创建一个 *projects* 文件夹，并保存你的所有项目。打开终端并输入以下命令为此特定项目创建目录：
|
||||
首先，创建一个目录来存储您的Rust代码。对于Rust驻留代码的位置来说，这无关紧要，但是对于本书中的练习和项目，我们建议在主目录中创建一个项目目录，并将所有项目保留在此目录中。
|
||||
|
||||
Linux 或 Mac:
|
||||
|
||||
```text
|
||||
|
||||
对于Windows上的Linux，macOS和PowerShell，请输入以下命令：
|
||||
|
||||
首先，创建一个文件来存放 Rust 代码。Rust 不关心代码存放的地方，这无关紧要，但对于本书中的练习和项目，我们建议在操作系统的主目录（home，在 Windows 下即用户目录）下创建一个 *projects* 目录，并保存你的所有项目。
|
||||
|
||||
打开终端，输入以下命令以创建 *projects* 项目目录，以及此项目目录里面的 “Hello, world!” 项目目录。
|
||||
|
||||
对于 Linux、macOS 和 Windows 上的 PowerShell，请输入以下命令：
|
||||
|
||||
```console
|
||||
$ mkdir ~/projects
|
||||
$ cd ~/projects
|
||||
$ mkdir hello_world
|
||||
$ cd hello_world
|
||||
```
|
||||
|
||||
Windows:
|
||||
对于 Windows CMD，输入以下内容：
|
||||
|
||||
```cmd
|
||||
> mkdir %USERPROFILE%\projects
|
||||
> cd %USERPROFILE%\projects
|
||||
> mkdir "%USERPROFILE%\projects"
|
||||
> cd /d "%USERPROFILE%\projects"
|
||||
> mkdir hello_world
|
||||
> cd hello_world
|
||||
```
|
||||
@ -39,19 +47,34 @@ fn main() {
|
||||
println!("Hello, world!");
|
||||
}
|
||||
```
|
||||
保存文件，然后返回到终端窗口。在 Linux 或 OSX 上，输入以下命令：
|
||||
|
||||
```text
|
||||
<span class="caption">示例 1-1：一个打印 `Hello, world!` 的程序</span>
|
||||
|
||||
保存文件，然后返回到终端窗口。在 Linux 或 macOS 上，输入以下命令：
|
||||
|
||||
```console
|
||||
$ rustc main.rs
|
||||
$ ./main
|
||||
Hello, world!
|
||||
```
|
||||
|
||||
在 Windows 上，运行 `.\main.exe` 而不是 `./main`。不管哪个操作系统，你都应该看到 `Hello, world!` 打印到了终端上。要是你做到了，那么祝贺你！你已经正式编写了一个 Rust 程序！欢迎进入 Rust 大家庭。
|
||||
在 Windows 上，输入 `.\main.exe` 来代替 `./main`：
|
||||
|
||||
```powershell
|
||||
> rustc main.rs
|
||||
> .\main.exe
|
||||
Hello, world!
|
||||
```
|
||||
|
||||
不管你使用哪种操作系统，该字符串 `Hello, world!` 都应打印到了终端上。如果看不到此输出，请参考“安装”小节的 [“疑难解答”][troubleshooting]<!-- ignore --> 部分，以获得帮助。
|
||||
|
||||
如果 `Hello, world!` 打印成功，那么祝贺你！你已经正式编写了一个 Rust 程序。你已经成为了一名 Rust 程序员——欢迎加入 Rust 大家庭！
|
||||
|
||||
### Rust 程序的详解
|
||||
|
||||
现在我们来深入了解 “Hello, world!” 程序的细节。这是 Rutt 代码的主体结构（Here's the first piece of the puzzle）：
|
||||
### Rust 程序剖析
|
||||
|
||||
让我们详细回顾一下 “Hello, world!” 程序发生了什么。这是难题的第一部分：
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
@ -59,213 +82,68 @@ fn main() {
|
||||
}
|
||||
```
|
||||
|
||||
这几行定义了 Rust 中的函数。`main` 函数（也称为主函数）很特别：它是每个可执行的 Rust 程序的入口。第一行说：“我声明了一个名为 `main` 的函数，不带参数也没有返回值。”如果有参数，那么它们的名字会放到括号内，`(` 和 `)`。
|
||||
这几行定义了 Rust 的函数。`main` 函数（也称为主函数）很特殊：它始终是每个可执行 Rust 程序中运行的第一个代码。第一行声明一个名为 `main` 的函数，不带参数也没有返回值。如果有参数，那么它们的名字会放到括号内，它们将放在括号 `()` 内。
|
||||
|
||||
另外注意到函数体包裹在大括号 `{` 和 `}` 中。Rust 需要函数体的所有内容都被括号包围起来。一种好的编程风格是将左大括号放在函数声明的同一行，且之间带有一个空格。
|
||||
另外，请注意，函数主体用大括号 `{}` 括起来。Rust 需要函数体的所有内容都被括号包围起来。一种好的代码风格是将左大括号放在函数声明的同一行，且之间带有一个空格。
|
||||
|
||||
`main` 函数的内部：
|
||||
如果想在 Rust 项目中坚持标准代码风格，则可以使用自动格式化程序工具 `rustfmt` 来将代码格式化为特定风格。Rust 团队已将此工具包含在标准 Rust 发行版中（如 `rustc`），因此它应该已经安装在你的计算机上！更多相关详细信息，请查看在线文档。
|
||||
|
||||
`main` 函数内部是以下代码：
|
||||
|
||||
```rust
|
||||
println!("Hello, world!");
|
||||
```
|
||||
|
||||
此行执行了这个小程序的所有工作：将文本打印到屏幕上。这里有很多细节需要注意。第一点是 Rust 的风格是使用 4 个空格而不是制表符作为缩进。
|
||||
该行完成了此小程序中的所有工作：它将文本打印到屏幕上。这里有 4 个要注意的重要细节。
|
||||
|
||||
第二个重要部分是 `println!`。这是在调用 Rust **宏**（*macro*），其中宏展示了 Rust 是如何元编程（metaprogramming）的。如果调用的是函数，那看起来类似这样：`println`（没有 `!`）。我们将在第 24 章详细讨论 Rust 的宏，但现在只需要知道，当看到一个 `!`，则意味着调用的是宏而不是普通的函数。
|
||||
首先，Rust 风格的缩进使用 4 个空格，而不是制表符。
|
||||
|
||||
接下来是 `"Hello, world!"`，这是一个**字符串**（*string*）。我们将这个字符串作为参数传递给 `println!`，接着 `println!` 将字符串打印到屏幕上。就是如此简单！
|
||||
其次，`println!` 调用 Rust 宏。如果改为调用函数，则应该将其输入为 `println`（不含 `!`）。我们将在第 19 章中更详细地讨论 Rust 宏。现在只需要知道，当看到一个 `!`，则意味着调用的是宏而不是普通的函数。
|
||||
|
||||
本行以分号（`;`）结尾。`;` 表示此表达式已结束，并且准备开始下一行。Rust 的大多数行都以一个 `;` 结尾。
|
||||
第三，您看到 `"Hello, world!"` 字符串。我们将这个字符串作为参数传递给 `println!`，接着 `println!` 将字符串打印到屏幕上。
|
||||
|
||||
第四，我们用分号（`;`）结束该行，这表明该表达式已结束，下一个表达式已准备好开始。Rust 代码的大多数行都以一个 `;` 结尾。
|
||||
|
||||
### 编译和运行是独立的步骤
|
||||
|
||||
在“编写和运行 Rust 程序”小节中，我们展示了如何运行一个新创建的程序。现在我们将分解这个过程，并检查每个步骤。
|
||||
刚才我们运行一个新创建的程序。现在我们将分解这个过程，并检查每个步骤。
|
||||
|
||||
在运行 Rust 程序之前，你必须编译它。可以使用 Rust 编译器，输入 `rustc` 命令并传入源文件的名称，如下所示：
|
||||
在运行 Rust 程序之前，必须使用 Rust 编译器来编译它，输入 `rustc` 命令并传入源文件的名称，如下所示：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ rustc main.rs
|
||||
```
|
||||
|
||||
如果有 C 或 C++ 语言基础，你会注意到这点和 `gcc` 或 `clang` 类似。编译成功后，Rust 就会输出一个二进制可执行文件，在 Linux 或 OSX 上输入 `ls` 命令将看到这些文件，如下所示：
|
||||
如果有 C 或 C++ 语言基础，你会注意到这点和 `gcc` 或 `clang` 类似。编译成功后，Rust 就会输出一个二进制可执行文件。
|
||||
|
||||
```text
|
||||
在 Linux、macOS 或 Windows 的 PowerShell 中，可通过输入 `ls` 命令来查看可执行文件。在 Linux 和 macOS 中，你将看到两个文件。使用 Windows 的 PowerShell，你将看到与使用 CMD 相同的三个文件。
|
||||
|
||||
```console
|
||||
$ ls
|
||||
main main.rs
|
||||
```
|
||||
|
||||
在 Windows，需要输入：
|
||||
对于 Windows 的 CMD，可输入以下内容：
|
||||
|
||||
```cmd
|
||||
> dir /B %= the /B option says to only show the file names =%
|
||||
main.exe
|
||||
main.pdb
|
||||
main.rs
|
||||
```
|
||||
|
||||
这里显示了两个文件：源代码文件（扩展名为 *.rs*），可执行文件（在 Windows 上格式为 *main.exe*，其他系统为 *main*）。还剩下要做的就是运行 *main* 或 *main.exe* 文件，像这样：
|
||||
这显示了带有.rs扩展名的源代码文件，可执行文件（在Windows上是main.exe，在所有其他平台上是main），以及在使用Windows时，包含一个带有.pdb扩展名的调试信息的文件。在这里，运行main或main.exe文件，如下所示：
|
||||
|
||||
```text
|
||||
$ ./main # or .\main.exe on Windows
|
||||
这里显示了扩展名为 *.rs* 的源代码文件和可执行文件（在 Windows 上为 *main.exe*，其他系统为 *main*），以及在使用 Windows 时，包含一个带有 `.pdb` 扩展名的调试信息的文件。在这里，运行 `main` 或 `main.exe` 文件，如下所示：
|
||||
|
||||
```console
|
||||
$ ./main # or .\main.exe on Windows
|
||||
```
|
||||
|
||||
如果 *main.rs* 是 “Hello, world!”程序，这将会打印 `Hello, world!` 到终端上。
|
||||
如果 *main.rs* 是 “Hello, world!” 程序，这将会打印 `Hello, world!` 到终端上。
|
||||
|
||||
如果你只用过动态语言，如 Ruby、Python 或 JavaScript，你很可能不习惯分开多个步骤来编译和运行程序的方式。Rust 是一门**预编译**(*ahead-of-time compiled*)语言，这意味着你可以编译一个程序，将编译后的可执行文件给别人，即使他们没有安装 Rust 也可以运行程序。如果你给某人 `.rb`、`.py` 或 `.js` 文件，那就是另外一种情形，对方也需要分别安装对应 Ruby、Python 或 JavaScript 的语言实现，但只需要一条命令来编译和运行程序。一切都是语言设计权衡的结果。
|
||||
如果你只更熟悉动态语言，如 Ruby、Python 或 JavaScript，你很可能不习惯分开多个步骤来编译和运行程序的方式。Rust 是一门**预编译**(*ahead-of-time compiled*)语言，这意味着你可以编译一个程序，将编译后的可执行文件给别人，即使他们没有安装 Rust 也可以运行程序。如果你为其他人提供 `.rb`、`.py` 或 `.js` 文件，那么对方也需要分别安装对应 Ruby、Python 或 JavaScript 的语言支持环境。但是在这些语言中，只需要一条命令来编译和运行程序。一切都是语言设计权衡的结果。
|
||||
|
||||
使用 `rustc` 编译对简单的程序可以轻松胜任，但随着项目的增长，你将会想要管理项目中所有相关内容，并想让其他用户和项目能够容易共享你的代码。接下来，我们将引入一个名为 Cargo 的工具，这将帮助你学会编写真实开发环境的 Rust 程序。
|
||||
使用 `rustc` 编译对简单的程序可以轻松胜任，但随着项目的增长，你将会想要管理项目中所有相关内容，并想让其他用户和项目能够容易共享你的代码。接下来，我们将引入 Cargo 工具，这将帮助你学会编写真实开发环境的 Rust 程序。
|
||||
|
||||
## 使用 Cargo
|
||||
|
||||
Cargo 是 Rust 的构建系统和包管理器，Rustaceans 使用 Cargo 来管理他们的 Rust 项目，因为它使很多任务变得更容易。例如，Cargo 负责构建代码，下载项目代码依赖的库，以及构建这些库。我们将项目代码需要的库称为**依赖**（*dependency*）。
|
||||
|
||||
最简单的 Rust 程序，比如我们到目前为止编写的程序，没有任何依赖，所以现在你只能用到 Cargo 负责构建代码的那部分功能。随着你编写更复杂的 Rust 程序，你将需要增加依赖，如果你开始使用 Cargo，那将会更容易做到。
|
||||
|
||||
既然绝大多数 Rust 项目都使用 Cargo，我们也将假设您在本书的剩下部分都使用它。如果你使用安装的章节提到的官方安装方式，那么 Cargo 将会随着 Rust 一块安装。如果你通过其他方式安装 Rust，你可以通过在终端中键入以下内容来检查是否安装了 Cargo：
|
||||
|
||||
```text
|
||||
$ cargo --version
|
||||
```
|
||||
|
||||
如果能看到一个版本号，那相当棒！如果是见到类似这样的错误 `command not found`，那就阅读你选择安装方式的文档，以确定如何单独安装 Cargo。
|
||||
|
||||
### Hello, Cargo!
|
||||
|
||||
我们使用 Cargo 创建一个新的项目，并看看它与前面的 `hello_world` 项目有什么不同。回到你的项目目录（或者你自己选定的存放代码的位置）：
|
||||
|
||||
Linux 和 Mac:
|
||||
|
||||
```text
|
||||
$ cd ~/projects
|
||||
```
|
||||
|
||||
Windows:
|
||||
|
||||
```cmd
|
||||
> cd %USERPROFILE%\projects
|
||||
```
|
||||
|
||||
然后在任一操作系统中运行：
|
||||
|
||||
```text
|
||||
$ cargo new hello_cargo --bin
|
||||
$ cd hello_cargo
|
||||
```
|
||||
|
||||
我们将 `-bin` 参数传给了 `cargo new`，因为我们的目标是创建一个可执行的应用程序，而不是一个库。可执行文件二进制可执行文件，通常只称作**二进制文件**。我们将 `hello_cargo` 作为项目的名称，Cargo 在一个同名的目录中创建了相关文件，然后我们可以进到目录内。
|
||||
|
||||
如果我们在 *hello_cargo* 目录中列出文件，我们可以看到 Cargo 为我们生成了两个文件和一个目录：一个 *Cargo.toml*，以及一个带有 *main.rs* 文件的 *src* 目录。它还为我们在 *hello_cargo* 目录中初始化了一个新的 git 仓库，以及一个 *.gitignore* 文件；你可以通过使用 `--vcs` 标志更改成使用其他版本控制系统或不使用版本控制系统。
|
||||
|
||||
在您选择的文本编辑器中打开 *Cargo.toml*。它的内容看起来类似这样：
|
||||
|
||||
<span class="filename">文件：Cargo.toml</span>
|
||||
|
||||
```toml
|
||||
[package]
|
||||
name = "hello_cargo"
|
||||
version = "0.1.0"
|
||||
authors = ["Your Name <you@example.com>"]
|
||||
|
||||
[dependencies]
|
||||
```
|
||||
|
||||
此文件采用 [*TOML*][toml]<!-- ignore --> (Tom's Obvious, Minimal Language) 格式。TOML 类似于 INI，但有一些额外的好处，并用作 Cargo 的配置格式。
|
||||
|
||||
[toml]: https://github.com/toml-lang/toml
|
||||
|
||||
第一行 `[package]` 是一个小节标题，表示下面语句正在配置包。当我们向此文件添加更多信息时，我们将添加其他小节。
|
||||
|
||||
接下来的三行设置了 Cargo 需要查看的三个配置点，以便知道它应该编译你的程序：程序名称，版本号，编写作者。Cargo 将从您的环境中获取您的姓名和电子邮件信息。如果信息有误，请修正并保存文件。
|
||||
|
||||
最后一行 `[dependencies]` 是另一个小节的开始，此节可列出项目将要依赖的任意 *crates*（这是我们对 Rust 代码的包的称呼），从而让 Cargo 知道下载和编译这些内容。我们在此项目不需要任何 cretes，但下一章节中的猜数字游戏就需要了。
|
||||
|
||||
现在我们来看看 *src/main.rs*:
|
||||
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
println!("Hello, world!");
|
||||
}
|
||||
```
|
||||
|
||||
Cargo 生成了一个“Hello, world!”，就像我们前面编写过的一样。所以这一部分是一样的。之前的项目和 Cargo 生成的项目之间的差异，我们目前看到的是：
|
||||
|
||||
- 我们的代码放在 *src* 目录中
|
||||
- 项目的顶层包含一个 *Cargo.toml* 配置文件
|
||||
|
||||
Cargo 期望您的源文件位于 *src* 目录中，以便顶层项目目录只存放 READMEs（说明文档）、license（许可证信息）、配置文件，以及任何与代码无关的其他内容。像这样，Cargo 可以保持项目美观且整洁。物各有其位，物各在其位（原文：There's a place for everything, and everything is in its place）。
|
||||
|
||||
如果你启动了一个不使用 Cargo 的项目，正如我们在 *hello_world* 目录中的项目所做的一样，你可以通过将源代码移动到 *src* 目录并创建一个合适的 *Cargo.toml*，就可以达到和 Cargo 创建的项目一样。
|
||||
|
||||
### 构建并运行一个 Cargo 项目
|
||||
|
||||
现在我们来看看通过 Cargo 构建和运行 “Hello Wrold” 程序不同之处。为此，请输入以下命令：
|
||||
|
||||
```text
|
||||
$ cargo build
|
||||
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
|
||||
```
|
||||
|
||||
这应该已经在 *target/debug/hello_cargo*（或 Windows 上的 *target\debug\hello_cargo.exe*）中创建了一个可执行文件，您可以使用此命令运行：
|
||||
|
||||
```text
|
||||
$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows
|
||||
Hello, world!
|
||||
```
|
||||
|
||||
如果一切顺利，“Hello, world!” 将再次打印到终端。
|
||||
|
||||
第一次运行 `cargo build` 也会触发 Cargo 在顶层目录创建一个名为 *Cargo.lock* 的新文件，其格式如下：
|
||||
|
||||
<span class="filename">文件名： Cargo.lock</span>
|
||||
|
||||
```toml
|
||||
[root]
|
||||
name = "hello_cargo"
|
||||
version = "0.1.0"
|
||||
```
|
||||
|
||||
Cargo 使用 *Cargo.lock* 来保持跟踪应用程序中的依赖关系。本项目没有依赖，所以内容有点少。实际上，你不需要自己接触这个文件；交给 Cargo 处理就可以了。
|
||||
|
||||
我们刚刚使用 `cargo build` 构建项目并使用 `./target/debug/hello_cargo`来运行，其实我们也可以使用 `cargo run` 来编译并运行：
|
||||
|
||||
```text
|
||||
$ cargo run
|
||||
Running `target/debug/hello_cargo`
|
||||
Hello, world!
|
||||
```
|
||||
|
||||
注意，这一次我们并没有见到输出结果告诉我们 Cargo 正在编译 `hello_cargo`。Cargo 推断出文件并没有改变，所以它只是运行二进制文件。如果你修改了源代码，Cargo 将在运行它之前重新构建项目，你会看到像这样的内容：
|
||||
|
||||
```text
|
||||
$ cargo run
|
||||
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
|
||||
Running `target/debug/hello_cargo`
|
||||
Hello, world!
|
||||
```
|
||||
|
||||
所以现在我们看到了更多的差异：
|
||||
|
||||
- 不使用 `rustc`，而使用 `cargo build` 构建项目（或使用 `cargo run` 一次性构建并运行）
|
||||
- Cargo 构建的结果不和代码放在同一目录，而是将它放到 *target/debug* 目录中。
|
||||
|
||||
使用 Cargo 的另一个优点是无论您用什么操作系统，命令都是相同的。所以到了这点，我们将不再为 Linux 或 Mac 提供特定的指令。
|
||||
|
||||
|
||||
### 为发布构建
|
||||
|
||||
当您的项目最终准备发布时，你可以使用 `cargo build --release` 加上优化来编译项目。这将在 *target/release* （而不是在 *target/debug*）上创建一个可执行文件。这些优化可以使 Rust 代码运行更快，但打开它们后会使程序的编译时间变得更长。这就是有两个不同的配置文件的原因：一个用于开发，适用于快速重新构建和频繁更新的情况；另一个用于构建最终的程序，交付给用户，不考虑重新构建，且希望运行尽可能快。如果你要对代码运行进行基准测试，请确保运行 `cargo build --release` 并使用 *target/release* 的可执行文件进行基准测试。
|
||||
|
||||
### 约定使用 Cargo
|
||||
|
||||
在简单项目中，Cargo 相比仅仅使用 `rustc` 并没有提供太多价值，但持续使用后将会证明它的价值所在。在由多个 crates 组成的复杂项目，使用 Cargo 整合构建则明显更加便利。有了 Cargo，你只需运行 `cargo build`，它就会恰当的方式工作。即使本项目很简单，但它也用到了很多真正的实用工具，并可用于后续使用 Rust 的开发中。事实上，您可以使用以下命令开始使用几乎所有要处理的 Rust 项目：
|
||||
|
||||
```text
|
||||
$ git clone someurl.com/someproject
|
||||
$ cd someproject
|
||||
$ cargo build
|
||||
```
|
||||
|
||||
> 注意：如果你想了解 Cargo 的更多详情，请查看官方的 [Cargo 指南][Cargo guide]，这涵盖了它所有的特性。
|
||||
|
||||
[Cargo guide]: http://doc.crates.io/guide.html
|
||||
[troubleshooting]: ch01-01-installation.html#troubleshooting
|
||||
|
||||
@ -4,9 +4,9 @@ Cargo 是 Rust 的构建系统和包管理器。大多数 Rustacean 们使用 Ca
|
||||
|
||||
最简单的 Rust 程序，比如我们刚刚编写的，没有任何依赖。所以如果使用 Cargo 来构建 “Hello, world!” 项目，将只会用到 Cargo 构建代码的那部分功能。在编写更复杂的 Rust 程序时，你将添加依赖项，如果使用 Cargo 启动项目，则添加依赖项将更容易。
|
||||
|
||||
由于绝大多数 Rust 项目使用 Cargo，本书接下来的部分假设你也使用 Cargo。如果使用 [“安装”][installation] 部分介绍的官方安装包的话，则自带了 Cargo。如果通过其他方式安装的话，可以在终端输入如下命令检查是否安装了 Cargo：
|
||||
由于绝大多数 Rust 项目使用 Cargo，本书接下来的部分假设你也使用 Cargo。如果使用 [“安装”][installation]<!-- ignore --> 部分介绍的官方安装包的话，则自带了 Cargo。如果通过其他方式安装的话，可以在终端输入如下命令检查是否安装了 Cargo：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ cargo --version
|
||||
```
|
||||
|
||||
@ -16,20 +16,22 @@ $ cargo --version
|
||||
|
||||
我们使用 Cargo 创建一个新项目，然后看看与上面的 Hello, world! 项目有什么不同。回到 *projects* 目录（或者你存放代码的目录）。接着，可在任何操作系统下运行以下命令：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ cargo new hello_cargo
|
||||
$ cd hello_cargo
|
||||
```
|
||||
|
||||
第一行命令新建了名为 *hello_cargo* 的目录。我们将项目命名为 *hello_cargo*，同时 Cargo 在一个同名目录中创建项目文件。
|
||||
|
||||
进入 *hello_cargo* 目录并列出文件。将会看到 Cargo 生成了两个文件和一个目录：一个 *Cargo.toml* 文件，一个 *src* 目录，以及位于 *src* 目录中的 *main.rs* 文件。它也在 *hello_cargo* 目录初始化了一个 git 仓库，以及一个 *.gitignore* 文件。
|
||||
进入 *hello_cargo* 目录并列出文件。将会看到 Cargo 生成了两个文件和一个目录：一个 *Cargo.toml* 文件，一个 *src* 目录，以及位于 *src* 目录中的 *main.rs* 文件。
|
||||
|
||||
> 注意：Git 是一个常用的版本控制系统（version control system， VCS）。可以通过 `--vcs` 参数使 `cargo new` 切换到其它版本控制系统（VCS），或者不使用 VCS。运行 `cargo new --help` 参看可用的选项。
|
||||
它也在 *hello_cargo* 目录初始化了一个 Git 仓库，以及一个 *.gitignore* 文件。如果您 `cargo new` 在现有的 Git 仓库中运行，则不会生成 Git 文件；您可以使用 `cargo new --vcs=git` 来覆盖此行为。
|
||||
|
||||
请自行选用文本编辑器打开 *Cargo.toml* 文件。它应该看起来如示例 1-2 所示：
|
||||
> 注意：Git 是一个常用的版本控制系统（version control system， VCS）。可以通过 `--vcs` 参数使 `cargo new` 切换到其它版本控制系统，或者不使用 VCS。运行 `cargo new --help` 参看可用的选项。
|
||||
|
||||
<span class="filename">文件名: Cargo.toml</span>
|
||||
使用你喜欢的文本编辑器打开 *Cargo.toml* 文件。它应该看起来如示例 1-2 所示：
|
||||
|
||||
<span class="filename">文件名：Cargo.toml</span>
|
||||
|
||||
```toml
|
||||
[package]
|
||||
@ -41,21 +43,19 @@ edition = "2018"
|
||||
[dependencies]
|
||||
```
|
||||
|
||||
<span class="caption">示例 1-2: *cargo new* 命令生成的 *Cargo.toml* 的内容</span>
|
||||
<span class="caption">示例 1-2：*cargo new* 命令生成的 *Cargo.toml* 的内容</span>
|
||||
|
||||
这个文件使用 [*TOML*][toml]<!-- ignore --> (*Tom's Obvious, Minimal Language*) 格式，这是 Cargo 配置文件的格式。
|
||||
|
||||
[toml]: https://github.com/toml-lang/toml
|
||||
这个文件使用 [*TOML*](https://toml.io)<!-- ignore --> (*Tom's Obvious, Minimal Language*) 格式，这是 Cargo 配置文件的格式。
|
||||
|
||||
第一行，`[package]`，是一个片段（section）标题，表明下面的语句用来配置一个包。随着我们在这个文件增加更多的信息，还将增加其他片段（section）。
|
||||
|
||||
接下来的四行设置了 Cargo 编译程序所需的配置：项目的名称、版本、作者以及要使用的 Rust 版本。Cargo 从环境中获取你的名字和 email 信息，所以如果这些信息不正确，请修改并保存此文件。附录 E 会介绍 `edition` 的值。
|
||||
接下来的四行设置了 Cargo 编译程序所需的配置：项目的名称、版本、作者以及要使用的 Rust 版本。Cargo 从环境中获取你的名字和 email 信息，所以如果这些信息不正确，请修改并保存此文件。附录 E 会介绍 `edition`（译注：Rust 的核心版本，即 2015、2018、2021 版等） 的值。
|
||||
|
||||
最后一行，`[dependencies]`，是罗列项目依赖的片段的开始。在 Rust 中，代码包被称为 *crates*。这个项目并不需要其他的 crate，不过在第二章的第一个项目会用到依赖，那时会用得上这个片段。
|
||||
最后一行的 `[dependencies]` 是罗列项目依赖的片段的开始。在 Rust 中，代码包被称为 *crate*。这个项目并不需要其他的 crate，不过在第 2 章的第一个项目会用到依赖，那时会用得上这个片段。
|
||||
|
||||
现在打开 *src/main.rs* 看看：
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
@ -63,17 +63,17 @@ fn main() {
|
||||
}
|
||||
```
|
||||
|
||||
Cargo 为你生成了一个 “Hello, world!” 程序，正如我们之前编写的示例 1-1！目前为止，之前项目与 Cargo 生成项目的区别是 Cargo 将代码放在 *src* 目录，同时项目根目录包含一个 *Cargo.toml* 配置文件。
|
||||
Cargo 生成了一个 “Hello, world!” 程序，正如我们之前编写的示例 1-1！到目前为止，之前项目与 Cargo 生成项目的区别是 Cargo 将代码放在 *src* 目录，同时项目根目录包含一个 *Cargo.toml* 配置文件。
|
||||
|
||||
Cargo 期望源文件存放在 *src* 目录中。项目根目录只存放 README、license 信息、配置文件和其他跟代码无关的文件。使用 Cargo 帮助你保持项目干净整洁，一切井井有条。
|
||||
Cargo 期望源文件存放在 *src* 目录中。项目根目录只存放说明文件（README）、许可协议（license）信息、配置文件和其他跟代码无关的文件。使用 Cargo 可帮助你保持项目干净整洁，一切井井有条。
|
||||
|
||||
如果没有使用 Cargo 开始项目，比如我们创建的 Hello,world! 项目，可以将其转化为一个 Cargo 项目。将代码放入 *src* 目录，并创建一个合适的 *Cargo.toml* 文件。
|
||||
对于没有使用 Cargo 开始项目，比如我们创建的 Hello,world! 项目，你可以将其转化为一个 Cargo 项目。将代码放入 *src* 目录，并创建一个合适的 *Cargo.toml* 文件。
|
||||
|
||||
### 构建并运行 Cargo 项目
|
||||
|
||||
现在让我们看看通过 Cargo 构建和运行 “Hello, world!” 程序有什么不同！在 *hello_cargo* 目录下，输入下面的命令来构建项目：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ cargo build
|
||||
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs
|
||||
@ -81,7 +81,7 @@ $ cargo build
|
||||
|
||||
这个命令会创建一个可执行文件 *target/debug/hello_cargo* （在 Windows 上是 *target\debug\hello_cargo.exe*），而不是放在目前目录下。可以通过这个命令运行可执行文件：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ ./target/debug/hello_cargo # 或者在 Windows 下为 .\target\debug\hello_cargo.exe
|
||||
Hello, world!
|
||||
```
|
||||
@ -90,7 +90,7 @@ Hello, world!
|
||||
|
||||
我们刚刚使用 `cargo build` 构建了项目，并使用 `./target/debug/hello_cargo` 运行了程序，也可以使用 `cargo run` 在一个命令中同时编译并运行生成的可执行文件：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ cargo run
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
|
||||
Running `target/debug/hello_cargo`
|
||||
@ -99,7 +99,7 @@ Hello, world!
|
||||
|
||||
注意这一次并没有出现表明 Cargo 正在编译 `hello_cargo` 的输出。Cargo 发现文件并没有被改变，就直接运行了二进制文件。如果修改了源文件的话，Cargo 会在运行之前重新构建项目，并会出现像这样的输出：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ cargo run
|
||||
Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
|
||||
@ -109,39 +109,40 @@ Hello, world!
|
||||
|
||||
Cargo 还提供了一个叫 `cargo check` 的命令。该命令快速检查代码确保其可以编译，但并不产生可执行文件：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ cargo check
|
||||
Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs
|
||||
```
|
||||
|
||||
为什么你会不需要可执行文件呢？通常 `cargo check` 要比 `cargo build` 快得多，因为它省略了生成可执行文件的步骤。如果你在编写代码时持续的进行检查，`cargo check` 会加速开发！为此很多 Rustaceans 编写代码时定期运行 `cargo check` 确保它们可以编译。当准备好使用可执行文件时才运行 `cargo build`。
|
||||
为什么你会不需要可执行文件呢？通常 `cargo check` 要比 `cargo build` 快得多，因为它省略了生成可执行文件的步骤。如果你在编写代码时持续的进行检查，`cargo check` 会加速开发！为此很多 Rustacean 编写代码时定期运行 `cargo check` 确保它们可以编译。当准备好使用可执行文件时才运行 `cargo build`。
|
||||
|
||||
我们回顾下已学习的 Cargo 内容：
|
||||
|
||||
* 可以使用 `cargo build` 或 `cargo check` 构建项目。
|
||||
* 可以使用 `cargo build` 构建项目。
|
||||
* 可以使用 `cargo run` 一步构建并运行项目。
|
||||
* 可以使用 `cargo check` 构建项目而无需生成二进制文件来检查错误。
|
||||
* 有别于将构建结果放在与源码相同的目录，Cargo 会将其放到 *target/debug* 目录。
|
||||
|
||||
使用 Cargo 的一个额外的优点是，不管你使用什么操作系统，其命令都是一样的。所以从现在开始本书将不再为 Linux 和 macOS 以及 Windows 提供相应的命令。
|
||||
使用 Cargo 的一个额外的优点是，不管你使用什么操作系统，其命令都是一样的。所以从现在开始本书将不再为 Linux 和 macOS 以及 Windows 提供平台特定的命令。
|
||||
|
||||
### 发布（release）构建
|
||||
### 发布构建
|
||||
|
||||
当项目最终准备好发布时，可以使用 `cargo build --release` 来优化编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。这也就是为什么会有两种不同的配置：一种是为了开发，你需要经常快速重新构建；另一种是为用户构建最终程序，它们不会经常重新构建，并且希望程序运行得越快越好。如果你在测试代码的运行时间，请确保运行 `cargo build --release` 并使用 *target/release* 下的可执行文件进行测试。
|
||||
当项目最终准备好发布时，可以使用 `cargo build --release` 来优化编译项目。这会在 *target/release* 而不是 *target/debug* 下生成可执行文件。这些优化可以让 Rust 代码运行的更快，不过启用这些优化也需要消耗更长的编译时间。这也就是为什么会有两种不同的配置：一种是为了开发，你需要经常快速重新构建；另一种是为用户构建最终程序，它们不会经常重新构建，并且希望程序运行得越快越好。如果你要对代码运行时间进行基准测试，请确保运行 `cargo build --release` 并使用 *target/release* 下的可执行文件进行测试。
|
||||
|
||||
### 把 Cargo 当作习惯
|
||||
|
||||
对于简单项目， Cargo 并不比 `rustc` 提供了更多的优势，不过随着开发的深入，终将证明其价值。对于拥有多个 crate 的复杂项目，交给 Cargo 来协调构建将简单的多。
|
||||
|
||||
即便 `hello_cargo` 项目十分简单，它现在也使用了很多在你之后的 Rust 生涯将会用到的实用工具。其实，要在任何已存在的项目上工作时，可以使用如下命令通过 Git 检出代码，移动到该项目目录并构建：
|
||||
即便 `hello_cargo` 项目十分简单，它现在也使用了很多在你之后的 Rust 生涯将会用到的实用工具。实际中，要在任何已存在的项目上构建时，可以使用下面命令通过 Git 检出代码，进入到该项目目录并构建：
|
||||
|
||||
```text
|
||||
$ git clone someurl.com/someproject
|
||||
```console
|
||||
$ git clone example.org/someproject
|
||||
$ cd someproject
|
||||
$ cargo build
|
||||
```
|
||||
|
||||
关于更多 Cargo 的信息，请查阅 [其文档][its documentation]。
|
||||
关于更多 Cargo 的信息，请查阅[对应文档][its documentation]。
|
||||
|
||||
[its documentation]: https://doc.rust-lang.org/cargo/
|
||||
|
||||
@ -153,8 +154,8 @@ $ cargo build
|
||||
* 更新到新版的 Rust
|
||||
* 打开本地安装的文档
|
||||
* 直接通过 `rustc` 编写并运行 Hello, world! 程序
|
||||
* 使用 Cargo 创建并运行新项目
|
||||
* 使用更常用的 Cargo 创建并运行新项目
|
||||
|
||||
是时候通过构建更实质性的程序来熟悉读写 Rust 代码了。所以在第二章我们会构建一个猜猜看游戏程序。如果你更愿意从学习 Rust 常用的编程概念开始，请阅读第三章，接着再回到第二章。
|
||||
是时候通过构建更具强大的程序来熟悉阅读和编写 Rust 代码了。所以在第 2 章我们会构建一个猜数字游戏程序。如果你更愿意从学习 Rust 常用的编程概念开始，请阅读第 3 章，接着再回到第 2 章。
|
||||
|
||||
[installation]: ch01-01-installation.html#installation
|
||||
[installation]: ch01-01-installation.html#安装
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
|
||||
要创建一个新项目，进入第一章中创建的 *projects* 目录，使用 Cargo 新建一个项目，如下：
|
||||
|
||||
```text
|
||||
```console
|
||||
$ cargo new guessing_game
|
||||
$ cd guessing_game
|
||||
```
|
||||
@ -17,38 +17,26 @@ $ cd guessing_game
|
||||
|
||||
看看生成的 *Cargo.toml* 文件：
|
||||
|
||||
<span class="filename">文件名: Cargo.toml</span>
|
||||
<span class="filename">文件名：Cargo.toml</span>
|
||||
|
||||
```toml
|
||||
[package]
|
||||
name = "guessing_game"
|
||||
version = "0.1.0"
|
||||
authors = ["Your Name <you@example.com>"]
|
||||
edition = "2018"
|
||||
|
||||
[dependencies]
|
||||
{{#include ../listings/ch02-guessing-game-tutorial/no-listing-01-cargo-new/Cargo.toml}}
|
||||
```
|
||||
|
||||
如果 Cargo 从环境中获取的开发者信息不正确，修改这个文件并再次保存。
|
||||
|
||||
正如第一章那样，`cargo new` 生成了一个 “Hello, world!” 程序。查看 *src/main.rs* 文件：
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust
|
||||
fn main() {
|
||||
println!("Hello, world!");
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/no-listing-01-cargo-new/src/main.rs}}
|
||||
```
|
||||
|
||||
现在使用 `cargo run` 命令，一步完成 “Hello, world!” 程序的编译和运行：
|
||||
|
||||
```text
|
||||
$ cargo run
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 1.50 secs
|
||||
Running `target/debug/guessing_game`
|
||||
Hello, world!
|
||||
```console
|
||||
{{#include ../listings/ch02-guessing-game-tutorial/no-listing-01-cargo-new/output.txt}}
|
||||
```
|
||||
|
||||
当你需要在项目中快速迭代时，`run` 命令就能派上用场，正如我们在这个游戏项目中做的，在下一次迭代之前快速测试每一次迭代。
|
||||
@ -59,23 +47,10 @@ Hello, world!
|
||||
|
||||
猜数字程序的第一部分请求和处理用户输入，并检查输入是否符合预期的格式。首先，允许玩家输入猜测。在 *src/main.rs* 中输入示例 2-1 中的代码。
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore
|
||||
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);
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:all}}
|
||||
```
|
||||
|
||||
<span class="caption">示例 2-1：获取用户猜测并打印的代码</span>
|
||||
@ -83,7 +58,7 @@ fn main() {
|
||||
这些代码包含很多信息，我们一行一行地过一遍。为了获取用户输入并打印结果作为输出，我们需要将 `io`（输入/输出）库引入当前作用域。`io` 库来自于标准库（也被称为 `std`）：
|
||||
|
||||
```rust,ignore
|
||||
use std::io;
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:io}}
|
||||
```
|
||||
|
||||
默认情况下，Rust 将 [*prelude*][prelude]<!-- ignore --> 模块中少量的类型引入到每个程序的作用域中。如果需要的类型不在 prelude 中，你必须使用 `use` 语句显式地将其引入作用域。`std::io` 库提供很多有用的功能，包括接收用户输入的功能。
|
||||
@ -93,7 +68,7 @@ use std::io;
|
||||
如第一章所提及，`main` 函数是程序的入口点：
|
||||
|
||||
```rust,ignore
|
||||
fn main() {
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:main}}
|
||||
```
|
||||
|
||||
`fn` 语法声明了一个新函数，`()` 表明没有参数，`{` 作为函数体的开始。
|
||||
@ -101,9 +76,7 @@ fn main() {
|
||||
第一章也提及了 `println!` 是一个在屏幕上打印字符串的宏：
|
||||
|
||||
```rust,ignore
|
||||
println!("Guess the number!");
|
||||
|
||||
println!("Please input your guess.");
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:print}}
|
||||
```
|
||||
|
||||
这些代码仅仅打印提示，介绍游戏的内容然后请求用户输入。
|
||||
@ -113,7 +86,7 @@ println!("Please input your guess.");
|
||||
接下来，创建一个储存用户输入的地方，像这样：
|
||||
|
||||
```rust,ignore
|
||||
let mut guess = String::new();
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:string}}
|
||||
```
|
||||
|
||||
现在程序开始变得有意思了！这一小行代码发生了很多事。注意这是一个 `let` 语句，用来创建 **变量**（*variable*）。这里是另外一个例子：
|
||||
@ -122,14 +95,14 @@ let mut guess = String::new();
|
||||
let foo = bar;
|
||||
```
|
||||
|
||||
这行代码新建了一个叫做 `foo` 的变量并把它绑定到值 `bar` 上。在 Rust 中，变量默认是不可变的。我们将会在第三章的 [“变量与可变性”][variables-and-mutability] 部分详细讨论这个概念。下面的例子展示了如何在变量名前使用 `mut` 来使一个变量可变：
|
||||
这行代码新建了一个叫做 `foo` 的变量并把它绑定到值 `bar` 上。在 Rust 中，变量默认是不可变的。我们将会在第三章的 [“变量与可变性”][variables-and-mutability]<!-- ignore --> 部分详细讨论这个概念。下面的例子展示了如何在变量名前使用 `mut` 来使一个变量可变：
|
||||
|
||||
```rust,ignore
|
||||
let foo = 5; // 不可变
|
||||
let mut bar = 5; // 可变
|
||||
```
|
||||
|
||||
> 注意：`//` 语法开始一个注释，持续到行尾。Rust 忽略注释中的所有内容，第三章将会详细介绍注释。
|
||||
> 注意：`//` 语法开始一个注释，持续到行尾。Rust 忽略注释中的所有内容，第 3 章将会详细介绍注释。
|
||||
|
||||
让我们回到猜数字程序中。现在我们知道了 `let mut guess` 会引入一个叫做 `guess` 的可变变量。等号（`=`）的右边是 `guess` 所绑定的值，它是 `String::new` 的结果，这个函数会返回一个 `String` 的新实例。[`String`][string]<!-- ignore --> 是一个标准库提供的字符串类型，它是 UTF-8 编码的可增长文本块。
|
||||
|
||||
@ -144,8 +117,7 @@ let mut bar = 5; // 可变
|
||||
回忆一下，我们在程序的第一行使用 `use std::io;` 从标准库中引入了输入/输出功能。现在调用 `io` 库中的函数 `stdin`：
|
||||
|
||||
```rust,ignore
|
||||
io::stdin().read_line(&mut guess)
|
||||
.expect("Failed to read line");
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:read}}
|
||||
```
|
||||
|
||||
如果程序的开头没有 `use std::io` 这一行，可以把函数调用写成 `std::io::stdin`。`stdin` 函数返回一个 [`std::io::Stdin`][iostdin]<!-- ignore --> 的实例，这代表终端标准输入句柄的类型。
|
||||
@ -158,14 +130,14 @@ io::stdin().read_line(&mut guess)
|
||||
|
||||
`read_line` 的工作是，无论用户在标准输入中键入什么内容，都将其存入一个字符串中，因此它需要字符串作为参数。这个字符串参数应该是可变的，以便 `read_line` 将用户输入附加上去。
|
||||
|
||||
`&` 表示这个参数是一个 **引用**（*reference*），它允许多处代码访问同一处数据，而无需在内存中多次拷贝。引用是一个复杂的特性，Rust 的一个主要优势就是安全而简单的操纵引用。完成当前程序并不需要了解如此多细节。现在，我们只需知道它像变量一样，默认是不可变的。因此，需要写成 `&mut guess` 来使其可变，而不是 `&guess`。（第四章会更全面的解释引用。）
|
||||
`&` 表示这个参数是一个 **引用**（*reference*），它允许多处代码访问同一处数据，而无需在内存中多次拷贝。引用是一个复杂的特性，Rust 的一个主要优势就是安全而简单的操纵引用。完成当前程序并不需要了解如此多细节。现在，我们只需知道它像变量一样，默认是不可变的。因此，需要写成 `&mut guess` 来使其可变，而不是 `&guess`。（第 4 章会更全面地解释引用。）
|
||||
|
||||
### 使用 `Result` 类型来处理潜在的错误
|
||||
|
||||
我们还没有完全分析完这行代码。虽然这是单独一行代码，但它是逻辑行（虽然换行了但仍是语句）的一部分。后一部分是这个方法：
|
||||
尽管我们现在正在讨论文本的第三行，但它仍然是逻辑代码行（虽然换行了但仍是语句）的一部分。下一部分是这个方法：
|
||||
|
||||
```rust,ignore
|
||||
.expect("Failed to read line");
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:expect}}
|
||||
```
|
||||
|
||||
当使用 `.foo()` 语法调用方法时，通过换行加缩进来把长行拆开是明智的。我们完全可以这样写：
|
||||
@ -174,14 +146,14 @@ io::stdin().read_line(&mut guess)
|
||||
io::stdin().read_line(&mut guess).expect("Failed to read line");
|
||||
```
|
||||
|
||||
不过，过长的行难以阅读，所以最好拆开来写，两个方法调用占两行。现在来看看这行代码干了什么。
|
||||
不过，过长的行难以阅读，所以最好拆开来写。现在来看看这行代码干了什么。
|
||||
|
||||
之前提到了 `read_line` 将用户输入附加到传递给它的字符串中，不过它也返回一个值——在这个例子中是 [`io::Result`][ioresult]<!-- ignore -->。Rust 标准库中有很多叫做 `Result` 的类型：一个通用的 [`Result`][result]<!-- ignore --> 以及在子模块中的特化版本，比如 `io::Result`。
|
||||
|
||||
[ioresult]: https://doc.rust-lang.org/std/io/type.Result.html
|
||||
[result]: https://doc.rust-lang.org/std/result/enum.Result.html
|
||||
|
||||
`Result` 类型是 [*枚举*（*enumerations*）][enums]<!-- ignore -->，通常也写作 *enums*。枚举类型持有固定集合的值，这些值被称为枚举的 **成员**（*variants*）。第六章将介绍枚举的更多细节。
|
||||
`Result` 类型是 [*枚举*（*enumeration*）][enums]<!-- ignore -->，通常也写作 *enums*。枚举类型持有固定集合的值，这些值被称为枚举的 **成员**（*variants*）。第 6 章将介绍枚举的更多细节。
|
||||
|
||||
[enums]: ch06-00-enums.html
|
||||
|
||||
@ -193,16 +165,8 @@ io::stdin().read_line(&mut guess).expect("Failed to read line");
|
||||
|
||||
如果不调用 `expect`，程序也能编译，不过会出现一个警告：
|
||||
|
||||
```text
|
||||
$ cargo build
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
warning: unused `std::result::Result` which must be used
|
||||
--> src/main.rs:10:5
|
||||
|
|
||||
10 | io::stdin().read_line(&mut guess);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: #[warn(unused_must_use)] on by default
|
||||
```console
|
||||
{{#include ../listings/ch02-guessing-game-tutorial/no-listing-02-without-expect/output.txt}}
|
||||
```
|
||||
|
||||
Rust 警告我们没有使用 `read_line` 的返回值 `Result`，说明有一个可能的错误没有处理。
|
||||
@ -214,7 +178,7 @@ Rust 警告我们没有使用 `read_line` 的返回值 `Result`，说明有一
|
||||
除了位于结尾的大括号，目前为止就只有这一行代码值得讨论一下了，就是这一行：
|
||||
|
||||
```rust,ignore
|
||||
println!("You guessed: {}", guess);
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-01/src/main.rs:print_guess}}
|
||||
```
|
||||
|
||||
这行代码打印存储用户输入的字符串。第一个参数是格式化字符串，里面的 `{}` 是预留在特定位置的占位符。使用 `{}` 也可以打印多个值：第一对 `{}` 使用格式化字符串之后的第一个值，第二对则使用第二个值，依此类推。调用一次 `println!` 打印多个值看起来像这样：
|
||||
@ -232,10 +196,16 @@ println!("x = {} and y = {}", x, y);
|
||||
|
||||
让我们来测试下猜数字游戏的第一部分。使用 `cargo run` 运行：
|
||||
|
||||
```text
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/listing-02-01/
|
||||
cargo clean
|
||||
cargo run
|
||||
input 6 -->
|
||||
|
||||
```console
|
||||
$ cargo run
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 6.44s
|
||||
Running `target/debug/guessing_game`
|
||||
Guess the number!
|
||||
Please input your guess.
|
||||
@ -255,37 +225,50 @@ You guessed: 6
|
||||
|
||||
记住，*crate* 是一个 Rust 代码包。我们正在构建的项目是一个 **二进制 crate**，它生成一个可执行文件。 `rand` crate 是一个 **库 crate**，库 crate 可以包含任意能被其他程序使用的代码。
|
||||
|
||||
Cargo 对外部 crate 的运用是其真正闪光的地方。在我们使用 `rand` 编写代码之前，需要修改 *Cargo.toml* 文件，引入一个 `rand` 依赖。现在打开这个文件并在底部的 `[dependencies]` 片段标题之下添加：
|
||||
Cargo 对外部 crate 的运用是其真正的亮点。在我们使用 `rand` 编写代码之前，需要修改 *Cargo.toml* 文件，引入一个 `rand` 依赖。现在打开这个文件并在底部的 `[dependencies]` 片段标题之下添加。请确保 `rand` 完全按照此处的说明进行指定，否则本教程中的代码示例可能无法正常工作。
|
||||
|
||||
<span class="filename">文件名: Cargo.toml</span>
|
||||
<!-- When updating the version of `rand` used, also update the version of
|
||||
`rand` used in these files so they all match:
|
||||
* ch07-04-bringing-paths-into-scope-with-the-use-keyword.md
|
||||
* ch14-03-cargo-workspaces.md
|
||||
-->
|
||||
|
||||
<span class="filename">文件名：Cargo.toml</span>
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
|
||||
rand = "0.5.5"
|
||||
{{#include ../listings/ch02-guessing-game-tutorial/listing-02-02/Cargo.toml:9:}}
|
||||
```
|
||||
|
||||
在 *Cargo.toml* 文件中，标题以及之后的内容属同一个片段，直到遇到下一个标题才开始新的片段。`[dependencies]` 片段告诉 Cargo 本项目依赖了哪些外部 crate 及其版本。本例中，我们使用语义化版本 `0.5.5` 来指定 `rand` crate。Cargo 理解[语义化版本（Semantic Versioning）][semver]<!-- ignore -->（有时也称为 *SemVer*），这是一种定义版本号的标准。`0.5.5` 事实上是 `^0.5.5` 的简写，它表示 “任何与 0.5.5 版本公有 API 相兼容的版本”。
|
||||
在 *Cargo.toml* 文件中，表头以及之后的内容属同一个表块，直到遇到下一个表头才开始新的表块。`[dependencies]` 表头告诉 Cargo 本项目依赖了哪些外部 crate 及其版本。本例中，我们使用语义化版本 `0.8.3` 来指定 `rand` crate。Cargo 理解[语义化版本（Semantic Versioning）][semver]<!-- ignore -->（有时也称为 *SemVer*），这是一种定义版本号的标准。`0.8.3` 实际上是 `^0.8.3` 的简写，它表示任何至少包含 `0.8.3` 但低于 `0.9.0` 的版本。 Cargo 认为这些版本具有与 `0.8.3` 版本兼容的公有 API， 并且此规范可保证你获得能够让本章代码编译的包含最新补丁程序的版本。`0.9.0` 或更高版本则不再确保 API 和以下示例所使用的 API 相同。
|
||||
|
||||
[semver]: http://semver.org
|
||||
|
||||
现在，不修改任何代码，构建项目，如示例 2-2 所示：
|
||||
现在，不修改任何代码就可以构建项目，如示例 2-2 所示：
|
||||
|
||||
```text
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/listing-02-02/
|
||||
cargo clean
|
||||
cargo build -->
|
||||
|
||||
```console
|
||||
$ cargo build
|
||||
Updating crates.io index
|
||||
Downloaded rand v0.5.5
|
||||
Downloaded libc v0.2.62
|
||||
Downloaded rand_core v0.2.2
|
||||
Downloaded rand_core v0.3.1
|
||||
Downloaded rand_core v0.4.2
|
||||
Compiling rand_core v0.4.2
|
||||
Compiling libc v0.2.62
|
||||
Compiling rand_core v0.3.1
|
||||
Compiling rand_core v0.2.2
|
||||
Compiling rand v0.5.5
|
||||
Downloaded rand v0.8.3
|
||||
Downloaded libc v0.2.86
|
||||
Downloaded getrandom v0.2.2
|
||||
Downloaded cfg-if v1.0.0
|
||||
Downloaded ppv-lite86 v0.2.10
|
||||
Downloaded rand_chacha v0.3.0
|
||||
Downloaded rand_core v0.6.2
|
||||
Compiling rand_core v0.6.2
|
||||
Compiling libc v0.2.86
|
||||
Compiling getrandom v0.2.2
|
||||
Compiling cfg-if v1.0.0
|
||||
Compiling ppv-lite86 v0.2.10
|
||||
Compiling rand_chacha v0.3.0
|
||||
Compiling rand v0.8.3
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 2.53 s
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 2.53s
|
||||
```
|
||||
|
||||
<span class="caption">示例 2-2: 将 rand crate 添加为依赖之后运行 `cargo build` 的输出</span>
|
||||
@ -296,13 +279,18 @@ $ cargo build
|
||||
|
||||
[cratesio]: https://crates.io
|
||||
|
||||
在更新完 registry 后，Cargo 检查 `[dependencies]` 片段并下载缺失的 crate 。本例中，虽然只声明了 `rand` 一个依赖，然而 Cargo 还是额外获取了 `libc` 和 `rand_core` 的拷贝，因为 `rand` 依赖 `libc` 和 `rand_core` 来正常工作。下载完成后，Rust 编译依赖，然后使用这些依赖编译项目。
|
||||
在更新完 registry 后，Cargo 检查 `[dependencies]` 表块并下载缺失的 crate 。本例中，虽然只声明了 `rand` 一个依赖，然而 Cargo 还是额外获取了 `libc` 和 `rand_core` 的拷贝，因为 `rand` 依赖 `libc` 和 `rand_core` 来正常工作。下载完成后，Rust 编译依赖，然后使用这些依赖编译项目。
|
||||
|
||||
如果不做任何修改，立刻再次运行 `cargo build`，则不会看到任何除了 `Finished` 行之外的输出。Cargo 知道它已经下载并编译了依赖，同时 *Cargo.toml* 文件也没有变动。Cargo 还知道代码也没有任何修改，所以它不会重新编译代码。因为无事可做，它简单的退出了。
|
||||
|
||||
如果打开 *src/main.rs* 文件，做一些无关紧要的修改，保存并再次构建，则会出现两行输出：
|
||||
|
||||
```text
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/listing-02-02/
|
||||
touch src/main.rs
|
||||
cargo build -->
|
||||
|
||||
```console
|
||||
$ cargo build
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs
|
||||
@ -312,25 +300,31 @@ $ cargo build
|
||||
|
||||
#### *Cargo.lock* 文件确保构建是可重现的
|
||||
|
||||
Cargo 有一个机制来确保任何人在任何时候重新构建代码，都会产生相同的结果：Cargo 只会使用你指定的依赖版本，除非你又手动指定了别的。例如，如果下周 `rand` crate 的 `0.5.6` 版本出来了，它修复了一个重要的 bug，同时也含有一个会破坏代码运行的缺陷，这时会发生什么呢？
|
||||
Cargo 有一个机制来确保任何人在任何时候重新构建代码，都会产生相同的结果：Cargo 只会使用你指定的依赖版本，除非你又手动指定了别的。例如，如果下周 `rand` crate 的 `0.8.4` 版本出来了，它修复了一个重要的 bug，同时也含有一个会破坏代码运行的缺陷，这时会发生什么呢？
|
||||
|
||||
这个问题的答案是 *Cargo.lock* 文件。它在第一次运行 `cargo build` 时创建，并放在 *guessing_game* 目录。当第一次构建项目时，Cargo 计算出所有符合要求的依赖版本并写入 *Cargo.lock* 文件。当将来构建项目时，Cargo 会发现 *Cargo.lock* 已存在并使用其中指定的版本，而不是再次计算所有的版本。这使得你拥有了一个自动化的可重现的构建。换句话说，项目会持续使用 `0.5.5` 直到你显式升级，多亏有了 *Cargo.lock* 文件。
|
||||
这个问题的答案是 *Cargo.lock* 文件。它在第一次运行 `cargo build` 时创建，并放在 *guessing_game* 目录。当第一次构建项目时，Cargo 计算出所有符合要求的依赖版本并写入 *Cargo.lock* 文件。当将来构建项目时，Cargo 会发现 *Cargo.lock* 已存在并使用其中指定的版本，而不是再次计算所有的版本。这使得你拥有了一个自动化的可重现的构建。换句话说，项目会持续使用 `0.8.3` 直到你显式地升级，多亏有了 *Cargo.lock* 文件。
|
||||
|
||||
#### 更新 crate 到一个新版本
|
||||
|
||||
当你 **确实** 需要升级 crate 时，Cargo 提供了另一个命令，`update`，它会忽略 *Cargo.lock* 文件，并计算出所有符合 *Cargo.toml* 声明的最新版本。如果成功了，Cargo 会把这些版本写入 *Cargo.lock* 文件。
|
||||
|
||||
不过，Cargo 默认只会寻找大于 `0.5.5` 而小于 `0.6.0` 的版本。如果 `rand` crate 发布了两个新版本，`0.5.6` 和 `0.6.0`，在运行 `cargo update` 时会出现如下内容：
|
||||
不过，Cargo 默认只会寻找大于 `0.8.3` 而小于 `0.9.0` 的版本。如果 `rand` crate 发布了两个新版本，`0.8.4` 和 `0.9.0`，在运行 `cargo update` 时会出现如下内容：
|
||||
|
||||
```text
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/listing-02-02/
|
||||
cargo update
|
||||
assuming there is a new 0.8.x version of rand; otherwise use another update
|
||||
as a guide to creating the hypothetical output shown here -->
|
||||
|
||||
```console
|
||||
$ cargo update
|
||||
Updating crates.io index
|
||||
Updating rand v0.5.5 -> v0.5.6
|
||||
Updating rand v0.8.3 -> v0.8.4
|
||||
```
|
||||
|
||||
这时，你也会注意到的 *Cargo.lock* 文件中的变化无外乎现在使用的 `rand` crate 版本是`0.5.6`
|
||||
在这一点上，你还会注意到 *Cargo.lock* 文件中发生了更改，并指出你正在使用的 `rand` crate 版本为 `0.8.4`。
|
||||
|
||||
如果想要使用 `0.6.0` 版本的 `rand` 或是任何 `0.6.x` 系列的版本，必须像这样更新 *Cargo.toml* 文件：
|
||||
如果要使用 `rand` 版本 `0.9.0` 或 `0.9.x` 系列中的任何版本，则必须像这样更新 *Cargo.toml* 文件：
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
@ -340,7 +334,7 @@ rand = "0.6.0"
|
||||
|
||||
下一次运行 `cargo build` 时，Cargo 会从 registry 更新可用的 crate，并根据你指定的新版本重新计算。
|
||||
|
||||
第十四章会讲到 [Cargo][doccargo]<!-- ignore --> 及其[生态系统][doccratesio]<!-- ignore --> 的更多内容，不过目前你只需要了解这么多。通过 Cargo 复用库文件非常容易，因此 Rustacean 能够编写出由很多包组装而成的更轻巧的项目。
|
||||
第 14 章会讲到 [Cargo][doccargo]<!-- ignore --> 及其[生态系统][doccratesio]<!-- ignore --> 的更多内容，不过目前你只需要了解这么多。通过 Cargo 复用库代码非常容易，因此 Rustacean 能够编写出由很多包组装而成的更轻巧的项目。
|
||||
|
||||
[doccargo]: http://doc.crates.io
|
||||
[doccratesio]: http://doc.crates.io/crates-io.html
|
||||
@ -349,53 +343,45 @@ rand = "0.6.0"
|
||||
|
||||
你已经把 `rand` crate 添加到 *Cargo.toml* 了，让我们开始使用 `rand`。下一步是更新 *src/main.rs*，如示例 2-3 所示。
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore
|
||||
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)
|
||||
.expect("Failed to read line");
|
||||
|
||||
println!("You guessed: {}", guess);
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-03/src/main.rs:all}}
|
||||
```
|
||||
|
||||
<span class="caption">示例 2-3：添加生成随机数的代码</span>
|
||||
|
||||
首先，我们新增了一行 `use`：`use rand::Rng`。`Rng` 是一个 trait，它定义了随机数生成器应实现的方法，想使用这些方法的话，此 trait 必须在作用域中。第十章会详细介绍 trait。
|
||||
首先，我们新增了一行 `use`：`use rand::Rng`。`Rng` 是一个 trait，它定义了随机数生成器应实现的方法，想使用这些方法的话，此 trait 必须在作用域中。第 10 章会详细介绍 trait。
|
||||
|
||||
接下来，我们在中间还新增加了两行。`rand::thread_rng` 函数提供实际使用的随机数生成器：它位于当前执行线程的本地环境中，并从操作系统获取 seed。接下来，调用随机数生成器的 `gen_range` 方法。这个方法由刚才引入到作用域的 `Rng` trait 定义。`gen_range` 方法获取两个数字作为参数，并生成一个范围在两者之间的随机数。它包含下限但不包含上限，所以需要指定 `1` 和 `101` 来请求一个 1 和 100 之间的数。
|
||||
接下来，我们在中间添加两行。`rand::thread_rng` 函数将为我们提供将要使用的特定随机数生成器：它位于当前执行线程的本地环境中，并从操作系统获取 seed。然后我们调用随机数生成器的 `gen_range` 方法。该方法由我们刚才使用 `use rand::Rng` 语句引入的 `Rng` trait 定义。`gen_range` 方法获得一个区间表达式（range expression）作为参数，并在区间内生成一个随机数。我们在这里使用的区间表达式采用的格式为 `start..end`。它包括起始端，但排除终止端。所以我们需要指定 `1..101` 生成一个 1 到 100 之间的数字。或者我们可以传入区间 `1..=100`，这和前面的表达等价。
|
||||
|
||||
> 注意：你不可能凭空就知道应该 use 哪个 trait 以及该从 crate 中调用哪个方法。crate 的使用说明位于其文档中。Cargo 有一个很棒的功能是：运行 `cargo doc --open` 命令来构建所有本地依赖提供的文档，并在浏览器中打开。例如，假设你对 `rand` crate 中的其他功能感兴趣，你可以运行 `cargo doc --open` 并点击左侧导航栏中的 `rand`。
|
||||
|
||||
新增加的第二行代码打印出了秘密数字。这在开发程序时很有用，因为可以测试它，不过在最终版本中会删掉它。如果游戏一开始就打印出结果就没什么可玩的了！
|
||||
新添加的第二行代码打印出了秘密数字。这在开发程序时很有用，因为可以测试它，不过在最终版本中会删掉它。如果游戏一开始就打印出结果就没什么可玩的了！
|
||||
|
||||
尝试运行程序几次：
|
||||
|
||||
```text
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/listing-02-03/
|
||||
cargo run
|
||||
4
|
||||
cargo run
|
||||
5
|
||||
-->
|
||||
|
||||
```console
|
||||
$ cargo run
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs
|
||||
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
|
||||
@ -410,25 +396,10 @@ You guessed: 5
|
||||
|
||||
现在有了用户输入和一个随机数，我们可以比较它们。这个步骤如示例 2-4 所示。注意这段代码还不能通过编译，我们稍后会解释。
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore,does_not_compile
|
||||
use std::io;
|
||||
use std::cmp::Ordering;
|
||||
use rand::Rng;
|
||||
|
||||
fn main() {
|
||||
|
||||
// ---snip---
|
||||
|
||||
println!("You guessed: {}", guess);
|
||||
|
||||
match guess.cmp(&secret_number) {
|
||||
Ordering::Less => println!("Too small!"),
|
||||
Ordering::Greater => println!("Too big!"),
|
||||
Ordering::Equal => println!("You win!"),
|
||||
}
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-04/src/main.rs:here}}
|
||||
```
|
||||
|
||||
<span class="caption">示例 2-4：处理比较两个数字可能的返回值</span>
|
||||
@ -439,78 +410,58 @@ fn main() {
|
||||
|
||||
[match]: ch06-02-match.html
|
||||
|
||||
一个 `match` 表达式由 **分支（arms）** 构成。一个分支包含一个 **模式**（*pattern*）和表达式开头的值与分支模式相匹配时应该执行的代码。Rust 获取提供给 `match` 的值并挨个检查每个分支的模式。`match` 结构和模式是 Rust 中强大的功能，它体现了代码可能遇到的多种情形，并帮助你确保没有遗漏处理。这些功能将分别在第六章和第十八章详细介绍。
|
||||
一个 `match` 表达式由 **分支（arms）** 构成。一个分支包含一个 **模式**（*pattern*）和表达式开头的值与分支模式相匹配时应该执行的代码。Rust 获取提供给 `match` 的值并挨个检查每个分支的模式。`match` 结构和模式是 Rust 中强大的功能，它体现了代码可能遇到的多种情形，并帮助你确保没有遗漏处理。这些功能将分别在第 6 章和第 18 章详细介绍。
|
||||
|
||||
让我们看看使用 `match` 表达式的例子。假设用户猜了 50，这时随机生成的秘密数字是 38。比较 50 与 38 时，因为 50 比 38 要大，`cmp` 方法会返回 `Ordering::Greater`。`Ordering::Greater` 是 `match` 表达式得到的值。它检查第一个分支的模式，`Ordering::Less` 与 `Ordering::Greater`并不匹配，所以它忽略了这个分支的代码并来到下一个分支。下一个分支的模式是 `Ordering::Greater`，**正确** 匹配！这个分支关联的代码被执行，在屏幕打印出 `Too big!`。`match` 表达式就此终止，因为该场景下没有检查最后一个分支的必要。
|
||||
让我们看看使用 `match` 表达式的例子。假设用户猜了 50，这时随机生成的秘密数字是 38。比较 50 与 38 时，因为 50 比 38 要大，`cmp` 方法会返回 `Ordering::Greater`。`Ordering::Greater` 是 `match` 表达式得到的值。它检查第一个分支的模式，`Ordering::Less` 与 `Ordering::Greater`并不匹配，所以它忽略了这个分支的代码并来到下一个分支。下一个分支的模式是 `Ordering::Greater`，**正确**匹配 `Ordering::Greater`！这个分支关联的代码被执行，在屏幕打印出 `Too big!`。`match` 表达式就此终止，因为该场景下没有检查最后一个分支的必要。
|
||||
|
||||
然而，示例 2-4 的代码并不能编译，可以尝试一下：
|
||||
|
||||
```text
|
||||
$ cargo build
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
error[E0308]: mismatched types
|
||||
--> src/main.rs:23:21
|
||||
|
|
||||
23 | match guess.cmp(&secret_number) {
|
||||
| ^^^^^^^^^^^^^^ expected struct `std::string::String`, found integer
|
||||
|
|
||||
= note: expected type `&std::string::String`
|
||||
= note: found type `&{integer}`
|
||||
|
||||
error: aborting due to previous error
|
||||
Could not compile `guessing_game`.
|
||||
```console
|
||||
{{#include ../listings/ch02-guessing-game-tutorial/listing-02-04/output.txt}}
|
||||
```
|
||||
|
||||
错误的核心表明这里有 **不匹配的类型**（*mismatched types*）。Rust 有一个静态强类型系统，同时也有类型推断。当我们写出 `let guess = String::new()` 时，Rust 推断出 `guess` 应该是 `String` 类型，并不需要我们写出类型。另一方面，`secret_number`，是数字类型。几个数字类型拥有 1 到 100 之间的值：32 位数字 `i32`；32 位无符号数字 `u32`；64 位数字 `i64` 等等。Rust 默认使用 `i32`，所以它是 `secret_number` 的类型，除非增加类型信息，或任何能让 Rust 推断出不同数值类型的信息。这里错误的原因在于 Rust 不会比较字符串类型和数字类型。
|
||||
|
||||
所以我们必须把从输入中读取到的 `String` 转换为一个真正的数字类型，才好与秘密数字进行比较。这可以通过在 `main` 函数体中增加如下两行代码来实现：
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore
|
||||
// --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!"),
|
||||
}
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/no-listing-03-convert-string-to-number/src/main.rs:here}}
|
||||
```
|
||||
|
||||
这两行新代码是：
|
||||
这行代码是：
|
||||
|
||||
```rust,ignore
|
||||
let guess: u32 = guess.trim().parse()
|
||||
.expect("Please type a number!");
|
||||
let guess: u32 = guess.trim().parse().expect("Please type a number!");
|
||||
```
|
||||
|
||||
这里创建了一个叫做 `guess` 的变量。不过等等，不是已经有了一个叫做 `guess` 的变量了吗？确实如此，不过 Rust 允许用一个新值来 **隐藏** （*shadow*） `guess` 之前的值。这个功能常用在需要转换值类型之类的场景。它允许我们复用 `guess` 变量的名字，而不是被迫创建两个不同变量，诸如 `guess_str` 和 `guess` 之类。（第三章会介绍 shadowing 的更多细节。）
|
||||
这里创建了一个叫做 `guess` 的变量。不过等等，不是已经有了一个叫做 `guess` 的变量了吗？确实如此，不过 Rust 允许用一个新值来 **遮蔽** （*shadow*） `guess` 之前的值。这个功能常用在需要转换值类型之类的场景。它允许我们复用 `guess` 变量的名字，而不是被迫创建两个不同变量，诸如 `guess_str` 和 `guess` 之类。（第 3 章会介绍变量遮蔽的更多细节。）
|
||||
|
||||
我们将 `guess` 绑定到 `guess.trim().parse()` 表达式上。表达式中的 `guess` 是包含输入的原始 `String` 类型。`String` 实例的 `trim` 方法会去除字符串开头和结尾的空白字符。`u32` 只能由数字字符转换，不过用户必须输入 <span class="keystroke">enter</span> 键才能让 `read_line` 返回，然而用户按下 <span class="keystroke">enter</span> 键时，会在字符串中增加一个换行（newline）符。例如，用户输入 <span class="keystroke">5</span> 并按下 <span class="keystroke">enter</span>，`guess` 看起来像这样：`5\n`。`\n` 代表 “换行”，回车键。`trim` 方法消除 `\n`，只留下 `5`。
|
||||
我们将 `guess` 绑定到 `guess.trim().parse()` 表达式上。表达式中的 `guess` 是包含输入的原始 `String` 类型。`String` 实例的 `trim` 方法会去除字符串开头和结尾的空白字符。`u32` 只能由数字字符转换，不过用户必须输入 <span class="keystroke">enter</span> 键才能让 `read_line` 返回，然而用户按下 <span class="keystroke">enter</span> 键时，会在字符串中增加一个换行（newline）符。例如，用户输入 <span class="keystroke">5</span> 并按下 <span class="keystroke">enter</span>，`guess` 看起来像这样：`5\n`。`\n` 代表 “换行”，回车键（在Windows中，按<span
|
||||
class="keystroke">enter</span>产生回车和换行符 `\r\n`）。`trim` 方法消除 `\n` 或 `\r\n`，只留下 `5`。
|
||||
|
||||
[字符串的 `parse` 方法][parse]<!-- ignore --> 将字符串解析成数字。因为这个方法可以解析多种数字类型，因此需要告诉 Rust 具体的数字类型，这里通过 `let guess: u32` 指定。`guess` 后面的冒号（`:`）告诉 Rust 我们指定了变量的类型。Rust 有一些内建的数字类型；`u32` 是一个无符号的 32 位整型。对于不大的正整数来说，它是不错的类型，第三章还会讲到其他数字类型。另外，程序中的 `u32` 注解以及与 `secret_number` 的比较，意味着 Rust 会推断出 `secret_number` 也是 `u32` 类型。现在可以使用相同类型比较两个值了！
|
||||
[字符串的 `parse` 方法][parse]<!-- ignore --> 将字符串解析成数字。因为这个方法可以解析多种数字类型，因此需要告诉 Rust 具体的数字类型，这里通过 `let guess: u32` 指定。`guess` 后面的冒号（`:`）告诉 Rust 我们指定了变量的类型。Rust 有一些内建的数字类型；`u32` 是一个无符号的 32 位整型。对于不大的正整数来说，它是不错的类型，第 3 章还会讲到其他数字类型。另外，程序中的 `u32` 注解以及与 `secret_number` 的比较，意味着 Rust 会推断出 `secret_number` 也是 `u32` 类型。现在可以使用相同类型比较两个值了！
|
||||
|
||||
[parse]: https://doc.rust-lang.org/std/primitive.str.html#method.parse
|
||||
|
||||
`parse` 调用很容易产生错误。例如，字符串中包含 `A👍%`，就无法将其转换为一个数字。因此，`parse` 方法返回一个 `Result` 类型。像之前 [“使用 `Result` 类型来处理潜在的错误”](#handling-potential-failure-with-the-result-type) 讨论的 `read_line` 方法那样，再次按部就班的用 `expect` 方法处理即可。如果 `parse` 不能从字符串生成一个数字，返回一个 `Result` 的 `Err` 成员时，`expect` 会使游戏崩溃并打印附带的信息。如果 `parse` 成功地将字符串转换为一个数字，它会返回 `Result` 的 `Ok` 成员，然后 `expect` 会返回 `Ok` 值中的数字。
|
||||
`parse` 调用很容易产生错误。例如，字符串中包含 `A👍%`，就无法将其转换为一个数字。因此，`parse` 方法返回一个 `Result` 类型。像之前 [“使用 `Result` 类型来处理潜在的错误”][handling-potential-failure-with-the-result-type]<!-- ignore
|
||||
-->) 讨论的 `read_line` 方法那样，再次按部就班地用 `expect` 方法处理即可。如果 `parse` 不能从字符串生成一个数字，返回一个 `Result` 的 `Err` 成员时，`expect` 会使游戏崩溃并打印附带的信息。如果 `parse` 成功地将字符串转换为一个数字，它会返回 `Result` 的 `Ok` 成员，然后 `expect` 会返回 `Ok` 值中的数字。
|
||||
|
||||
[handling-potential-failure-with-the-result-type]: #使用-result-类型来处理潜在的错误
|
||||
|
||||
现在让我们运行程序！
|
||||
|
||||
```text
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/no-listing-03-convert-string-to-number/
|
||||
cargo run
|
||||
76
|
||||
-->
|
||||
|
||||
```console
|
||||
$ cargo run
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 0.43 secs
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 0.43s
|
||||
Running `target/debug/guessing_game`
|
||||
Guess the number!
|
||||
The secret number is: 58
|
||||
@ -528,35 +479,32 @@ Too big!
|
||||
|
||||
`loop` 关键字创建了一个无限循环。将其加入后，用户可以反复猜测：
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore
|
||||
// --snip--
|
||||
|
||||
println!("The secret number is: {}", secret_number);
|
||||
|
||||
loop {
|
||||
println!("Please input your guess.");
|
||||
|
||||
// --snip--
|
||||
|
||||
match guess.cmp(&secret_number) {
|
||||
Ordering::Less => println!("Too small!"),
|
||||
Ordering::Greater => println!("Too big!"),
|
||||
Ordering::Equal => println!("You win!"),
|
||||
}
|
||||
}
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/no-listing-04-looping/src/main.rs:here}}
|
||||
```
|
||||
|
||||
如上所示，我们将提示用户猜测之后的所有内容放入了循环。确保 loop 循环中的代码多缩进四个空格，再次运行程序。注意这里有一个新问题，因为程序忠实地执行了我们的要求：永远地请求另一个猜测，用户好像无法退出啊！
|
||||
|
||||
用户总能使用 <span class="keystroke">ctrl-c</span> 终止程序。不过还有另一个方法跳出无限循环，就是 [“比较猜测与秘密数字”](#comparing-the-guess-to-the-secret-number) 部分提到的 `parse`：如果用户输入的答案不是一个数字，程序会崩溃。用户可以利用这一点来退出，如下所示：
|
||||
用户总能使用 <span class="keystroke">ctrl-c</span> 终止程序。不过还有另一个方法跳出无限循环，就是 [“比较猜测的数字和秘密数字”][comparing-the-guess-to-the-secret-number]<!--
|
||||
ignore --> 部分提到的 `parse`：如果用户输入的答案不是一个数字，程序会崩溃。用户可以利用这一点来退出，如下所示：
|
||||
|
||||
```text
|
||||
[comparing-the-guess-to-the-secret-number]: #比较猜测的数字和秘密数字
|
||||
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/no-listing-04-looping/
|
||||
cargo run
|
||||
(too small guess)
|
||||
(too big guess)
|
||||
(correct guess)
|
||||
quit
|
||||
-->
|
||||
|
||||
```console
|
||||
$ cargo run
|
||||
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 1.50 secs
|
||||
Finished dev [unoptimized + debuginfo] target(s) in 1.50s
|
||||
Running `target/debug/guessing_game`
|
||||
Guess the number!
|
||||
The secret number is: 59
|
||||
@ -574,9 +522,8 @@ You guessed: 59
|
||||
You win!
|
||||
Please input your guess.
|
||||
quit
|
||||
thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/libcore/result.rs:785
|
||||
note: Run with `RUST_BACKTRACE=1` for a backtrace.
|
||||
error: Process didn't exit successfully: `target/debug/guess` (exit code: 101)
|
||||
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` 确实退出了程序，同时其他任何非数字输入也一样。然而，这并不理想，我们想要当猜测正确的数字时游戏能自动退出。
|
||||
@ -585,21 +532,10 @@ error: Process didn't exit successfully: `target/debug/guess` (exit code: 101)
|
||||
|
||||
让我们增加一个 `break` 语句，在用户猜对时退出游戏：
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore
|
||||
// --snip--
|
||||
|
||||
match guess.cmp(&secret_number) {
|
||||
Ordering::Less => println!("Too small!"),
|
||||
Ordering::Greater => println!("Too big!"),
|
||||
Ordering::Equal => {
|
||||
println!("You win!");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/no-listing-05-quitting/src/main.rs:here}}
|
||||
```
|
||||
|
||||
通过在 `You win!` 之后增加一行 `break`，用户猜对了神秘数字后会退出循环。退出循环也意味着退出程序，因为循环是 `main` 的最后一部分。
|
||||
@ -608,22 +544,10 @@ error: Process didn't exit successfully: `target/debug/guess` (exit code: 101)
|
||||
|
||||
为了进一步改善游戏性，不要在用户输入非数字时崩溃，需要忽略非数字，让用户可以继续猜测。可以通过修改 `guess` 将 `String` 转化为 `u32` 那部分代码来实现，如示例 2-5 所示：
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore
|
||||
// --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--
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-05/src/main.rs:here}}
|
||||
```
|
||||
|
||||
<span class="caption">示例 2-5: 忽略非数字的猜测并重新请求数字而不是让程序崩溃</span>
|
||||
@ -632,13 +556,23 @@ println!("You guessed: {}", guess);
|
||||
|
||||
如果 `parse` 能够成功的将字符串转换为一个数字，它会返回一个包含结果数字的 `Ok`。这个 `Ok` 值与 `match` 第一个分支的模式相匹配，该分支对应的动作返回 `Ok` 值中的数字 `num`，最后如愿变成新创建的 `guess` 变量。
|
||||
|
||||
如果 `parse` *不* 能将字符串转换为一个数字，它会返回一个包含更多错误信息的 `Err`。`Err` 值不能匹配第一个 `match` 分支的 `Ok(num)` 模式，但是会匹配第二个分支的 `Err(_)` 模式：`_` 是一个通配符值，本例中用来匹配所有 `Err` 值，不管其中有何种信息。所以程序会执行第二个分支的动作，`continue` 意味着进入 `loop` 的下一次循环，请求另一个猜测。这样程序就有效的忽略了 `parse` 可能遇到的所有错误！
|
||||
如果 `parse` **不** 能将字符串转换为一个数字，它会返回一个包含更多错误信息的 `Err`。`Err` 值不能匹配第一个 `match` 分支的 `Ok(num)` 模式，但是会匹配第二个分支的 `Err(_)` 模式：`_` 是一个通配符值，本例中用来匹配所有 `Err` 值，不管其中有何种信息。所以程序会执行第二个分支的动作，`continue` 意味着进入 `loop` 的下一次循环，请求另一个猜测。这样程序就有效的忽略了 `parse` 可能遇到的所有错误！
|
||||
|
||||
现在万事俱备，只需运行 `cargo run`：
|
||||
|
||||
```text
|
||||
<!-- manual-regeneration
|
||||
cd listings/ch02-guessing-game-tutorial/listing-02-05/
|
||||
cargo run
|
||||
(too small guess)
|
||||
(too big guess)
|
||||
foo
|
||||
(correct guess)
|
||||
-->
|
||||
|
||||
```console
|
||||
$ 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
|
||||
@ -660,43 +594,10 @@ You win!
|
||||
|
||||
太棒了！再有最后一个小的修改，就能完成猜数字游戏了：还记得程序依然会打印出秘密数字。在测试时还好，但正式发布时会毁了游戏。删掉打印秘密数字的 `println!`。示例 2-6 为最终代码：
|
||||
|
||||
<span class="filename">文件名: src/main.rs</span>
|
||||
<span class="filename">文件名：src/main.rs</span>
|
||||
|
||||
```rust,ignore
|
||||
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)
|
||||
.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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
{{#rustdoc_include ../listings/ch02-guessing-game-tutorial/listing-02-06/src/main.rs}}
|
||||
```
|
||||
|
||||
<span class="caption">示例 2-6：猜数字游戏的完整代码</span>
|
||||
@ -705,7 +606,7 @@ fn main() {
|
||||
|
||||
此时此刻，你顺利完成了猜数字游戏。恭喜！
|
||||
|
||||
本项目通过动手实践，向你介绍了 Rust 新概念：`let`、`match`、方法、关联函数、使用外部 crate 等等，接下来的几章，你会继续深入学习这些概念。第三章介绍大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用它们。第四章探索所有权（ownership），这是一个 Rust 同其他语言大不相同的功能。第五章讨论结构体和方法的语法，而第六章侧重解释枚举。
|
||||
本项目通过动手实践，向你介绍了许多 Rust 的新概念：`let`、`match`、方法、关联函数、使用外部 crate 等等。接下来的几章，你会继续深入学习这些概念。第 3 章介绍大部分编程语言都有的概念，比如变量、数据类型和函数，以及如何在 Rust 中使用它们。第 4 章探索所有权（ownership），这是一个 Rust 同其他语言大不相同的功能。第 5 章讨论结构体和方法的语法，而第 6 章侧重解释枚举。
|
||||
|
||||
[variables-and-mutability]:
|
||||
ch03-01-variables-and-mutability.html#variables-and-mutability
|
||||
|
||||
Loading…
Reference in New Issue
Block a user