返回专栏
· 16 分钟阅读

数据类型(Data Types)


一、什么是数据类型?

数据类型(Data Type)是编程语言对数据的一种抽象描述,用于定义一类数据具有怎样的值、如何表示,以及允许执行哪些操作。

例如:

age = 25
price = 19.99
name = "Reverie"
is_active = True

这些变量分别使用了整数、浮点数、字符串和布尔类型。

数据类型不仅仅是给数据贴上一个标签,它通常涉及以下几个方面:

维度 含义 示例
取值范围 数据能够表示哪些值 整数、有限精度浮点数
存储表示 数据在内存中如何编码 二进制补码、IEEE 754
操作集合 数据允许执行哪些操作 加减乘除、字符串拼接
类型规则 哪些操作合法,哪些不合法 整数与字符串能否相加
类型检查 如何发现类型错误 编译期检查、运行期检查

可以将数据类型理解为:

数据类型 = 值的集合 + 操作集合 + 类型规则

需要注意,不同编程语言对数据类型的定义和实现可能不同。同一个概念在不同语言中,可能具有不同的取值范围、精度、内存布局和类型检查行为。

二、为什么需要数据类型?

计算机底层处理的是二进制数据。相同的一组二进制位,如果采用不同的解释方式,就可能代表完全不同的值。

例如,下面的 8 位二进制数据:

00000101

可以解释为:

  • 无符号整数:5
  • 有符号整数:5
  • 字符编码:取决于所采用的字符编码标准
  • 其他数据结构中的一个字节:取决于具体协议和上下文

二进制数据本身并不天然携带完整的业务含义。数据类型为这些位提供了解释规则。

2.1 明确数据的含义

数据类型让程序能够区分不同性质的数据。

例如:

count = 10
message = "10"

虽然两个变量看起来都包含 10,但它们的语义不同:

  • count 表示数值,可以参与数学运算。
  • message 表示文本,可以参与字符串拼接。
print(count + 5)       # 15
print(message + "5")   # "105"

2.2 约束数据操作

数据类型定义了数据可以参与哪些操作。

例如:

age = 25
name = "Alice"

print(age + 10)
print(name + " Smith")

整数可以进行数值运算,字符串可以进行拼接。

如果尝试执行不符合语言规则的操作,程序可能在编译阶段或运行阶段产生类型错误。

2.3 提供内存表示规则

数据类型通常影响数据的存储方式、大小、对齐方式和解释规则。

例如,在常见的 C 实现中:

int age = 25;
float price = 19.99f;
char grade = 'A';

不同类型通常采用不同的内存表示。

但需要注意,C 标准并不保证所有平台上的 int、float 都具有完全相同的字节数。具体大小取决于实现。

2.4 提高程序的可靠性

类型检查能够提前或及时发现一部分错误。

例如:

let age: number = 25;

age = "twenty-five";

TypeScript 会在静态类型检查阶段报告类型不匹配。

类型系统不能保证程序没有错误,但可以缩小错误空间,让一部分问题在程序运行之前就被发现。

三、数据类型的主要分类

不同编程语言的类型分类方式并不完全一致。

从基础数据结构和语言设计角度,可以将常见数据类型划分为以下几类:

flowchart TB
    A["数据类型"] --> B["基本类型"]
    A --> C["复合类型"]
    A --> D["特殊类型"]

    B --> B1["整数类型"]
    B --> B2["浮点数类型"]
    B --> B3["布尔类型"]
    B --> B4["字符类型"]

    C --> C1["数组"]
    C --> C2["结构体"]
    C --> C3["类与对象"]
    C --> C4["元组"]
    C --> C5["集合与映射"]

    D --> D1["空值类型"]
    D --> D2["指针类型"]
    D --> D3["引用类型"]
    D --> D4["函数类型"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style B1 fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B2 fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B3 fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B4 fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C1 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C2 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C3 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C4 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C5 fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D1 fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D2 fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style D3 fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style D4 fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这是一种便于理解的概念分类,并非所有语言都采用相同的分类体系。

四、基本数据类型

基本数据类型(Primitive Types)通常是语言直接提供的基础类型,用于表示最常见的数据。

4.1 整数类型(Integer)

整数类型用于表示没有小数部分的数值。

常见整数包括:

-100
-1
0
1
100

常见整数类型:

类型 含义
int8 8 位有符号整数
int16 16 位有符号整数
int32 32 位有符号整数
int64 64 位有符号整数
uint8 8 位无符号整数
uint16 16 位无符号整数
uint32 32 位无符号整数
uint64 64 位无符号整数

对于 n 位整数:

无符号整数的取值范围:

0 \leq x \leq 2^n-1

有符号整数采用二进制补码时的取值范围:

-2^{n-1} \leq x \leq 2^{n-1}-1

例如:

类型 取值范围
int8 -128 ~ 127
uint8 0 ~ 255
int16 -32768 ~ 32767
uint16 0 ~ 65535

整数的位数决定了其可表示范围。

整数溢出

当计算结果超出类型能够表示的范围时,就可能发生整数溢出。

例如,8 位无符号整数最大值为 255:

255 + 1

在采用模 2^8 运算的无符号整数模型中,结果会回绕为:

0

但不能将这一行为推广到所有整数类型和语言。

例如:

  • C 语言中,无符号整数溢出按模运算处理。
  • C 语言中,有符号整数溢出属于未定义行为。
  • Java 的整数运算溢出会保留低位,产生回绕结果。
  • Python 的整数可以自动扩展精度,直到受到可用内存等资源限制。

因此,处理整数溢出时,必须结合具体语言的规范。

4.2 浮点数类型(Floating-Point)

浮点数用于表示带有小数部分的数值,以及较大或较小范围内的近似数值。

常见类型:

类型 常见精度 典型用途
float32 单精度,约 7 位十进制有效数字 图形计算、一般数值计算
float64 双精度,约 15~16 位十进制有效数字 科学计算、通用数值计算

很多语言使用 IEEE 754 标准定义浮点数的表示与运算行为。

以 32 位单精度浮点数为例:

1 位符号位
8 位指数位
23 位尾数位

浮点数可以表示非常大的数值范围,但不能精确表示所有实数。

例如:

print(0.1 + 0.2)

可能得到:

0.30000000000000004

原因是十进制的 0.1 和 0.2 无法用有限长度的二进制小数精确表示。

浮点数的核心特点是:

  • 表示范围较大。
  • 精度有限。
  • 运算可能产生舍入误差。
  • 不适合直接用于要求严格十进制精度的金融计算。

对于金额等业务数据,可以考虑使用十进制定点数、整数最小货币单位或专门的 Decimal 类型。

浮点数的特殊值

IEEE 754 浮点数还定义了一些特殊值:

特殊值 含义
+Infinity 正无穷
-Infinity 负无穷
NaN 非数值
+0 正零
-0 负零

其中,NaN 具有特殊的比较规则:

x = float("nan")

print(x == x)  # False

因此,判断 NaN 通常应该使用专门的检测函数,而不是直接与自身比较。

4.3 布尔类型(Boolean)

布尔类型用于表示逻辑状态,通常只有两个值:

True
False

例如:

is_login = True
is_admin = False

布尔类型广泛用于:

  • 条件判断
  • 循环控制
  • 逻辑运算
  • 状态表达
  • 权限判断

常见逻辑运算:

运算 含义
AND 逻辑与
OR 逻辑或
NOT 逻辑非

例如:

age = 25
is_member = True

if age >= 18 and is_member:
    print("允许访问")

需要注意,布尔值在不同语言中的底层表示不一定相同。

例如,C 语言使用 _Bool 类型,逻辑值通常表现为 0 和 1;Python 中 bool 是 int 的子类;JavaScript 中则有独立的 boolean 类型。

4.4 字符类型(Character)

字符类型用于表示单个字符。

例如:

'A'
'中'
'7'

不同语言对字符类型的定义存在明显差异。

语言 字符表示方式
C char,通常用于存储一个字节
Java char,使用 16 位 UTF-16 代码单元
Go rune,表示 Unicode 码点,底层为 int32
Python 没有独立的单字符类型,单个字符仍然是字符串

需要特别区分三个概念:

  • 字节(Byte):通常是 8 位数据单位。
  • Unicode 码点(Code Point):Unicode 为字符分配的编号。
  • 用户感知字符(Grapheme Cluster):用户看到的一个完整字符,可能由多个码点组成。

例如,一个带有组合附加符号的字符,可能由多个 Unicode 码点构成。

因此,字符不一定等于一个字节,也不一定等于一个 Unicode 码点。

五、复合数据类型

复合数据类型(Composite Types)由多个数据元素组合而成,用于表达更复杂的数据结构。

5.1 数组(Array)

数组是一种由多个相同类型或受特定类型规则约束的元素组成的数据结构。

例如:

int numbers[5] = {10, 20, 30, 40, 50};

数组通常具有以下特点:

  • 元素按照一定顺序排列。
  • 可以通过索引访问元素。
  • 在固定长度数组中,长度通常在创建时确定。
  • 数组元素通常具有相同类型。

数组的典型内存布局:

flowchart LR
    A["数组 numbers"] --> B["索引 0"]
    A --> C["索引 1"]
    A --> D["索引 2"]
    A --> E["索引 3"]

    B --> F["10"]
    C --> G["20"]
    D --> H["30"]
    E --> I["40"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style I fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

数组的优势在于元素通常连续存储,能够通过索引快速定位。

不过,不同语言中的数组并不完全相同。例如,C 的数组与 JavaScript 的动态数组、Python 的 list,在内存布局和类型约束上有很大区别。

5.2 结构体(Struct)

结构体用于将多个不同类型的数据组合成一个整体。

例如:

struct User {
    int id;
    char name[32];
    int age;
};

一个用户对象可能包含:

  • 用户 ID
  • 用户名称
  • 用户年龄

结构体适合表达具有多个属性的实体。

结构体的内存布局受到成员顺序、对齐要求和填充字节等因素影响。

例如:

struct Example {
    char a;
    int b;
};

即使 char 只占一个字节,整个结构体也不一定只占五个字节。编译器可能插入填充字节,以满足 int 的对齐要求。

5.3 类与对象(Class and Object)

在面向对象语言中,类通常用于定义对象的属性和行为。

例如:

class User {
    int id;
    String name;

    void login() {
        System.out.println("User login");
    }
}

创建对象:

User user = new User();
user.id = 1001;
user.name = "Alice";

类与结构体都可以组合多个数据成员,但二者的语言语义和能力并不相同。

类通常还涉及:

  • 封装
  • 继承
  • 多态
  • 方法分派
  • 对象生命周期

需要注意,类是否属于引用类型、对象如何分配内存,取决于具体语言。例如,Java 的类实例通常通过引用访问,而 C++ 的类对象既可以直接存储,也可以通过指针或引用访问。

5.4 元组(Tuple)

元组用于将多个不同类型的值组合在一起。

例如:

user = (1001, "Alice", 25)

其中可以包含:

  • 整数
  • 字符串
  • 整数

元组常用于:

  • 多值返回
  • 临时数据组合
  • 函数参数传递
  • 结构化数据表达

在 Python 中,元组通常不可变;在其他语言中,元组的可变性和类型规则可能不同。

5.5 集合与映射(Set and Map)

集合和映射用于表达不同的数据组织关系。

集合(Set)

集合通常存储不重复的元素:

numbers = {1, 2, 3, 4}

主要特点:

  • 元素通常具有唯一性。
  • 适合成员关系判断。
  • 不一定保证元素顺序。

映射(Map)

映射使用键值对组织数据:

user = {
    "id": 1001,
    "name": "Alice",
    "age": 25
}

映射中的每个元素由键和值组成。

常见名称包括:

语言 映射类型
Python dict
Java Map
Go map
JavaScript Map、普通对象
Rust HashMap

集合和映射的底层实现可能采用哈希表、树或其他数据结构,具体性能特征取决于实现。

六、特殊数据类型

除了基本类型和复合类型,编程语言还提供了许多用于表达特殊语义的类型。

6.1 空值类型(Null / None / Nil)

空值用于表示缺少值、没有对象或某种特殊的空状态。

不同语言使用不同的表示:

语言 空值表示
Python None
Java null
JavaScript null、undefined
Go nil
Rust 通常通过 Option 表达可选值

需要区分:

  • 空字符串:""
  • 数值零:0
  • 布尔假:false
  • 空值:null 或对应语言的空值表示

它们并不是同一个概念。

例如:

let a = "";
let b = 0;
let c = false;
let d = null;
let e;

console.log(a === null); // false
console.log(b === null); // false
console.log(c === null); // false
console.log(d === null); // true
console.log(e === undefined); // true

空值处理是实际开发中非常重要的边界问题。

6.2 指针类型(Pointer)

指针用于保存另一个对象或数据所在的内存地址。

例如 C 语言:

int age = 25;
int *ptr = &age;

其中:

  • age 是一个整数变量。
  • &age 表示变量的地址。
  • ptr 保存该地址。
  • *ptr 表示通过指针访问对应的值。

指针的核心关系:

flowchart LR
    A["指针变量 ptr"] --> B["内存地址"]
    B --> C["变量 age"]
    C --> D["数值 25"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

指针是理解底层编程的重要概念,涉及:

  • 内存地址
  • 指针运算
  • 动态内存分配
  • 空指针
  • 野指针
  • 悬空指针
  • 内存安全

指针并不等于引用。二者在语言语义、操作能力和安全约束方面可能存在明显差异。

6.3 引用类型(Reference)

引用通常用于间接访问某个对象或数据。

例如 Java:

User user = new User();

这里的 user 是一个引用变量,用于访问 User 对象。

引用与指针有相似之处,但并不完全相同:

对比维度 指针 引用
是否间接访问数据 是 是
是否可以为空 取决于语言 取决于语言
是否可以改变指向 通常可以 取决于语言
是否支持地址运算 部分语言支持 通常不支持
安全约束 取决于语言 取决于语言

需要特别注意,Java 的引用、C++ 的引用、Rust 的引用并不是完全相同的概念。

不能简单地认为所有引用都等于指针的语法封装。

6.4 函数类型(Function Type)

函数本身也可以作为一种类型。

函数类型通常描述:

  • 参数类型
  • 返回值类型
  • 调用约定或其他约束

例如 TypeScript:

type AddFunction = (a: number, b: number) => number;

const add: AddFunction = (a, b) => {
    return a + b;
};

这里 AddFunction 描述了一个接收两个数字并返回数字的函数类型。

函数类型是函数式编程、高阶函数、回调机制和依赖注入等技术的重要基础。

七、静态类型与动态类型

数据类型的分类,还可以从类型检查发生的时间进行理解。

这也是编程语言中非常重要的一组概念。

7.1 静态类型(Static Typing)

静态类型语言通常在编译阶段或其他程序执行前的分析阶段进行类型检查。

例如 Java:

int age = 25;
age = "Alice"; // 编译错误

编译器能够在程序运行前发现类型不匹配。

常见静态类型语言:

  • C
  • C++
  • Java
  • Go
  • Rust
  • TypeScript(通过类型检查器进行静态分析)

静态类型的优势:

  • 能够提前发现一部分类型错误。
  • 有利于代码重构和工具分析。
  • 类型信息有助于 IDE 提供自动补全。
  • 更容易表达复杂的数据约束。

但静态类型不意味着所有错误都能在编译阶段发现,也不意味着程序运行时完全不存在类型问题。

7.2 动态类型(Dynamic Typing)

动态类型语言通常在程序运行期间确定或检查对象的类型。

例如 Python: