Chapter 1: Cargo——Rust 的包管理器

Cargo 是 Rust 的一个强大的 包管理器，通过 cargo 可以快速构建一个结构完整的 Rust 项目，并且通过命令行来编译运行项目

1.cargo new

该指令用于创建一个完整的 Rust 项目。可加参数 " vsc ==" 来创建附加内容，默认创建了一个 git 存储库，但是我关掉了，具体关掉的方法如下:

在 Rust 中使用 cargo 创建新项目时，默认会初始化一个 Git 仓库。如果你希望 不自动添加 Git 版本控制，可以使用以下两种方法：

方法 1：使用 --vcs none 参数

在创建项目时，显式指定 不初始化任何版本控制系统：

bash

1

cargo new --vcs none my_project

这会跳过 Git 仓库的初始化。

方法 2：全局配置 Cargo 默认不初始化 Git

如果你希望所有新项目都默认不初始化 Git，可以修改 Cargo 的全局配置：

1. 打开或创建 Cargo 的配置文件 ~/.cargo/config.toml（Linux/macOS）或 %USERPROFILE%\.cargo\config.toml（Windows）。

2. 添加以下内容：

   toml

   1 2	[cargo-new] vcs = "none"

这样之后所有 cargo new 命令都会跳过版本控制系统的初始化。

补充说明

• 如果已经创建了项目，你可以直接删除项目根目录下的 .git 文件夹来移除 Git 跟踪。
• 支持的 --vcs 选项包括：git（默认）、hg（Mercurial）、pijul 或 none。

这种方法既简单又干净，适合不需要版本控制或打算使用其他版本控制系统（如 Mercurial 或 SVN）的情况。

2.cargo build

该指令用于 编译并生成一个可执行的二进制文件。注意与后文的 cargo check 区分。可以添加 --release 来让生成文件存放在 targer/release 中，而非默认的 target/debug 中。

3.cargo check

该指令用来编译当前的工程，但注意，cargo check 并不会 和 cargo build 一样生成一个可执行的二进制文件，所以耗时会大大快于后者，通常用于代码工程编写中途来 检测当前有无显著语法错误。

4.cargo run

编译并且运行。

Chapter 2: 猜数游戏

程序将生成一个介于 1 到 100 之间的随机整数。然后它会提示玩家输入猜测。输入猜测后，程序会指示猜测是太低还是太高。如果猜对，游戏将打印一条祝贺消息并退出。

2.1 使用标准输入输出流

想要实现一个猜数游戏，首先能够进行标准的输入输出，所以就要引入 Rust 官方的 标准输入输出流 use std::io;。其作用类似于 C 语言中的 #include <stdio.h>，其中 “std” 表示 “standard library”，即标准库的意思，而 “io” 就是输入输出模块的意思。

正常情况下，Rust 的标准库中存在很多模块，称之为 prelude，具体的所有内容可以通过 [Rust 标准库](Hello, Cargo! - The Rust Programming Language “Rust 标准库”)中查看。

2.2.fn main()

在 Rust 中，关键字 fn 表示声明一个函数，() 中填入函数的入参，和 C 语言一样，Rust 总是从 main 函数 中作为入口进入。

2.3.println!()

作为一个输出语句，Rust 标准的输出语句是 println，没有 !, 这个感叹号的意思是这是一个 宏(marco)，而非一个函数。而 println! 的标准占位符是 {}，具体用法后文再提。

2.4.let

在 Rust 中，let 用来声明一个变量，比如 let apple = 5; 在这个语句中，我们声明了一个变量名为 apple，其值为 5 的一个变量。在 Rust 中，如果不做说明，则默认声明的变量是一个 不可变的(immutable)。意思就是，在我们声明了这个 apple 之后，是没有办法修改其值 5 的，编译器会报错，如下图所示：

我们现在删除修改其值的语句之后再次编译会发现就可以成功通过编译并且运行:

如果所有的变量都是不可变的，那 Rust 也太鸡肋了，所以官方有一个关键字 mut，来声明这个变量是 可变的(mutable)，在声明变量的时候加上这个关键字就可以告知编译器，当前这个变量是一个可变的变量。如下图所示:

2.5.String:: new()

1
2
3
4
5
6
7
8
9

use std::io; //意思是使用标准输入输出流 类似于C中的 #include <stdio.h>

fn main() {
    println!("Guess a Number Please!"); //Rust的println!会自带一个回车
    let mut guess = String::new(); //创建了一个字符串类型的变量，mut表示可变 new()表示创建了一个String的实例

    io::stdin().read_line(&mut guess).expect("Fail to readline");
    println!("You guessed:{guess}");
}

let mut guess = String::new(); 创建了一个字符串类型的变量，其中 mut 表示可变，new()表示创建了一个 String 的实例。在 Rust 中，:: 表示一个与前者关联的一个函数，在这里，String 是 Rust 标准库提供的一个字符串数据类型，new() 表示创建一个新的实例，是 String 所提供的一个 关联函数(associated function)，所谓关联函数，是一个类中的函数，可以理解为 Python 中一个 类（class） 中的一个 方法（method）。

2.6 读取用户输入

io::stdin().read_line(&mut guess).expect("Fail to readline"); 这条语句用来读取用户的终端输入。由于我们在第一行就显式的引入了标准输入输出，我们这里可以直接使用 io::stdin() 来使用 stdin() 这个方法。如果我们没有在第一行中显式的导入标准输入输出，我们同样可以直接调用 stdin() 但是需要说明来源，如 stdio::io::stdin。

在 io::stdin() 中，stdin() 会返回一个 std::io::Stdin 的一个实例，该类型是作为一个获取用户终端输入的一个 句柄（handle）。

之后的 .read_line(&mut guess) 调用了 read_line 方法来获取用户的输入，并且传入了 &mut guess 来告诉 Rust 将读到的字符串放到 guess 变量中。read_line 会将用户在终端中输入的所有内容都变换成一个字符串来存储，存储方式是 追加（append），而不是 覆写（overwrite）。

代码中的 &，表示是 引用（reference），提供了一种让代码的多个部分都可以访问这一条数据，并且不需要多次复制这条数据的方法。本章中不做深究，在后续的章节中会详细讲解 Rust 的 &。目前我们只需要知道引用默认是不可变的，所以我们需要传入 &mut guess 作为参数而不是直接传入 &guess。

2.7 处理潜在的问题

可以注意到，在读取输入的过程中我们还有一句话，是 .expect("Fail to readline")。本小节我们将着重讨论这个语句。

如前文所提到的，read_line 方法会将用户的任何输入都读取到一个字符串中，但是它也会返回一个 Result 来表明语句的执行情况。这个 Result 是一个 枚举值（enumeration）（也简写为 enum）。用于进行 错误处理 的。详细内容将在后面仔细讲解如何通过这个值来在 Rust 中对代码进行错误处理。

Result 的值有两种，分别是 Err 和 Ok，前者表示语句执行出现错误，并且会包含一些调试信息，后者表示顺利执行。而 except 是 Result 类型的一种方法，如果 Result 的返回值为 Err，那么 except 就会终止程序，并且在终端中显示我们传入进去的字符串。如果 Result 的返回值是 Ok，在本条语句中，返回值将是用户输入的字节数目。如果不添加 except，项目依旧可以正常编译，但是编译器会向我们发送警告：

2.8 导入外部 crate

在使用 rand 生成随机数之前，我们首先需要修改 Cargo.toml，把 rand 添加到我们的 依赖（dependencies） 中：

其中格式为 “crate 名 + 版本号”（Rust 中的 crates 可以简单理解为外部库），这里的 0.8.5 是 ^0.8.5 的简写，意味着任何低于 0.9 但是高于等于 0.8.5 的版本。

接下来不对代码做任何修改，直接编译运行，我们会发现，它在自己下载相关依赖并且重新编译：

当我们包含外部依赖项时，Cargo 会从 注册表 中获取依赖项所需的所有内容的最新版本， 注册表 是 Crates.io 中的数据副本。Crates.io 是 Rust 生态系统中的人们发布他们的开源 Rust 项目供其他人使用的地方。

Cargo 拥有一种机制，确保每次你或其他人构建代码时都能重新构建相同的工件：Cargo 将仅使用你指定的依赖版本，直到你明确表示更改。例如，假设下周 rand crate 发布了 0.8.6 版本，该版本包含一个重要的错误修复，但也包含一个会导致你的代码出错的回归问题。为了处理这种情况，Rust 在你第一次运行 cargo build 时会创建 Cargo.lock 文件，因此现在我们在 guessing_game 目录中有了这个文件。

当你第一次构建项目时，Cargo 会确定所有符合要求的依赖版本，并将这些版本写入 Cargo.lock 文件中。以后当你再次构建项目时，Cargo 会看到 Cargo.lock 文件存在，并使用该文件中指定的版本，而不是重新计算版本。这使得你可以自动获得可重复的构建结果。换句话说，由于 Cargo.lock 文件的存在，你的项目会一直保持在 0.8.5 版本，直到你显式地进行升级。因为 Cargo.lock 文件对于可重复构建非常重要，所以它通常会和其他代码一起被纳入源代码控制中。

当你需要更新一个 crates 时，Cargo 提供了 update 命令，该命令会忽略 Cargo.lock 文件，并找出所有符合 Cargo.toml 中你指定条件的最新版本。然后 Cargo 会将这些版本写入 Cargo.lock 文件。在这种情况下，Cargo 将只查找版本号大于 0.8.5 且小于 0.9.0 的版本。如果 rand crates 发布了两个新版本 0.8.6 和 0.9.0，当你运行 cargo update 时，你会看到以下内容:

1
2
3
4

$ cargo update
    Updating crates.io index
     Locking 1 package to latest Rust 1.85.0 compatible version
    Updating rand v0.8.5 -> v0.8.6 (available: v0.9.0)

2.9 生成随机数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

use rand::Rng; //添加了rand库中的Rng模块
use std::io;

fn main() {
    let mut guess = String::new();
    let secret_number = rand::thread_rng().gen_range(1..=100); //生成一个1~100的随机数
    println!("The secre number is {secret_number}");
    println!("Guess a Number Please!");
    io::stdin().read_line(&mut guess).expect("Fail to readline");
    println!("You guessed:{guess}");
}

如上更新了代码，我们先是引用了 rand 库的 Rng 模块，里面定义了生成随机数的方法，之后使用不可变的变量获得了一个 1~100 的随机数。rand::thread_rng 是一个仅限于当前执行线程且由操作系统初始化的生成器，加上后文的 gen_range 就可以产生一个随机数，其中 gen_range 的入参是一个 范围表达式，用来指定生成随机数的范围。

[!TIP]

你无法凭空知道该使用哪些特性（traits）、调用哪些方法和函数，因此每个 crate（Rust 库）都附带了说明文档。Cargo 还有一个便捷功能：运行 cargo doc --open 命令会在本地构建所有依赖项的文档，并在浏览器中打开。例如，如果你想了解 rand crate 的其他功能，只需运行 cargo doc --open，然后在左侧边栏点击 rand 即可查看其文档。

2.10 match——通过分支结构来比较随机数与猜测数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

use rand::Rng;
use std::cmp::Ordering;
use std::io; //引入cmp库    

fn main() {
    let mut guess = String::new();
    let secret_number = rand::thread_rng().gen_range(1..=100); //生成1~100的随机数
    println!("Plz guess a int from 1 to 100");
    io::stdin().read_line(&mut guess).expect("Can`t read line"); //读取猜测数
    match guess.cmp(&secret_number) {
        //比较、并且输出对应调试信息
        Ordering::Equal => println!("u got right answer{secret_number}"),
        Ordering::Greater => println!("guess {guess} is bigger than secret number {secret_number}"),
        Ordering::Less => println!("guess {guess} is less than secret number {secret_number}"),
    }
}

首先我们先导入 cmp 库中的 Ordering 模块，Ordering 本质也是一个枚举，拥有 Equal, Greater, Less 三个值。match 在这里的作用是根据后面的 Ordering 的值来匹配执行不同的语句，类似与 C 语言中的 switch case 语句，它是 顺序依次匹配。而不同的返回值对应的执行语句则是通过 => 来引出。我们通过 .cmp 方法来比较 guess 和 secret_number 的值, 并且返回对应的 Ordering 的枚举值。注意，.cmp 中应当使用 & 来引用，而不是直接通过传入变量名来比较！

接下来我们编译运行，会发现运行报错：

报错的主要问题是 类型不匹配（mismatch）。Rust 作为一个强静态类型语言，具有一个 数据类型推测功能。我们的 guess，在最开始声明的时候就是 String 字符串类型，但是我们生成的随机数，由于我们没有显式的指定类型，编译器会自己猜测数据类型，通常会猜测是一个 整型（integer），Rust 的几种数值类型中，有些可以在 1 到 100 之间取值： i32 （32 位数值）、 u32 （无符号 32 位数值）、 i64 （64 位数值），以及其他类型。除非另有指定，Rust 默认使用 i32 类型。我们想要把一个字符串与整型比较，这显然是不符合常理的，所以编译器才会报错，说 expected &String, found &{integer}, 预期输入的是一个字符串，但是却发现输入的是一个整型。

想要能够正确识别，我们可以将 guess 从字符串转换为整型。代码如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

fn main() {
    let mut guess = String::new();
    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Plz guess a int from 1 to 100");
    io::stdin().read_line(&mut guess).expect("Can`t read line");

    let guess: u32 = guess
        .trim()
        .parse()
        .expect("Please type a number rather than ohter types!"); //类型转换

    match guess.cmp(&secret_number) {
        //比较、并且输出对应调试信息
        Ordering::Equal => println!("u got right answer{secret_number}"),
        Ordering::Greater => println!("guess {guess} is bigger than secret number {secret_number}"),
        Ordering::Less => println!("guess {guess} is less than secret number {secret_number}"),
    }
}

我们会惊奇的发现，明明 guess 这个变量在之前定义过了，这里怎么还可以再次定义，而且编译器还没有报错？！这是因为 Rust 中允许重复使用一个变量名，但是之后的变量会覆盖前面的变量值。在这里，我们后面的 guess 就成功用整型的数值覆盖了之前的 guess 的字符串类型的数值。这种特性可以让我们重复的使用一个变量名，而不是使用 guess_str 和 guess_int 来区分。眼下我们只需要知道，我们进行数据类型变换的时候通常会使用这个特性。

我们现在来看看我们的转换语，首先 guess.trim() 中的 guess，是最先开始的那个字符串，而其调用了 trim() 方法，该方法的作用是消除开头和结尾的任何空白，这是在将字符串转换为只能包含数值数据的 u32 之前必须做的。用户必须按下 enter 来触发 read_line 并输入他们的猜测，这会在字符串中添加一个换行符。例如，如果用户输入 5 并按下 enter ， guess 看起来是这样的： 5\n 。 \n 代表 “换行” （在 Windows 上，按下 enter 会导致回车和换行， \r\n ）。 trim 方法会消除 \n 或 \r\n ，结果只剩下 5 。

接下里的 parse() 则是把字符串类型转换成别的数类型。使用的时候我们必须显式的告诉编译器我们期望转换的类型，通过赋值语句之前的 :u32 来告诉编译器我们想要的数据类型是一个无符号 32 位整型。同时这也意味着编译器会推断 secret_number 也是一个 u32 的数据类型，以此才方便两者比较。最后再加上 except() 来进行可能的错误处理。

[!NOTE]

parse 方法只适用于逻辑上可以转换为数字的字符，因此很容易导致错误。例如，如果字符串包含 A👍% ，则无法将其转换为数字。由于它可能会失败， parse 方法返回 Result 类型，就像 read_line 方法一样。我们将以相同的方式处理这个 Result ，再次使用 expect 方法。如果 parse 因为无法从字符串中创建数字而返回 Err ， expect 调用将崩溃游戏并打印我们给它的消息。如果 parse 成功将字符串转换为数字，它将返回 Ok 变体的 Result ，而 expect 将返回我们从 Ok 值中想要的数字。

接下来我们直接编译并且运行代码，会发现代码成功运行起来了：

但是有个显而易见的问题，不论我们猜测的正确与否，我们都只能猜测依次，我们预期的是，我们不停猜测，直到我们猜测的结果正确为止，这就涉及到了一个重要概念——循环（loop）！

2.11 通过循环实现多次猜测

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

fn main() {

    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Plz guess a int from 1 to 100");
    loop {
        //Loop循环 死循环 需要手动退出
        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("Can`t read line");
        let guess: u32 = guess
            .trim()
            .parse()
            .expect("Please type a number rather than ohter types!");

        match guess.cmp(&secret_number) {
            Ordering::Equal => println!("u got right answer{secret_number}"),
            Ordering::Greater =>println!("guess {guess} is bigger than secret number {secret_number}"),
            Ordering::Less => println!("guess {guess} is less than secret number {secret_number}"),
        }
    }
}

现在我们可以多次循环猜测，但是也出现了一个问题：没有终止体条件！！ 所以我们要添加一个终止条件，即如果我们猜测的数刚好就是产生的数，则自动停止。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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

fn main() {
    let secret_number = rand::thread_rng().gen_range(1..=100);
    println!("Plz guess a int from 1 to 100");

    loop {
        //Loop循环

        let mut guess = String::new();
        io::stdin().read_line(&mut guess).expect("Can`t read line");

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,//如果是Ok的话(num)会让num自动等于转换完成的值
            Err(_) => {
                println!("Please input number between 1 and 100");//Err的话()中是什么不重要 用_代替 表示捕获所有的错误值
                continue;
            }//使用match分支来代替简单的except
        };

        match guess.cmp(&secret_number) {
            Ordering::Greater => {
                println!("{guess} is too big")
            }
            Ordering::Less => println!("{guess} is too small"),
            Ordering::Equal => {
                println!("you got right answer:{secret_number}");
                break;
            } 
        }
    }
}

在这里，我们使用 match 分支来处理错误情况，上文提到过 Result 作为一个枚举值，有 OK 和 Err 两种情况。如果是 Ok 那么它会包含一个值，这个值就是我们预期想得到的一个类型转换后的值。如果是 Err，则 Err(_)。其中 _ 是一个 catch-all value，代表着不论这里存储的是什么，我们都期望与我们的这个分支匹配。

Chapter 3: 常见的编程概念

3.1 Rust 中特有概念

与其他编程语言不同，Rust 中有很多独有的概念，同时也是 Rust 的最重要的特性。

3.1.1.变量(variable)和可变性（mutability）

正如之前所提到的，Rust 中的所有的变量默认是不可变的。如果我们想要让这个变量可变，需要使用到关键字 mut 来显式声明这个变量是可变的。

3.1.2.常量(constants)

对于常量来说，我们是严令禁止 mut 声明的，因为常量本身的意义就在于不可变。声明一个常量我们使用的关键字是 const 而不是 let，并且 常量必须显式的声明其数据类型，而不是和普通变量一样可以让编译器自己推测。

3.1.3.变量遮蔽(shadowing)

在第二章中，我们使用了相同的变量名来处理数据类型变换的问题。在 Rust 中，我们通常说前一个变量被之后的变量给 遮蔽了(shadowed by)，遮蔽的不仅是值，还有可变/不可变的属性。但是 变量遮蔽仅仅存在于后来的变量的作用域中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fn main() {
    let x = 5;          // 外部作用域 x = 5
    let x = x + 2;      // 遮蔽：x 重新绑定为 7（仍在外层作用域）
    println!("x = {x}"); // 输出: x = 7
    {
        let x = 9999;    // 内部作用域的新变量 x，遮蔽外层的 x
        println!("x = {x}"); // 输出: x = 9999
    }                   // 内部 x 离开作用域，被丢弃
    println!("x = {x}"); // 恢复外部作用域的 x，输出: x = 7
}

1
2
3
4

结果:
x`s value is 7
x`s value is 9999
x`s value is 7

在这个例子中，x 首先被声明为 5，紧接着就被 7（5 + 2）给遮蔽了，但是又在代码块中被 9999 给遮蔽，在 Rust 中，一个大括号对就代表一个代码块，其内部的变量的作用域只能作用域声明它的代码块中。所以当程序执行完第 7 行之后，值为 9999 的变量 x 会被销毁，所以第 9 行打印的 x 的值是之前的 x，即 7。

mut 和遮蔽的另一个区别在于，当我们再次使用 let 关键字时，我们实际上是在 创建一个新的变量，因此我们可以改变值的类型但重用相同的名称。例如，假设我们的程序要求用户输入一些空格字符来显示他们希望在文本之间有多少空格，然后我们想把输入存储为数字：

1
2

let spaces = "   ";
let spaces = spaces.len();

第一个 spaces 变量是字符串类型，第二个 spaces 变量是数字类型。因此，我们不必想出不同的名称，比如 spaces_str 和 spaces_num ；相反，我们可以重用更简单的 spaces 名称。然而，如果我们尝试像这样使用 mut ，我们会得到一个 编译时错误：

1
2

let mut spaces = "   ";
spaces = spaces.len();

这是因为我们在第一行已经声明了 space 变量为一个字符串，而 len() 方法返回值是当前字符串的长度，是一个整数。我们尝试把一个整数赋值给一个字符串，这是 Rust 不允许的，所以报错了。正确做法应该是和上文一样使用两次 let。

3.2 数据类型

Rust 作为一个静态类型语言，在编译的时候必须知道所有的数据的类型。一般来说，编译器可以通过我们给的赋值和使用来自己推断大多数的数据的类型。但是对于一些特殊情况，我们必须显式的声明数据类型，比如在声明一个常量的时候，比如我们在猜数游戏中的强制类型转换的时候。

1

let guess: u32 = "42".parse().expect("Not a number!");

如果我们不添加 :u32，那么编译器会报错如下：

3.2.1 标量

Rust 中的四种常见的标量分别是 整数（integer）、浮点数（floating-point numbers）、布尔值（Booleans）和字符（characters）。

3.2.2 整型

整型分为 有符号整型 i 和无符号整型 u，具体内容如下表：

每个变体都可以是有符号或无符号的，并且具有明确的大小。有符号和无符号指的是该数字是否可能为负数——换句话说，该数字是否需要带有符号（有符号）或是否永远为正数，因此可以不需要符号来表示（无符号）。这就像在纸上写数字一样：当符号重要时，数字会显示加号或减号；然而，当可以安全地假设数字为正数时，则不显示符号。有符号数字使用二进制补码表示法存储。

每个有符号变体可以存储从 −(2 ^n-1^ ) 到 2^n-1^-1 的数字，其中 n 是该变体使用的位数。因此一个 i8 可以存储从 −(2^7^ ) 到 2^7^ − 1 的数字，这等于 −128 到 127。无符号变体可以存储从 0 到 2^n^− 1 的数字，所以一个 u8 可以存储从 0 到 2^8^ − 1 的数字，这等于 0 到 255。

此外，isize 和 usize 类型取决于你的程序运行在哪种计算机架构上：如果你在 64 位架构上，它们是 64 位的；如果你在 32 位架构上，它们是 32 位的。

同时，你可以按照下表的所有方式书写整型。请注意，可以表示为多种数值类型的数字字面量允许使用 类型后缀，例如 57u8 ，来指定类型。数字字面量也可以使用 _ 作为视觉分隔符，以便更容易阅读数字，例如 1_000 ，它将与你指定 1000 时具有相同的值。

[!NOTE]

假设你有一个类型为 u8 的变量，它可以存储 0 到 255 之间的值。如果你尝试将变量更改为该范围之外的值，例如 256，就会发生整数溢出，这可能导致两种行为之一。在调试模式下编译时，Rust 会包含整数溢出的检查，如果发生这种行为，程序将在运行时崩溃。Rust 使用术语 panicking 来描述程序以错误退出。 当你以带 --release 标志的发布模式编译时，Rust 不会包含导致恐慌的整数溢出检查。相反，如果发生溢出，Rust 会执行补码回绕。简而言之，超出类型所能持有的最大值的值会“回绕”到类型所能持有的最小值。对于 u8 类型，值 256 会变成 0，值 257 会变成 1，以此类推。程序不会恐慌，但变量的值可能并不是你期望的值。依赖整数溢出的回绕行为被认为是一种错误。

3.2.3 浮点数

Rust 中也有两种浮点数 f32，f64。分别代表双经度和单精度，分别占用 32 位和 64 位。默认类型是 f64，因为在现代 CPU 上，它的速度与 f32 大致相同，但能提供更高的精度。所有浮点数类型都是带符号的。

1
2
3
4

fn main() {
    let x = 2.0; // f64
    let y: f32 = 3.0; // f32
}

3.2.4 数值运算

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

fn main() {
    // 加法
    let sum = 5 + 10;//15
    // 减法
    let difference = 95.5 - 4.3;//91.2
    // 乘法
    let product = 4 * 30;//120
    // 除法
    let quotient = 56.7 / 32.2;//1.7608695652173913
    let truncated = -5 / 3; // -1
    // 取余
    let remainder = 43 % 5;//3
}

[!CAUTION]

let value2 = 5.4 / -2; 这样的语句会报错，因为浮点数类型只能和浮点数类型相除。同样，浮点数不能取余。

3.2.5 布尔值

和大多数其他编程语言一样，Rust 中的布尔类型有两个可能的值：true 和 false。布尔类型的大小为 1 个字节。在 Rust 中，使用 bool 来指定布尔类型。例如：

1
2
3
4

fn main() {
    let t = true;
    let f: bool = false; // 显式声明
}

3.2.6 字符类型

Rust 的 char 类型是语言中最原始的字母类型。这里有一些声明 char 值的例子：

1
2
3
4
5

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // 显式声明
    let heart_eyed_cat = '😻';
}

请注意，我们使用单引号指定 char 字面量，而字符串字面量则使用双引号。Rust 的 char 类型占用四个字节，表示 Unicode 标量值，这意味着它不仅限于 ASCII 字符。带重音的字母；中、日、韩文字符；表情符号；以及零宽空格都是 Rust 中有效的 char 值。Unicode 标量值的范围从 U+0000 到 U+D7FF ，以及 U+E000 到 U+10FFFF 。然而，在 Unicode 中，“字符”并非一个真正存在的概念，因此你对“字符”的人类直觉可能与 Rust 中的 char 不一致。我们将在第 8 章的“使用字符串存储 UTF-8 编码文本”中详细讨论这一主题。

3.2.6 复合类型

复合类型可以将多个值组合为一个类型。Rust 有两种原始复合类型：元组和数组。

元组 Tuple

元组可以将不同类型的值存储在一个变量之中，但是 一旦声明之后，就不能更改元组的长度。

我们通过在括号内编写用逗号分隔的值列表来创建元组。元组中的每个位置都有一个类型，元组中不同值的类型不必相同。在这个示例中，我们添加了可选的类型注解：

1

let tup: (i32, f64, u8) = (500, 6.4, 1);

变量 tup 绑定到整个元组，因为元组被视为一个复合元素。要从元组中获取各个值，我们可以使用 模式匹配来解构元组值，如下所示：

1
2
3
4
5

fn main() {
    let tup = (500, 6.4, 1);
    let (x, y, z) = tup;
    println!("The value of y is: {y}");
}

上述代码首先创建了一个元组，并绑定在一个变量 tup 中，之后又使用 let 来让 (x,y,z) 分别获取 tup 对应位置的值。这个过程就叫 "解构（destructuring）"。

我们也可以通过 **".+索引值 " ** 来直接引用元组中的值，如下所示：

1
2
3
4
5
6

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);
    let five_hundred = x.0;//500
    let six_point_four = x.1;//6.4
    let one = x.2;//1
}

这个程序创建了元组 x ，然后使用各自的索引访问元组的每个元素。和大多数编程语言一样，元组中的第一个索引是 0。但是，我们 不能通过 . 配合一个变量来动态的访问一个元素：

1
2
3
4
5

fn main() {
    let index: i32 = 0;
    let x: (i32, f64, u8) = (500, 6.4, 1);
    let five_hundred = x.index;//这是不允许的！
}

编译上面这段代码会如下报错:

这是因为如果是用一个变量动态的访问一个元组，很有可能，这个变量的面值超过了元组的元素数量，会造成类似数组越界的错误。这是 Rust 所不希望看见的。

没有任何值的元组有一个特殊的名称，称为 unit。这个值及其对应类型都写作 () ，表示一个空值或一个空的返回类型。如果表达式没有返回其他值，则会隐式返回 unit 值。

数组 Array

数组也是一种常见的复合数据类型，但是与元组不同的是，数组中的数据的类型必须是同一种。与某些语言不同的是，Rust 中的数组长度是固定的。

我们通常使用 [] 来将一组数框起来作为数组。如下所示：

1

let a = [1, 2, 3, 4, 5];

和之前介绍的类型一样，数组的声明会从“栈（stack）”中申请内存，而不是“堆（heap）”中。而“向量（vector）”不同，它是分配在堆区的，所以它 可以自由的增加或减少。如果您不确定是否应该使用数组或向量，那么您很可能应该使用向量。我们将在后面的章节详细阐述这一点。

然而，当你知道元素数量不会改变时，数组更有用。例如，如果你在程序中使用月份的名称，你可能会使用数组而不是向量，因为你知道它总是包含 12 个元素：

1
2

let months = ["January", "February", "March", "April", "May", "June", "July",
              "August", "September", "October", "November", "December"];

可以使用方括号来编写数组的类型，其中包含每个元素的类型、分号，然后是数组中的元素数量，如下所示：

1

let a: [i32; 5] = [1, 2, 3, 4, 5];

在这里，i32 就是这个数组的数据类型。

同样，我们也可以指定数组的初始值。如下所示：

1

let a = [3; 5];

此处，我们就声明了一个叫做 a 的数组，有 5 个成员初始值都为 3。等同于 let a = [3, 3, 3, 3, 3];

数组是一个已知大小且固定大小的内存块，可以在栈上分配。你可以使用索引来访问数组的元素，就像这样：

1
2
3
4
5

fn main() {
    let a = [1, 2, 3, 4, 5];
    let first = a[0];
    let second = a[1];
}

在这个例子中，名为 first 的变量将获得值 1 ，因为这是数组中索引 [0] 的值。名为 second 的变量将从数组中的索引 [1] 获得值 2 。

和其他语言一样，数组会存在越界现象，比如下面的代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

use std::io;

fn main()
{
    let arry:[u32;5] = [0,1,2,3,4];
    println!("please input a index:");
    let mut index = String::new();

    io::stdin().read_line(&mut index).expect("Read Error");
    let index:usize = index.trim().parse().expect("Parse Error");
    let element = arry[index];
    println!("The value of the element at index {index} is: {element}");
}

如果我们输入的索引值超过了 4，那么就会看到如下报错：

程序在使用索引操作时无效值导致运行时错误。程序退出并显示错误消息，未执行最后的 println! 语句。当你尝试使用索引访问元素时，Rust 会检查你指定的索引是否小于数组长度。如果索引大于或等于长度，Rust 将发生 panic。这个检查必须在运行时进行，特别是这种情况，因为编译器不可能知道用户在后期运行代码时会输入什么值。

这是 Rust 内存安全原则的一个实例。在许多低级语言中，这种检查不会进行，当你提供错误的索引时，可能会访问无效的内存。Rust 通过立即退出而不是允许内存访问并继续来保护你免受这种错误的影响。

3.3 函数(Functions)

函数在 Rust 代码中非常普遍。你已经见过语言中最重要之一的函数： main 函数，它是许多程序的入口点。你还见过 fn 关键字，它允许你声明新的函数。

在 Rust 中，多使用 蛇形命名法 来对一个函数命名。所谓蛇形命名法，就是将函数名按照 “小写字母 + 下划线” 的组合进行命名。如下面的两个例子：

1
2
3
4
5
6
7
8

fn main() {
    println!("Hello, world!");
    function();
}

fn function() {
    println!("function call");
}

和 C 语言一样，我们使用 {} 来将一个函数括起来，表示这个函数的作用域，来表明函数的开始和结束。

同时我们可以注意到，我们明明在 main 函数之后声明的这个 function，但是我们依旧可以在 main 函数中调用这个函数。因为在 Rust 中，编译器并不像 C 语言的编译器一样那么严格要求函数的声明必须要在调用之前；不论你在哪里定义了这个函数，你都可以调用。

3.3.1 参数(parameters)

上文我们定义的 another_function，没有入参。在 Rust 中，我们也可以定义拥有入参的函数。技术上，具体的值被称为 实参（arguments），但在日常对话中，人们往往将 参数（parameter） 和实参这两个词混用，指代函数定义中的变量或调用函数时传入的具体值。

1
2
3
4
5
6
7
8

fn main() {
    println!("Hello, world!");
    function(10);
}

fn function(x:i32) {
    println!("x is {x}");
}

我们修改了我们的 function，给他添加了一个数据类型为 i32 的入参 x，其函数功能就是将它的值打印出来。

在定义函数的时候，我们 必须显式的指定 我们每一个入参的数据类型。同样我们也可以定义一个有多个入参的函数，如下：

1
2
3
4
5
6
7
8

fn main() {
    println!("Hello, world!");
    function(10,'h');
}

fn function(x:i32, y:char) {
    println!("x is {x},y is {y}");
}

1
2
3

结果：
Hello, world!
x is 10,y is h

如果我们想要入参是一个字符串而不是单纯是一个指针，我们首先想到的代码如下：

1
2
3
4
5
6
7
8

fn main() {
    println!("Hello, world!");
    function(10, "N1netyNine99");
}

fn function(x: i32, y: str) {
    println!("x is {x},y is {y}");
}

在这段代码中我们直接指定 y 的数据类型是 str 字符串型，然后在调用函数的时候传入我们想要的字符串即可，可是我们编译运行发现不能通过编译。编译器报错如下图：

我们查看编译器的第一个报错，它说 function 在 y 的位置预期得到的是一个 str 类型，但是我们传入的 "N1netyNine99" 确实一个 &str 类型。这让我很疑惑，但是我们按下不表，接着看下面的报错。后面两个报错的都是 doesn't have a size known at compile-time，意思是在编译的时候不知道大小。经过我的查询，Rust 作为一个严格的内存安全的语言，其不允许任何可能造成内存错误的事情发生，就比如我们想要传入一个不知道大小的数据。在 Rust 中，str 和 &str 是两种不同的数据类型；前者是一个抽象的数据类型，表示一段 UTF-8 字符串，它是动态大小类型(DST)，编译时不知道具体大小。而 &str 它是对 str 的借用引用，&str 本质是一个胖指针(fat pointer)，它包含了两个部分：一个指向实际字符串数据的内存地址的指针、字符串的字节长度；&str 的大小是固定的，在 64 位系统中总是 16 字节(8 字节指针 + 8 字节长度)。所以可以使用，因为编译器清楚的知道其大小。

[!NOTE]

想象一下：

• str 就像 “一本书的内容” - 你知道有内容，但不知道有多少页
• &str 就像 “书签 + 页数标记” - 告诉你内容在哪里，有多少页

所以我们对代码修改一下:

1
2
3
4
5
6
7
8

fn main() {
    println!("Hello, world!");
    function(10, "N1netyNine99");
}

fn function(x: i32, y: &str) {//使用&str而非str
    println!("x is {x},y is {y}");
}

编译运行之后就发现可以正常运行了！

3.3.2 语句（Statement）和表达式（Expression）

函数体由一系列可选以表达式结尾的语句组成。到目前为止，我们讨论过的函数还没有包含结尾表达式，但你已经见过表达式作为语句的一部分。由于 Rust 是一种基于表达式的语言，理解这一点非常重要。其他语言没有这样的区别，所以让我们看看 语句 和 表达式 是什么，以及它们的差异如何影响函数体。

• 语句是执行某些操作，但是没有返回值。
• 表达式是经过一些计算，然后返回一个值。

1
2
3

fn main(){
    let y = 5;
}

比如上述的 let y = 5; 就是一个语句，它没有任何的返回值。所以下列的操作是明确禁止的：

1
2
3

fn main(){
    let y = (let x = 5);
}

编译器报错说 error: expected expression, found let statement，这也和我们上述的表述相同。let x = 5 语句不返回值，所以 y 没有可以绑定到的东西。这与 C 语言和 Ruby 等其他语言不同，在这些语言中，赋值会返回赋值的值。在这些语言中，你可以写 x = y = 6 ，让 x 和 y 都具有值 `5 ；在 Rust 中则不是这种情况。

在 Rust 中，使用 {} 可以创建一个表达式，表达式是有返回值的。

1
2
3
4
5
6
7

fn main() {
    let x = {
        let y = 1;
        y + 1
    };
    println!("x is {x}");
}

在这个例子中，我们给 x 的赋值就是一个表达式，这个表达式的返回值就是第 4 行的 y + 1，由于我们在第三行定义了 y 是 1，那么这个表达式的返回值就是 1 + 1 即 2，所以我们打印出来的值就是 2。

注意 y + 1 行末尾没有分号，这与你之前看到的绝大多数行不同。表达式不包括结束分号。如果你在表达式末尾添加分号，它会变成一个语句，并且不会返回值。 在接下来探索函数返回值和表达式时，请记住这一点。

3.3.3 带返回值的函数

函数可以向调用它们的代码返回值。我们不命名返回值，但必须在箭头（ -> ）之后声明它们的类型。在 Rust 中，函数的返回值与函数体块中最后一条表达式的值是同义的。你可以使用 return 关键字并指定一个值来提前返回函数，但大多数函数会隐式地返回最后一条表达式。 下面是一个返回值的函数示例：

1
2
3
4
5
6
7
8

fn five() -> i32 {
    5
}

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

运行这段代码，你会看见终端显示 The value of x is: 5，表明 5 已经正确返回到了调用它的主函数当中。我们也可以使用 return 来返回一个值或者表达式：

1
2
3
4
5
6
7
8

fn five() -> i32 {
    return 5;
}

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

其效果和上面的代码一样。

在上述的代码中，我们使用了一个无入参，返回值为 i32 的函数来对一个变量初始化了，同样的，我们可以通过使用一个带参数的函数来达到初始化一个变量的目的：

1
2
3
4
5
6
7
8
9

fn x_add_y(x: i32, y: i32) -> i32 {
    x + y
    //等价于return x + y;
}

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

此时我们 x 的值就是 3。但是我们对代码稍作修改：

1
2
3
4
5
6
7
8

fn x_add_y(x: i32, y: i32) -> i32 {
    x + y;//添加了;
}

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

编译后运行发现:

这是因为，函数声明中显示说将会返回一个 i32 类型的值。但是我们的函数体内部，没有显式的返回值，第二行代码也只是简单的对 x 和 y 执行了一次加法，并且由于以 ; 结尾，表明这是一个语句，没有返回值。那么函数的返回值便是 ()，我们之前提到过，其数据类型是 unit，与我们的预取 i32 并不符合，所以编译器报错了。

3.4 注释

所有程序员都力求让他们的代码易于理解，但有时需要额外的解释。在这种情况下，程序员会在他们的源代码中留下注释，编译器会忽略这些注释，但阅读源代码的人可能会觉得有用。

这是一个简单的注释：

1

//我是一个注释

在 Rust 中，惯用的注释风格以两个斜杠开始注释，注释内容持续到行尾。 对于跨越多行的注释，你需要在每一行都包含 // ，像这样：

1
2
3

//我是注释1号
//我是注释2号
//我是注释3号

注释也可以放在包含代码的行末：

1
2
3

fn main() {
    let lucky_number = 7; //我是一个注释
}

[!NOTE]

官方文档中没有提到，但是在我的开发环境中（vscode）确实是可以通过 /* */ 来达到和 C 语言一样的注释风格。

3.5 控制流

能够在条件为 true 时运行某些代码，以及在条件为 true 时重复运行某些代码，是大多数编程语言中的基本构建块。让 Rust 代码执行流控制的最常见结构是 if 表达式和循环。

3.5.1 if 分支

一个 if 表达式 允许你根据条件分支你的代码。你提供一个条件，然后说明，“如果这个条件满足，运行这块代码。如果条件不满足，不要运行这块代码。”

所有 if 表达式都以关键词 if 开头，后面跟着一个条件。我们将要执行的代码块立即放在大括号内的条件后面。与 if 表达式中的条件关联的代码块有时被称为 臂，就像我们在第 2 章的 “比较猜测值与秘密数字” 部分讨论的 match 表达式中的臂一样。

我们也可以选择包含一个 else 表达式，以便在条件评估为 false 时给程序提供一个可执行的代码块。如果你不提供 else 表达式并且条件为 false ，程序将直接跳过 if 块并继续执行下一段代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

use std::io;

fn main() {
    println!("Please input a number:");

    loop {
        let mut input = String::new();
        //要把创建变量放在循环里面
        //因为read_line只会在input变量中追加，而不是覆盖
        //所以如果把这句话放到loop中，只要第一次输入的是字符串
        //即使后面输入的是数字，也无法解析
        //因为之前的字符串还在变量中存储着的
        //放到循环内部每次循环开始都会自动清空变量
        io::stdin().read_line(&mut input).expect("Fail to Read!");

        let input: u32 = match input.trim().parse() {
            //强制类型转换的时候要指定数据类型！
            Ok(num) => num,
            Err(_) => {
                println!("Please input a number!");
                continue;
            }
        };

        if input < 5 {
            println!("number {input} is less than 5");
            break;
        } else if input == 5 {
            println!("number {input} is equal to 5");
            break;
        } else {
            println!("number {input} is gearter than 5");
            break;
        }
    }
}

例如这段代码，其功能就是从终端中读取用户输入的值来与 5 作比较，根据不同的比较结果来向终端中打印不同的语句。注意，我们这里使用了 loop 和 match 来处理如果用户输入的值不是一个数字的情况，顺道复习了一下第二章所学习到的内容。

在 Rust 中，控制分支的条件必须是一个布尔值。而不能像 C 语言一样使用一个整型来当作 if 的条件。例如下面的代码就是不合法的：

1
2
3
4
5
6

fn main() {
    let number = 3;
    if number {
        println!("number was three");
    }
}

编译运行这段代码会发现编译器报错如下:

报错表明 Rust 期望一个 bool ，但得到的是一个整数。与 Ruby 和 JavaScript 等语言不同，Rust 不会自动尝试将非布尔类型转换为布尔类型。你必须明确指定，并且始终使用布尔值作为 if 的条件。例如，如果我们希望 if 代码块仅在数字不等于 0 时执行，我们可以将 if 表达式更改为以下内容：

1
2
3
4
5
6
7

fn main() {
    let number = 3;

    if number != 0 {
        println!("number was something other than zero");
    }
}

在 Rust 中，if 是一个表达式，这意味着我们可以在 let 语句的右侧使用它来给变量赋值，如下所示：

1
2
3
4
5

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("The value of number is: {number}");
}

在这个例子中，number 变量将绑定到基于 if 表达式结果的值。运行此代码以查看会发生什么：

1
2
3
4
5

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished dev [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/branches`
The value of number is: 5

记住，代码块的值是其最后一个表达式的值，数字本身也是表达式。在这种情况下，整个 if 表达式的值取决于执行哪个代码块。这意味着 if 的每个分支的潜在返回值必须是相同的类型；在上面的例子中，if 分支和 else 分支的结果都是 i32 整数。如果类型不匹配，如下例所示，我们会得到一个错误：

1
2
3
4

fn main() {
    let condition = true;
    let number = if condition { 5 } else { "six" };
}

当我们尝试编译此代码时，我们会得到一个错误。if 和 else 分支具有不兼容的值类型，Rust 明确指出在程序中找到问题的位置：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:44
  |
4 |     let number = if condition { 5 } else { "six" };
  |                                 -          ^^^^^ expected integer, found `&str`
  |                                 |
  |                                 expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `branches` due to previous error

if 代码块中的表达式计算为整数，而 else 代码块中的表达式计算为字符串。这不起作用，因为变量必须具有单一类型，并且 Rust 需要在编译时明确知道 number 变量的类型。知道 number 的类型让编译器验证该类型在我们使用 number 的任何地方都有效。如果 number 的类型只能在运行时确定，Rust 就无法做到这一点；如果编译器必须跟踪任何变量的多个假设类型，编译器会更复杂，对代码的保证会更少。

3.2 使用循环重复执行

多次执行一段代码通常很有用。对于这个任务，Rust 提供了几种循环，它们将运行循环体内的代码直到结束，然后立即从头开始。为了试验循环，让我们创建一个名为 loops 的新项目。

Rust 有三种循环：loop、while 和 for。让我们尝试每一种。

3.2.1 使用 loop 重复执行代码

loop 关键字告诉 Rust 一遍又一遍地执行一段代码，直到你明确告诉它停止。

作为示例，将 loops 目录中的 src/main.rs 文件更改为如下所示：

1
2
3
4
5

fn main() {
    loop {
        println!("again!");
    }
}

当我们运行这个程序时，我们会看到 again! 连续打印，直到我们手动停止程序。大多数终端支持键盘快捷键 ctrl-c 来中断陷入连续循环的程序。试一试：

1
2
3
4
5
6
7
8
9

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.29s
     Running `target/debug/loops`
again!
again!
again!
again!
^Cagain!

符号 ^C 表示你按下 ctrl-c 的位置。你可能会或可能不会在 ^C 之后看到单词 again! 打印，这取决于代码在接收到中断信号时在循环中的位置。

幸运的是，Rust 还提供了一种使用代码跳出循环的方法。你可以在循环内放置 break 关键字来告诉程序何时停止执行循环。回想一下，我们在第 2 章的猜数游戏中的 “猜对后退出” 部分中这样做了，当用户通过猜对数字赢得游戏时退出程序。

你也可以在循环中使用 continue，它告诉程序跳过此循环迭代中的任何剩余代码并转到下一次迭代。

从循环返回值

loop 的用途之一是重试你知道可能失败的操作，例如检查线程是否已完成其作业。你可能还需要将该操作的结果从循环传递到代码的其余部分。为此，你可以在用于停止循环的 break 表达式之后添加你想要返回的值；该值将从循环中返回，以便你可以使用它，如下所示：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("The result is {result}");
}

在循环之前，我们声明一个名为 counter 的变量并将其初始化为 0。然后我们声明一个名为 result 的变量来保存从循环返回的值。在循环的每次迭代中，我们将 1 添加到 counter 变量，然后检查 counter 是否等于 10。当它等于时，我们使用 break 关键字和值 counter * 2。循环后，我们使用分号结束将值赋给 result 的语句。最后，我们打印 result 中的值，在这种情况下是 20。

循环标签以消除多个循环之间的歧义

如果你在循环内有循环，break 和 continue 适用于该点的最内层循环。你可以选择在循环上指定循环标签，然后我们可以将其与 break 或 continue 一起使用，以指定这些关键字适用于标记的循环而不是最内层循环。循环标签必须以单引号开头。这是一个带有两个嵌套循环的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;
        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }
        count += 1;
    }
    println!("End count = {count}");
}

外层循环有标签 'counting_up，它将从 0 计数到 2。没有标签的内层循环从 10 倒数到 9。第一个没有指定标签的 break 将只退出内层循环。break 'counting_up; 语句将退出外层循环。此代码打印：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.58s
     Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

3.2.2 使用 while 的条件循环

程序经常需要评估循环内的条件。当条件为 true 时，循环运行。当条件不再为 true 时，程序调用 break，停止循环。可以使用 loop、if、else 和 break 的组合来实现这样的行为；如果你愿意，你现在可以在程序中尝试这样做。然而，这种模式非常常见，以至于 Rust 为它提供了一个内置的语言构造，称为 while 循环。在下面的例子中，我们使用 while 循环程序三次，每次倒数，然后，循环后，打印一条消息并退出。

1
2
3
4
5
6
7
8

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("{number}!");
        number -= 1;
    }
    println!("LIFTOFF!!!");
}

这种构造消除了使用 loop、if、else 和 break 时需要的大量嵌套，并且更清晰。当条件为 true 时，代码运行；否则，它退出循环。

3.2.3 使用 for 遍历集合

你可以使用 while 构造来循环遍历集合的元素，例如数组。例如，下面的循环打印数组 a 中的每个元素。

1
2
3
4
5
6
7
8

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;
    while index < 5 {
        println!("the value is: {}", a[index]);
        index += 1;
    }
}

这里，代码计数遍历数组中的元素。它从索引 0 开始，然后循环直到它到达数组中的最终索引（即，当 index < 5 不再为 true 时）。运行此代码将打印数组中的每个元素：

1
2
3
4
5
6
7
8
9

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/loops`
the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50

数组中的所有五个元素都按预期出现在终端中。即使 index 在某个点将达到值 5，循环也会在尝试从数组中获取第六个值之前停止执行。

但是，这种方法容易出错；如果索引值或测试条件不正确，我们可能会导致程序崩溃。例如，如果你将 a 数组的定义更改为有四个元素，但忘记将条件更新为 while index < 4，代码将崩溃。它也很慢，因为编译器添加运行时代码以 在循环的每次迭代中执行条件检查，以检查索引是否在数组的边界内。

作为更简洁的替代方案，你可以使用 for 循环并对数组的每个项目执行一些代码。for 循环看起来像下面的代码：

1
2
3
4
5
6

fn main() {
    let a = [10, 20, 30, 40, 50];
    for element in a {
        println!("the value is: {element}");
    }
}

当我们运行此代码时，我们将看到与前面的例子相同的输出。更重要的是，我们现在提高了代码的安全性并消除了可能由于超出数组末尾或没有走得足够远而遗漏某些项目而导致的错误的可能性。

使用 for 循环，如果你更改了数组中值的数量，你不需要记住更改任何其他代码，就像你使用前面的方法一样。

for 循环的安全性和简洁性使它们成为 Rust 中最常用的循环构造。即使在你想要运行一些代码一定次数的情况下，就像前面使用 while 循环的倒数示例一样，大多数 Rustaceans 也会使用 for 循环。做到这一点的方法是使用 Range，它是标准库提供的一种类型，它按顺序生成从一个数字开始到另一个数字结束之前的所有数字。

这是使用 for 循环和我们尚未谈论的 rev 方法来反转范围的倒数的样子：

1
2
3
4
5
6

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

这段代码更好一些，不是吗？

3.6 课后训练

3.6.1 编写一个华氏度和摄氏度相互转换的程序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

use std::io;

fn temprature_f_c_convert(temp: f32, f_c: char) -> f32 {
    let mut temp_res = f32::default(); //默认值 f32不是一个动态数据类型 所以没有String那样的new()方法
    match f_c {
        'C' => temp_res = 9f32 * (temp / 5f32) + 32f32,//摄氏度转华氏度
        'F' => temp_res = 5f32 * (temp - 32f32) / 9f32,//华氏度转摄氏度
        _ => temp_res = temp, //错误处理 类似于default
    }
    return temp_res;
}

fn main() {
    let mut temp_now = String::new(); //当前温度
    let mut temp_f_c = String::new(); //当前温度类型

    //使用loop循环中断来赋值
    let temp_f_c: char = loop {
        let mut temp_f_c = String::new(); //当前温度类型
        println!("Please input what kind of unit of your temprature(C or F):");
        io::stdin().read_line(&mut temp_f_c).expect("Fail to Read");
        match temp_f_c.trim().parse::<char>() {
            //::<x>是让parse方法转换成x类型
            Ok(c) => {
                if c == 'C' || c == 'F' {
                    break c;
                } else {
                    println!("please input F or C!");
                }
            }
            Err(_) => println!("invalid input, please try again."),
        }
    };

    let temp_now = loop {
        let mut temp_now = String::new(); //当前温度
        println!("Please input temp value you want to convert:");
        io::stdin().read_line(&mut temp_now).expect("Fail to Read");
        match temp_now.trim().parse::<f32>() {
            Ok(value) => break value,
            Err(_) => println!("invalid input, please try again."),
        }
    };

    println!("your input:{temp_now} with unit {temp_f_c}");
    println!("start convert ...");
    let temp_after = temprature_f_c_convert(temp_now, temp_f_c);
    let temp_f_c_after = match temp_f_c {
        'C' => 'F',
        'F' => 'C',
        _ => 'C', //错误处理 类似于default 这是必须的！
    };
    println!("convert finished!");
    println!("{temp_now} {temp_f_c} => {temp_after} {temp_f_c_after}");
}

3.6.2 生成第 n 个斐波那契数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

use std::io;

//斐波那契数:从第二项开始，每一项都是前两项的和
fn fibonacci(n: u64) -> u64 {
    if n == 0 || n == 1 {
        return n;
    }
    let mut now_value: u64 = 1; //n = 2的时候
    let mut last_value: u64 = 0; //上一次的值
    for i in (2..n + 1) {
        //左开右闭 第n项的条件是n+1
        let next_value = now_value + last_value; //新值 = 当前值+上一次值
        last_value = now_value; //更新上一项的值
        now_value = next_value; //更新当前值
    }
    return now_value;
}

fn main() {
    let n = loop {
        let mut n = String::new();
        println!("Please input n:");
        io::stdin().read_line(&mut n).expect("Fail to Read");

        match n.trim().parse::<u64>() {
            Ok(num) => break num,
            Err(_) => println!("n must be a int!"),
        }
    };
    let fibo = fibonacci(n);
    println!("when n={n},the fibonaci number is {fibo}");
}

Chapter 4: 理解所有权

4.1 什么是所有权？

所有权 是一套管理 Rust 程序如何管理内存的规则。所有程序都必须在运行时管理它们使用计算机内存的方式。有些语言有垃圾回收机制，会定期在程序运行时查找不再使用的内存；在其他语言中，程序员必须显式地分配和释放内存。Rust 采用第三种方法：通过一套编译器会进行检查的所有权规则系统来管理内存。如果任何规则被违反，程序将无法编译。所有权的所有特性都不会在程序运行时减慢其速度。

由于所有权对许多程序员来说是一个新概念，确实需要一些时间来适应。好消息是，随着你对 Rust 和所有权系统规则的经验越来越丰富，你会发现自然而然地开发出安全且高效的代码变得越来越容易。坚持下去！

当你理解了所有权，你就有了理解使 Rust 独特的特性的坚实基础。在本章中，你将通过一些专注于一个非常常见的数据结构的示例来学习所有权：字符串。

4.1.1 栈（Stack）与堆（Heap）

许多编程语言不要求你经常考虑栈和堆。但在像 Rust 这样的系统编程语言中，值是在栈上还是在堆上会影响语言的行为以及你必须做出某些决定的原因。本章稍后将描述与栈和堆相关的所有权部分，所以这里有一个简要的解释作为准备。

• 栈 以严格的 后进先出（LIFO） 顺序存储数据。想象一叠盘子：新盘子只能放在顶部，取用时也只能从顶部拿取（不可从中间或底部操作）。数据的存入称为 压栈（push），移除称为 出栈（pop）。所有存储在栈中的数据必须具有 编译期已知的固定大小，无法满足此条件的数据必须存放在堆中。

• 堆 的组织更为松散：在堆上存储数据时，需先申请特定大小的空间。内存分配器（allocator）会在堆中找到足够大的空闲区域，将其标记为已占用，并返回指向该位置的 指针（即内存地址），此过程称为 堆分配（allocating）。由于堆指针本身是固定大小的，它可以被存储在栈上，但访问实际数据时需通过指针跳转。类比餐厅等位：入场时告知人数，服务员会安排合适餐桌并引导入座；若有人迟到，只需根据桌号定位即可。

访问栈中的数据比访问堆中的数据更快，原因有二：

1. 速度：压栈操作远快于堆分配，因为栈的写入位置永远在顶部（无需搜索空闲内存），而堆分配需先寻找足够空间并维护分配记录。
2. 访问效率：访问堆数据通常更慢，因为需要通过指针间接寻址。现代处理器对连续内存访问（如栈）有优化，而随机跳转（如堆）会降低缓存命中率。延续餐厅类比：服务员若在 A、B 两桌间反复切换处理订单，效率必然低于集中处理完一桌再处理下一桌。

当你的代码调用一个函数时，传递给函数的值（包括可能指向堆上数据的指针）和函数的局部变量会被推送到栈上。当函数结束时，这些值会从栈中弹出。

跟踪代码的哪些部分正在使用堆上的哪些数据，最小化堆上的重复数据量，以及清理堆上未使用的数据以免空间不足，这些都是所有权要解决的问题。一旦你理解了所有权，你就不需要经常考虑栈和堆了，但知道管理堆数据是所有权存在的主要原因可以帮助解释为什么它会这样工作。

4.1.2 所有权规则

首先，让我们看看所有权规则。当我们通过示例来说明这些规则时，请记住这些规则：

• 在 Rust 中，每个值都有一个 所有者。
• 同一时间，一个值只能被一个所有者拥有。
• 当程序超出所有者的作用域，其所有的值会被舍弃。

4.1.3 变量作用域

现在我们已经过了基本的 Rust 语法，我们不会在示例中包含所有的 fn main() { 代码，所以如果你正在跟着做，请确保手动将以下示例放在 main 函数内。因此，我们的示例会更简洁一些，让我们专注于实际细节而不是样板代码。

作用域是指程序中某个项目有效的范围。以下是一个变量：

1
2
3
4
5

{
    let s = "hello";   // s 从这里开始有效

    // 使用 s 做一些事情
}                      // 这个作用域现在结束了，s 不再有效

变量 s 指向一个字符串字面量，其中字符串的值硬编码在程序的文本中。该变量从声明点开始直到当前作用域的末尾都有效。此时，作用域与变量有效性的关系与其他编程语言相似。现在我们将基于这一理解，引入 String 类型。

4.1.4 String 类型

为了说明所有权规则，我们需要一个比第三章 “数据类型” 部分所涵盖的 更复杂的数据类型。之前 涵盖的类型是已知大小的，可以存储在栈上，在其作用域结束时从栈中弹出，并且可以快速且简单地复制以创建一个新的独立实例，如果代码的其他部分需要在不同的作用域中使用相同的值。但我们想要查看存储在堆上的数据，并探索 Rust 何时清理这些数据，而 String 类型就是一个很好的例子。

我们已经见过字符串字面量，其中字符串值被植入到我们的程序中。字符串字面量很方便，但它们并不适用于我们可能想要使用文本的每种情况。一个原因是它们是不可变的。另一个原因是并非每个字符串值在我们编写代码时都能知道：例如，如果我们想要获取用户输入并将其存储起来怎么办？对于这些情况，Rust 有一种第二种字符串类型，即 String。这种类型管理堆上分配的数据，因此能够存储编译时我们不知道数量的文本。你可以使用 from 函数从一个字符串字面量创建一个 String，就像这样：

1

let s = String::from("hello");

双冒号 :: 运算符允许我们在这个特定的 from 函数下命名 String 类型，而不是使用某种名称，如 string_from。我们将在第 5 章的 “方法语法” 部分和第 7 章的 “模块路径引用项目” 中更多地讨论这种语法。

很自然的我们就能想到，这个 String 和我们之前使用的 String，两者有何区别呢？

有一个很显著的区别就是，后者是可变的:

1
2
3
4
5

let mut s = String::from("hello");

s.push_str(", world!"); // push_str() 在字符串后追加字面量

println!("{s}"); // 这将打印 `hello, world!`

那么，这里有什么区别呢？为什么 String 可以被改变而字面量不行？区别在于这两种类型如何处理内存。

4.1.5 内存与分配

在字符串字面量的情况下，我们知道编译时的内容，因此文本直接硬编码到最终的可执行文件中。这就是为什么字符串字面量速度快且高效的原因。但这些特性只来自于字符串字面量的不可变性。不幸的是，我们不能为每个在编译时大小未知且运行时大小可能会变化的文本块在二进制文件中放入一块内存。

使用 String 类型，为了支持一个可变且可增长的文本，我们需要在堆上分配一段在编译时未知大小的内存来存储内容。这意味着：

• 内存必须在运行时从内存分配器请求。
• 我们需要一种方式在完成对 String 的使用后将这块内存返回给分配器。

第一部分是由我们完成的：当我们调用 String::from 时，它会 向堆申请内存。这在编程语言中几乎是通用的。

然而，第二部分是不同的。在具有垃圾收集器（GC）的语言中，垃圾收集器会跟踪并清理不再使用的内存，我们不需要考虑这些。在大多数没有垃圾收集器的语言中，我们需要自己识别不再使用的内存，并调用代码显式地释放它，就像我们请求内存时所做的那样。正确地做到这一点历来是一个困难的编程问题。如果我们忘记了，我们会浪费内存。如果我们过早地释放，会导致变量无效。如果我们释放两次，这也是一种错误。我们需要一对一地配对 allocate 和 free。

Rust 采取了不同的路径：内存会在拥有它的变量超出作用域时自动返回。比如下列代码:

1
2
3
4
5

{
    let s = String::from("hello"); // s 从这里开始有效

    // 使用 s 做一些事情
}                                  // 这个作用域现在结束了，s 不再有效

有一个自然的时机可以将 String 所需的内存返回给分配器：当 s 超出作用域时。当一个变量超出作用域时，Rust 会为我们调用一个特殊函数。这个函数叫做 drop，作者可以在 drop 中放入返回内存的代码。Rust 会在闭大括号时自动调用 drop。

这种模式对 Rust 代码的编写方式产生了深远的影响。现在看来可能很简单，但在更复杂的情况下，当我们希望多个变量使用我们在堆上分配的数据时，代码的行为可能会出乎意料。我们现在就来探讨一些这种情况。

4.1.6 变量与数据交互的方式：移动

多个变量可能会在程序中通过不同的方式相互影响。比如下列的例子

1
2

let x = 5;
let y = x;

显而易见的，我们先定义了一个变量 x 让它的值变成了 5，然后又让一个变量 y 与 x 也就是 5 绑定。这样的话 x 和 y 的值都是 5。并且由于 5 是一个整型，其大小固定且已知，这两个 5 都会入栈。

但是如果是 String 类型，情况就有所不同了：

1
2

let s1 = String::from("hello");
let s2 = s1;

这看起来非常相似，所以我们可能会假设它的工作方式是相同的：也就是说，第三行会复制 s1 中的值并将其绑定到 s2。但这并不是实际发生的真实情况。

看看下图，了解 String 在底层发生了什么。String 由三部分组成，如图左侧所示：一个指向存放字符串内容的内存的指针、一个长度和一个容量。这组数据存储在栈上。右侧是堆上存放内容的内存。

长度是指 String 的内容目前使用的内存大小（以字节为单位）。容量是指 String 从分配器那里获得的内存总大小（以字节为单位）。长度和容量之间的差异很重要，但在当前上下文中并不重要，因此暂时可以忽略容量。

当我们把 s1 赋值给 s2 时，String 数据会被复制，这意味着我们复制了栈上的指针、长度和容量。我们不会复制指针所指向的堆上的数据。

之前，我们说过当变量超出作用域时，Rust 会自动调用 drop 函数并清理该变量的堆内存。但上图显示两个数据指针都指向相同的位置。这是一个问题：当 s2 和 s1 超出作用域时，它们都会尝试释放同一块内存。这被称为 双重释放错误，也是我们之前提到的内存安全漏洞之一。重复释放内存会导致内存损坏，这可能会引发安全漏洞。

为确保内存安全，在行 let s2 = s1; 之后，Rust 将 s1 视为不再有效。因此，当 s1 超出作用域时，Rust 无需释放任何内容。看看在 s2 创建后尝试使用 s1 会发生什么；它将无法工作：

1
2
3
4

let s1 = String::from("hello");
let s2 = s1;

println!("{s1}, world!");

你会得到类似这样的错误，因为 Rust 阻止你使用失效的引用：

如果你在其他语言中听说过浅拷贝和深拷贝这两个术语，那么复制指针、长度和容量而不复制数据的概念听起来可能就像是在进行浅拷贝。但由于 Rust 也会使第一个变量失效，所以它不是被称为浅拷贝，而是被称为 移动。在这个例子中，我们会说 s1 被移动到了 s2。

这样就解决了我们的问题！当只有 s2 有效时，当它超出作用域时，它将单独释放内存，我们就完成了。

此外，还有一个由此暗示的设计选择：Rust 永远不会自动创建数据的 “深度” 副本。因此，任何自动复制都可以被认为是运行时性能上成本不高的。

4.1.6.1 变量重新赋值时的内存管理

对于作用域、所有权以及通过 drop 函数释放内存之间的关系，情况也正好相反。当你给一个现有变量赋予一个全新的值时，Rust 会立即调用 drop 并释放原始值的内存。例如，考虑以下代码：

1
2
3

let mut s = String::from("hello");
s = String::from("ahoy");
println!("{s}, world!");