猜数字游戏和RUST基本语法

RustKK

已于 2024-08-01 08:28:40 修改

阅读量1k

点赞数 8

文章标签： rust 开发语言后端

于 2024-07-16 21:36:23 首次发布

本文链接：https://blog.csdn.net/m0_52526873/article/details/140476111

版权

猜字谜小游戏；

use rand::Rng;        // 生成随机数字库引入当前作用域，需要在cargo.toml加入依赖rand = "0.8.5"         
use std::cmp::Ordering;         //ORdering是枚举三个对象通过cmp进行比较
use std::io;                        //输入输出库引入当前作用域

fn main() {
println!("猜数字！！");
let secret_number = rand::thread_rng().gen_range(1..=100);//对secret_number赋值1-100随机数字
  loop {                                     //循环
        println!("请输入你的猜想.");
        let mut guess = String::new();          //给可变量赋予一个空的地址
        io::stdin()
            .read_line(&mut guess)               //读取输入行的值
            .expect("Failed to read line");

        let guess: u32 = guess.trim().parse().expect("请输入数字");   
       //Rust 不会比较字符串类型和数字类型.复用guess的变量并绑定到.trim.parse
       // trim 方法会去除字符串开头和结尾的空白字符，因为用输入enter会有空白/ 因为u32只包含数字字符
       // 字符串的 parse 方法 将字符串转换成其他类型。这里用它来把字符串转换为数值。

        println!("你猜得数字是{}", guess);
        match guess.cmp(&secret_number) {
            Ordering::Less => println!("太小!"),
            Ordering::Greater => println!("太大!"),
            Ordering::Equal => {
                println!("正好!");
                break;
            }
        }
    }
}

1. 变量和可变性

定义变量：使用 let 关键字定义变量。
可变变量：使用 mut 关键字定义可变变量。
常量： 类似于不可变变量，常量 (constants) 是绑定到一个名称的不允许改变的值，不过常量与变量还是有一些区别。首先，不允许对常量使用 mut 。常量不光默认不可变，它总是不可变。声明常量使用 const 关键字而不是 let ，并且必须注明值的类型。在下一部分，“数据类型” 中会介绍类型和类型注解，现在无需关心这些细节，记住总是标注类型即可。常量可以在任何作用域中声明，包括全局作用域，这在一个值需要被很多部分的代码用到时很有用。最后一个区别是，常量只能被设置为常量表达式，而不可以是其他任何只能在运行时计算出的值。
常量在整个程序生命周期中都有效，此属性使得常量可以作为多处代码使用的全局范围的值，例如一个游戏中所有玩家可以获取的最高分或者光速。
将遍布于应用程序中的硬编码值声明为常量，能帮助后来的代码维护人员了解值的意图。如果将来需要修改硬编码值，也只需修改汇聚于一处的硬编码值。
隐藏：我们可以定义一个与之前变量同名的新变量。Rustacean 们称之为第一个变量被第二个隐藏（Shadowing）了，这意味着当您使用变量的名称时，编译器将看到第二个变量。实际上，第二个变量“遮蔽”了第一个变量，此时任何使用该变量名的行为中都会视为是在使用第二个变量，直到第二个变量自己也被隐藏或第二个变量的作用域结束。可以用相同变量名称来隐藏一个变量，以及重复使用 let 关键字来多次隐藏，

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);

    let mut y = 10;
    println!("The initial value of y is: {}", y);
    y = 20;
    println!("The new value of y is: {}", y);
}

2. 数据类型

标量类型：包括整数、浮点数、布尔值和字符。
整型：整数是一个没有小数部分的数字。我们在第二章使用过 u32 整数类型。该类型声明表明，它关联的值应该是一个占据 32 比特位的无符号整数（有符号整数类型以 i 开头而不是 u ）。表格 3-1 展示了 Rust 内建的整数类型。我们可以使用其中的任一个来声明一个整数值的类型。
整型溢出：比方说有一个 u8 ，它可以存放从零到 255 的值。那么当你将其修改为 256 时会发生什么呢？这被称为 “整型溢出”（“integer overflow” ），这会导致以下两种行为之一的发生。当在 debug 模式编译时，Rust 检查这类问题并使程序 panic，这个术语被 Rust 用来表明程序因错误而退出。
为了显式地处理溢出的可能性，可以使用这几类标准库提供的原始数字类型方法： • 所有模式下都可以使用 wrapping_* 方法进行 wrapping，如 wrapping_add • 如果 checked_* 方法出现溢出，则返回 None 值 • 用 overflowing_* 方法返回值和一个布尔值，表示是否出现溢出 • 用 saturating_* 方法在值的最小值或最大值处进行饱和处理
浮点型 Rust 也有两个原生的浮点数（floating-point numbers）类型，它们是带小数点的数字。Rust 的浮点数类型是 f32 和 f64 ，分别占 32 位和 64 位。默认类型是 f64 ，因为在现代 CPU 中，它与 f32 速度几乎一样，不过精度更高。所有的浮点型都是有符号的。
布尔型正如其他大部分编程语言一样，Rust 中的布尔类型有两个可能的值：true 和 false 。Rust 中的布尔类型使用 bool 表示。
字符类型 Rust 的 char 类型是语言中最原生的字母类型。
复合类型：包括元组和数组。
复合类型（Compound types）可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple）和数组（array）。
元组类型元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小。我们使用包含在圆括号中的逗号分隔的值列表来创建一个元组。元组中的每一个位置都有一个类型，而且这些不同值的类型也不必是相同的。
数组类型另一个包含多个值的方式是数组（array）。与元组不同，数组中的每个元素的类型必须相同。 Rust 中的数组与一些其他语言中的数组不同，Rust 中的数组长度是固定的。

fn main() {
    let a: i32 = 42;
    let b: f64 = 3.14;
    let c: bool = true;
    let d: char = 'R';

    let tuple: (i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tuple;
    println!("The value of y is: {}", y);

    let array: [i32; 3] = [1, 2, 3];
    println!("The first element of the array is: {}", array[0]);
}

3. 函数

定义和调用函数。
参数和返回值。

fn main() {
    greet("Rust");
    let result = add(5, 3);
    println!("The sum is: {}", result);
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

4. 控制流

if 表达式。
if 表达式允许根据条件执行不同的代码分支。你提供一个条件并表示 “如果条件满足，运行这段代码；如果条件不满足，不运行这段代码。
循环：loop、while 和 for。
loop 关键字告诉 Rust 一遍又一遍地执行一段代码直到你明确要求停止。
while 条件循环在程序中计算循环的条件也很常见。当条件为 true ，执行循环。当条件不再为 true ，调用 break 停止循环。这个循环类型可以通过组合 loop 、if 、else 和 break 来实现；如果你喜欢的话，现在就可以在程序中试试。然而，这个模式太常用了，Rust 为此内置了一个语言结构，它被称为 while 循环。示例 3-3 使用了 while ：程序循环三次，每次数字都减一。接着，在循环结束后，打印出另一个信息并退出。
for 遍历集合可以使用 while 结构来遍历集合中的元素
区别总结；
控制方式：loop 是无限循环，需要手动 break；while 是条件循环，每次循环前检查条件；for 是迭代循环，用于遍历集合或范围。
使用场景：loop 适用于明确的中断条件；while 适用于动态条件判断；for 适用于遍历固定集合。

fn main() {
    let number = 7;

    if number < 10 {
        println!("The number is less than 10");
    } else {
        println!("The number is 10 or more");
    }

    let mut count = 0;
    loop {
        count += 1;
        if count == 5 {
            break;
        }
    }
    println!("Loop stopped at count: {}", count);

    let mut num = 3;
    while num != 0 {
        println!("{}!", num);
        num -= 1;
    }

    let arr = [10, 20, 30, 40, 50];
    for element in arr.iter() {
        println!("The value is: {}", element);
    }
}