一、什么是语言规范?
语言规范(Language Specification)是对一门编程语言进行正式描述的技术文档,用于定义程序应该如何编写、解释、编译和执行。
它回答几个核心问题:
- 哪些代码是合法的?
- 不同语法结构代表什么含义?
- 表达式应该按照什么规则计算?
- 类型系统如何约束程序?
- 程序执行时应该表现出什么行为?
- 编译器和运行时需要满足哪些要求?
例如,下面的 JavaScript 代码:
let x = 10;
let y = x + 20;
console.log(y);
语言规范需要定义:
let的语法和词法作用域规则。- 数字字面量的表示方式。
+运算符的求值语义。- 变量声明和初始化规则。
console.log则不是 ECMAScript 核心语言规范定义的标准语法,而是宿主环境提供的 API。
这说明,语言规范不仅描述代码长什么样,还描述代码应该具有什么行为。
1. 语言规范的主要组成
| 组成 | 主要内容 |
|---|---|
| 词法规范 | 标识符、关键字、字面量、注释和空白符 |
| 语法规范 | 表达式、语句、声明和程序结构 |
| 语义规范 | 运算、控制流、作用域和执行规则 |
| 类型规范 | 类型定义、类型检查、转换和兼容性 |
| 内存模型 | 对象、引用、内存访问和并发可见性规则 |
| 标准库规范 | 标准类型、函数、容器和 API |
| 运行时规范 | 异常、资源管理、模块加载和执行行为 |
| 实现要求 | 编译器、运行时需要满足的约束 |
不同语言的规范覆盖范围不同。
例如,C++ 标准不仅规定语法和类型系统,还涉及对象生命周期、内存模型、标准库和并发行为;ECMAScript 规范主要定义 JavaScript 语言本身及其内置对象,并不统一规定浏览器 DOM API。
2. 语言规范与语言实现
语言规范和语言实现不是同一个概念。
- 语言规范:定义语言应当如何工作。
- 编译器:将源代码转换为目标代码,或执行相关编译处理。
- 解释器:按照语言规则执行程序。
- 运行时:提供程序执行所需的环境和基础能力。
- 标准库:提供语言生态中约定的通用功能。
例如,Java 语言规范定义 Java 程序的语法和语义,JVM 规范定义 Java 虚拟机的行为,具体的 OpenJDK 实现则负责将这些规范落地。
flowchart TD
A["语言规范"] --> B["定义语法与语义"]
B --> C["编译器或解释器实现"]
C --> D["运行时执行"]
D --> E["程序表现出规定行为"]
F["标准库规范"] --> G["标准库实现"]
G --> D
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:#E0F0FE,stroke:#93BCE8,color:#1E4976
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
规范通常允许实现者在满足要求的前提下选择具体实现方式。
例如:
- Java 虚拟机可以采用解释执行,也可以使用 JIT 编译。
- JavaScript 引擎可以采用不同的垃圾回收算法。
- C++ 编译器可以采用不同的优化策略。
- Python 的不同实现可以采用不同的内部对象表示。
因此,语言规范定义的是外部可观察行为和实现约束,并不一定规定所有底层实现细节。
二、语言规范为什么重要?
如果没有统一规范,不同编译器可能对相同程序产生不同理解,开发者也很难保证程序能够跨平台运行。
语言规范主要解决以下问题。
1. 保证语言行为的一致性
假设不同编译器对同一个表达式采用不同的运算规则:
int result = 10 + 20 * 3;
如果没有明确的运算符优先级,编译器可能产生不同结果。
语言规范通过定义优先级、结合性和求值规则,减少不同实现之间的行为差异。
2. 支持跨平台与跨实现
同一份符合规范的程序,可以在不同实现上运行。
例如:
- 不同厂商的 Java 虚拟机。
- 不同平台上的 C++ 编译器。
- 不同浏览器中的 JavaScript 引擎。
- 不同操作系统上的 Python 实现。
不过,跨平台能力还取决于程序是否依赖操作系统、硬件、外部库和实现扩展。
符合语言规范,并不意味着所有依赖外部环境的行为都完全一致。
3. 明确实现者的责任
语言规范会区分不同性质的行为:
- 必须遵循的规则。
- 允许实现者选择的行为。
- 由具体实现定义的行为。
- 规范没有规定或明确不保证的行为。
这些分类对编译器开发和跨平台编程尤其重要。
4. 为工具生态提供基础
编译器、静态分析工具、格式化工具、代码编辑器和调试器,都需要理解语言的语法和语义。
例如:
- 语法分析器需要理解语言语法。
- 类型检查器需要理解类型规则。
- 代码格式化工具需要识别语法结构。
- 静态分析工具需要理解变量作用域和控制流。
- IDE 需要理解模块、符号和类型信息。
语言规范为这些工具提供了统一的行为依据。
三、语言规范中的关键概念
不同语言标准的术语不完全相同,但有几个重要概念值得重点理解。
1. 语法规则(Syntax)
语法规定程序结构如何组织。
例如,Python 函数定义:
def add(a, b):
return a + b
语法规则决定:
def关键字的位置。- 函数名称的形式。
- 参数列表的结构。
- 冒号的位置。
- 函数体的缩进规则。
return语句的使用方式。
语法错误意味着代码无法按照语言规定的结构进行解析。
2. 语义规则(Semantics)
语义定义合法代码应该表达什么含义,以及执行时应该产生什么行为。
例如:
x = 10
y = x + 20
语义需要定义变量绑定、表达式求值和加法运算的行为。
语法正确并不代表语义一定正确。
例如:
x = "hello" - 10
这段代码符合基本的语法结构,但在 Python 中执行减法时会产生 TypeError。
3. 类型规则(Type Rules)
类型规则规定值、表达式和变量之间的类型关系。
例如,在 Java 中:
int age = 20;
String name = "Alice";
类型系统规定:
age是int类型。name是String类型。- 不兼容的类型赋值需要满足相应转换规则,否则会产生编译错误。
不同语言对类型检查、类型转换和类型推断的规定存在较大差异。
4. 未定义行为(Undefined Behavior)
未定义行为是某些语言规范中的重要概念。
以 C 和 C++ 为例,某些操作一旦发生,标准就不再要求程序具有特定行为。
例如,在 C 中:
int x = 2147483647;
x = x + 1;
如果 int 是 32 位有符号整数,这种有符号整数溢出属于未定义行为。
编译器不需要保证程序按照开发者预期的方式回绕到负数。
需要注意,整数位宽以及具体数值范围也受到实现和标准版本的约束,示例中的 32 位假设应当结合目标平台确认。
未定义行为可能带来严重后果:
- 编译器可以基于程序不发生未定义行为的假设进行优化。
- 程序可能出现难以预测的结果。
- 调试版本和优化版本可能表现不同。
- 不同编译器之间可能出现行为差异。
5. 实现定义行为(Implementation-defined Behavior)
实现定义行为是规范允许实现者选择,但要求实现者明确记录选择结果的行为。
例如,C 语言中某些整数类型的具体宽度可能取决于实现。
不同编译器和平台可以有不同选择,但必须满足标准要求,并对相关选择作出说明。
6. 未指定行为(Unspecified Behavior)
未指定行为是规范允许多个可能结果,但不要求实现者必须记录具体选择的行为。
例如,在 C 中:
int x = 0;
int result = f() + g();
如果 f() 和 g() 都有副作用,不能仅凭这个表达式断定哪个函数先执行。
对于不同表达式,具体的求值顺序规则需要依据语言标准判断。
7. 三种行为的区别
| 类型 | 规范是否允许多种结果 | 是否要求实现者记录 |
|---|---|---|
| Undefined Behavior | 规范不再施加通常的行为要求 | 否 |
| Implementation-defined | 允许实现者选择 | 是 |
| Unspecified | 允许多个可能结果 | 通常不要求 |
这三个概念在 C/C++ 中尤其重要,不能简单理解为“结果不确定”的同义词。
四、语言标准与标准化组织
编程语言的规范通常由标准化组织、技术委员会或语言治理组织制定和维护。
不同语言拥有不同的标准化机制。
1. ISO
国际标准化组织(International Organization for Standardization,ISO)负责制定国际标准。
一些重要编程语言标准由 ISO 发布。
例如:
| 语言 | 标准系列 | 主要作用 |
|---|---|---|
| C | ISO/IEC 9899 | C 语言标准 |
| C++ | ISO/IEC 14882 | C++ 语言标准 |
| Java | ISO/IEC 23270 等相关标准体系 | Java 语言相关国际标准 |
| SQL | ISO/IEC 9075 | SQL 数据库语言标准 |
需要注意,Java 的主要语言和平台规范也由 Java 社区流程及 Oracle 等相关规范体系维护,不能将 ISO 标准视为其唯一规范来源。
2. ECMA International
ECMA International 是一个负责制定信息通信技术标准的组织。
JavaScript 的核心语言规范 ECMAScript 由 ECMA International 标准化。
常见标准名称:
- ECMA-262:ECMAScript 语言规范。
- ECMA-402:ECMAScript 国际化 API 规范。
ECMAScript 主要定义语言核心能力,例如:
- 变量与函数。
- 对象与属性。
- 表达式与语句。
- 类与模块。
- Promise。
- 异步函数。
- 内置对象。
浏览器中的 DOM、Web API 等能力则由其他标准组织和规范体系定义。
3. W3C 与 WHATWG
W3C 和 WHATWG 在 Web 技术标准中扮演重要角色。
W3C 曾经制定和维护大量 Web 相关标准。
WHATWG 则维护 HTML Living Standard 等持续演进的 Web 标准。
例如:
- HTML:页面结构与文档语义。
- DOM:文档对象模型。
- Fetch:网络请求接口。
- URL:URL 解析与处理规则。
这些规范与 JavaScript 语言规范相互配合,但并不属于 ECMAScript 核心语言规范本身。
4. Java 社区流程(JCP)
Java Community Process(JCP)是 Java 技术规范的重要社区治理机制。
它通过 Java Specification Request(JSR)提出和推动 Java 平台相关规范。
例如:
- Java 语言和虚拟机相关规范。
- Java 平台 API。
- 企业级 Java 技术。
- Java 生态中的其他标准能力。
Java 语言规范(JLS)和 Java 虚拟机规范(JVMS)是理解 Java 语言和运行环境的重要文档。
5. 不同语言的规范体系
| 语言 | 主要规范体系 | 典型规范 |
|---|---|---|
| C | ISO | ISO/IEC 9899 |
| C++ | ISO | ISO/IEC 14882 |
| JavaScript | ECMA | ECMA-262 |
| Java | JCP、Oracle 等规范体系 | JLS、JVMS |
| Python | Python 核心开发社区 | Python Language Reference |
| Go | Go 官方项目 | Go Language Specification |
| Rust | Rust 项目与社区 | Rust Reference |
并非所有语言都采用 ISO 这种传统国际标准化模式。
例如,Python 主要通过 Python 官方文档、PEP 和核心开发流程演进;Go 由 Go 项目维护语言规范和相关工具链。
五、编程语言的版本号与版本演进
编程语言通常通过版本号标识语言规范、编译器、运行时或工具链的演进状态。
例如:
- C11、C17、C23。
- C++11、C++14、C++17、C++20、C++23。
- Java 8、Java 11、Java 17、Java 21、Java 25。
- ECMAScript 2015、2016、2017 等。
- Python 3.10、3.11、3.12、3.13 等。
- Go 1.20、1.21、1.22 等。
版本号的命名方式并不统一。
1. 版本号的基本组成
很多软件使用语义化版本(Semantic Versioning,SemVer):
MAJOR.MINOR.PATCH
例如:
3.12.2
一般表示:
- MAJOR:主版本。
- MINOR:次版本。
- PATCH:补丁版本。
但需要注意,语义化版本并不是所有编程语言标准采用的统一版本编号规则。
例如,C++ 使用年份编号,Java 使用整数版本号,ECMAScript 使用年份和标准版本序号。
因此,阅读语言版本时,需要先确认它指的是:
- 语言标准版本。
- 编译器版本。
- 运行时版本。
- 标准库版本。
- 工具链版本。
这些版本可能并不相同。
2. 语言版本演进的主要内容
语言版本通常会涉及以下变化:
| 变化类型 | 说明 | 示例 |
|---|---|---|
| 新语法 | 引入新的语法结构 | 模式匹配 |
| 新类型能力 | 扩展类型系统 | 泛型、代数数据类型 |
| 新运行时能力 | 增加执行时机制 | 协程、虚拟线程 |
| 标准库扩展 | 增加新的 API | 集合、并发工具 |
| 行为修正 | 明确或调整已有行为 | 异常处理规则 |
| 安全改进 | 减少危险操作 | 更严格的类型和边界约束 |
| 弃用与删除 | 淘汰旧功能 | 移除废弃 API |
语言版本演进并不意味着每次更新都会改变核心语法。
有些版本主要扩展标准库,有些版本重点改善运行时,有些版本则主要处理规范缺陷和兼容性问题。
六、语言版本是如何制定的?
不同语言的治理方式不同,但典型的规范演进通常包含需求提出、方案讨论、规范审查、实现验证和正式发布等环节。
1. 提出新特性需求
开发者、语言维护者、企业和社区可能提出新的语言能力需求。
例如:
- 希望简化异步编程。
- 希望增强类型推断。
- 希望改善泛型表达能力。
- 希望减少内存安全问题。
- 希望提升编译性能。
需求提出时,通常需要说明:
- 当前存在什么问题。
- 现有语言能力为什么不足。
- 新特性解决什么问题。
- 是否会破坏已有代码。
- 实现成本和生态影响是什么。
2. 提交提案
不同语言采用不同提案机制。
例如:
| 语言 | 提案机制 |
|---|---|
| Python | PEP(Python Enhancement Proposal) |
| Java | JEP(JDK Enhancement Proposal)、JSR 等机制 |
| Rust | RFC(Request for Comments) |
| ECMAScript | TC39 Proposal Process |
| Go | Go Proposal Process |
| C++ | WG21 提案和标准委员会流程 |
这些提案机制并不完全相同。
有些用于提出语言特性,有些用于改进标准库、工具链或开发流程。
3. 讨论与评审
提案通常需要经过技术讨论和审查。
重点关注:
- 设计是否合理。
- 是否与现有语法冲突。
- 是否影响已有程序。
- 是否能够被不同实现支持。
- 是否会引入难以维护的复杂性。
- 是否具有足够的实际价值。
例如,新增一个语法关键字,可能导致以前合法的变量名称变成非法标识符。
这就是语言演进中需要考虑的兼容性问题。
4. 参考实现与实验验证
一些语言会先在实验分支、预览版本或编译器原型中实现新特性。
通过真实项目验证:
- 语法是否容易使用。
- 编译器实现是否可行。
- 性能是否受到影响。
- 与现有工具是否兼容。
- 开发者是否能够正确理解。
参考实现有助于发现设计阶段不容易发现的问题。
5. 正式接受与发布
经过评审和批准后,新特性可能进入正式语言版本或标准版本。
发布后,编译器和运行时需要逐步实现相关能力。
但标准发布并不意味着所有编译器立即支持全部特性。
不同实现的支持进度可能不同。
6. 语言演进流程
flowchart TD
A["发现语言能力需求"] --> B["提出改进提案"]
B --> C["技术讨论与评审"]
C --> D{"提案是否通过"}
D -->|"否"| E["修改或暂缓提案"]
E --> B
D -->|"是"| F["设计规范与参考实现"]
F --> G["实验验证与反馈"]
G --> H{"是否满足要求"}
H -->|"否"| E
H -->|"是"| I["正式接受提案"]
I --> J["纳入语言版本或标准"]
J --> K["编译器与运行时实现"]
K --> L["生态逐步采用"]
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 E fill:#FBE9E9,stroke:#D9AAAA,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style J fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style K fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style L fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这是一种概念性流程,不代表所有语言都严格按照相同阶段和顺序发布版本。
七、主流语言的版本演进案例
理解语言版本演进,最好的方式是观察真实语言的发展过程。
1. C 语言:从过程式语言到现代标准
C 语言的发展与 Unix 操作系统密切相关。
早期 C 语言主要通过不同编译器和实现进行传播,后来逐渐形成正式标准。
| 版本 | 主要变化 |
|---|---|
| C89 / C90 | 形成早期标准化规范 |
| C99 | 引入变长数组、复合字面量、内联函数等能力 |
| C11 | 引入线程支持、原子操作和泛型选择表达式等能力 |
| C17 | 主要进行缺陷修正 |
| C23 | 引入多项语言与标准库改进 |
C89 / C90
C89 是 ANSI 制定的 C 语言标准,之后形成 ISO C90。
它为不同编译器之间的 C 语言兼容性奠定了基础。
C99
C99 带来了大量改进,例如:
for (int i = 0; i < 10; i++) {
printf("%d\n", i);
}
允许在 for 循环初始化部分声明变量。
其他重要变化还包括:
long long整数类型。- 变长数组。
- 复合字面量。
inline函数。//单行注释。- 可变参数宏的增强。
C11
C11 引入了语言层面的并发和原子操作支持。
例如:
#include <stdatomic.h>
atomic_int counter = 0;
void increment(void) {
atomic_fetch_add(&counter, 1);
}
这使 C 程序可以使用标准定义的原子类型和原子操作。
C23
C23 继续改进 C 语言的类型系统、语法和标准库。
例如:
- 引入
nullptr关键字。 - 引入
bool、true、false等相关语言支持。 - 改进整数常量和属性机制。
- 增强标准库和类型支持。
C 语言演进的一个特点是:在保持长期兼容性的同时,逐步完善现代编程能力。
2. C++:从面向对象到现代多范式语言
C++ 在 C 的基础上发展,逐渐形成支持多种编程范式的复杂语言体系。
| 版本 | 重要特性 |
|---|---|
| C++98 / C++03 | 早期标准化和修正 |
| C++11 | 移动语义、Lambda、智能指针、并发库 |
| C++14 | 泛型 Lambda、make_unique 等 |
| C++17 | optional、variant、结构化绑定 |
| C++20 | Concepts、Ranges、协程、模块 |
| C++23 | std::expected、std::print 等能力 |
C++11:现代 C++ 的重要转折
C++11 引入了大量影响深远的特性。
移动语义:
std::vector<int> source = {1, 2, 3};
std::vector<int> target = std::move(source);
Lambda:
auto add = [](int a, int b) {
return a + b;
};
智能指针:
auto ptr = std::make_unique<int>(100);
这些能力改善了资源管理、函数式编程表达和对象生命周期控制。
C++17:标准库和语言表达能力增强
例如:
#include <optional>
std::optional<int> find_value(bool found) {
if (found) {
return 100;
}
return std::nullopt;
}
std::optional 用于表示一个可能存在、也可能不存在的值。
C++20:重要的语言能力升级
C++20 引入了 Concepts、Ranges、协程和模块等重要特性。
Concepts 示例:
#include <concepts>
template <typename T>
requires std::integral<T>
T add(T a, T b) {
return a + b;
}
它允许为模板参数增加明确的类型约束。
C++ 的演进体现了大型语言在保持兼容性的同时,不断扩展抽象能力和工程表达能力。
3. Java:从虚拟机平台到现代语言
Java 通过 JVM 实现跨平台运行,并持续增强语言和运行时能力。
| 版本 | 重要变化 |
|---|---|
| Java 8 | Lambda、Stream API、默认方法 |
| Java 9 | 模块系统 |
| Java 10 | 局部变量类型推断 |
| Java 11 | HTTP Client 标准 API 等 |
| Java 14 | Switch 表达式正式发布 |
| Java 16 | Record 正式发布 |
| Java 17 | Sealed Classes 正式发布 |
| Java 21 | 虚拟线程、模式匹配等正式特性 |
| Java 25 | 新一轮 LTS 版本及后续语言与平台改进 |
Java 8 的 Lambda 表达式:
List<String> names = List.of("Alice", "Bob", "Tom");
names.forEach(name -> System.out.println(name));
Java 10 的局部变量类型推断:
var message = "Hello Java";
这里的 var 不代表 Java 变成了动态类型语言。
变量类型仍然在编译期确定。
Java 21 的虚拟线程:
Thread.startVirtualThread(() -> {
System.out.println("Hello from virtual thread");
});
虚拟线程属于 Java 运行时的重要并发能力,旨在降低大量阻塞式任务的线程管理成本。
需要区分:Java 语言特性、JDK API 和 JVM 能力并不完全相同。某个版本增加的功能可能属于语言、标准库或运行时中的不同层次。
4. JavaScript:从脚本语言到现代应用语言
JavaScript 的标准化名称是 ECMAScript。
早期 JavaScript 主要用于浏览器交互,随着 Web 应用复杂度提升,语言持续引入新的抽象能力。
| 版本 | 主要特性 |
|---|---|
| ES5 | 严格模式、数组方法、JSON 支持 |
| ES2015(ES6) | let、const、箭头函数、类、模块、Promise |
| ES2016 | 指数运算符、Array.includes |
| ES2017 | async/await |
| ES2018 | 异步迭代器、对象展开 |
| ES2019 | flat、flatMap 等 |
| ES2020 | BigInt、可选链、空值合并 |
| ES2022 | 类字段、私有字段、顶层 await |
ES2015 引入的箭头函数:
const add = (a, b) => a + b;
ES2017 引入的异步函数:
async function getUser() {
const response = await fetch("/api/user");
return response.json();
}
ES2020 的可选链:
const city = user?.address?.city;
JavaScript 的版本演进体现了从简单脚本语言向大型应用开发语言的发展过程。
5. Python:从简洁语法到现代类型与并发能力
Python 以简洁语法和丰富生态著称,其语言和运行时也在持续演进。
| 版本 | 主要变化 |
|---|---|
| Python 2.7 | Python 2 系列最后一个主要版本 |
| Python 3.0 | 不兼容性较大的重大版本升级 |
| Python 3.5 | 引入 async/await 语法 |
| Python 3.6 | 引入变量注解、格式化字符串 |
| Python 3.7 | dataclasses、上下文变量等 |
| Python 3.8 | 海象运算符 |
| Python 3.10 | 结构化模式匹配、联合类型语法增强 |
| Python 3.11 | 性能改进、异常组 |
| Python 3.12 | 类型参数语法等改进 |
| Python 3.13 | 实验性自由线程构建等能力 |
Python 3.6 的格式化字符串:
name = "Alice"
message = f"Hello, {name}"
Python 3.10 的模式匹配:
def handle(value):
match value:
case 0:
return "zero"
case 1:
return "one"
case _:
return "other"
Python 3.12 的类型参数语法:
def first[T](items: list[T]) -> T:
return items[0]
需要注意,Python 的类型注解主要用于静态分析和开发工具支持,通常不会自动在运行时执行完整的静态类型检查。
Python 3.13 的自由线程构建也需要结合具体构建选项和运行环境理解,不能简单认为所有 Python 3.13 程序都默认没有 GIL。
八、语言新特性的兼容性问题
语言版本升级并不只是增加新语法,还需要考虑旧代码是否能够继续运行。
兼容性是语言长期演进中最重要的工程问题之一。