数据类型

在 Rust 中，每一个值都属于某一个 数据类型（data type），这告诉 Rust 它被指定为何种数据，以便明确数据处理方式。我们将看到两类数据类型子集：标量（scalar）和复合（compound）。

Rust 是 静态类型（statically typed）语言，也就是说在编译时就必须知道所有变量的类型。根据值及其使用方式，编译器通常可以推断出我们想要用的类型。当多种类型均有可能时，比如第二章的 “比较猜测的数字和秘密数字” 使用 parse 将 String 转换为数字时，必须增加类型注解，像这样：

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

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

:::tips $ cargo build

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

error[E0282]: type annotations needed

—> src/main.rs:2:9

|

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

| ^^^^^

|

help: consider giving guess an explicit type

|

2 | let guess: _ = “42”.parse().expect(“Not a number!”);

| +++

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

error: could not compile no_type_annotations due to previous error

:::

标量类型

标量（scalar）类型代表单独的值。Rust 有四种基本的标量类型：整形、浮点型、布尔类型和字符类型。你可能在其他语言中见过它们。让我们深入了解他们在 Rust 中是如何工作的。

整形

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

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

• 十进制：没有前缀，直接写数字，如 42、2023。
• 十六进制：以 0x 开头，如 0xff 表示十六进制的 255。
• 八进制：以 0o 开头，如 0o77 表示八进制的 63。
• 二进制：以 0b 开头，如 0b1111 表示二进制的 15。
• 大小类型后缀：可以添加类型后缀来明确数值的类型，如 57u8 表示一个 u8 类型的 57。

整型溢出

:::info

整型溢出

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

:::

浮点型

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

数值运算

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

布尔类型

fn main() {
    let t = true;
    let f: bool = false; // with explicit type annotation
}

字符类型

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // with explicit type annotation
    let heart_eyed_cat = '😻';
}

复合类型

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

元组类型

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

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

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

数组类型

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

然而，当你确定元素个数不会改变时，数组会更有用。例如，当你在一个程序中使用月份名字时，你更应趋向于使用数组而不是 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];

访问数组元素

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

无效的数组元素访问

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

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

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

:::