返回专栏
· 18 分钟阅读

语义(Semantics)


一、什么是语义?

语义(Semantics)是编程语言中用于描述程序含义、执行行为以及计算结果的一套规则。

简单来说:

  • 语法(Syntax):代码应该如何书写,结构是否合法。
  • 语义(Semantics):代码表达什么含义,执行时应该发生什么。

例如:

x = 10
y = 20
z = x + y

这段代码在语法上符合 Python 的规则。

从语义上看:

  • x = 10:将整数值 10 绑定到变量名 x。
  • y = 20:将整数值 20 绑定到变量名 y。
  • x + y:执行加法运算。
  • z = x + y:将计算结果 30 绑定到变量名 z。

语义不仅描述表达式的计算结果,还涉及:

  • 数据类型及其操作规则。
  • 变量的作用域与生命周期。
  • 名称绑定与引用关系。
  • 函数调用与返回行为。
  • 控制流与执行顺序。
  • 内存访问与状态变化。
  • 异常处理与程序终止。
  • 并发执行与内存模型。

语义是理解程序真正如何工作的基础。

二、语法与语义的区别

语法和语义是编程语言中两个不同但紧密相关的概念。

1. 语法关注代码结构

例如:

if age >= 18:
    print("成年人")

这段代码符合 Python 的语法规则。

如果写成:

if age >= 18
    print("成年人")

缺少冒号,属于语法错误。

语法分析器通常无法按照 Python 的语法规则构建对应的完整程序结构。

2. 语义关注代码含义

下面的代码:

age = "18"
result = age + 10

语法是合法的。

但 Python 不允许字符串与整数直接执行这种加法运算,因此运行时会产生 TypeError。

这说明:

语法正确,不代表语义一定正确。

再看一个例子:

price = 100
discount = 0.2

final_price = price * discount

代码语法正确,类型也匹配,但如果业务要求计算的是折后价格,那么这里的计算逻辑可能有误。

正确的计算可能应该是:

final_price = price * (1 - discount)

这属于业务逻辑层面的语义问题。

3. 语法错误、语义错误与逻辑错误

错误类型 核心问题 示例
语法错误 代码结构不符合语言规则 缺少括号、冒号
静态语义错误 代码结构合法,但违反静态语义约束 静态类型不匹配
运行时语义错误 执行时违反操作规则 除以零、非法类型操作
业务逻辑错误 程序行为不符合业务预期 折扣计算公式错误

不同语言对错误的检查时机不同。

例如,Java 会在编译阶段检查大量类型问题,而 Python 作为动态类型语言,部分类型问题需要运行到对应代码时才能发现。

4. 语法与语义的关系

flowchart TB
    A["源代码"] --> B["语法分析"]
    B --> C{"语法是否合法"}
    C -->|"否"| D["语法错误"]
    C -->|"是"| E["语义检查"]
    E --> F{"语义约束是否满足"}
    F -->|"否"| G["语义错误"]
    F -->|"是"| H["执行程序"]
    H --> I["产生运行结果"]

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

需要注意,图中展示的是概念上的处理关系。实际语言实现中,语义检查可能分布在编译期、加载期和运行期,并不一定是严格独立的阶段。

三、编程语言语义的三种主要描述方式

编程语言理论中,常见的语义描述方法有三种:

  1. 操作语义(Operational Semantics)。
  2. 指称语义(Denotational Semantics)。
  3. 公理语义(Axiomatic Semantics)。

它们从不同角度描述程序的含义。

1. 操作语义(Operational Semantics)

操作语义通过描述程序执行时的状态变化,定义程序的含义。

它关注:

程序每执行一步,会发生什么变化?

例如:

x = 10
x = x + 5

程序执行过程可以抽象为:

  • 初始状态:变量 x 尚未绑定。
  • 执行第一条语句:x 绑定到 10。
  • 执行第二条语句:读取 x 的值,计算 10 + 5。
  • 更新状态:x 绑定到 15。

可以将程序状态表示为:

\sigma = \{x \mapsto 10\}

其中:

  • \sigma 表示程序状态。
  • x 表示变量。
  • 10 表示变量当前关联的值。

执行第二条语句后:

\sigma' = \{x \mapsto 15\}

整个过程可以表示为状态转换:

\sigma \rightarrow \sigma'

操作语义常用于描述:

  • 表达式求值。
  • 变量赋值。
  • 函数调用。
  • 控制流执行。
  • 异常处理。
  • 并发操作。

小步语义与大步语义

操作语义又可以细分为两种常见描述方式。

小步操作语义(Small-Step Operational Semantics)

描述程序从一个计算状态到下一个计算状态的逐步变化。

例如:

1 + 2 \times 3

可以逐步归约:

1 + 2 \times 3 \rightarrow 1 + 6 \rightarrow 7

它关注每一步计算过程。

大步操作语义(Big-Step Operational Semantics)

直接描述一个表达式或程序最终求得什么结果。

例如:

1 + 2 \times 3 \Downarrow 7

符号 \Downarrow 表示表达式最终求值为 7。

两者区别:

对比维度 小步语义 大步语义
描述方式 一步一步执行 直接描述最终结果
关注重点 中间状态 最终求值结果
适合分析 执行细节、状态变化 整体计算结果
特点 更细致 更简洁

2. 指称语义(Denotational Semantics)

指称语义通过数学对象和数学函数,为程序结构赋予数学意义。

它关注:

一个程序结构在数学上表示什么?

例如:

def square(x):
    return x * x

可以将 square 表示为数学函数:

\llbracket square \rrbracket = f

其中:

f(x) = x^2

这里的双括号:

\llbracket \cdot \rrbracket

通常用于表示某个程序结构的语义解释。

例如:

\llbracket 1 + 2 \rrbracket = 3

表示表达式 1 + 2 对应的数学含义是 3。

对于变量赋值,可以将程序语义理解为状态之间的映射:

\llbracket x = x + 1 \rrbracket : \Sigma \rightarrow \Sigma

其中 \Sigma 表示程序状态的集合。

这意味着赋值语句可以被看作一个状态转换函数。

指称语义常用于:

  • 编程语言理论研究。
  • 语言特性的数学建模。
  • 函数式语言研究。
  • 程序行为的形式化描述。
  • 语言设计与正确性分析。

3. 公理语义(Axiomatic Semantics)

公理语义通过逻辑规则描述程序执行前后的条件关系。

它关注:

程序执行前需要满足什么条件,执行后能够保证什么结果?

最经典的方法是霍尔逻辑(Hoare Logic)。

霍尔逻辑使用三元组表示:

\{P\}\ C\ \{Q\}

其中:

  • P:前置条件(Precondition)。
  • C:程序语句(Command)。
  • Q:后置条件(Postcondition)。

含义是:

如果程序执行前满足条件 P,并且程序 C 正常终止,那么执行后应满足条件 Q。

例如:

{x = 10}
x = x + 5
{x = 15}

可以表示为:

\{x = 10\}\ x := x + 5\ \{x = 15\}

这里描述的是程序执行前后的逻辑关系,而不是具体执行步骤。

公理语义常用于:

  • 程序正确性证明。
  • 算法验证。
  • 安全关键系统。
  • 形式化验证。
  • 程序逻辑研究。

4. 三种语义描述方式的区别

对比维度 操作语义 指称语义 公理语义
英文 Operational Denotational Axiomatic
核心思想 描述执行过程 建立数学映射 描述逻辑条件
关注重点 状态如何变化 程序表示什么 程序是否满足条件
主要工具 状态转换规则 数学函数和域 逻辑推理规则
常见应用 语言执行模型 语言形式化定义 程序正确性证明

5. 三种语义的整体视角

flowchart TB
    A["程序语义"] --> B["操作语义"]
    A --> C["指称语义"]
    A --> D["公理语义"]
    B --> E["执行步骤"]
    B --> F["状态转换"]
    C --> G["数学映射"]
    C --> H["函数与域"]
    D --> I["前置条件"]
    D --> J["后置条件"]
    E --> K["描述程序行为"]
    F --> K
    G --> K
    H --> K
    I --> K
    J --> K

    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:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style J fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style K fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

三种方式并不是互相排斥的。它们可以从执行、数学抽象和逻辑证明三个角度描述同一种语言或程序。

四、静态语义与动态语义

除了操作语义、指称语义和公理语义,编程语言设计中还经常从检查时机和行为阶段区分静态语义与动态语义。

1. 静态语义(Static Semantics)

静态语义描述程序在执行之前需要满足的约束。

它通常由编译器或静态分析工具检查。

常见检查内容:

  • 类型是否合法。
  • 变量是否已经声明。
  • 标识符是否处于有效作用域。
  • 函数参数与返回类型是否匹配。
  • 访问权限是否符合规则。
  • 控制结构是否满足语言约束。

例如 Java:

int age = 18;

String name = age;

代码语法结构合法,但不能将 int 类型的值直接赋给 String 类型变量。

Java 编译器会在编译阶段发现这个类型不匹配问题。

这属于静态语义约束违反。

2. 动态语义(Dynamic Semantics)

动态语义描述程序运行时的行为。

它关注:

  • 表达式如何求值。
  • 函数如何调用。
  • 变量如何更新。
  • 对象如何创建。
  • 内存如何分配和释放。
  • 异常如何传播。
  • 并发任务如何执行。

例如:

numbers = [1, 2, 3]
print(numbers[10])

代码通过了 Python 的语法分析,也可以通过相应的静态语法检查。

但执行时访问不存在的列表索引,会产生 IndexError。

这属于运行时行为问题。

3. 静态语义与动态语义的区别

对比维度 静态语义 动态语义
英文 Static Semantics Dynamic Semantics
关注阶段 程序执行前 程序执行期间
主要内容 类型、作用域、声明约束 求值、状态变化、控制流
常见实现 编译器检查、静态分析 解释器、运行时系统
典型问题 类型不匹配、未声明变量 越界访问、除零异常

需要注意,静态语义与动态语义是按程序约束和执行行为进行的概念划分,并不完全等同于编译时和运行时。

某些语言会在运行时执行类型检查,也有静态分析工具能够在不执行程序的情况下发现部分潜在运行时错误。

五、类型系统与语义

类型系统(Type System)是编程语言语义的重要组成部分。

它规定不同类型的数据能够执行哪些操作,以及类型之间如何转换。

1. 类型决定操作是否合法

例如:

a = 10
b = 20

result = a + b

这里 a 和 b 都是整数,可以执行加法。

但:

a = "Hello"
b = 10

result = a + b

在 Python 中会产生类型错误。

因为字符串与整数不支持这种直接相加操作。

类型系统可以帮助语言定义:

  • 数据的分类。
  • 合法操作集合。
  • 类型兼容规则。
  • 类型转换规则。
  • 函数参数和返回值约束。
  • 泛型和复合类型关系。

2. 静态类型与动态类型

静态类型语言

通常在编译或运行前的分析阶段确定表达式和变量的类型约束。

例如 Java:

int number = 10;
String name = "Alice";

动态类型语言

类型检查通常与运行时值相关,变量名不一定具有固定的静态类型。

例如 Python:

value = 10
value = "Hello"

同一个变量名可以先后绑定不同类型的对象。

3. 类型检查与程序语义

flowchart TB
    A["表达式"] --> B["确定操作数类型"]
    B --> C["检查操作规则"]
    C --> D{"类型是否兼容"}
    D -->|"是"| E["执行对应操作"]
    D -->|"否"| 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:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

类型系统不仅影响错误检查,也会影响程序的执行方式、内存布局、运算规则和优化空间。

六、作用域、绑定与生命周期

变量的语义不仅包含它当前保存的值,还涉及名称如何关联到数据,以及名称在什么位置、什么时间有效。

1. 作用域(Scope)

作用域是程序中名称可以被访问的区域。

常见作用域包括:

  • 全局作用域。
  • 局部作用域。
  • 函数作用域。
  • 块级作用域。
  • 类作用域。

例如:

name = "Global"


def show():
    name = "Local"
    print(name)


show()
print(name)

输出:

Local
Global

函数内部的 name 与全局作用域中的 name 是不同的局部绑定。

作用域决定名称在程序的哪些位置可见。

2. 词法作用域与动态作用域

这是理解编程语言语义时非常重要的区别。

词法作用域(Lexical Scope)

也称静态作用域。名称的查找规则由代码的词法结构决定。

例如:

const name = "Global";

function outer() {
    const name = "Outer";

    function inner() {
        console.log(name);
    }

    return inner;
}

const fn = outer();
fn();

输出:

Outer

inner() 在 outer() 内部定义,因此它可以访问定义位置外层作用域中的 name。

即使 outer() 已经执行结束,返回的 inner() 仍然可以访问相关词法环境。

这就是闭包的重要基础。

动态作用域(Dynamic Scope)

动态作用域根据函数调用时的调用链决定名称查找位置。

也就是说,变量的查找与当前调用路径有关,而不是仅由函数定义位置决定。

动态作用域在现代主流通用编程语言中相对少见,但在部分语言特性、宏系统和动态绑定机制中可以看到类似思想。

3. 名称绑定(Binding)

绑定是将名称与某个实体关联起来的过程。

例如:

age = 18

这里变量名 age 被绑定到整数对象 18。

在不同语言中,绑定的对象和时机可能不同:

  • 变量名与值绑定。
  • 函数名与函数实现绑定。
  • 类型名与类型定义绑定。
  • 方法调用与具体实现绑定。
  • 符号引用与模块或链接目标绑定。

名称绑定可以发生在编译期、链接期或运行期。

4. 生命周期(Lifetime)

生命周期是对象或数据在程序执行过程中保持有效的时间范围。

例如:

def create_user():
    user = {"name": "Alice"}
    return user

局部名称 user 的作用域只在函数内部。

但返回的字典对象仍然可以被函数调用者使用。

这说明:

变量作用域与对象生命周期不是同一个概念。

在 Python 中,对象通常由引用计数和垃圾回收机制管理;在 Rust 中,生命周期和所有权规则会参与编译期安全检查;在 C 和 C++ 中,还需要考虑自动存储期、静态存储期和动态存储期等概念。

5. 作用域、绑定与生命周期的区别

概念 主要回答的问题
作用域 名称在哪里可以被访问?
绑定 名称与哪个对象或实体关联?
生命周期 对象或数据何时创建、何时失效?

这三个概念相互关联,但不能混为一谈。

七、表达式求值与执行顺序

程序中的表达式不仅有语法结构,还具有明确的求值规则。

1. 表达式求值

例如:

result = 1 + 2 * 3

语义规则规定:

  • 先计算乘法。
  • 再计算加法。
  • 最终得到 7。

表达式的求值通常由运算符优先级、结合性、操作数类型和语言定义的求值规则共同决定。

2. 短路求值(Short-Circuit Evaluation)

短路求值是一种逻辑表达式的求值策略。

当表达式左侧已经能够确定整个逻辑结果时,右侧表达式可能不再执行。

例如 Python:

x = 0

result = x != 0 and 10 / x > 1

print(result)

输出:

False

由于 x != 0 为 False,and 表达式已经可以确定结果,因此右侧的除法不会执行。

这避免了除以零的问题。

对于逻辑或:

result = True or some_function()

当左侧为 True 时,右侧通常不会被求值。

短路求值是语言语义的一部分,不只是编译器优化。

3. 求值顺序与副作用

下面的代码:

let count = 0;

function increment() {
    count++;
    return count;
}

const result = increment() + increment();

两个函数调用都会修改外部状态。

因此,表达式的求值顺序可能影响最终结果。

不同语言对运算数求值顺序的规定不同:

  • Java 对大多数运算符的操作数求值顺序规定为从左到右。
  • Python 通常按照从左到右的顺序求值表达式中的子表达式。
  • C 和 C++ 中,部分运算符的操作数求值顺序没有固定保证,某些表达式还可能涉及未定义行为。

不能仅凭代码书写顺序,就推断所有语言都会以相同顺序执行所有子表达式。

4. 表达式求值的过程

flowchart TB
    A["表达式"] --> B["识别运算符与操作数"]
    B --> C["确定求值规则"]
    C --> D["执行子表达式求值"]
    D --> E["应用运算规则"]
    E --> F["产生表达式结果"]
    F --> 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:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

八、函数调用与返回语义

函数调用是程序执行过程中非常重要的语义行为。

它不仅意味着执行另一段代码,还涉及参数传递、执行环境建立、返回值处理和控制流转移。

1. 函数调用的基本过程

例如:

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


value = add(10, 20)

从语义角度看:

  1. 计算调用参数。
  2. 将实参与形参建立对应关系。
  3. 建立函数执行所需的局部环境。
  4. 执行函数体。
  5. 执行 return。
  6. 将返回值交还给调用者。
  7. 继续执行调用位置之后的程序。