在 projects 目录，使用cargo 新建一个项目，如下

  1. # cargo new guessing_GAME
  2. warning: the name `guessing_GAME` is not snake_case or kebab-case which is recommended for package names, consider `guessing_game`
  3.      Created binary (application) `guessing_GAME` package
  4. # cd guessing_GAME/

打开 src/main.rs 文件在这个文件中编写全部代码

  1. # cd src/
  2. # vim main.rs
  3. use std::io
  4. fn main() {
  5.     println!("Guess the number!");
  6.     println!("Please input your guess.");
  8.     let mut guess = String::new();
  10.     io::stdin()
  11.         .read_line(&mut guess)
  12.         .expect("Failed to read line");
  13.     println!("You guessed: {guess}");
  14. }

为了获取用户输入并打印结果作为输出，我们需要将 io 输入/输出库引入当前作用域， io 库来自于标准库，也被称为 std：

use std::io;

默认情况下，Rust 设定了若干个会自动导入到每个程序作用域中的标准库内容，这组内容被称为 预导入（preclude） 内容。你可以在标准库文档中查看预导入的所有内容。

main 函数是程序的入口点：
fn main(){

fn 语法声明了一个新函数，小括号()表明没有参数，大括号 { 作为函数体的开始。

println! 是一个在屏幕上打印字符串的宏：

  1.     println!("Guess the number!");
  2.     println!("Please input your guess.");

使用变量储存值

创建一个变量(variable) 来储存用户输入，像这样：

let mut guess = String::new();

我们使用 let 语句来创建变量，这里是另外一个例子：

let apples = 5;

这行代码新建了一个叫做 apples 的变量并把它绑定到值 5 上。在 Rust 中，变量默认是不可变的，这意味着一旦我们给变量赋值，这个值就不再可以修改了。下面例子展示了如何在变量名前使用 mut 来使一个变量可变：

let apples = 5; //不可变

let mut bananas = 5; //可变

现在知道了 let mut guess 创建一个叫做 guess 的可变变量。 等号(=)告诉 Rust 我们现在将 = 右边的值绑定在变量上。它是 String::new 的结果。

这个函数会返回一个 String 的新实例。 String 时一个标准库提供的字符串类型。它是 UTF-8 编码的可增文本块。

::new那一行::语法表明 new 是 String 类型的一个关联函数。关联函数是类型的实现，在这个例子中 类型是 String，而不是Sreing的某个特定实例。一些语言中把它称为静态方法。

接受用户输入

我们在程序第一行使用 use std::io;从标准库中引入了输入/输出功能。现在调用io库中的函数 stdin：

  1. io::stdin()
  2.     .read_line(&mut guess)

如果程序开头没有使用use std::io;引入io库,我们仍可以直接调用函数std::io::stdin来使用函数。stdin函数返回一个std::io::stdin的实例，这代表终端标准输入句柄的类型。

代码的下一部分，.read_line(&mut guess)，调用[read_line](https://doc.rust-lang.org/std/io/struct.Stdin.html#method.read_line)方法从标准输入句柄获取用户输入。我们还将 &mut guess 作为参数传递给 read_line() 函数，让其将用户输入储存到这个字符串中。read_line 的工作是，无论用户在标准输入中键入什么内容，都将其追加（不会覆盖其原有内容）到一个字符串中，因此它需要字符串作为参数。这个字符串参数应该是可变的，以便 read_line 将用户输入附加上去。

&表示这个参数是一个引用,它允许多处代码访问同一处数据，而无需在内存中多次拷贝。引用是一个复杂特性，Rust 的一个主要优势就是安全而简单的操纵引用。它像变量一样，默认是不可变的。因此需要写成&mut guess来使其可变，而不是&guess。

使用 Result 类型来处理潜在错误

.expect("Failed to read line");

也可以将代码写成这样：

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

不过，过长的代码行难以阅读，所以最好拆开来写。通常来说，当使用 .method_name() 语法调用方法时引入换行符和空格将长的代码行拆开是明智的。现在来看看这行代码干了什么。

之前提到了 readline 会将用户输入附加到传递给它的字符串中，不过它也会返回一个类型为 Result 的值。 Result 是一种枚举类型，通常也写作 _enum。枚举类型变量的值可以是多种可能状态中的一个。我们把每种可能的状态称为一种 枚举成员（variant）。

Result 的成员是 Ok 和 Err，Ok 成员表示操作成功，内部包含成功时产生的值。Err 成员则意味着操作失败，并且包含失败的前因后果。

这些 Result 类型的作用是编码错误处理信息。Result 类型的值，像其他类型一样，拥有定义于其上的方法。Result 的实例拥有 expect 方法。如果 io::Result 实例的值是 Err，expect 会导致程序崩溃，并显示当做参数传递给 expect 的信息。如果 read_line 方法返回 Err，则可能是来源于底层操作系统错误的结果。如果 Result 实例的值是 Ok，expect 会获取 Ok 中的值并原样返回。在本例中，这个值是用户输入到标准输入中的字节数。

如果不调用 expect，程序也能编译，不过会出现一个警告：

  1. $ cargo build
  2.    Compiling guessing_game v0.1.0 (/Users/yog/projects/guessing_game)
  3. warning: unused `Result` that must be used
  4.   --> src/main.rs:10:5
  5.    |
  6. 10 |     io::stdin().read_line(&mut guess);
  7.    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  8.    |
  9.    = note: `#[warn(unused_must_use)]` on by default
  10.    = note: this `Result` may be an `Err` variant, which should be handled
  12. warning: `guessing_game` (bin "guessing_game") generated 1 warning
  13.     Finished dev [unoptimized + debuginfo] target(s) in 0.59s

使用 println! 占位符打印值

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

这行代码现在打印了存储用户输入的字符串。里面的 {} 是预留在特定位置的占位符：把 {} 想象成小蟹钳，可以夹住合适的值。当打印变量的值时，变量名可以写进大括号中。当打印表达式的执行结果时，格式化字符串（format string）中大括号中留空，格式化字符串后跟逗号分隔的需要打印的表达式列表，其顺序与每一个空大括号占位符的顺序一致。在一个 println! 调用中打印变量和表达式的值看起来像这样：

  1. let x = 5;
  2. let y = 10;
  4. println!("x = {x} and y + 2 = {}", y + 2);

这行代码会打印出x = 5 and y + 2 = 12

  1.  # cargo run
  2.    Compiling guessing_GAME v0.1.0 (/Users/yog/projects/guessing_GAME)
  3. warning: crate `guessing_GAME` should have a snake case name
  4.   |
  5.   = help: convert the identifier to snake case: `guessing_game`
  6.   = note: `#[warn(non_snake_case)]` on by default
  8. warning: `guessing_GAME` (bin "guessing_GAME") generated 1 warning
  9.     Finished dev [unoptimized + debuginfo] target(s) in 0.66s
  10.      Running `target/debug/guessing_GAME`
  11. Guess the number!
  12. Please input your guess.
  13. 2
  14. You guessed: 2

至此为止，游戏第一部分完成：从键盘获取输入并打印了出来。

生成一个随机数字

倒入依赖

生成一个随机数字，让用户来猜，范围1-100。

Rust 标准库中尚未包含随机数功能。然而，Rust 团队提供了一个包含上述功能的 rand crate。

Cargo 对外部 rand 的运用是真正的亮点所在。在我没使用 rand 编写代码之前，需要修改 Cargo.toml 文件，引入一个 rand 依赖。现在打开这个文件并将下面这一行添加到 [dependencies] 片段标题之下。

在当前版本下，请确保按照我没这里的方式指定 rand，

  1. [package]
  2. name = "guessing_GAME"
  3. version = "0.1.0"
  4. edition = "2021"
  6. # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
  8. [dependencies]
  9. rand = "0.8.5"

在 Cargo.toml 文件中，标题以及之后的内容属于同一个片段，直到下一个标题才开始新的片段。
[dependencies] 片段告诉 Cargo 本项目依赖了哪些外部 crate 及版本。本例中，我没使用语义化版本0.8.5来指定 randcrate。Cargo 理解 语义化版本（Semantic Versioning）（有时也称为 SemVer），这是一种定义版本号的标准。0.8.5 事实上是 ^0.8.5 的简写，它表示任何至少是 0.8.5 但小于 0.9.0

Cargo 认为这些版本与 0.8.5 版本的公有 API 相兼容，这样的版本指定确保了我们可以获取能使本章代码编译的最新的补丁（patch）版本。任何大于等于 0.9.0 的版本不能保证和接下来的示例采用了相同的 API。

现在，不修改任何代码，构建项目，如下所示：

  1. # cargo build
  2.     Updating crates.io index
  3.   Downloaded rand_core v0.6.4
  4.   Downloaded rand_chacha v0.3.1
  5.   Downloaded getrandom v0.2.12
  6.   Downloaded rand v0.8.5
  7.   Downloaded ppv-lite86 v0.2.17
  8.   Downloaded cfg-if v1.0.0
  9.   Downloaded libc v0.2.153
  10.   Downloaded 7 crates (932.0 KB) in 0.24s
  11.    Compiling libc v0.2.153
  12.    Compiling cfg-if v1.0.0
  13.    Compiling ppv-lite86 v0.2.17
  14.    Compiling getrandom v0.2.12
  15.    Compiling rand_core v0.6.4
  16.    Compiling rand_chacha v0.3.1
  17.    Compiling rand v0.8.5
  18.    Compiling guessing_GAME v0.1.0 (/Users/yog/projects/guessing_GAME)
  19.     Finished dev [unoptimized + debuginfo] target(s) in 2.40s

本例中，虽然只声明了 rand 一个依赖，然而 Cargo 还是额外获取了 rand 所需要的其他 crates，因为 rand 依赖它们来正常工作。下载完成后，Rust 编译依赖，然后使用这些依赖编译项目。

如果不做任何修改，立刻再次运行 cargo build，则不会看到任何除了 Finished 行之外的输出。Cargo 知道它已经下载并编译了依赖，同时 _Cargo.toml_文件也没有变动。Cargo 还知道代码也没有任何修改，所以它不会重新编译代码。因为无事可做，它简单的退出了。

Cargo.lock文件确保构建是可重现的

Cargo 有一个机制来确保任何人在任何时候重新构建代码，都会产生相同的结果：Cargo 只会使用你指定的依赖版本，除非你又手动指定了别的。例如，如果下周 rand crate 的 0.8.6 版本出来了，它修复了一个重要的 bug，同时也含有一个会破坏代码运行的缺陷。为了处理这个问题，Rust 在你第一次运行 cargo build时建立了 _Cargo.lock_文件，我们现在可以在guessing_game 目录找到它。

当第一次构建项目时，Cargo 计算出所有符合要求的依赖版本并写入 _Cargo.lock_ 文件。当将来构建项目时，Cargo 会发现 _Cargo.lock_ 已存在并使用其中指定的版本，而不是再次计算所有的版本。这使得你拥有了一个自动化的可重现的构建。换句话说，项目会持续使用 0.8.5 直到你显式升级，多亏有了 _Cargo.lock_ 文件。由于 _Cargo.lock_文件对于“可重复构建”非常重要，因此它通常会和项目中的其余代码一样纳入到版本控制系统中。

更新依赖

当你 确实 需要升级 crate 时，Cargo 提供了这样一个命令，update，它会忽略 Cargo.lock 文件，并计算出所有符合 Cargo.toml 声明的最新版本。Cargo 接下来会把这些版本写入 Cargo.lock 文件。不过，Cargo 默认只会寻找大于 0.8.5 而小于 0.9.0 的版本。如果 rand crate 发布了两个新版本，0.8.6 和 0.9.0，在运行 cargo update 时会出现如下内容：

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

Cargo 忽略了 0.9.0 版本。这时，你也会注意到的 Cargo.lock 文件中的变化无外乎现在使用的 rand crate 版本是0.8.6 。如果想要使用 0.9.0 版本的 rand 或是任何 0.9.x 系列的版本，必须像这样更新 Cargo.toml 文件：

  1. [dependencies]
  3. rand = "0.9.0"
生成随机数

开始使用 rand来生成一个猜猜看随机数，在src/main.rs 中更新代码

  1. use std::io;
  2. use rand::Rng;
  4. fn main() {
  5.     println!("Guess the number!");
  7.     let secret_number = rand::thread_rng().gen_range(1..=100);
  9.     println!("The secret number is: {secret_number}");
  10.     println!("Please input your guess.");
  12.     let mut guess = String::new();
  14.     io::stdin()
  15.         .read_line(&mut guess)
  16.         .expect("Failed to read line");
  17.     println!("You guessed: {guess}");
  18. }

首先，我们新增了一行 use rand::Rng;。Rng 是一个 trait，它定义了随机数生成器应实现的方法，想使用这些方法的话，此 trait 必须在作用域中。

接下来，我们在中间还新增加了两行。第一行调用了 rand::thread_rng 函数提供实际使用的随机数生成器：它位于当前执行线程的本地环境中，并从操作系统获取 seed。接着调用随机数生成器的 gen_range 方法。这个方法由 use rand::Rng语句引入到作用域的 Rng trait 定义。gen_range 方法获取一个范围表达式（range expression）作为参数，并生成一个在此范围之间的随机数。这里使用的这类范围表达式使用了 start..=end 这样的形式，也就是说包含了上下端点，所以需要指定 1..=100 来请求一个 1 和 100 之间的数。

:::tips 注意：你不可能凭空就知道应该 use 哪个 trait 以及该从 crate 中调用哪个方法，因此每个 crate 有使用说明文档。Cargo 有一个很棒的功能是：运行 cargo doc —open 命令来构建所有本地依赖提供的文档，并在浏览器中打开。例如，假设你对 rand crate 中的其他功能感兴趣，你可以运行 cargo doc —open 并点击左侧导航栏中的 rand。

:::

比较随机数字和用户输入

用户输入的数字和随机生成的数字做比较

  1. use rand::Rng;
  2. use std::cmp::Ordering;
  3. use std::io;
  5. fn main() {
  6.     // --snip--
  8.     println!("You guessed: {guess}");
  10.     match guess.cmp(&secret_number) {
  11.         Ordering::Less => println!("Too small!"),
  12.         Ordering::Greater => println!("Too big!"),
  13.         Ordering::Equal => println!("You win!"),
  14.     }
  15. }

处理2个数字的比较结果。

首先我们增加了另一个 use 声明，从标准库引入了一个叫做 std::cmp::Ordering 的类型到作用域中。 Ordering 也是一个枚举，不过它的成员是 Less、Greater 和 Equal。这是比较两个值时可能出现的三种结果。

接着，底部的五行新代码使用了 Ordering 类型，cmp 方法用来比较两个值并可以在任何可比较的值上调用。它获取一个被比较值的引用：这里是把 guess 与 secret_number 做比较。然后它会返回一个刚才通过 use 引入作用域的 Ordering 枚举的成员。使用一个 match 表达式，根据对 guess 和 secret_number 调用 cmp 返回的 Ordering 成员来决定接下来做什么。

一个 match 表达式由 分支（arms） 构成。一个分支包含一个 模式（pattern）和表达式开头的值与分支模式相匹配时应该执行的代码。Rust 获取提供给 match 的值并挨个检查每个分支的模式。match 结构和模式是 Rust 中强大的功能，它体现了代码可能遇到的多种情形，并帮助你确保没有遗漏处理。

让我们看看使用 match 表达式的例子。假设用户猜了 50，这时随机生成的秘密数字是 38。

比较 50 与 38 时，因为 50 比 38 要大，cmp 方法会返回 Ordering::Greater。Ordering::Greater 是 match 表达式得到的值。它检查第一个分支的模式，Ordering::Less 与 Ordering::Greater并不匹配，所以它忽略了这个分支的代码并来到下一个分支。下一个分支的模式是 Ordering::Greater，正确 匹配！这个分支关联的代码被执行，在屏幕打印出 Too big!。match 表达式会在第一次成功匹配后终止，因为该场景下没有检查最后一个分支的必要。

然而代码并不能编译：

  1. # cargo build    
  2.    Compiling guessing_GAME v0.1.0 (/Users/yog/projects/guessing_GAME)
  3. error[E0308]: mismatched types
  4.   --> src/main.rs:20:21
  5.    |
  6. 20 |     match guess.cmp(&secret_number){
  7.    |                 --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
  8.    |                 |
  9.    |                 arguments to this method are incorrect
  10.    |
  11.    = note: expected reference `&String`
  12.               found reference `&{integer}`
  13. note: method defined here
  14.   --> /rustc/aedd173a2c086e558c2b66d3743b344f977621a7/library/core/src/cmp.rs:815:8
  16. For more information about this error, try `rustc --explain E0308`.
  17. error: could not compile `guessing_GAME` (bin "guessing_GAME") due to 1 previous error

错误的核心表明这里有 不匹配的类型（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 函数体中增加如下代码来实现：

  1.     // --snip--
  3.     let mut guess = String::new();
  5.     io::stdin()
  6.         .read_line(&mut guess)
  7.         .expect("Failed to read line");
  9.     let guess: u32 = guess.trim().parse().expect("Please type a number!");
  11.     println!("You guessed: {guess}");
  13.     match guess.cmp(&secret_number) {
  14.         Ordering::Less => println!("Too small!"),
  15.         Ordering::Greater => println!("Too big!"),
  16.         Ordering::Equal => println!("You win!"),
  17.     }

新加入的代码是：
<font style="color:#000000;">let guess: u32 = guess.trim().parse().expect("Please type a number!");</font>

这里创建了一个叫做 guess 的变量。不过等等，不是已经有了一个叫做 guess 的变量了吗？确实如此，不过 Rust 允许把新的值赋予给 guess。这个功能常用在需要转换值类型之类的场景。它允许我们复用 guess 变量的名字，而不是被迫创建两个不同变量，诸如 guess_str 和 guess 之类。 我们将这个新变量绑定到 <font style="color:#000000;">guess.trim().parse()</font> 表达式上。表达式中的 guess 指的是包含输入的字符串类型 guess 变量。String 实例的 trim 方法会去除字符串开头和结尾的空白字符，我们必须执行此方法才能将字符串与 u32 比较，因为 u32 只能包含数值型数据。用户必须输入 enter 键才能让 read_line 返回并输入他们的猜想，这将会在字符串中增加一个换行（newline）符。例如，用户输入 5 并按下 enter（在 Windows 上，按下 enter 键会得到一个回车符和一个换行符，\r\n），guess 看起来像这样：5\n 或者 5\r\n。\n 代表 “换行”，回车键；\r 代表 “回车”，回车键。trim 方法会消除 \n 或者 \r\n，只留下 5。

字符串的 parse 方法 将字符串转换成其他类型。这里用它来把字符串转换为数值。我们需要告诉 Rust 具体的数字类型，这里通过 let guess: u32 指定。guess 后面的冒号（:）告诉 Rust 我们指定了变量的类型。Rust 有一些内建的数字类型；u32 是一个无符号的 32 位整型。对于不大的正整数来说，它是不错的默认类型。

另外，程序中的 u32 注解以及与 secret_number 的比较，意味着 Rust 会推断出 secret_number 也是 u32 类型。现在可以使用相同类型比较两个值了！ parse 方法只有在字符逻辑上可以转换为数字的时候才能工作所以非常容易出错。例如，字符串中包含 A👍%，就无法将其转换为一个数字。因此，parse 方法返回一个 Result 类型。像之前 “使用 Result 类型来处理潜在的错误” 讨论的 read_line 方法那样，再次按部就班的用 expect 方法处理即可。如果 parse 不能从字符串生成一个数字，返回一个 Result 的 Err 成员时，expect 会使游戏崩溃并打印附带的信息。如果 parse 成功地将字符串转换为一个数字，它会返回 Result 的 Ok 成员，然后 expect 会返回 Ok 值中的数字。 运行程序 
  1. # cargo run
  2.    Compiling guessing_GAME v0.1.0 (/Users/yog/projects/guessing_GAME)
  3.     Finished dev [unoptimized + debuginfo] target(s) in 0.74s
  4.      Running `target/debug/guessing_GAME`
  5. Guess the number!
  6. The secret number is: 90
  7. Please input your guess.
  8. 90
  9. You guessed: 90
  10. You win!
使用循环来允许多次猜测

loop 关键字创建了一个无限循环。我们会增加循环来给用户更多机会猜数字：

  1.     // --snip--
  3.     println!("The secret number is: {secret_number}");
  5.     loop {
  6.         println!("Please input your guess.");
  8.         // --snip--
  10.         match guess.cmp(&secret_number) {
  11.             Ordering::Less => println!("Too small!"),
  12.             Ordering::Greater => println!("Too big!"),
  13.             Ordering::Equal => println!("You win!"),
  14.         }
  15.     }
  16. }

用户会一直陷入循环无法退出，添加猜对后退出游戏

  1.         // --snip--
  3.         match guess.cmp(&secret_number) {
  4.             Ordering::Less => println!("Too small!"),
  5.             Ordering::Greater => println!("Too big!"),
  6.             Ordering::Equal => {
  7.                 println!("You win!");
  8.                 break;
  9.             }
  10.         }
  11.     }
  12. }

通过在 You win! 之后增加一行 break，用户猜对了神秘数字后会退出循环。退出循环也意味着退出程序，因为循环是 main 的最后一部分。

处理无效输入

忽略用户输入的非数字内容，通过修改 guess 将 String 转化为 u32 那部分代码来实现

  1.         // --snip--
  3.         io::stdin()
  4.             .read_line(&mut guess)
  5.             .expect("Failed to read line");
  7.         let guess: u32 = match guess.trim().parse() {
  8.             Ok(num) => num,
  9.             Err(_) => continue,
  10.         };
  12.         println!("You guessed: {guess}");
  14.         // --snip--

我们将 expect 调用换成 match 语句，以从遇到错误就崩溃转换为处理错误。须知 parse 返回一个 Result 类型，而 Result 是一个拥有 Ok 或 Err 成员的枚举。这里使用的 match 表达式，和之前处理 cmp 方法返回 Ordering 时用的一样。

如果 parse 能够成功的将字符串转换为一个数字，它会返回一个包含结果数字的 Ok。这个 Ok 值与 match 第一个分支的模式相匹配，该分支对应的动作返回 Ok 值中的数字 num，最后如愿变成新创建的 guess 变量。

如果 parse不能将字符串转换为一个数字，它会返回一个包含更多错误信息的 Err。Err 值不能匹配第一个 match 分支的 Ok(num) 模式，但是会匹配第二个分支的 Err() 模式： 是一个通配符值，本例中用来匹配所有 Err 值，不管其中有何种信息。所以程序会执行第二个分支的动作，continue 意味着进入 loop 的下一次循环，请求另一个猜测。这样程序就有效的忽略了 parse 可能遇到的所有错误！

  1. # cargo run      
  2.    Compiling guessing_GAME v0.1.0 (/Users/yog/projects/guessing_GAME)
  3.     Finished dev [unoptimized + debuginfo] target(s) in 0.75s
  4.      Running `target/debug/guessing_GAME`
  5. Guess the number!
  6. The secret number is: 21
  7. Please input your guess.
  8. 20
  9. You guessed: 20
  10. Too small!
  11. Please input your guess.
  12. 30
  13. You guessed: 30
  14. Too big!
  15. Please input your guess.
  16. sasdasada
  17. Please input your guess.
  18. !2
  19. Please input your guess.
  20. [][[
  21. Please input your guess.
  22. 21
  23. You guessed: 21
  24. You win!

删掉打印答案的代码就完成了

<font style="color:#000000;">println!("The secret number is: {secret_number}");</font>