在这个章节,我们将会直接使用 Rust 编程语言来创建出猜数字程序的项目,并逐步将它完成!并在撰写程序的过程中,来练习 Rust 编程语言基础的程序语法和引用外部套件的方式。这支小程序在运行之后,将会先从 1 到 100 的整数中,随机抽取一个数字作为答案,并且允许用户输入要猜的数字,如果答错了,程序会回答用户输入的数字究竟是大于答案,还是小于答案,并持续让用户继续猜下去;如果答对了,程序会出现用户赢了的消息,并且结束程序。

创建新的 Cargo 项目

使用 Cargo 来创建出猜数字程序的项目,将其命名为 guessing_game,指令如下:

cargo new --bin guessing_game

在这里我们加了 --bin 参数,让 Cargo 创建出可运行的应用程序项目。

接着就将工作目录移动到程序项目的根目录吧!也就是刚才创建出来的 guessing_game 目录。

如果您不放心程序项目可能没有产生成功,那么可以使用以下指令来直接运行刚才产生出来的 guessing_game 项目。

cargo run

就如同前一章所介绍的一样,Cargo 创建出来的可运行应用程序项目,就是 Hello World 程序。所以会看到程序在屏幕上印出了 Hello, world!。

创建 guessing_game 项目并运行

修改项目设置档

成功产生出 Cargo 的项目后,用文字编辑器打开 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]

在套件的设置区域中,name 字段对应的就是项目名称,Cargo 的项目名称习惯使用底线来将两个单字区隔开来。我们在一开始下指令创建项目的时候,就已经将项目名称取名为 guessing_game 了,所以这边已经预先填好了 guessing_game。如果想要改变项目名称,直接改掉这个字段的值即可。项目目录的名称可以跟项目名称不相同。

再来,version 字段对应的是程序的版本,Cargo 支持「语意化版本」(Semantic Versioning),版本的表示方式如下:

主版号(major).次版号(minor).修订号(patch)

预设的新项目的程序版本号码是从 0.1.0 开始,之后每做一次程序项目的修改,在发布新版本的程序时,就应该要去修改这边的版本号码,将其按照底下的规则递增(通常是加 1):

  • 主版号:做了不兼容的 API 修改。
  • 次版号:做了向下兼容的功能性添加。
  • 修订号:做了向下兼容的问题修正。

如果要更讲究使用版本号码的话,详细的语意化版本控制规范(SemVer)可以到底下这个网页来查看:

edition 字段表示要使用的 Rust 编程语言的版本,版本以公元年份来表示,2015 为初版,2018 为第二版,2021 为第三版。不同版本的 Rust 编程语言无法完全上下兼容。

开始撰写代码

设置好程序项目之后,就可以开始专心写程序啦!

用文字编辑器打开 main.rs,将 println!("Hello, world!"); 改成 println!("Guess the number!");,目的是要让程序在屏幕上印出 Guess the number! 这几个字。

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

程序在屏幕上印出 Guess the number! 之后,应该要先出好猜数字的题目,也就是随机从 1 到 100 的整数中挑出一个作为猜数字的答案。然而,Rust 的标准函数库,并没有提供随机数值的函数,因此在此我们需要引用外部的套件,来完成。至于要使用哪个套件呢?那就是官方提供的 rand 啦。

为了让 Cargo 程序项目能够使用外部的套件,我们必须编辑 Cargo.toml 项目设置档,要在 [dependencies] 的区块中加入 rand 套件,撰写的格式如下:

[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]
rand = "0.8.4"

注意 Cargo.toml 设置档的第 9 行,我们加入了 rand = "0.8.4"。等号左边表示套件的名称,等号右边表示套件的版本。也就是说,在此我们会把「rand v0.8.4」这个套件加入至我们的项目中使用。根据语意化版本控制规范,如果将版本写成 ^0.8.4,代表「任何 API 兼容于 0.8.4 版本的版本」,Cargo 会选择当时最新且符合这个条件的套件来使用。举例来说,如果之后 rand 套件有了三个新版本,分别是 0.8.5、0.9.2 与 1.0.0,而在我们的 Cargo.toml 设置档中,rand 套件的版本是设置为 ^0.8.4 的话,Cargo 将会自动选择 0.8.5 来使用,确保程序项目能用到比较新版本的套件,且也能够在不用修改项目原本代码的情况下,依然可以成功编译程序。可是,为什么 Cargo 会是选择 0.8.5,而不是 0.9.2 呢?主版号一样的话不是表示 API 都是兼容的吗?这其实是个例外状况,当「主版号」为 0 的时候,表示这个套件还在开发阶段,API 会改来改去,但因为程序还在开发阶段,不应该将「主版号」递增到 1 以上,因此会退而求其次,只递增「次版号」。这个例外规则称作「Magic Zero」!

虽然刚才提到版本写成 ^0.8.4 的话就会有自动使用最新兼容套件版本的功能,事实上,在 Cargo.toml 设置档中,若将套件的版本直接写成 0.8.4,其实就代表 ^0.8.4 了!

将 rand 套件加入 Cargo.toml 设置档后,请试试看用以下指令编译项目:

cargo build

cargo build 下载并编译 rand 套件

Cargo 就会自动从 crates.io 将我们刚才加入至 Cargo.toml 设置档的套件和其本身相依的套件都下载下来编译了!

crates.io 是 Rust 官方提供的一个能让 Rust 编程者们分享开源套件的平台,rand 套件就是 crates.io 上的其中一个套件,网址如下:

此时如果直接再运行一次 cargo build,因为我们对项目没有进行任何的修改,因此 Cargo 也不会花时间重新下载套件和编译项目。

再次运行 cargo build 不会重新编译

如果我们对 main.rs 进行一些改动,比如说,将输出的 Guess the number!,在最后多加一个 !。

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

此时再运行一次 cargo build,会发现 Cargo 只会重新编译刚才修改的 main.rs 文件,而并未重新下载 rand 套件,也没有对它进行重新编译的动作。因为 Cargo 只重新编译有做修改的部份,可以大大增加编译速度。

只重新编译修改过的 main.rs

在编译项目之后,程序项目的根目录中会产生出 Cargo.lock 文件。这个文件被用来记录此 Cargo 程序项目使用的相依套件版本,假使之后这些套件有的发布了 API 兼容的新版本,Cargo 在编译项目时,还是会根据 Cargo.lock 里面记载的套件版本,也就是最一开始编译项目时选择使用的套件版本,来继续沿用那个版本的套件,而不是去使用新版本,如此一来也不用每次编译项目都要去寻找和下载比较新的套件。但若要让 Cargo 去使用 API 兼容的新版本套件,也可以使用以下指令来更新 Cargo.lock 文件:

cargo update

这里要注意的是,cargo update 只会更新 Cargo.lock 文件,并不会去更新 Cargo.toml 设置档内的套件版本哦!

知道怎么加套件至 Cargo 程序项目后,再来就是要在代码中使用它啦!在上一章节有稍微提到,Rust 对于套件有定义了一个新的名称──「crate」(板条箱),若要在代码中使用套件,需在代码的最上方使用 extern crate 关键字。由于我们要使用的套件为 rand,因此在代码第一行插入 extern crate 叙述,插入后的代码如下:

extern crate rand;

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

接下来介绍产生一个 1 到 100 随机整数的方式。

extern crate rand;

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

    let secret_number = rand::thread_rng().gen_range(1..=100);
}

来看一下我们添加的第六行叙述。let 这个关键字可以创建变量,例如:

let foo = bar;

这进程式可以声明出一个变量 foo,并且让它存放 bar 这个值(value)。在 Rust 编程语言中,预设声明出来的变量是不可以改变(immutable)的,举例来说:

let x = 5;

如果要让声明出来的变量可以被改变(mutable),则需要在 let 关键字加上 mut。代码如下:

let mut foo = bar;

举例来说:

let x = 5; // immutable
let mut y = 5; // mutable

以上程序会声明出两个变量 x 和 y,并且让它们都存放 5 这个数值。变量 x 由于在声明时没有使用 mut 关键字的关系,因此它只能够被访问,无法进行修改,也就是说 x 的值永远是 5。而变量 y 在声明时使用了 mut 关键字,因此在程序运行阶段,变量 y 的值有可能从原本的 5,被改成其它同类型的值。就像大多数的编程语言一样,// 也是 Rust 语言的单行注解开头。加入注解只是为了方便理解代码,对于程序本身来说,注解并没有任何用处,Rust 编译器会忽略所有代码中的注解,因此也不用担心注解写太多会造成编译出来的程序体积变大。

回到 main.rs 代码的部份。

extern crate rand;

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

    let secret_number = rand::thread_rng().gen_range(1..=100);
}

在一般情况下,通常我们会省略不写 extern crate 叙述。那么,在什么情况下必须要写 extern crate 叙述呢?当我们需要使用 Rust 自带的 crate 时就必须要,例如 proc_macro、alloc、std,不过在预设情况下 Rust 会自己引入标准函数库,所以我们其实也不太需要写 extern crate std; 这样的叙述。

总而言之,以上程序可以简写如下:

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

    let secret_number = rand::thread_rng().gen_range(1..=100);
}

在这个猜数字程序中,用来保存猜数字答案的变量 secret_number 并不需要被改变,因此在被声明出来时不使用 mut 关键字。如此一来可以确保我们在撰写程序的时候不会不小心去改到这个变量的值,而编译器也可以有机会对这种值不会被改变的变量进行特别优化。

接下来我们来看一下 rand::thread_rng().gen_range(1..=100) 到底是什么意思吧!Rust 编程语言使用 :: 这样的语法来寻找指定套件或是模块下的项目,像是这里使用的 rand::thread_rng(),表示要从 rand 套件中调用 thread_rng 这个函数。thread_rng 这个函数会回传一个 ThreadRng 结构(struct)的实体(instance),可以根据目前运行这个函数是用哪个线程,来决定要用什么乱数种子(seed)。

接着看到 thread_rng().gen_range(1..=100)。Rust 编程语言使用 . 这样的语法来使用结构实体的方法(method),因此这个叙述将会再去调用由 thread_rng 函数回传的 ThreadRng 结构实体的 gen_range 方法。然而,事实上,原始的 ThreadRng 结构,并没有实作 gen_range 这样如此高级的方法,因此目前的程序是无法成功编译的。

为了要让程序能够成功编译,我们需要在代码中定义函数的上方,再加入一行叙述,代码如下:

use rand::Rng;

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

    let secret_number = rand::thread_rng().gen_range(1..=100);
}

第 1 进程式,我们使用了 use 这个关键字来使用 rand 套件所提供的 Rng。Rng 是 rand 套件已经实作好的特性(trait),简单来说 Rng 这个特性能够扩充 ThreadRng 结构所拥有的方法,使其拥有一些高级产生随机数值的方法,gen_range 方法就是其中之一。

gen_range 方法需要传入一个参数,来决定要从哪个范围中随机产生数值。这个参数要传入一个范围(range),在 Rust 编程语言中可以用 最小值..最大值 这类的语法来表示一个范围,这里要注意的是,若是只有写 .. 来连接最小值和最大值,则最大值本身并不在范围内,要使用 ..=(多一个等于)来连接才可以使范围包含最大值。因此,若要使用 gen_range 方法来随机产生 1 到 100 中的一个整数,代码需写成 gen_range(1..=100),或是 gen_range(1..101)。

您可能会注意到,我们将保存猜数字答案的变量取名叫 secret_number,而刚才用到的方法名称则是 thread_rng 和 gen_range,这是 Rust 编程语言对于项目、变量、函数、方法的命名习惯──使用底线将单字区分开来,英文字母为小写。而像是 Rng 等结构、特性、枚举(enum)、枚举值的命名习惯,则是使用驼峰式大小写的方式区隔单字,且第一个字母为大写。

有关于 Rust 的结构、特性和枚举将会在之后的章节详细介绍,现阶段只要知道运行 gen_range 方法之后,我们会得到指定范围内的一个随机数值。

紧接着我们可以将这个随机产生出来的数值再利用 println! 这个宏输出到屏幕上。程序如下:

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);
}

就像是其它编程语言有的字符串格式化(format)功能,Rust 当然也有自己的一套。在练习 Hello World 程序时我们也稍微了解到,Rust 用的 println! 不是一般的函数,而是宏!

宏 println! 第一个参数传入字符串的样本,并允许在字符串样本中使用大括号 {} 来表示要预留的空位,格式化时就会把紧接着传入进宏 println! 的其它参数用来取代字符串样本预留的空位。

大括号 {} 内还可以再加上其他消息,用来控制参数代入的顺序和方式,这个在之后的章节会更详细地介绍,现在我们只需知道我们可以直接把变量名称填写到大括号 {} 内,就不必再从后面的参数传入空位的值了。程序如下:

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! 的叙述,在屏幕上印出消息,来提示用户该要开始输入要猜的数字了。程序如下:

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.");
}

再来,我们要声明出一个变量,用来保存用户输入的文字。程序如下:

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();
}

程序第 12 行,由于我们不知道用户究竟会输入怎么样的文字,因此在声明 guess 变量时加上 mut 关键字。String 为 Rust 编程语言的标准函数库所内置的一个结构体,使用 UTF-8 编码来处理可变动长度的字符串数据,其提供的 new 函数可以快速产生 String 结构的实体。

接着,为了让用户输入文字了,我们需要使用 std::io 这个模块(mod),std::io 提供了一些有关输入与输出的功能,在之后的章节会详细介绍模块的用法。

若要在代码中方便使用 std::io 模块,我们可以利用 use 关键字将其引用进来。程序如下:

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 来表示 std::io 模块了!

在预设的情况下,Rust 只会自动引用一些东西进入目前程序的使用范围(scope),这些自动引入的东西均定义在 std::prelude 模块中。如果要使用没有定义在 std::prelude 模块中的东西,就要靠 use 关键字来引用。

引用了 std::io 模块之后,即可加入新的程序叙述:

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");
}

程序第 16 行,利用 std::io 提供的 stdin 函数,来创建出一个用来处理标准输入的 Stdin 结构实体。第 17 行调用其提供的 read_line 方法,来让用户能透过标准输入串流输入文字,并且将输入的文字存进从参数传入的 String 结构实体。前面我们使用 use 关键字,将 std::io 模块加入至我们的程序 scope 中,如果只是临时要使用某套件的某个模块或函数,不想将其加入整个程序的 scope 中的话,也可以省略 use 关键字,之后在使用时改用完整的名称来指定即可。举例来说,不用 use 关键字来引用 std::io 模块的话,原本第 16 行的 io::stdin() 可以改写成 std::io::stdin()。

传入 read_line 方法的参数类型为 &mut String,& 所代表的意思是取得这个变量的参考(reference),至于为什么在此要用参考的方式传递参数,将留在之后的章节介绍。在 & 后面加上 mut 是用来表示这个参考所指到的值是可变的,因为我们需要把用户输入的文字存进传进 read_line 方法的 String 结构中,所以使用 mut。read_line 方法还会回传一个 Result 枚举的值,方便我们判断这个方法有没有运行成功。事实上,我们不一定要处理函数或是方法回传的 Result 枚举的值,只不过若没有去使用到函数或是方法的回传值的话,编译器是会出现警告消息的!为了能够增加程序的安全性,我们还是应该要去处理函数或是方法的回传值。

Result 枚举是 Rust 编程语言提供的类型,只有两种值(准确来说是「变体」(variant)),分别是 Ok 和 Err。顾名思义,Ok 代表程序运行成功,Err 则代表程序运行失败,这两种值分别包裹运行成功的值和运行错误的值。Result 枚举经常被函数或是方法作为回传值,来回传函数或是方法有没有运行成功。由于判断「Result 枚举的值是 Ok 还是 Err」的这个动作会很频繁的在代码中被使用到,因此 Rust 编程语言提供了一个简化判断 Result 枚举的语法糖──expect 方法。

程序第 18 行,我们调用了 read_line 方法所回传的 Result 枚举的 expect 方法,如果该 Result 枚举的值是 Err 的话,将会造成程序 panic(惊慌),而 panic 消息就是代入至 expect 方法之参数的 Failed to read line 文字。如果该 Result 枚举的值是 Ok 的话,则会回传被 Ok 包裹的值。

接着使用 println! 宏,输出用户刚才输入的文字。程序如下:

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}");
}

我们刚才使用 read_line 方法让用户输入进来的文字是 String 类型,为了让它能够与猜数字的答案 secret_number 进行数值大小比较,我们必须将 String 转成 i32。Rust 编程语言对于数值类型,区分了有号整数(i)、无号整数(u)和浮点数(f),整数依照表示范围区分为 8 比特、16 比特、32 比特、64 比特和 128 比特,浮点数也依照精准度区分为 32 比特和 64 比特。由于我们在使用 gen_range 方法时所代入的参数值为整数的范围,在 Rust 编程语言中,直接写在代码的整数预设使用 32 比特的整数类型,也就是 i32,因此 secret_number 的类型也就是 i32。为了能够与类型为 i32 的 secret_number 变量进行比较,我们需要将 guess 变量所保存的 String 结构体也转成 i32 类型。程序如下:

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");

    let guess: i32 = guess.trim().parse().expect("Please type a number!");

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

程序第 20 行,我们使用 let 关键字声明了一个 guess 变量,并且使用 : 语法将其的类型指定为 i32。可是程序第 14 行不是已经有用 let 声明过 guess 变量了吗?而且还使用了 mut 关键字让它是可变的,为什么不直接使用这个 guess 变量,而在程序第 20 行的时候用 let 重新声明呢?这是因为 Rust 编程语言所使用的变量一旦被定义好类型,就不能再进行改变了,程序第 20 行其实是使用 let 声明一个新的且类型不同的 guess 变量,由于变量名称相同的关系,这个新的 guess 变量在声明之后会屏蔽(shadowing)掉原先的 guess 变量。程序 = 右边的式子会先运行完毕之后再指派给左边,因此程序第 20 行等号右边的 guess 变量,其实还是第 14 行声明的那个 String 结构体的 guess 变量。String 结构实体提供了 trim 方法,可以消除字符串头尾所使用的空白与换行字符,并回传另一种类型的字符串──str,这个在之后的章节会详细介绍。总而言之,透过 trim 方法,我们也可以过滤掉用户确认输入时按下 Enter 键而产生的 \n 字符,避免造成之后转换成数值类型时发生问题。无论是 String 还是 str 类型的字符串,都可以使用 parse 方法,来将字符串转成有实作 FromStr 这个特性的类型,例如数值类型。在此,变量的类型不像程序第 14 行一样,可以自动根据最一开始指派的值来定义类型,而是必须先定义好,否则会编译错误。或者,也可以用「turbofish」语法来指定 parse 方法要转成的数值类型,语法如下:

let guess = guess.trim().parse::<i32>();

或许这种 ::<> 的语法很像是一种叫作「Turbot」(大菱鲆)的鱼,所以才会称作「turbofish」吧?之后的章节会详细介绍 <> 语法所表示的泛型(generic)概念。

程序第 20 行,由于 parse 方法运行之后会回传 Result 枚举,所以同样也可以使用 expect 方法来处理。

接着就要来判断用户输入的数值是否刚好猜中答案,如果是的话,要印出 You win!;如果不是的话,要印出 Too small! 或是 Too big!。程序如下:

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");

    let guess: i32 = guess.trim().parse().expect("Please type a number!");

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

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

程序第 24 行到第 28 行,使用了 match 关键字来控制程序流程。match 关键字是 Rust 编程语言中提供的一种类似其它语言 switch 关键字控制流程的功能,它能够判断传入的数值符合哪个它定义好的「arm」(手臂),来决定要运行什么程序。类型为 i32 的 guess 变量,可以使用 cmp 这个方法来与传入另一个 i32 的值进行比较,如果 guess 变量的值小于传进来比较的值,cmp 方法就会回传 std::cmp::Ordering 枚举的 Less 值;如果大于,会回传 Greater;如果等于,会回传 Equal。程序第 25 行定义了一个 match 的 arm,如果传入 match 的值为 std::cmp::Ordering 枚举的 Less 值的话,程序就会用 println! 宏印出 Too small!。同理,程序第 26、27 行就是定义符合其它值时候的流程。之后的章节会详细介绍 match 的用法,现在先理解到这样的程度即可。

由于 std::cmp::Ordering::Less 这样的写法实在又臭又长,我们可以利用 use 关键字,将 std::cmp::Ordering 引用到我们程序的 scope 中。代码可以改写成如下的样子:

use std::cmp::Ordering;
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");

    let guess: i32 = 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!"),
    }
}

再来,我们要想办法让用户在猜错之后,还能够依照提示继续猜下去,而不是直接结束程序,因此我们会需要用到 loop 关键字来创建程序循环。将程序改写如下:

use std::cmp::Ordering;
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}");

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

        let mut guess = String::new();

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

        let guess: i32 = 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!"),
        }
    }
}

程序第 13 行和第 31 行,我们利用 loop 关键字将让用户输入文字并显示猜测结果的程序包成了一个区块,程序如果未在这个区块运行到 break 或是 return 叙述,就会不断的重复运行这个区块内的叙述。为了能够让用户在猜对数字之后结束程序,我们需要再将程序进行改写,如下:

use std::cmp::Ordering;
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}");

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

        let mut guess = String::new();

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

        let guess: i32 = 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!");
                break;
            }
        }
    }
}

程序第 29 行到第 32 行,改写了原先 Ordering::Equal 这个 match arm 的写法,在印出 You win! 文字之后运行 break 叙述。和其他大多数的编程语言一样,Rust 编程语言 loop 区块中的 break 叙述是用来跳出循环;continue 叙述是用来跳过这次循环的运行,直接进入下一次。由于原先的 arm 只有一行叙述,所以不需要另外用大括号 {} 表示程序区块,但现在需要运行超过一个叙述,因此要使用大括号 {} 将需要运行的叙述包起来。

至此,我们已经差不多完成了这个猜数字程序了。可以用 cargo run 指令玩个几次试试。

以 cargo run 玩猜数字程序

我们预期用户输入的字符串是数字,接着再由我们的程序将字符串转成数值类型,但如果用户输入的字符串不是正确的数字,就会出现带有 Please type a number! 消息的 panic,程序就这样莫名其妙的停止结束运行了。

输入非数字时发生 panic 的猜数字程序

这样的方式对于用户来说会是一个很糟糕的体验,为了解决这个问题,我们可以利用 match 关键字来处理 parse 方法回传的 Result 枚举。将程序改写如下:

use std::cmp::Ordering;
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}");

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

        let mut guess = String::new();

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

        let guess: i32 = 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;
            }
        }
    }
}

程序第 22 行到第 25 行,我们把原先使用 expect 方法来处理 Result 枚举的方式改为使用 match 关键字。在 match 的 arm 中,我们判断 parse 方法回传的 Result 是否符合 Ok(num) 或是 Err(_)。num 是一个表示 Ok 第一个包裹的参数的变量,透过这样的语法,就可以在 => 右方用 num 取得 Ok 包裹在第一个参数的值。若在此使用的不是 num 这样的变量名称,而是一个明确的值的话,就表示 parse 方法回传的 Result::Ok,第一个参数必须要正好包裹着这个明确的值。若我们将程序改写成如下的样子:

use std::cmp::Ordering;
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}");

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

        let mut guess = String::new();

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

        let guess: i32 = match guess.trim().parse() {
            Ok(-1) => {
                println!("Bye bye!");
                break;
            }
            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;
            }
        }
    }
}

当用户猜的数字为 -1 时,就会印出 Bye bye! 文字,然后跳出循环,结束程序。

输入 -1 时印出 Bye bye! 并结束

请注意,若把 Ok(-1) 这条 arm 放在 Ok(num) 之后,将会永远无法被运行到,因为 match 关键字判断要运行哪条 arm 的方式是依照代码撰写顺序的。

至于 Err(_) 的 _,则是表示要忽略这个参数,如果将其改写成 Err(e) 的话,程序虽然也可以被编译运行,但因 e 这个变量并没有用到,所以编译器会出现警告消息。

程序写到这里,这个章节的猜数字程序已经完成了,最后使用 cargo build --release 指令将项目编译出可执行文件,然后把这个可执行文件传给亲朋好友们玩玩看吧!

以 cargo build --release 编译后运行

总结

在这一章中,我们成功地完成了猜数字程序,已经用过了 let、match、use、extern crate 等等的关键字,稍微接触了 Rust 的基本数据类型、结构、特性和枚举,也用了一些标准函数库提供的功能。在接下来的章节中,将会对变量、数据类型、函数、程序流程进行更深入的探讨。

下一章:Rust 编程语言的基础概念。