基础概念

整数 是一个 没有小数部分的数字

      以前使用过 u32 整数类型

      该类型声明表明，它关联的值应该是一个占据 32 比特位的无符号整数
      有符号整数类型以 i 开头而不是 u

下面表格展示了 Rust 内建的整数类型。在有符号列和无符号列中的每一个变体（例如，i16）都可以用来声明整数值的类型：

每一个变体都可以是有符号或无符号的，并有一个明确的大小：

• 有符号 和 无符号 代表数字能否为负值，换句话说，数字是否需要有一个符号（有符号数），或者永远为正而不需要符号（无符号数）

      这有点像在纸上书写数字：当需要考虑符号的时候，数字以加号或减号作为前缀
      然而，可以安全地假设为正数时，加号前缀通常省略

      有符号数以补码形式存储

每一个有符号的变体可以储存包含从 -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 位的

可以使用下面表格中的任何一种形式编写数字字面值：

      注意除 byte 以外的所有数字字面值允许使用类型后缀，例如 57u8

      同时也允许使用 _ 做为分隔符以方便读数，例如1_000

Rust 也有两个原生的 浮点数 类型，它们是 带小数点的数字 。Rust 的浮点数类型是 f32 和 f64 ，分别占 32 位和 64 位。 默认类型是 f64

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

      浮点数采用 IEEE-754 标准表示：f32 是单精度浮点数，f64 是双精度浮点数

      在现代 CPU 中，f64 与 f32 速度几乎一样，不过精度更高

Rust 中的所有数字类型都支持基本数学运算： 加法 、 减法 、 乘法 、 除法 和 取余 。下面的代码展示了如何在 let 语句中使用它们：

fn main() {
    // 加法
    let sum = 5 + 10;

    // 减法
    let difference = 95.5 - 4.3;

    // 乘法
    let product = 4 * 30;

    // 除法
    let quotient = 56.7 / 32.2;

    // 取余
    let remainder = 43 % 5;
}

这些语句中的每个表达式使用了一个数学运算符并计算出了一个值，然后绑定给一个变量

Rust 中的布尔类型有两个可能的值： true 和 false 。Rust 中的布尔类型使用 bool 表示。例如：

fn main() {
    let t = true;

    let f: bool = false; // 显式指定类型注解
}

      使用布尔值的主要场景是条件表达式，例如 if 表达式

目前为止只使用到了数字，不过 Rust 也支持字母。Rust 的 char 类型是语言中 最原生的字母类型 ，如下代码展示了如何使用它：

fn main() {
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
}

      注意 char 由单引号指定，不同于字符串使用双引号

Rust 的 char 类型的大小为 四个字节 ，并代表了一个 Unicode 标量值 ，这意味着它可以比 ASCII 表示更多内容

在 Rust 中，拼音字母，中文、日文、韩文等字符，emoji以及零长度的空白字符都是有效的 char 值

Unicode 标量值包含从 U+0000 到 U+D7FF 和 U+E000 到 U+10FFFF 在内的值

不过，“字符” 并不是一个 Unicode 中的概念，所以人直觉上的 “字符” 可能与 Rust 中的 char 并不符合

元组 是一个将 多个其他类型的值 组合 进一个 复合类型 的主要方式

• 元组 长度固定 ：一旦声明，其长度不会增大或缩小
• 使用包含在 圆括号中的逗号分隔 的值列表来创建一个元组
• 元组中的每一个位置都有一个类型，而且这些 不同值的类型也不必是相同的

下面例子中使用了可选的类型注解：

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

tup 变量绑定到整个元组上，因为元组是一个单独的复合元素。为了从元组中获取单个值，可以使用 模式匹配 来 解构 元组值 ，像这样：

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("The value of y is: {}", y);
}

      首先创建了一个元组并绑定到 tup 变量上

      接着使用了 let 和一个模式将 tup 分成了三个不同的变量，x、y 和 z
      这叫做解构，因为它将一个元组拆成了三个部分

      最后，程序打印出了 y 的值，也就是 6.4。

除了使用模式匹配解构外，也可以使用点号 . 后跟 值的索引 来直接访问它们。例如：

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let five_hundred = x.0;

    let six_point_four = x.1;

    let one = x.2;
}

      这个程序创建了一个元组，x，并接着使用索引为每个元素创建新变量

      跟大多数编程语言一样，元组的第一个索引值是 0

另一个包含多个值的方式是 数组 ：

• 与元组不同，数组中的 每个元素的类型必须相同
• Rust 中的数组是 固定长度 的：一旦声明，它们的长度不能增长或缩小

Rust 中，数组中的值位于 中括号内的逗号 分隔的列表中：

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

      当想要在栈而不是在堆上为数据分配空间，或者是想要确保总是有固定数量的元素时，数组非常有用

      但是数组并不如 vector 类型灵活，vector 类型是标准库提供的一个 允许 增长和缩小长度的类似数组的集合类型

      当不确定是应该使用数组还是 vector 的时候，你可能应该使用 vector

一个可能想要使用数组而不是 vector 的例子是，当程序需要知道一年中月份的名字时。程序不大可能会去增加或减少月份。这时可以使用数组，因为它总是包含 12 个元素：

fn main() {
    let months = ["January", "February", "March", "April", "May", "June", "July",
                  "August", "September", "October", "November", "December"];
}

可以像这样编写数组的类型：在方括号中包含 每个元素的类型 ，后跟 分号 ，再后跟数组 元素的数量 ：

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

      这里，i32 是每个元素的类型。分号之后，数字 5 表明该数组包含五个元素

如果希望创建一个 每个元素都相同 的数组，可以在中括号内指定其 初始值 ，后跟 分号 ，再后跟数组的 长度 ，如下所示：

let a = [3; 5];