Rust 数据类型详解：整数、浮点数、布尔、字符、元组和数组

《Rust 编程实战》系列第 7 篇

上一篇文章，我们学习了 Rust 的变量与不可变性。

变量只是一个"容器"，而变量里面保存的数据，就需要有明确的数据类型（Data Type）。

Rust 是一门静态类型语言（Statically Typed Language）。

这意味着：

每一个变量在编译时都必须知道自己的类型。

Rust 编译器会尽可能自动推导类型，但类型一旦确定，就不能随意改变。

本文将详细介绍 Rust 中最常用的基础数据类型。

---

什么是数据类型？

数据类型决定了变量能够保存什么样的数据，以及可以执行哪些操作。

例如：

let age = 18;
let price = 99.8;
let ok = true;
let name = 'A';

虽然都是变量，但它们分别表示：

变量	类型
age	整数
price	浮点数
ok	布尔值
name	字符

Rust 根据不同的数据类型，在内存中采用不同的存储方式。

---

Rust 数据类型分类

Rust 的基础数据类型可以分为两大类。

标量类型（Scalar Types）

一个变量只保存一个值。

包括：

• 整数（Integer）

• 浮点数（Float）

• 布尔值（Boolean）

• 字符（Character）

---

复合类型（Compound Types）

一个变量可以保存多个值。

包括：

• 元组（Tuple）

• 数组（Array）

以后还会学习：

• Struct

• Enum

• Vec

• String

• HashMap

---

整数类型

整数表示没有小数部分的数字。

例如：

let age = 18;

Rust 提供了很多整数类型。

类型	大小	是否有符号
i8	8 位	有
i16	16 位	有
i32	32 位	有
i64	64 位	有
i128	128 位	有
isize	与平台相关	有
u8	8 位	无
u16	16 位	无
u32	32 位	无
u64	64 位	无
u128	128 位	无
usize	与平台相关	无

---

i 和 u 有什么区别？

例如：

let a: i32 = -10;

可以保存负数。

而：

let b: u32 = 10;

不能保存负数。

因此：

一般情况下：

年龄：

u8

文件大小：

u64

数组索引：

usize

---

默认整数类型

例如：

let x = 100;

编译器默认：

i32

这是 Rust 中最常见的整数类型。

---

浮点数

Rust 有两种浮点数：

f32

和：

f64

例如：

let price = 99.5;

默认：

f64

指定：

let pi: f32 = 3.14;

或者：

let pi = 3.14_f32;

---

浮点计算

例如：

fn main() {

    let a = 3.5;

    let b = 2.5;

    println!("{}", a + b);

}

输出：

6

支持：

• /

• %

---

布尔类型

布尔值只有两个：

true

false

例如：

let ok = true;

let login = false;

通常用于：

if ok {

}

布尔类型：

bool

例如：

let success: bool = true;

---

字符类型

Rust 的字符：

使用：

char

例如：

let c = 'A';

注意：

必须：

单引号。

正确：

'A'

错误：

"A"

因为：

双引号表示：

字符串。

---

Unicode 支持

Rust 的 char 不是 ASCII。

而是：

Unicode。

例如：

let c = '中';

let emoji = '😀';

都合法。

这一点比很多语言更方便。

---

元组（Tuple）

Tuple 可以保存：

多个不同类型的数据。

例如：

let user = ("Tom", 20, true);

这里：

分别保存：

• 字符串

• 整数

• 布尔值

---

获取 Tuple 元素

例如：

fn main() {

    let user = ("Tom", 20, true);

    println!("{}", user.0);

    println!("{}", user.1);

    println!("{}", user.2);

}

输出：

Tom
20
true

Tuple 使用：

.索引

访问。

---

解构 Tuple

例如：

let (name, age, ok) = ("Alice", 18, true);

以后：

直接：

println!("{}", name);

即可。

非常方便。

---

数组（Array）

Rust 数组：

长度固定。

例如：

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

获取：

println!("{}", nums[0]);

输出：

1

---

指定类型

例如：

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

语法：

[类型; 长度]

例如：

[i32;5]

表示：

5 个：

i32

---

创建相同元素数组

例如：

let nums = [0; 10];

等价于：

[
0,0,0,0,0,
0,0,0,0,0
]

非常适合初始化。

---

类型推导

Rust 能自动推导：

例如：

let age = 18;

自动：

i32

例如：

let ok = true;

自动：

bool

因此：

大部分时候：

无需指定类型。

---

显式类型

如果需要：

可以指定：

let age: u8 = 18;

let score: f64 = 98.5;

let ok: bool = true;

这样代码更清晰。

---

类型转换

Rust 不允许隐式转换。

例如：

let a: i32 = 10;

let b: u32 = 20;

下面：

错误：

let c = a + b;

必须：

let c = a as u32 + b;

或者：

let c = a as i64;

Rust 要求开发者显式进行类型转换，避免因为自动转换带来精度丢失或逻辑错误。

---

常见错误

字符使用双引号

错误：

let c = "A";

这是：

字符串。

正确：

let c = 'A';

---

数组越界

例如：

let nums = [1,2,3];

println!("{}", nums[10]);

运行：

直接 panic。

Rust 会保护程序。

---

整数类型不同

例如：

let a:i32 = 1;

let b:u32 = 2;

不能：

直接相加。

需要：

显式转换。

---

最佳实践

开发过程中可以遵循以下建议：

• 默认使用类型推导，让代码更简洁。

• 与硬件、网络协议或数据库交互时，显式指定整数类型。

• 数组用于固定长度的数据，长度可变时使用 Vec。

• char 表示单个字符，字符串请使用 String 或 &str。

• 避免频繁使用 as 强制转换，尽量保证变量类型一致。

---

本章小结

数据类型决定了 Rust 如何存储和处理数据，也是后续学习函数、所有权和结构体的基础。

本文学习了：

• Rust 数据类型分类

• 整数类型

• 浮点数类型

• 布尔类型

• 字符类型

• 元组（Tuple）

• 数组（Array）

• 类型推导

• 显式类型声明

• 类型转换

• 常见错误和最佳实践

掌握这些基础数据类型后，你已经能够编写简单的 Rust 程序，并理解编译器对类型安全的严格要求。

---

下一篇预告

下一篇我们将学习 Rust 常量与静态变量（Constants & Static Variables）。

包括：

• const 的使用

• static 的使用

• const 与 let 的区别

• const 与 static 的区别

• 全局变量

• 静态生命周期

• 企业项目中的最佳实践

这些内容在配置管理、全局状态和大型项目中都会经常用到。