Rust 是 静态类型 （statically typed） 语言，也就是说在编译时就必须知道所有变量的类型

使用 <code>parse 将 String 转换为数字时，必须增加类型注解，像这样：

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

如果不像上面的代码这样添加类型注解 : u32 ，Rust 会显示如下错误，这说明编译器需要我们提供更多信息，来了解我们想要的类型：

$ cargo build

Compiling no_type_annotations v0.1.0 (file:///projects/no_type_annotations)

error[E0284]: type annotations needed

--> src/main.rs:2:9

|

2 | let guess = "42".parse().expect("Not a number!");

| ^^^^^ ----- type must be known at this point

|

= note: cannot satisfy `<_ as FromStr>::Err == _`

help: consider giving `guess` an explicit type

|

2 | let guess: /* Type */ = "42".parse().expect("Not a number!");

| ++++++++++++

For more information about this error, try `rustc --explain E0284`.

error: could not compile `no_type_annotations` (bin "no_type_annotations") due to 1 previous error

标量类型

Rust 有四种基本的标量类型：整型、浮点型、布尔类型和字符类型。

整型

整数是一个没有小数部分的数字，i 开头的是有符号数，u 开头的是无符号数。有符号 和 无符号 代表数字能否为负值，换句话说，这个数字是否有可能是负数（有符号数），或者永远为正而不需要符号（无符号数）。

有符号数以补码形式（two’s complement representation） 存储。

isize 和 usize 类型依赖运行程序的计算机架构：64 位架构上它们是 64 位的，32 位架构上它们是 32 位的。

可以使用表格中的任何一种形式编写数字字面值。请注意可以是多种数字类型的数字字面值允许使用类型后缀，例如 57u8 来指定类型，同时也允许使用 _ 做为分隔符以方便读数，例如1_000，它的值与你指定的 1000 相同。

Rust 数字类型默认是 i32。 isize 或 usize 主要作为某些集合的索引。

整型溢出

比方说有一个 u8 ，它可以存放从零到 255 的值。那么当你将其修改为 256 时会发生什么呢？这被称为 “整型溢出”（“integer overflow” ），这会导致以下两种行为之一的发生。当在 debug 模式编译时，Rust 检查这类问题并使程序 panic，这个术语被 Rust 用来表明程序因错误而退出。

使用 --release flag 在 release 模式中构建时，Rust 不会检测会导致 panic 的整型溢出。相反发生整型溢出时，Rust 会进行一种被称为二进制补码 wrapping（two’s complement wrapping）的操作。简而言之，比此类型能容纳最大值还大的值会回绕到最小值，值 256 变成 0，值 257 变成 1，依此类推。程序不会 panic，不过变量可能也不会是你所期望的值。依赖整型溢出 wrapping 的行为被认为是一种错误。

为了显式地处理溢出的可能性，可以使用这几类标准库提供的原始数字类型方法：

• 所有模式下都可以使用 wrapping_* 方法进行 wrapping，如 wrapping_add
• 如果 checked_* 方法出现溢出，则返回 None值
• 用 overflowing_* 方法返回值和一个布尔值，表示是否出现溢出
• 用 saturating_* 方法在值的最小值或最大值处进行饱和处理

浮点型

Rust 也有两个原生的 浮点数（floating-point numbers）类型，它们是带小数点的数字。Rust 的浮点数类型是 f32 和 f64，分别占 32 位和 64 位。默认类型是 f64，因为在现代 CPU 中，它与 f32 速度几乎一样，不过精度更高。所有的浮点型都是有符号的。

fn main() {

let x = 2.0; // f64

let y: f32 = 3.0; // f32

}

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

数值运算

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

fn main() {

// addition

let sum = 5 + 10;

// subtraction

let difference = 95.5 - 4.3;

// multiplication

let product = 4 * 30;

// division

let quotient = 56.7 / 32.2;

let truncated = -5 / 3; // 结果为 -1

// remainder

let remainder = 43 % 5;

}

布尔型

Rust 中的布尔类型有两个可能的值：true 和 false

fn main() {

let t = true;

let f: bool = false; // with explicit type annotation

}

字符类型

Rust 的 char 类型是语言中最原生的字母类型

fn main() {

let c = 'z';

let z: char = 'ℤ'; // with explicit type annotation

let heart_eyed_cat = '😻';

}

单引号声明 char 字面量，双引号声明字符串字面量

char 类型的大小为四个字节 (four bytes)，并代表了一个 Unicode 标量值（Unicode Scalar Value）

复合类型

复合类型（Compound types）可以将多个值组合成一个类型，Rust 有两个原生的复合类型：元组（tuple）和数组（array）。

元组类型

元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小。

使用包含在圆括号中的逗号分隔的值列表来创建一个元组。元组中的每一个位置都有一个类型，而且这些不同值的类型也不必是相同的。这个例子中使用了可选的类型注解：

fn main() {

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

}

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

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。这叫做 解构（destructuring），因为它将一个元组拆成了三个部分。最后，程序打印出了 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;

}

元组的第一个索引值是 0。

不带任何值的元组有个特殊的名称，叫做 单元（unit） 元组。这种值以及对应的类型都写作 ()，表示空值或空的返回类型。如果表达式不返回任何其他值，则会隐式返回单元值。

数组类型

另一个包含多个值的方式是 数组（array）。与元组不同，数组中的每个元素的类型必须相同。Rust 中的数组与一些其他语言中的数组不同，Rust 中的数组长度是固定的。

将数组的值写成在方括号内，用逗号分隔：

fn main() {

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

}

当你想要在栈（stack）而不是在堆（heap）上为数据分配空间，或者是想要确保总是有固定数量的元素时，数组非常有用。但是数组并不如 vector 类型灵活。vector 类型是标准库提供的一个 允许 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，那么很可能应该使用 vector。

当确定元素个数不会改变时，数组会更有用。例如，当你在一个程序中使用月份名字时，你更应趋向于使用数组而不是 vector，月份只会有 12 个元素。

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];

变量名为 a 的数组将包含 5 个元素，这些元素的值最初都将被设置为 3。这种写法与 let a = [3, 3, 3, 3, 3]; 效果相同，但更简洁。

访问数组元素

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

fn main() {

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

let first = a[0];

let second = a[1];

}

无效的数组元素访问

如果访问数组结尾之后的元素会发生什么呢

use std::io;

fn main() {

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

println!("Please enter an array index.");

let mut index = String::new();

io::stdin()

.read_line(&mut index)

.expect("Failed to read line");

let index: usize = index

.trim()

.parse()

.expect("Index entered was not a number");

let element = a[index];

println!("The value of the element at index {index} is: {element}");

}

此代码编译成功。如果使用 cargo run 运行此代码并输入 0、1、2、3 或 4，程序将在数组中的索引处打印出相应的值。如果你输入一个超过数组末端的数字，如 10，你会看到这样的输出：

thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19

note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

程序在索引操作中使用一个无效的值时导致 运行时 错误。程序带着错误信息退出，并且没有执行最后的 println! 语句。当尝试用索引访问一个元素时，Rust 会检查指定的索引是否小于数组的长度。如果索引超出了数组长度，Rust 会 panic。这种检查必须在运行时进行，特别是在这种情况下，因为编译器不可能知道用户在以后运行代码时将输入什么值。