猜数字游戏（Rust实现）

游戏说明

游戏说明

游戏运行逻辑如下：

1. 随机生成一个1-100的数字作为神秘数字，并提示玩家进行猜测。
2. 如果玩家猜测的数字小于神秘数字，则提示用户“猜测的数字太小了”。
3. 如果玩家猜测的数字大于神秘数字，则提示用户“猜测的数字太大了”。
4. 让玩家不断进行猜测，直到最终猜出神秘数字，游戏结束。

游戏效果展示

游戏效果展示

游戏代码

游戏代码

游戏完整代码如下：

use rand::Rng;
use std::io;
use std::cmp::Ordering;

fn main() {
    println!("欢迎来到猜数游戏!");
    //1、生成神秘数字
    let secret_number = rand::thread_rng().gen_range(1, 101);
    println!("神秘数字已经生成!");

    loop {
        //2、让用户进行猜测
        println!("请猜测:>");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("无法读取行");

        //3、将用户输入的数字字符串转化为整型
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("请您输入一个合法的整数!");
                continue;
            }
        };

        //4、将用户猜测的数与神秘数字进行比较
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("您猜测的数字太小了"),
            Ordering::Greater => println!("您猜测的数字太大了"),
            Ordering::Equal => {
                println!("恭喜您猜对了, 神秘数字就是{}!", secret_number);
                break;
            }
        }
    }
}

游戏代码详解

下面对猜数字游戏中所用到的Rust语法和包（crate）进行讲解。

生成神秘数字

rand包

• Rust团队没有把随机数字生成功能内置到标准库中，而是选择将它作为rand包（rand crate）提供给用户。
• Rust中的包（crate）代表了一系列源代码文件的集合，我们当前正在构建的项目是一个用于生成可执行程序的二进制包（binary crate），而我们引用的rand包则是一个用于复用功能的库包（library crate）。
• rand包中有一个名为Rng的trait，它定义了随机数生成器需要实现的方法集合，比如Rng中的gen_range方法可以根据指定的范围来生成随机数。

在rand包中有一个名为thread_rng的方法，该方法会返回一个特定的随机数生成器，通过调用该随机数生成器的gen_range方法即可在指定范围内生成随机数。如下：

use rand::Rng;

fn main() {
    let secret_number = rand::thread_rng().gen_range(1, 101); //在[1,101)范围生成随机数
    println!("生成的神秘数字是: {}", secret_number);
}

说明一下：

• thread_rng方法返回的随机数生成器（ThreadRng类型）位于本地线程空间，并通过操作系统获得随机种子。
• ThreadRng类型实际并没有实现gen_range方法，我们调用的实际是Rng trait中默认实现的gen_range方法，因此需要通过use语句将rand包中的Rng trait引入到当前作用域。
• Rust中的trait可以类比其他语言中的接口的概念，它定义了一组方法，比如可以类比Golang中的interface，但trait的职责远比interface更多。
• 代码中生成的随机数位与1-100之间，而Rust中很多整数类型都能涵盖这个范围，比如i32、u32、i64等，除非在代码中增加更多的信息用于类型推断，否则这个类型将会被视为i32类型，代码中定义secret_number变量时就没有指定它的类型，因此其为i32类型。
• 代码中通过fn关键字声明了一个无参无返回值的main函数，通过let关键字定义一个secret_number变量来存储生成的随机值。
• 代码中的println!是一个宏，其功能是将字符串格式化后打印到标准输出，格式化字符串中包含占位符{}，从第二个参数开始，各参数依次替换格式化字符串中的占位符。

添加依赖

Cargo最主要的功能就是帮助我们管理和使用第三方库，在使用rand包编写代码之前，需要在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.3.14"

执行cargo build命令后，Cargo就会从crates.io网站下载并编译指定的包，并基于这些依赖编译我们自己的项目。如下：

说明一下：

• 在Cargo.toml文件中指明的0.3.14实际上是^0.3.14的简写，它表示任何与0.3.14版本公共API相兼容的版本，因此我们下载不一定是我们指定版本号的包。
• Cargo可以从注册表（registry）中获取所有可用rand包的最新版本信息，这些信息通常是从crates.io上复制过来的。（crates.io是用于分享各种各样开源Rust项目的网站）
• Cargo会在更新完注册表后逐条检查[dependencies]片段下的依赖，并下载当前缺失的依赖包，由于rand包依赖于libc，因此在下载rand包的时候额外下载了一份libc数据。

Cargo.lock

Cargo提供了一套机制来保证我们构建的结果是可重现的，任何人是任何时候编译我们的代码都会生成相同的产物，因为Cargo会一直使用某个特定版本的依赖，直到我们手动指定了其他版本。

• 当第一次使用cargo build构建项目时，在项目目录下会生成Cargo.lock文件，Cargo会依次遍历我们声明的依赖及其对应的语义化版本，找到符合要求的具体版本号，并将其写入Cargo.lock文件中。
• 后续再次构建项目时，Cargo会先检索Cargo.lock文件，如果文件中存在已经指明具体版本的依赖库，那么它就会跳过计算版本号的过程，并直接使用文件中指明的版本，这就使得我们构建的结果是可重现的。

如果你确实需要升级某个依赖包，那么可以使用cargo update命令，该命令会强制Cargo忽略Cargo.lock文件，并重新计算出所有依赖包中符合Cargo.toml声明的最新版本。如下：

说明一下：

• 如果cargo update命令运行成功，Cargo会将各个依赖包更新后的版本号写入Cargo.lock文件。
• 在当前示例中，Cargo在自动升级时只会寻找大于0.3.0版本，并且小于0.4.0版本的最新版本，如果要将rand包的升级到0.4.x，那么就需要在Cargo.toml文件中指明对应的版本。
• 当前示例执行cargo update命令后，Cargo.lock中的内容实际不会改变，因为之前构建项目的时候Cargo.lock中写入的就是0.3开头的最新的版本0.3.23。

读取用户输入

io模块

• 标准库（std）中的io模块包含了许多有用的功能，通过io模块可以获取到用户输入的数据。
• io模块中有一个名为Stdin的struct，该struct中的read_line方法可以从标准输入中读取用户的一行输入。

在io模块中有一个关联函数叫做stdin，该函数会创建一个Stdin的实例并返回，通过这个实例来调用read_line方法即可读取用户的一行输入。如下：

use std::io;

fn main() {
    let mut guess = String::new();
    io::stdin().read_line(&mut guess).expect("无法读取行");
    println!("输入的内容: {}", guess);
}

说明一下：

• Rust会将预导入（prelude）模块自动引入每一段程序的作用域中，该模块包含了一小部分常用的类型，如果你要使用的类型不在预导入模块中，那么就需要使用use语句显示进行导入声明。
• 调用read_line方法读取用户数据时，为了将读取到的数据传递出来，需要以引用的方式传入一个String类型的变量，因此需要定义一个String类型的guess变量。（String是标准库中的一个字符串类型，该类型的new方法会创建一个新的空白字符串。）
• 由于在read_line函数内部会将读取到的数据写入到guess变量中，因此在定义guess变量时使用mut关键字将其定义成一个可变的String变量，并且在将guess传递给read_line函数时也需要使用mut关键字来传递这个可变的引用变量。（Rust中的变量默认是不可变的）
• Rust有一个静态强类型系统，同时拥有自动类型推导的能力，因此当代码中定义guess变量时虽然没有指明guess的类型，Rust也会自动将其推导为String类型。

小贴士：Rust中很多类型都有new方法，因为这是创建类型实例的惯用函数名称。

Result枚举

• read_line函数会将读取到的内容存储到我们传入的字符串中，该函数的返回值类型是io::Result。
• 在Rust标准库中有很多以Result命名的类型，它们通常是各个子模块中的Result泛型的特定版本。
• Result是一个枚举类型，枚举类型由一系列固定的值组合而成，这些值被称作枚举的变体。

对于Result枚举来说，它有Ok和Err两个变体：

• Ok变体表示当前操作执行成功，此时代码的结果值会存储在Ok变体中。
• Err变体表示当前操作执行失败，此时引发失败的具体原因会存储在Err变体中。

Result枚举的定义如下：

pub enum Result<T, E> {
    /// Contains the success value
    Ok(T),
    /// Contains the error value
    Err(E),
}

Result类型中定义了一系列方法，其中有一个方法叫做expect，该方法接收一个字符串：

• 如果Result枚举的值为Ok，那么expect会提取出Ok中附带的值，并将其作为结果返回给用户。
• 如果Result枚举的值为Err，那么expect会中断当前的程序，并将传入的字符串显示出来。

expect方法的定义如下：

impl<T, E> Result<T, E> {
	//...
    pub fn expect(self, msg: &str) -> T
    where
        E: fmt::Debug,
    {
        match self {
            Ok(t) => t,
            Err(e) => unwrap_failed(msg, &e),
        }
    }
    //...
}

说明一下：

• 如果不对read_line函数的返回值做处理，那么会产生告警，因为read_line函数的返回值可能是一个Err变体，这就意味着我们没有对潜在的错误进行处理，通过这点就可以看到Rust的安全性。

解析用户输入

解析用户输入

现在我们已经能够获得用户的输入了，但此时guess变量是String类型的，而我们生成的神秘数字是整型的，为了能够将它们进行比较，需要将guess变量转化为整型。如下：

use std::io;

fn main() {
    println!("请输入一个整数:>");
    let mut guess = String::new();
    io::stdin().read_line(&mut guess).expect("无法读取行");
    
    let guess: u32 = guess.trim().parse().expect("请您输入一个合法的整数!");
    println!("解析成功, 输入的数字是: {}", guess);
}

说明一下：

• 字符串的trim方法的作用是去掉字符串两端的空白字符，包括空白字符、Tab、回车（\n）等，该方法会将处理后的字符串进行返回。
• 字符串的parse方法的作用是将字符串解析成某种数值类型，比如i32、u32、i64、f64等，该方法的返回值是一个Result枚举，当字符串无法解析成数值类型时便会返回Err变体。
• 由于parse方法的解析结果可能是多种数值类型，可以是浮点数也可以是整数，因此需要指定接收解析结果的变量的类型，定义变量时在变量名后面加一个冒号，再在冒号后面指定变量的类型即可。
• 代码中接收解析结果的变量的变量名仍为guess，在Rust中不会报错，因为Rust允许使用同名的新变量来隐藏（shadow）原来同名的旧变量的值，这一特性通常被用在需要转换值类型的场景中。

多次处理用户输入

为了猜中神秘数字，用户可能需要进行多次猜测，因此我们也需要多次对用户的输入进行解析，在Rust中使用loop关键字即可创建一个无限循环。如下：

use std::io;

fn main() {
    loop {
        println!("请输入一个整数:>");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("无法读取行");
        
        let guess: u32 = match guess.trim().parse().expect("请您输入一个合法的整数!");
        println!("解析成功, 输入的数字是: {}", guess);
    }
}

match表达式

当用户输入非数字字符串时，parse方法就会解析失败，这时最好让用户重新猜测，而不是终止程序，鉴于parse方法的返回值类型是Result类型，因此可以用match表达式来代替expect函数，这也是在Rust中处理错误的一个惯用手段。

• 如果parse返回的是Ok变体，那么表示解析成功，并且解析结果存储在Ok变体中，此时将Ok变体中的值返回即可。
• 如果parse返回的是Err变体，那么表示解析失败，并且引发失败的具体原因会存储在Err变体中，此时打印一句提示语句并让循环continue即可。

代码如下：

use std::io;

fn main() {
    loop {
        println!("请输入一个整数:>");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("无法读取行");
        
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("请您输入一个合法的整数!");
                continue;
            }
        };
        println!("解析成功, 输入的数字是: {}", guess);
    }
}

说明一下：

• match表达式由多个分支（arm）组成，这些分支必须涵盖所有可能的情况，每个分支都包含一个用于匹配的模式（pattern），以及匹配成功后要执行的相应的代码。
• Rust会尝试用我们传入match表达式的值去依次匹配每个分支的模式，如果匹配成功，它就会执行当前分支中的代码。
• 对于match中的每个分支来说，模式中不需要的信息可以通过_忽略，而如果匹配成功后要执行的代码有多条，可以将这些代码放到一个代码块中。

进行猜测比较

进行猜测比较

现在要做的就是将用户猜测的数字和神秘数字进行比较。

• 如果比较成功，则通过break跳出循环，游戏结束。
• 如果比较失败，则提示用户猜大了还是猜小了，游戏继续。

这里也可以使用match表达式来处理。如下：

use rand::Rng;
use std::io;
use std::cmp::Ordering;

fn main() {
    println!("欢迎来到猜数游戏!");
    //1、生成神秘数字
    let secret_number = rand::thread_rng().gen_range(1, 101);
    println!("神秘数字已经生成!");

    loop {
        //2、让用户进行猜测
        println!("请猜测:>");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("无法读取行");

        //3、将用户输入的数字字符串转化为整型
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("请您输入一个合法的整数!");
                continue;
            }
        };

        //4、将用户猜测的数与神秘数字进行比较
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("您猜测的数字太小了"),
            Ordering::Greater => println!("您猜测的数字太大了"),
            Ordering::Equal => {
                println!("恭喜您猜对了, 神秘数字就是{}!", secret_number);
                break;
            }
        }
    }
}

说明一下：

• 通过调用guess变量的cmp方法，可以将guess变量与同类型变量进行比较，在比较时传入另一个变量的引用即可。
• cmp方法的返回值的类型是Ordering枚举，该枚举有Less、Greater和Equal三个变体，分别表示比较结果为小于、大于和等于。

此外，也可以使用if else语句对用户猜测的数字和神秘数字进行比较。如下：

use rand::Rng;
use std::io;

fn main() {
    println!("欢迎来到猜数游戏!");
    //1、生成神秘数字
    let secret_number = rand::thread_rng().gen_range(1, 101);
    println!("神秘数字已经生成!");

    loop {
        //2、让用户进行猜测
        println!("请猜测:>");
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("无法读取行");

        //3、将用户输入的数字字符串转化为整型
        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("请您输入一个合法的整数!");
                continue;
            }
        };

        //4、将用户猜测的数与神秘数字进行比较
        if guess < secret_number {
            println!("您猜测的数字太小了");
        } else if guess > secret_number {
            println!("您猜测的数字太大了")
        } else {
            println!("恭喜您猜对了, 神秘数字就是{}!", secret_number);
            break;
        }
    }
}

说明一下：文章来源地址https://www.toymoban.com/news/detail-716003.html

• 虽然之前secret_number变量被默认推导为i32类型，但由于这里将guess和secret_number进行了比较，而guess变量是u32类型的，因此Rust会将secret_number也推导为相同的u32类型。

到了这里，关于猜数字游戏（Rust实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！