免費(fèi)AI編程助手
Rust 寫個(gè)猜數(shù)字游戲
ch02-00-guessing-game-tutorial.md
commit 6e2fe7c0f085989cc498cec139e717e2af172cb7
讓我們一起動(dòng)手完成一個(gè)項(xiàng)目，來快速上手 Rust！本章將介紹 Rust 中一些常用概念，并通過真實(shí)的程序來展示如何運(yùn)用它們。你將會(huì)學(xué)到 let、match、方法（method）、關(guān)聯(lián)函數(shù)（associated function）、使用外部 crate 等知識(shí)！后續(xù)章節(jié)會(huì)深入探討這些概念的細(xì)節(jié)。在這一章，我們將練習(xí)基礎(chǔ)內(nèi)容。
我們會(huì)實(shí)現(xiàn)一個(gè)經(jīng)典的新手編程問題：猜猜看游戲。它是這么工作的：程序?qū)?huì)隨機(jī)生成一個(gè) 1 到 100 之間的隨機(jī)整數(shù)。接著它會(huì)請(qǐng)玩家猜一個(gè)數(shù)并輸入，然后提示猜測是大了還是小了。如果猜對(duì)了，它會(huì)打印祝賀信息并退出。
準(zhǔn)備一個(gè)新項(xiàng)目
要?jiǎng)?chuàng)建一個(gè)新項(xiàng)目，進(jìn)入第一章中創(chuàng)建的 projects 目錄，使用 Cargo 新建一個(gè)項(xiàng)目，如下：
$ cargo new guessing_game
$ cd guessing_game
第一個(gè)命令，cargo new，它獲取項(xiàng)目的名稱（guessing_game）作為第一個(gè)參數(shù)。第二個(gè)命令進(jìn)入到新創(chuàng)建的項(xiàng)目目錄。
看看生成的 Cargo.toml 文件：
文件名: Cargo.toml
[package]
name = "guessing_game"
version = "0.1.0"
edition = "2021"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
正如第一章那樣，cargo new 生成了一個(gè) “Hello, world!” 程序。查看 src/main.rs 文件：
文件名: src/main.rs
fn main() {
println!("Hello, world!");
}
現(xiàn)在使用 cargo run 命令，一步完成 “Hello, world!” 程序的編譯和運(yùn)行：
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 1.50s
Running `target/debug/guessing_game`
Hello, world!
當(dāng)你需要在項(xiàng)目中快速迭代時(shí)，run 命令就能派上用場，正如我們?cè)谶@個(gè)游戲項(xiàng)目中做的，在下一次迭代之前快速測試每一次迭代。
重新打開 src/main.rs 文件。我們將會(huì)在這個(gè)文件中編寫全部的代碼。
處理一次猜測
猜猜看程序的第一部分請(qǐng)求和處理用戶輸入，并檢查輸入是否符合預(yù)期的格式。首先，允許玩家輸入猜測。在 src/main.rs 中輸入示例 2-1 中的代碼。
文件名: src/main.rs
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
示例 2-1：獲取用戶猜測并打印的代碼
這些代碼包含很多信息，我們一行一行地過一遍。為了獲取用戶輸入并打印結(jié)果作為輸出，我們需要將 io輸入/輸出庫引入當(dāng)前作用域。io 庫來自于標(biāo)準(zhǔn)庫，也被稱為 std：
use std::io;默認(rèn)情況下，Rust 設(shè)定了若干個(gè)會(huì)自動(dòng)導(dǎo)入到每個(gè)程序作用域中的標(biāo)準(zhǔn)庫內(nèi)容，這組內(nèi)容被稱為 預(yù)導(dǎo)入（preclude） 內(nèi)容。你可以在標(biāo)準(zhǔn)庫文檔中查看預(yù)導(dǎo)入的所有內(nèi)容。
如果你需要的類型不在預(yù)導(dǎo)入內(nèi)容中，就必須使用 use 語句顯式地將其引入作用域。std::io 庫提供很多有用的功能，包括接收用戶輸入的功能。
如第一章所提及，main 函數(shù)是程序的入口點(diǎn)：
fn main() {fn 語法聲明了一個(gè)新函數(shù)，小括號(hào) () 表明沒有參數(shù)，大括號(hào) { 作為函數(shù)體的開始。
第一章也提及了 println! 是一個(gè)在屏幕上打印字符串的宏：
println!("Guess the number!");
println!("Please input your guess.");這些代碼僅僅打印提示，介紹游戲的內(nèi)容然后請(qǐng)求用戶輸入。
使用變量儲(chǔ)存值
接下來，創(chuàng)建一個(gè) 變量（variable）來儲(chǔ)存用戶輸入，像這樣：
let mut guess = String::new();現(xiàn)在程序開始變得有意思了！這一小行代碼發(fā)生了很多事。我們使用 let 語句來創(chuàng)建變量。這里是另外一個(gè)例子：
let apples = 5;這行代碼新建了一個(gè)叫做 apples 的變量并把它綁定到值 5 上。在 Rust 中，變量默認(rèn)是不可變的，這意味著一旦我們給變量賦值，這個(gè)值就不再可以修改了。我們將會(huì)在第三章的 “變量與可變性” 部分詳細(xì)討論這個(gè)概念。下面的例子展示了如何在變量名前使用 mut 來使一個(gè)變量可變：
let apples = 5; // 不可變
let mut bananas = 5; // 可變注意：?
//? 語法開始一個(gè)注釋，持續(xù)到行尾。Rust 忽略注釋中的所有內(nèi)容，第三章將會(huì)詳細(xì)介紹注釋。
回到猜猜看程序中?，F(xiàn)在我們知道了 let mut guess 會(huì)引入一個(gè)叫做 guess 的可變變量。等號(hào)（=）告訴Rust我們現(xiàn)在想將某個(gè)值綁定在變量上。等號(hào)的右邊是 guess 所綁定的值，它是 String::new 的結(jié)果，這個(gè)函數(shù)會(huì)返回一個(gè) String 的新實(shí)例。String 是一個(gè)標(biāo)準(zhǔn)庫提供的字符串類型，它是 UTF-8 編碼的可增長文本塊。
::new 那一行的 :: 語法表明 new 是 String 類型的一個(gè) 關(guān)聯(lián)函數(shù)（associated function）。關(guān)聯(lián)函數(shù)是針對(duì)類型實(shí)現(xiàn)的，在這個(gè)例子中是 String，而不是 String 的某個(gè)特定實(shí)例。一些語言中把它稱為 靜態(tài)方法（static method）。
new 函數(shù)創(chuàng)建了一個(gè)新的空字符串，你會(huì)發(fā)現(xiàn)很多類型上有 new 函數(shù)，因?yàn)樗莿?chuàng)建類型實(shí)例的慣用函數(shù)名。
總的來說，let mut guess = String::new(); 這一行創(chuàng)建了一個(gè)可變變量，當(dāng)前它綁定到一個(gè)新的 String 空實(shí)例上。
接收用戶輸入
回憶一下，我們?cè)诔绦虻牡谝恍惺褂?nbsp;use std::io; 從標(biāo)準(zhǔn)庫中引入了輸入/輸出功能?，F(xiàn)在調(diào)用 io 庫中的函數(shù) stdin：
io::stdin()
.read_line(&mut guess)如果程序的開頭沒有使用 use std::io 引入 io 庫，我們?nèi)钥梢酝ㄟ^把函數(shù)調(diào)用寫成 std::io::stdin 來使用函數(shù)。stdin 函數(shù)返回一個(gè) std::io::Stdin 的實(shí)例，這代表終端標(biāo)準(zhǔn)輸入句柄的類型。
代碼的下一部分，.read_line(&mut guess)，調(diào)用 read_line 方法從標(biāo)準(zhǔn)輸入句柄獲取用戶輸入。我們還將 &mut guess 作為參數(shù)傳遞給 read_line() 函數(shù)，讓其將用戶輸入儲(chǔ)存到這個(gè)字符串中。read_line 的工作是，無論用戶在標(biāo)準(zhǔn)輸入中鍵入什么內(nèi)容，都將其追加（不會(huì)覆蓋其原有內(nèi)容）到一個(gè)字符串中，因此它需要字符串作為參數(shù)。這個(gè)字符串參數(shù)應(yīng)該是可變的，以便 read_line 將用戶輸入附加上去。
& 表示這個(gè)參數(shù)是一個(gè) 引用（reference），它允許多處代碼訪問同一處數(shù)據(jù)，而無需在內(nèi)存中多次拷貝。引用是一個(gè)復(fù)雜的特性，Rust 的一個(gè)主要優(yōu)勢就是安全而簡單的操縱引用。完成當(dāng)前程序并不需要了解如此多細(xì)節(jié)。現(xiàn)在，我們只需知道它像變量一樣，默認(rèn)是不可變的。因此，需要寫成 &mut guess 來使其可變，而不是 &guess。（第四章會(huì)更全面的解釋引用。）
使用 Result 類型來處理潛在的錯(cuò)誤
我們還沒有完全分析完這行代碼。雖然我們已經(jīng)講到了第三行代碼，但要注意：它仍是邏輯行（雖然換行了但仍是語句）的一部分。后一部分是這個(gè)方法（method）：
.expect("Failed to read line");我們也可以將代碼這樣寫：
io::stdin().read_line(&mut guess).expect("Failed to read line");不過，過長的代碼行難以閱讀，所以最好拆開來寫。通常來說，當(dāng)使用 .method_name() 語法調(diào)用方法時(shí)引入換行符和空格將長的代碼行拆開是明智的?，F(xiàn)在來看看這行代碼干了什么。
之前提到了 read_line 會(huì)將用戶輸入附加到傳遞給它的字符串中，不過它也會(huì)返回一個(gè)類型為 Result 的值。 Result 是一種枚舉類型，通常也寫作 enum。枚舉類型變量的值可以是多種可能狀態(tài)中的一個(gè)。我們把每種可能的狀態(tài)稱為一種 枚舉成員（variant）。
第六章將介紹枚舉的更多細(xì)節(jié)。這里的 Result 類型將用來編碼錯(cuò)誤處理的信息。
Result 的成員是 Ok 和 Err，Ok 成員表示操作成功，內(nèi)部包含成功時(shí)產(chǎn)生的值。Err 成員則意味著操作失敗，并且包含失敗的前因后果。
這些 Result 類型的作用是編碼錯(cuò)誤處理信息。Result 類型的值，像其他類型一樣，擁有定義于其上的方法。Result 的實(shí)例擁有 expect 方法。如果 io::Result 實(shí)例的值是 Err，expect 會(huì)導(dǎo)致程序崩潰，并顯示當(dāng)做參數(shù)傳遞給 expect 的信息。如果 read_line 方法返回 Err，則可能是來源于底層操作系統(tǒng)錯(cuò)誤的結(jié)果。如果 Result 實(shí)例的值是 Ok，expect 會(huì)獲取 Ok 中的值并原樣返回。在本例中，這個(gè)值是用戶輸入到標(biāo)準(zhǔn)輸入中的字節(jié)數(shù)。
如果不調(diào)用 expect，程序也能編譯，不過會(huì)出現(xiàn)一個(gè)警告：
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
warning: unused `Result` that must be used
--> src/main.rs:10:5
|
10 | io::stdin().read_line(&mut guess);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(unused_must_use)]` on by default
= note: this `Result` may be an `Err` variant, which should be handled
warning: `guessing_game` (bin "guessing_game") generated 1 warning
Finished dev [unoptimized + debuginfo] target(s) in 0.59s
Rust 警告我們沒有使用 read_line 的返回值 Result，說明有一個(gè)可能的錯(cuò)誤沒有處理。
消除警告的正確做法是實(shí)際去編寫錯(cuò)誤處理代碼，不過由于我們就是希望程序在出現(xiàn)問題時(shí)立即崩潰，所以直接使用 expect。第九章 會(huì)學(xué)習(xí)如何從錯(cuò)誤中恢復(fù)。
使用 println! 占位符打印值
除了位于結(jié)尾的右花括號(hào)，目前為止就只有這一行代碼值得討論一下了，就是這一行：
println!("You guessed: {guess}");這行代碼現(xiàn)在打印了存儲(chǔ)用戶輸入的字符串。第一個(gè)參數(shù)是格式化字符串，里面的 {} 是預(yù)留在特定位置的占位符：把 {} 想象成小蟹鉗，可以夾住合適的值。使用 {} 也可以打印多個(gè)值：第一對(duì) {} 使用格式化字符串之后的第一個(gè)值，第二對(duì)則使用第二個(gè)值，依此類推。調(diào)用一次 println! 打印多個(gè)值看起來像這樣：
let x = 5;
let y = 10;
println!("x = {} and y = {}", x, y);這行代碼會(huì)打印出 x = 5 and y = 10。
測試第一部分代碼
讓我們來測試下猜猜看游戲的第一部分。使用 cargo run 運(yùn)行：
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 6.44s
Running `target/debug/guessing_game`
Guess the number!
Please input your guess.
6
You guessed: 6
至此為止，游戲的第一部分已經(jīng)完成：我們從鍵盤獲取輸入并打印了出來。
生成一個(gè)秘密數(shù)字
接下來，需要生成一個(gè)秘密數(shù)字，好讓用戶來猜。秘密數(shù)字應(yīng)該每次都不同，這樣重復(fù)玩才不會(huì)乏味；范圍應(yīng)該在 1 到 100 之間，這樣才不會(huì)太困難。Rust 標(biāo)準(zhǔn)庫中尚未包含隨機(jī)數(shù)功能。然而，Rust 團(tuán)隊(duì)還是提供了一個(gè)包含上述功能的 rand crate。
使用 crate 來增加更多功能
記住，crate 是一個(gè) Rust 代碼包。我們正在構(gòu)建的項(xiàng)目是一個(gè) 二進(jìn)制 crate，它生成一個(gè)可執(zhí)行文件。 rand crate 是一個(gè) 庫 crate，庫 crate 可以包含任意能被其他程序使用的代碼，但是不能自執(zhí)行。
Cargo 對(duì)外部 crate 的運(yùn)用是其真正的亮點(diǎn)所在。在我們使用 rand 編寫代碼之前，需要修改 Cargo.toml 文件，引入一個(gè) rand 依賴?，F(xiàn)在打開這個(gè)文件并將下面這一行添加到 [dependencies] 片段標(biāo)題之下。在當(dāng)前版本下，請(qǐng)確保按照我們這里的方式指定 rand，否則本教程中的示例代碼可能無法工作。
文件名: Cargo.toml
rand = "0.8.3"
在 Cargo.toml 文件中，標(biāo)題以及之后的內(nèi)容屬同一個(gè)片段，直到遇到下一個(gè)標(biāo)題才開始新的片段。[dependencies] 片段告訴 Cargo 本項(xiàng)目依賴了哪些外部 crate 及其版本。本例中，我們使用語義化版本 0.8.3 來指定 rand crate。Cargo 理解 語義化版本（Semantic Versioning）（有時(shí)也稱為 SemVer），這是一種定義版本號(hào)的標(biāo)準(zhǔn)。0.8.3 事實(shí)上是 ^0.8.3 的簡寫，它表示任何至少是 0.8.3 但小于 0.9.0 的版本。
Cargo 認(rèn)為這些版本與 0.8.3 版本的公有 API 相兼容，這樣的版本指定確保了我們可以獲取能使本章代碼編譯的最新的補(bǔ)丁（patch）版本。任何大于等于 0.9.0 的版本不能保證和接下來的示例采用了相同的 API。
現(xiàn)在，不修改任何代碼，構(gòu)建項(xiàng)目，如示例 2-2 所示：
示例 2-2: 將 rand crate 添加為依賴之后運(yùn)行 cargo build 的輸出
可能會(huì)出現(xiàn)不同的版本號(hào)（多虧了語義化版本，它們與代碼是兼容的?。瑫r(shí)顯示順序也可能會(huì)有所不同。
現(xiàn)在我們有了一個(gè)外部依賴，Cargo 從 registry 上獲取所有包的最新版本信息，這是一份來自 Crates.io 的數(shù)據(jù)拷貝。Crates.io 是 Rust 生態(tài)環(huán)境中的開發(fā)者們向他人貢獻(xiàn) Rust 開源項(xiàng)目的地方。
在更新完 registry 后，Cargo 檢查 [dependencies] 片段并下載列表中包含但還未下載的 crates 。本例中，雖然只聲明了 rand 一個(gè)依賴，然而 Cargo 還是額外獲取了 rand 所需要的其他 crates，因?yàn)?nbsp;rand 依賴它們來正常工作。下載完成后，Rust 編譯依賴，然后使用這些依賴編譯項(xiàng)目。
如果不做任何修改，立刻再次運(yùn)行 cargo build，則不會(huì)看到任何除了 Finished 行之外的輸出。Cargo 知道它已經(jīng)下載并編譯了依賴，同時(shí) Cargo.toml 文件也沒有變動(dòng)。Cargo 還知道代碼也沒有任何修改，所以它不會(huì)重新編譯代碼。因?yàn)闊o事可做，它簡單的退出了。
如果打開 src/main.rs 文件，做一些無關(guān)緊要的修改，保存并再次構(gòu)建，則會(huì)出現(xiàn)兩行輸出：
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs
這一行表示 Cargo 只針對(duì) src/main.rs 文件的微小修改而更新構(gòu)建。依賴沒有變化，所以 Cargo 知道它可以復(fù)用已經(jīng)為此下載并編譯的代碼。它只是重新構(gòu)建了部分（項(xiàng)目）代碼。
Cargo.lock 文件確保構(gòu)建是可重現(xiàn)的
Cargo 有一個(gè)機(jī)制來確保任何人在任何時(shí)候重新構(gòu)建代碼，都會(huì)產(chǎn)生相同的結(jié)果：Cargo 只會(huì)使用你指定的依賴版本，除非你又手動(dòng)指定了別的。例如，如果下周 rand crate 的 0.8.4 版本出來了，它修復(fù)了一個(gè)重要的 bug，同時(shí)也含有一個(gè)會(huì)破壞代碼運(yùn)行的缺陷。為了處理這個(gè)問題，Rust在你第一次運(yùn)行 cargo build 時(shí)建立了 Cargo.lock 文件，我們現(xiàn)在可以在guessing_game 目錄找到它。
當(dāng)?shù)谝淮螛?gòu)建項(xiàng)目時(shí)，Cargo 計(jì)算出所有符合要求的依賴版本并寫入 Cargo.lock 文件。當(dāng)將來構(gòu)建項(xiàng)目時(shí)，Cargo 會(huì)發(fā)現(xiàn) Cargo.lock 已存在并使用其中指定的版本，而不是再次計(jì)算所有的版本。這使得你擁有了一個(gè)自動(dòng)化的可重現(xiàn)的構(gòu)建。換句話說，項(xiàng)目會(huì)持續(xù)使用 0.8.3 直到你顯式升級(jí)，多虧有了 Cargo.lock 文件。由于 Cargo.lock 文件對(duì)于“可重復(fù)構(gòu)建”非常重要，因此它通常會(huì)和項(xiàng)目中的其余代碼一樣納入到版本控制系統(tǒng)中。
更新 crate 到一個(gè)新版本
當(dāng)你 確實(shí) 需要升級(jí) crate 時(shí)，Cargo 提供了這樣一個(gè)命令，update，它會(huì)忽略 Cargo.lock 文件，并計(jì)算出所有符合 Cargo.toml 聲明的最新版本。Cargo 接下來會(huì)把這些版本寫入 Cargo.lock 文件。不過，Cargo 默認(rèn)只會(huì)尋找大于 0.8.3 而小于 0.9.0 的版本。如果 rand crate 發(fā)布了兩個(gè)新版本，0.8.4 和 0.9.0，在運(yùn)行 cargo update 時(shí)會(huì)出現(xiàn)如下內(nèi)容：
$ cargo update
Updating crates.io index
Updating rand v0.8.3 -> v0.8.4
Cargo 忽略了 0.9.0 版本。這時(shí)，你也會(huì)注意到的 Cargo.lock 文件中的變化無外乎現(xiàn)在使用的 rand crate 版本是0.8.4 。如果想要使用 0.9.0 版本的 rand 或是任何 0.9.x 系列的版本，必須像這樣更新 Cargo.toml 文件：
[dependencies]
rand = "0.9.0"
下一次運(yùn)行 cargo build 時(shí)，Cargo 會(huì)從 registry 更新可用的 crate，并根據(jù)你指定的新版本重新計(jì)算。
第十四章會(huì)講到 Cargo 及其生態(tài)系統(tǒng) 的更多內(nèi)容，不過目前你只需要了解這么多。通過 Cargo 復(fù)用庫文件非常容易，因此 Rustacean 能夠編寫出由很多包組裝而成的更輕巧的項(xiàng)目。
生成一個(gè)隨機(jī)數(shù)
讓我們開始使用 rand 來生成一個(gè)猜猜看隨機(jī)數(shù)。下一步是更新 src/main.rs，如示例 2-3 所示。
文件名: src/main.rs
use std::io;
use rand::Rng;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
示例 2-3：添加生成隨機(jī)數(shù)的代碼
首先，我們新增了一行 use rand::Rng。Rng 是一個(gè) trait，它定義了隨機(jī)數(shù)生成器應(yīng)實(shí)現(xiàn)的方法，想使用這些方法的話，此 trait 必須在作用域中。第十章會(huì)詳細(xì)介紹 trait。
接下來，我們?cè)谥虚g還新增加了兩行。第一行調(diào)用了 rand::thread_rng 函數(shù)提供實(shí)際使用的隨機(jī)數(shù)生成器：它位于當(dāng)前執(zhí)行線程的本地環(huán)境中，并從操作系統(tǒng)獲取 seed。接著調(diào)用隨機(jī)數(shù)生成器的 gen_range 方法。這個(gè)方法由 use rand::Rng 語句引入到作用域的 Rng trait 定義。gen_range 方法獲取一個(gè)范圍表達(dá)式（range expression）作為參數(shù)，并生成一個(gè)在此范圍之間的隨機(jī)數(shù)。這里使用的這類范圍表達(dá)式使用了 start..=end 這樣的形式，也就是說包含了上下端點(diǎn)，所以需要指定 1..=100 來請(qǐng)求一個(gè) 1 和 100 之間的數(shù)。
注意：你不可能憑空就知道應(yīng)該 use 哪個(gè) trait 以及該從 crate 中調(diào)用哪個(gè)方法，因此每個(gè)crate 有使用說明文檔。Cargo 有一個(gè)很棒的功能是：運(yùn)行 ?
cargo doc --open? 命令來構(gòu)建所有本地依賴提供的文檔，并在瀏覽器中打開。例如，假設(shè)你對(duì) ?rand?crate 中的其他功能感興趣，你可以運(yùn)行 ?cargo doc --open? 并點(diǎn)擊左側(cè)導(dǎo)航欄中的 ?rand?。
新增加的第二行代碼打印出了秘密數(shù)字。這在開發(fā)程序時(shí)很有用，因?yàn)榭梢詼y試它，不過在最終版本中會(huì)刪掉它。如果游戲一開始就打印出結(jié)果就沒什么可玩的了！
嘗試運(yùn)行程序幾次：
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 2.53s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 7
Please input your guess.
4
You guessed: 4
$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 83
Please input your guess.
5
You guessed: 5
你應(yīng)該能得到不同的隨機(jī)數(shù)，同時(shí)它們應(yīng)該都是在 1 和 100 之間的。干得漂亮！
比較猜測的數(shù)字和秘密數(shù)字
現(xiàn)在有了用戶輸入和一個(gè)隨機(jī)數(shù)，我們可以比較它們。這個(gè)步驟如示例 2-4 所示。注意這段代碼還不能通過編譯，我們稍后會(huì)解釋。
文件名: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
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!"),
}
}示例 2-4：處理比較兩個(gè)數(shù)字可能的返回值
首先我們?cè)黾恿肆硪粋€(gè) use 聲明，從標(biāo)準(zhǔn)庫引入了一個(gè)叫做 std::cmp::Ordering 的類型到作用域中。 Ordering 也是一個(gè)枚舉，不過它的成員是 Less、Greater 和 Equal。這是比較兩個(gè)值時(shí)可能出現(xiàn)的三種結(jié)果。
接著，底部的五行新代碼使用了 Ordering 類型，cmp 方法用來比較兩個(gè)值并可以在任何可比較的值上調(diào)用。它獲取一個(gè)被比較值的引用：這里是把 guess 與 secret_number 做比較。 然后它會(huì)返回一個(gè)剛才通過 use 引入作用域的 Ordering 枚舉的成員。使用一個(gè) match 表達(dá)式，根據(jù)對(duì) guess 和 secret_number 調(diào)用 cmp 返回的 Ordering 成員來決定接下來做什么。
一個(gè) match 表達(dá)式由 分支（arms） 構(gòu)成。一個(gè)分支包含一個(gè) 模式（pattern）和表達(dá)式開頭的值與分支模式相匹配時(shí)應(yīng)該執(zhí)行的代碼。Rust 獲取提供給 match 的值并挨個(gè)檢查每個(gè)分支的模式。match 結(jié)構(gòu)和模式是 Rust 中強(qiáng)大的功能，它體現(xiàn)了代碼可能遇到的多種情形，并幫助你確保沒有遺漏處理。這些功能將分別在第六章和第十八章詳細(xì)介紹。
讓我們看看使用 match 表達(dá)式的例子。假設(shè)用戶猜了 50，這時(shí)隨機(jī)生成的秘密數(shù)字是 38。比較 50 與 38 時(shí)，因?yàn)?50 比 38 要大，cmp 方法會(huì)返回 Ordering::Greater。Ordering::Greater 是 match 表達(dá)式得到的值。它檢查第一個(gè)分支的模式，Ordering::Less 與 Ordering::Greater并不匹配，所以它忽略了這個(gè)分支的代碼并來到下一個(gè)分支。下一個(gè)分支的模式是 Ordering::Greater，正確 匹配！這個(gè)分支關(guān)聯(lián)的代碼被執(zhí)行，在屏幕打印出 Too big!。match 表達(dá)式會(huì)在第一次成功匹配后終止，因?yàn)樵搱鼍跋聸]有檢查最后一個(gè)分支的必要。
然而，示例 2-4 的代碼并不能編譯，可以嘗試一下：
$ cargo build
Compiling libc v0.2.86
Compiling getrandom v0.2.2
Compiling cfg-if v1.0.0
Compiling ppv-lite86 v0.2.10
Compiling rand_core v0.6.2
Compiling rand_chacha v0.3.0
Compiling rand v0.8.3
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
error[E0308]: mismatched types
--> src/main.rs:22:21
|
22 | match guess.cmp(&secret_number) {
| ^^^^^^^^^^^^^^ expected struct `String`, found integer
|
= note: expected reference `&String`
found reference `&{integer}`
error[E0283]: type annotations needed for `{integer}`
--> src/main.rs:8:44
|
8 | let secret_number = rand::thread_rng().gen_range(1..=100);
| ------------- ^^^^^^^^^ cannot infer type for type `{integer}`
| |
| consider giving `secret_number` a type
|
= note: multiple `impl`s satisfying `{integer}: SampleUniform` found in the `rand` crate:
- impl SampleUniform for i128;
- impl SampleUniform for i16;
- impl SampleUniform for i32;
- impl SampleUniform for i64;
and 8 more
note: required by a bound in `gen_range`
--> /Users/carolnichols/.cargo/registry/src/github.com-1ecc6299db9ec823/rand-0.8.3/src/rng.rs:129:12
|
129 | T: SampleUniform,
| ^^^^^^^^^^^^^ required by this bound in `gen_range`
help: consider specifying the type arguments in the function call
|
8 | let secret_number = rand::thread_rng().gen_range::<T, R>(1..=100);
| ++++++++
Some errors have detailed explanations: E0283, E0308.
For more information about an error, try `rustc --explain E0283`.
error: could not compile `guessing_game` due to 2 previous errors
錯(cuò)誤的核心表明這里有 不匹配的類型（mismatched types）。Rust 有一個(gè)靜態(tài)強(qiáng)類型系統(tǒng)，同時(shí)也有類型推斷。當(dāng)我們寫出 let guess = String::new() 時(shí)，Rust 推斷出 guess 應(yīng)該是 String 類型，并不需要我們寫出類型。另一方面，secret_number，是數(shù)字類型。幾個(gè)數(shù)字類型擁有 1 到 100 之間的值：32 位數(shù)字 i32；32 位無符號(hào)數(shù)字 u32；64 位數(shù)字 i64 等等。Rust 默認(rèn)使用 i32，所以它是 secret_number 的類型，除非增加類型信息，或任何能讓 Rust 推斷出不同數(shù)值類型的信息。這里錯(cuò)誤的原因在于 Rust 不會(huì)比較字符串類型和數(shù)字類型。
所以我們必須把從輸入中讀取到的 String 轉(zhuǎn)換為一個(gè)真正的數(shù)字類型，才好與秘密數(shù)字進(jìn)行比較。這可以通過在 main 函數(shù)體中增加如下代碼來實(shí)現(xiàn)：
文件名: src/main.rs
// --snip--
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}這行新代碼是：
let guess: u32 = guess.trim().parse().expect("Please type a number!");這里創(chuàng)建了一個(gè)叫做 guess 的變量。不過等等，不是已經(jīng)有了一個(gè)叫做 guess 的變量了嗎？確實(shí)如此，不過 Rust 允許用一個(gè)新值來 隱藏 （shadow） guess 之前的值。這個(gè)功能常用在需要轉(zhuǎn)換值類型之類的場景。它允許我們復(fù)用 guess 變量的名字，而不是被迫創(chuàng)建兩個(gè)不同變量，諸如 guess_str 和 guess 之類。（第三章會(huì)介紹 shadowing 的更多細(xì)節(jié)。）
我們將這個(gè)新變量綁定到 guess.trim().parse() 表達(dá)式上。表達(dá)式中的 guess 指的是包含輸入的字符串類型 guess 變量。String 實(shí)例的 trim 方法會(huì)去除字符串開頭和結(jié)尾的空白字符，我們必須執(zhí)行此方法才能將字符串與 u32 比較，因?yàn)?nbsp;u32 只能包含數(shù)值型數(shù)據(jù)。用戶必須輸入 enter 鍵才能讓 read_line 返回并輸入他們的猜想，這將會(huì)在字符串中增加一個(gè)換行（newline）符。例如，用戶輸入 5 并按下 enter（在 Windows 上，按下 enter 鍵會(huì)得到一個(gè)回車符和一個(gè)換行符，\r\n），guess 看起來像這樣：5\n 或者 5\r\n。\n 代表 “換行”，回車鍵；\r 代表 “回車”，回車鍵。trim 方法會(huì)消除 \n 或者 \r\n，只留下 5。
字符串的 parse 方法 將字符串轉(zhuǎn)換成其他類型。這里用它來把字符串轉(zhuǎn)換為數(shù)值。我們需要告訴 Rust 具體的數(shù)字類型，這里通過 let guess: u32 指定。guess 后面的冒號(hào)（:）告訴 Rust 我們指定了變量的類型。Rust 有一些內(nèi)建的數(shù)字類型；u32 是一個(gè)無符號(hào)的 32 位整型。對(duì)于不大的正整數(shù)來說，它是不錯(cuò)的默認(rèn)類型，第三章還會(huì)講到其他數(shù)字類型。另外，程序中的 u32 注解以及與 secret_number 的比較，意味著 Rust 會(huì)推斷出 secret_number 也是 u32 類型?，F(xiàn)在可以使用相同類型比較兩個(gè)值了！
parse 方法只有在字符邏輯上可以轉(zhuǎn)換為數(shù)字的時(shí)候才能工作所以非常容易出錯(cuò)。例如，字符串中包含 A%，就無法將其轉(zhuǎn)換為一個(gè)數(shù)字。因此，parse 方法返回一個(gè) Result 類型。像之前 “使用 Result 類型來處理潛在的錯(cuò)誤” 討論的 read_line 方法那樣，再次按部就班的用 expect 方法處理即可。如果 parse 不能從字符串生成一個(gè)數(shù)字，返回一個(gè) Result 的 Err 成員時(shí)，expect 會(huì)使游戲崩潰并打印附帶的信息。如果 parse 成功地將字符串轉(zhuǎn)換為一個(gè)數(shù)字，它會(huì)返回 Result 的 Ok 成員，然后 expect 會(huì)返回 Ok 值中的數(shù)字。
現(xiàn)在讓我們運(yùn)行程序！
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 0.43s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 58
Please input your guess.
76
You guessed: 76
Too big!
漂亮！即便是在猜測之前添加了空格，程序依然能判斷出用戶猜測了 76。多運(yùn)行程序幾次，輸入不同的數(shù)字來檢驗(yàn)不同的行為：猜一個(gè)正確的數(shù)字，猜一個(gè)過大的數(shù)字和猜一個(gè)過小的數(shù)字。
現(xiàn)在游戲已經(jīng)大體上能玩了，不過用戶只能猜一次。增加一個(gè)循環(huán)來改變它吧！
使用循環(huán)來允許多次猜測
loop 關(guān)鍵字創(chuàng)建了一個(gè)無限循環(huán)。我們會(huì)增加循環(huán)來給用戶更多機(jī)會(huì)猜數(shù)字：
文件名: src/main.rs
// --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!"),
}
}
}如上所示，我們將提示用戶猜測之后的所有內(nèi)容移動(dòng)到了循環(huán)中。確保 loop 循環(huán)中的代碼多縮進(jìn)四個(gè)空格，再次運(yùn)行程序。注意這里有一個(gè)新問題，因?yàn)槌绦蛑覍?shí)地執(zhí)行了我們的要求：永遠(yuǎn)地請(qǐng)求另一個(gè)猜測，用戶好像無法退出??！
用戶總能使用 ctrl-c 終止程序。不過還有另一個(gè)方法跳出無限循環(huán)，就是 “比較猜測與秘密數(shù)字” 部分提到的 parse：如果用戶輸入的答案不是一個(gè)數(shù)字，程序會(huì)崩潰。我們可以利用這一點(diǎn)來退出，如下所示：
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 1.50s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 59
Please input your guess.
45
You guessed: 45
Too small!
Please input your guess.
60
You guessed: 60
Too big!
Please input your guess.
59
You guessed: 59
You win!
Please input your guess.
quit
thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/main.rs:28:47
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
輸入 quit 將會(huì)退出程序，同時(shí)你會(huì)注意到其他任何非數(shù)字輸入也一樣。然而，這并不理想，我們想要當(dāng)猜測正確的數(shù)字時(shí)游戲停止。
猜測正確后退出
讓我們?cè)黾右粋€(gè) break 語句，在用戶猜對(duì)時(shí)退出游戲：
文件名: src/main.rs
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}通過在 You win! 之后增加一行 break，用戶猜對(duì)了神秘?cái)?shù)字后會(huì)退出循環(huán)。退出循環(huán)也意味著退出程序，因?yàn)檠h(huán)是 main 的最后一部分。
處理無效輸入
為了進(jìn)一步改善游戲性，不要在用戶輸入非數(shù)字時(shí)崩潰，需要忽略非數(shù)字，讓用戶可以繼續(xù)猜測?？梢酝ㄟ^修改 guess 將 String 轉(zhuǎn)化為 u32 那部分代碼來實(shí)現(xiàn)，如示例 2-5 所示：
文件名: src/main.rs
// --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--示例 2-5: 忽略非數(shù)字的猜測并重新請(qǐng)求數(shù)字而不是讓程序崩潰
我們將 expect 調(diào)用換成 match 語句，以從遇到錯(cuò)誤就崩潰轉(zhuǎn)換為處理錯(cuò)誤。須知 parse 返回一個(gè) Result 類型，而 Result 是一個(gè)擁有 Ok 或 Err 成員的枚舉。這里使用的 match 表達(dá)式，和之前處理 cmp 方法返回 Ordering 時(shí)用的一樣。
如果 parse 能夠成功的將字符串轉(zhuǎn)換為一個(gè)數(shù)字，它會(huì)返回一個(gè)包含結(jié)果數(shù)字的 Ok。這個(gè) Ok 值與 match 第一個(gè)分支的模式相匹配，該分支對(duì)應(yīng)的動(dòng)作返回 Ok 值中的數(shù)字 num，最后如愿變成新創(chuàng)建的 guess 變量。
如果 parse 不能將字符串轉(zhuǎn)換為一個(gè)數(shù)字，它會(huì)返回一個(gè)包含更多錯(cuò)誤信息的 Err。Err 值不能匹配第一個(gè) match 分支的 Ok(num) 模式，但是會(huì)匹配第二個(gè)分支的 Err(_) 模式：_ 是一個(gè)通配符值，本例中用來匹配所有 Err 值，不管其中有何種信息。所以程序會(huì)執(zhí)行第二個(gè)分支的動(dòng)作，continue 意味著進(jìn)入 loop 的下一次循環(huán)，請(qǐng)求另一個(gè)猜測。這樣程序就有效的忽略了 parse 可能遇到的所有錯(cuò)誤！
現(xiàn)在萬事俱備，只需運(yùn)行 cargo run：
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished dev [unoptimized + debuginfo] target(s) in 4.45s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 61
Please input your guess.
10
You guessed: 10
Too small!
Please input your guess.
99
You guessed: 99
Too big!
Please input your guess.
foo
Please input your guess.
61
You guessed: 61
You win!
太棒了！再有最后一個(gè)小的修改，就能完成猜猜看游戲了：還記得程序依然會(huì)打印出秘密數(shù)字。在測試時(shí)還好，但正式發(fā)布時(shí)會(huì)毀了游戲。刪掉打印秘密數(shù)字的 println!。示例 2-6 為最終代碼：
文件名: src/main.rs
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
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;
}
}
}
}示例 2-6：猜猜看游戲的完整代碼
總結(jié)
此時(shí)此刻，你順利完成了猜猜看游戲。恭喜！
本項(xiàng)目通過動(dòng)手實(shí)踐，向你介紹了 Rust 新概念：let、match、函數(shù)、使用外部 crate 等等，接下來的幾章，你會(huì)繼續(xù)深入學(xué)習(xí)這些概念。第三章介紹大部分編程語言都有的概念，比如變量、數(shù)據(jù)類型和函數(shù)，以及如何在 Rust 中使用它們。第四章探索所有權(quán)（ownership），這是一個(gè) Rust 同其他語言大不相同的功能。第五章討論結(jié)構(gòu)體和方法的語法，而第六章側(cè)重解釋枚舉。
掃描二維碼
下載編程獅App
編程獅公眾號(hào)
更多建議：