返回专栏
· 12 分钟阅读

静态语言与动态语言


一、什么是静态语言与动态语言?

静态语言(Statically Typed Language)和动态语言(Dynamically Typed Language),主要是根据类型检查发生的时机进行的分类。

  • 静态类型语言:变量、表达式等的类型通常在编译阶段确定,并由编译器进行类型检查。
  • 动态类型语言:类型信息主要在程序运行期间确定和检查,变量可以在不同时间引用不同类型的对象。

例如:

Java:静态类型

int age = 18;

age = "hello"; // 编译错误

变量 age 声明为 int,后续不能直接赋值为字符串。

Python:动态类型

age = 18

age = "hello"  # 合法

Python 中,变量名可以先后绑定不同类型的对象。

需要注意:

  • 静态类型不意味着变量的值永远不能变化。
  • 动态类型不意味着没有类型系统。
  • 静态类型不等于编译型语言。
  • 动态类型不等于解释型语言。

这几个概念经常被混淆,需要分别理解。

二、什么是类型系统?

理解静态语言和动态语言之前,需要先理解类型系统。

1. 类型的本质

类型(Type)是对数据及其允许操作的一种抽象描述。

类型通常规定:

  • 数据可以表示什么样的值。
  • 数据占用或组织内存的方式。
  • 数据支持哪些操作。
  • 不同类型之间能否进行转换。
  • 某个表达式可能产生什么类型的结果。

例如:

int age = 18;
float price = 19.9;
char grade = 'A';

这里定义了三种不同类型:

类型 含义 示例
int 整数 18
float 浮点数 19.9
char 字符 'A'

不同类型的数据支持的操作并不完全相同。

例如,整数可以进行算术运算,字符串通常支持拼接、截取等操作。

类型系统通过规则约束这些操作,减少不合理的程序行为。

2. 类型系统的主要职责

一个类型系统通常承担以下职责:

类型约束

规定变量、函数参数、返回值和表达式可以使用什么类型。

类型检查

判断程序中的操作是否符合类型规则。

类型转换

规定不同类型之间如何进行转换。

类型推断

根据表达式、赋值关系和上下文推导类型。

类型安全

尽可能防止不符合类型规则的操作,减少类型错误。

3. 类型检查的基本过程

flowchart TB
    A["编写源代码"] --> B["识别变量与表达式"]
    B --> C["确定或推断类型"]
    C --> D["检查类型规则"]
    D --> E{"是否符合类型约束"}
    E -->|"是"| F["继续编译或执行"]
    E -->|"否"| G["报告类型错误"]

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

静态类型语言通常在编译阶段完成大量类型检查;动态类型语言则主要在运行期间检查实际参与操作的对象类型。

三、静态语言的工作原理

1. 静态类型是什么?

静态类型(Static Typing)是指程序中的类型信息通常在编译阶段就能够确定,编译器可以在程序运行之前检查类型是否合法。

例如 Java:

public class Main {
    public static void main(String[] args) {
        int age = 18;
        String name = "Tom";

        age = 20;
        // age = "hello"; // 编译错误
    }
}

在编译阶段,编译器就能知道:

  • age 是 int 类型。
  • name 是 String 类型。
  • age = 20 符合类型规则。
  • age = "hello" 不符合类型规则。

因此,程序可以在运行之前发现部分类型错误。

2. 静态类型检查流程

flowchart TB
    A["源代码"] --> B["编译器解析"]
    B --> C["建立类型信息"]
    C --> D["类型推断与类型检查"]
    D --> E{"类型是否合法"}
    E -->|"合法"| F["生成目标代码"]
    E -->|"不合法"| G["编译失败"]
    F --> H["程序运行"]

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

静态类型检查能够提前发现:

  • 不兼容的类型赋值。
  • 函数参数类型不匹配。
  • 返回值类型错误。
  • 不支持的运算操作。
  • 部分空值使用问题。

但静态类型检查并不能保证程序没有运行时错误。例如数组越界、空指针、网络异常和业务逻辑错误,仍然可能发生。

3. 静态类型不代表必须显式声明类型

一个常见误区是认为静态类型语言必须为每个变量手动指定类型。

实际上,现代静态类型语言通常支持类型推断(Type Inference)。

例如 Go:

package main

import "fmt"

func main() {
    age := 18
    name := "Tom"

    fmt.Println(age, name)
}

虽然没有显式写出 int 和 string,但编译器可以根据初始化表达式推断变量类型。

再看 TypeScript:

let age = 18;
let name = "Tom";

age = 20;
// age = "hello"; // 类型错误

TypeScript 可以自动推断变量类型,并在静态检查阶段发现不兼容赋值。

因此:

显式类型声明与静态类型检查是两个不同的概念。

静态类型语言可以允许开发者少写类型,但并不意味着放弃类型约束。

4. 静态语言的主要特点

  • 类型错误提前发现:大量类型错误可以在编译阶段暴露。
  • 代码约束明确:变量、函数参数和返回值具有清晰的类型约束。
  • 工具支持较好:IDE 可以利用类型信息实现自动补全、重构和静态分析。
  • 大型项目可维护性较强:类型声明能够帮助开发者理解接口和模块边界。
  • 运行时类型检查开销可能较少:部分类型约束已经在编译阶段处理。

需要注意,静态类型不一定意味着运行时完全没有类型检查。例如 Java 仍然需要处理类型转换、动态分派和运行时类型检查。

四、动态语言的工作原理

1. 动态类型是什么?

动态类型(Dynamic Typing)是指类型信息主要在程序运行期间确定和检查。

以 Python 为例:

value = 100
print(type(value))

value = "hello"
print(type(value))

value = [1, 2, 3]
print(type(value))

输出:

<class 'int'>
<class 'str'>
<class 'list'>

变量名 value 先后绑定了整数、字符串和列表对象。

这里需要理解一个重要概念:

动态类型通常意味着变量名不固定绑定某一种类型,而不是对象本身没有类型。

在 Python 中,整数对象仍然是整数对象,字符串对象仍然是字符串对象。变化的是变量名所引用的对象。

2. 动态类型的执行机制

动态语言通常在运行时获取对象的类型信息,并根据实际类型决定操作是否合法。

flowchart TB
    A["编写源代码"] --> B["解析或编译为中间表示"]
    B --> C["程序运行"]
    C --> D["获取对象运行时类型"]
    D --> E["执行类型相关操作"]
    E --> F{"操作是否合法"}
    F -->|"合法"| G["继续执行"]
    F -->|"不合法"| H["抛出运行时异常"]

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

例如:

a = 10
b = "20"

result = a + b

这段代码通常可以通过 Python 的语法解析和字节码编译,但运行到 a + b 时,会因为整数与字符串不支持这种加法操作而抛出 TypeError。

这说明动态类型语言并不是不检查类型,而是很多检查发生在运行期间。

3. 动态语言的主要特点

  • 类型使用灵活:变量名可以在不同时间绑定不同类型的对象。
  • 开发表达简洁:通常不需要为每个变量声明类型。
  • 运行时适应能力较强:适合动态数据结构、反射和灵活扩展。
  • 部分错误延迟暴露:类型错误可能只有执行到相关代码路径时才会发现。
  • 运行时需要处理类型信息:部分操作需要进行动态分派、类型判断或方法查找。

动态类型并不意味着代码质量低,也不意味着一定难以维护。合理的模块设计、测试、文档和类型检查工具,同样可以建立可靠的动态语言项目。

五、静态语言与动态语言的核心区别

对比维度 静态语言 动态语言
类型确定 通常在编译阶段确定 主要在运行阶段确定
类型检查 通常以编译期检查为主 通常以运行时检查为主
类型声明 可以显式声明,也可以推断 通常不要求显式声明
变量类型 通常受到声明或推断类型约束 变量名可以绑定不同类型的对象
错误发现 部分类型错误提前发现 部分类型错误在运行时暴露
开发灵活性 类型约束相对明确 类型使用通常更加灵活
IDE 支持 类型信息通常更容易用于静态分析 依赖推断、注解及运行时信息
典型语言 Java、C、C++、Go、Rust、TypeScript Python、JavaScript、Ruby、PHP

1. 错误发现时机

静态语言通常能够在运行之前发现类型不匹配问题。

动态语言则可能在程序执行到具体操作时才发现类型错误。

例如:

Java:

int age = 18;

age = "hello";

编译器会拒绝这段代码。

Python:

age = 18
age = "hello"

print(age)

这段代码可以正常执行。

但是:

age = 18
result = age + "hello"

程序运行到加法操作时才会产生类型错误。

2. 开发效率与维护成本

动态语言通常具有较低的初始编码成本。

例如:

def add(a, b):
    return a + b

开发者不需要声明参数类型和返回值类型。

静态语言通常需要更多类型约束:

public int add(int a, int b) {
    return a + b;
}

不过,在大型项目中,类型信息可以成为重要的维护工具。

例如修改一个公共函数的参数类型时,静态类型检查器能够帮助开发者发现受到影响的调用位置。

因此:

  • 小型脚本和快速原型,动态语言通常更加灵活。
  • 大型工程和复杂模块协作,静态类型通常更容易建立明确的接口约束。
  • 具体效果还取决于团队规范、测试体系和语言工具链。

六、静态类型与动态类型不等于编译型与解释型

这是编程语言分类中非常重要的知识点。

两组概念关注的是不同问题:

分类 关注的问题
静态类型与动态类型 类型在什么时候确定和检查
编译型与解释型 代码通过什么机制转换和执行

它们之间不存在必然对应关系。

1. 四种组合关系

类型系统 代码执行机制 代表语言
静态类型 编译为机器代码 C、C++、Rust、Go
静态类型 编译为字节码并由虚拟机执行 Java、C#
动态类型 解释执行或虚拟机执行 Python、Ruby
动态类型 解释与 JIT 混合执行 JavaScript

需要注意,表格中的执行方式是常见实现形态,不代表语言只能采用这一种实现。

例如:

  • Java 是静态类型语言,但不是简单的传统本地机器码编译执行模式。
  • Python 是动态类型语言,但 CPython 会先将源代码编译为字节码。
  • JavaScript 是动态类型语言,但现代引擎大量使用 JIT 编译。
  • TypeScript 是静态类型检查工具链,但通常会将类型信息擦除后生成 JavaScript,再由 JavaScript 引擎执行。

2. TypeScript 为什么特别?

TypeScript 是理解这两组概念区别的典型例子。

function add(a: number, b: number): number {
    return a + b;
}

console.log(add(10, 20));

TypeScript 在开发和构建阶段进行静态类型检查。

但 TypeScript 代码通常会被转换为 JavaScript。

例如:

function add(a, b) {
    return a + b;
}

console.log(add(10, 20));

运行时,JavaScript 引擎并不会保留并执行 TypeScript 的 number 类型声明。

因此:

  • TypeScript 提供静态类型检查能力。
  • JavaScript 负责最终运行。
  • TypeScript 的类型系统主要服务于开发和编译阶段。
  • 类型信息通常不会作为运行时强制约束保留。

这也是 TypeScript 与 Java、C# 等具有运行时类型系统的语言之间的重要区别。

七、静态类型语言中的高级类型机制

静态类型并不只是简单地声明 int、string 等基本类型。现代语言的类型系统已经发展出大量高级能力。

1. 类型推断(Type Inference)

编译器根据上下文自动推导表达式或变量的类型。

例如 Rust: