返回专栏
· 21 分钟阅读

语言规范与版本演进


一、什么是语言规范?

语言规范(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。


八、语言新特性的兼容性问题

语言版本升级并不只是增加新语法,还需要考虑旧代码是否能够继续运行。

兼容性是语言长期演进中最重要的工程问题之一。