Endorphin-Document/appendices/language-keywords.md

# 12 门编程语言的关键词分类与逐词说明

本文是其他语言的学习与比较参考。Endorphin 的词法与语法标记定义见[词法结构](../guide/06-lexical-structure.md)，设计状态见[规范状态](specification-status.md)。

核对日期：2026-10-09。范围：Python、JavaScript、TypeScript、Java、C、C++、C#、Go、Rust、Swift、Kotlin、Julia。

执行模型补充日期：2026-10-13。每门语言末尾增加执行与生命周期摘要；完整分析见[12 门语言的执行模型与生命周期](language-runtime-lifecycles.md)，应用入口见[框架如何接管代码执行](framework-runtime-lifecycles.md)。关键词说明代码可以表达什么；运行时、宿主及框架进一步决定怎样进入执行、保存状态和安排后续工作。

## 分类框架

“定义相关、控制流相关、作用域与模块”适合作为入门分类，但如果要求每个关键词都有清楚的归属，建议补充下面的类别。这是按用途设计的学习框架，不是各语言统一采用的官方分类。

| 分类 | 回答的问题 | 例子 |
| --- | --- | --- |
| 定义与声明 | 定义什么变量、函数、数据结构？ | `def`、`var`、`struct` |
| 类型与泛型 | 值是什么类型？如何表达类型参数和约束？ | `int`、`typeof`、`template` |
| 控制流 | 下一步执行哪一段？ | `if`、`for`、`return` |
| 作用域、模块与可见性 | 名字在哪里有效？如何组织与公开代码？ | `import`、`global`、`private` |
| 对象、继承与成员 | 如何访问对象、继承、重写成员？ | `this`、`super`、`virtual` |
| 运算、判断与查询 | 如何组合条件、检查关系、表达查询？ | `and`、`in`、`select` |
| 异常与断言 | 出错后怎么处理？如何验证前提？ | `try`、`throw`、`assert` |
| 资源、内存与生命周期 | 谁持有资源？何时释放？如何借用？ | `delete`、`defer`、`move` |
| 并发与异步 | 如何启动并发任务、暂停与同步？ | `go`、`await`、`lock` |
| 编译期与元编程 | 哪些工作在编译阶段完成？如何生成代码？ | `constexpr`、`macro` |
| 值与字面量 | 如何表达真、假、空等特殊值？ | `true`、`None`、`nullptr` |
| 保留与兼容 | 哪些词仅被保留，或仅用于旧语法？ | Java `goto`、Rust `gen` |

类别可以重叠：异常也是控制流，访问权限也是声明修饰，类型也是声明的一部分。表中给出主要用途；一个词有多种用途时放在同一行解释。无法仅凭某个关键词的拼写就推断它在所有语言中的含义。

例如：C 的 `static` 可以影响存储期或链接属性；Java 的 `static` 表示类级成员；Rust 的 `static` 定义静态项。JavaScript 的 `const` 禁止重新赋值，但并不让对象内部变成不可修改；C++ 的 `const` 是类型限定。

## 如何阅读

- **关键词**：语言语法赋予其特殊意义。
- **保留关键词**：不能在普通标识符位置直接使用；有些语言允许转义，例如 C# 的 `@class`。
- **上下文关键词／软关键词**：仅在特定语法位置具有特殊意义，其他位置通常能用作名字。
- **预声明或内置名称**：由语言环境或标准库提供，不等同于关键词，例如 Python `print`、Go `make`、Julia `Int`。
- **字面量／运算符／指令**：有时拼写像词，但官方词法类别可能不是关键词。本文对这些情况明确标注。

标记：**〔上下文〕**、**〔保留未用〕**、**〔旧／兼容〕**、**〔非关键词〕**、**〔预览〕**。未标记的条目按该节所述基线解释。只覆盖标准语言与公开文档语法，不把第三方库函数、编译器私有扩展或所有注解名称列作关键词。

版本基线：Python 3.14；JavaScript ECMAScript 2026；TypeScript 5.9；Java SE 26；C23；C++23；C#14（另列 C#15 预览新增词）；Go 官方规范；Rust 2024 edition；Swift 6 系列公开语法；Kotlin 2.4 及公开关键词参考；Julia 1.11（含 `public`）。它们不是“全部语言最新版本”的断言。

## 1. Python

Python 3.14 有 35 个硬关键词，以及 `match`、`case`、`_`、`type` 四个软关键词。[词法参考](https://docs.python.org/3.14/reference/lexical_analysis.html#keywords)

### 定义、作用域与模块

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `def` | 定义 | 定义函数；函数体可以包含多条语句。 |
| `lambda` | 定义 | 创建匿名函数；主体是一个表达式。 |
| `class` | 定义／对象 | 定义类，并可指定基类。 |
| `type`〔上下文〕 | 定义／类型 | `type Alias = ...` 定义类型别名，也可带类型参数；普通表达式中的 `type(...)` 是内置函数。 |
| `global` | 作用域 | 声明当前代码块中的名字指向模块级绑定。 |
| `nonlocal` | 作用域 | 声明名字指向外层函数作用域中已有的绑定；不能用它创建模块级绑定。 |
| `import` | 模块 | 导入模块或模块中的名字。 |
| `from` | 模块／异常／控制流 | 指定导入来源；`raise E from cause` 指定异常原因；`yield from iterable` 委托生成器。 |
| `as` | 模块／资源／异常／模式 | 给导入项取别名，绑定上下文管理器结果或异常对象，也用于模式的整体绑定。 |
| `del` | 资源／绑定 | 删除名字绑定、容器元素或属性；不保证对象立即销毁。 |

### 控制流与模式

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流 | 条件分支；也用于条件表达式和推导式筛选。 |
| `elif` | 控制流 | 前面条件不成立时继续测试另一条件。 |
| `else` | 控制流／异常 | 提供剩余分支；循环中表示没有通过 `break` 退出；`try` 中表示主体没有抛出异常。 |
| `for` | 控制流 | 遍历可迭代对象；也用于推导式。 |
| `while` | 控制流 | 条件为真时重复执行。 |
| `break` | 控制流 | 退出最近一层循环。 |
| `continue` | 控制流 | 跳过本轮剩余部分，进入下一轮。 |
| `return` | 控制流 | 结束函数并返回值；省略值时返回 `None`。 |
| `pass` | 控制流／占位 | 什么也不执行，用于语法上必须有语句的位置。 |
| `yield` | 控制流／生成器 | 暂停生成器并产出值；恢复后继续执行，也可接收调用者发送的值。 |
| `match`〔上下文〕 | 控制流／模式 | 对值进行结构化模式匹配。 |
| `case`〔上下文〕 | 控制流／模式 | 定义一个匹配分支，可带守卫条件。 |
| `_`〔上下文〕 | 模式 | 在 `case` 模式中匹配任意值，不绑定名字；其他位置可为普通标识符。 |

### 运算、异常、资源、异步与特殊值

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `and` | 运算 | 短路逻辑与；返回某个操作数，而不一定是布尔值。 |
| `or` | 运算 | 短路逻辑或；返回某个操作数。 |
| `not` | 运算 | 对真值判断取反，结果是布尔值。 |
| `in` | 判断／遍历 | 检查成员关系；也连接 `for` 的目标与被遍历对象。 |
| `is` | 判断 | 检查是否为同一个对象；不同于检查值相等的 `==`。 |
| `try` | 异常 | 开始异常处理结构。 |
| `except` | 异常 | 捕获匹配异常；`except*` 用于异常组的分组处理。 |
| `finally` | 异常／资源 | 在正常或异常离开 `try` 时执行清理代码。 |
| `raise` | 异常 | 抛出异常，或在异常处理过程中重新抛出当前异常。 |
| `assert` | 断言 | 检查条件，不满足时抛出 `AssertionError`；优化运行可移除断言。 |
| `with` | 资源 | 使用上下文管理器执行进入与退出操作，如文件关闭或锁的释放。 |
| `async` | 异步 | 与 `def`、`for`、`with` 组合，定义或使用异步语法。 |
| `await` | 异步 | 等待可等待对象，允许协程暂停，之后恢复。 |
| `True` | 值 | 布尔真。 |
| `False` | 值 | 布尔假。 |
| `None` | 值 | 表示没有值的单例对象；不是数字零或空字符串。 |

`print`、`len`、`int`、`str`、`list`、`self` 都不是关键词；`self` 只是实例方法首个参数的常见命名约定。更详细的语义见[简单语句](https://docs.python.org/3.14/reference/simple_stmts.html)、[复合语句](https://docs.python.org/3.14/reference/compound_stmts.html)、[表达式](https://docs.python.org/3.14/reference/expressions.html)。

### 执行与生命周期摘要

在 CPython 中，模块顶层、函数定义和函数调用是不同的执行动作；函数对象、code object 与本次执行的帧也不同。普通调用进入函数体，`async def` 调用先创建协程，随后由 await／Task 等推进。`yield`、`await` 保存继续关系，`with`、`finally` 组织退出；`del` 不保证立即销毁。[Python 完整分析](language-runtime-lifecycles.md#1-python) · [FastAPI 请求路径](framework-runtime-lifecycles.md#路径二fastapi)

## 2. JavaScript

下面区分正式保留词、严格模式或特定语境下受限制的词，以及语法中使用的上下文词。JavaScript 允许对象属性名使用许多保留词，因此“不能用作变量名”不等于“不能出现在任何名字位置”。基线见 [ECMAScript 2026 词法规范](https://tc39.es/ecma262/2026/multipage/ecmascript-language-lexical-grammar.html#sec-keywords-and-reserved-words)。

### 声明、对象与模块

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `var` | 定义／作用域 | 声明函数作用域或全局作用域变量，不具有普通块作用域。 |
| `let`〔上下文限制〕 | 定义／作用域 | 声明块作用域变量，允许重新赋值；声明前存在暂时性死区。 |
| `const` | 定义／作用域 | 声明块作用域绑定，初始化后不能重新赋值；所指对象仍可能被修改。 |
| `function` | 定义 | 定义普通函数；结合 `*` 定义生成器函数。 |
| `class` | 定义／对象 | 定义类，包含构造器、方法、字段等。 |
| `extends` | 继承 | 指定类的父类。 |
| `new` | 对象 | 调用构造器创建实例；也出现在 `new.target` 元属性中。 |
| `this` | 对象 | 当前调用语境中的接收者；箭头函数沿用外层 `this`。 |
| `super` | 继承 | 调用父类构造器或访问父类成员实现。 |
| `static`〔上下文／严格模式保留〕 | 成员 | 定义类级成员或类静态初始化块。 |
| `get`〔上下文〕 | 成员 | 定义读取属性时执行的访问器。 |
| `set`〔上下文〕 | 成员 | 定义写入属性时执行的访问器。 |
| `import` | 模块 | 静态导入；`import(...)` 动态加载模块；`import.meta` 提供模块元信息。 |
| `export` | 模块 | 将声明或名字暴露给其他模块。 |
| `from`〔上下文〕 | 模块 | 在导入或再导出语法中指定模块来源。 |
| `as`〔上下文〕 | 模块 | 在导入或导出语法中指定别名。 |
| `with` | 作用域／模块 | 旧 `with` 语句把对象属性加入名字查找环境，严格模式禁止；也用于导入属性的 `with { ... }`。 |

### 控制流、异常与异步

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流 | 满足条件时执行分支。 |
| `else` | 控制流 | 条件不成立时执行分支。 |
| `switch` | 控制流 | 依据表达式值选择分支。 |
| `case` | 控制流 | 标记 `switch` 中的候选分支。 |
| `default` | 控制流／模块 | `switch` 的默认分支；也标记模块的默认导出。 |
| `for` | 控制流 | 支持计数循环、`for...in`、`for...of` 与异步迭代。 |
| `of`〔上下文〕 | 控制流 | `for...of` 遍历可迭代对象的值；`for await...of` 支持异步迭代。 |
| `while` | 控制流 | 先判断条件，再重复执行。 |
| `do` | 控制流 | 与 `while` 组合，先执行一次再判断条件。 |
| `break` | 控制流 | 退出循环或 `switch`；也可退出带标签的语句。 |
| `continue` | 控制流 | 进入循环下一轮，可指定循环标签。 |
| `return` | 控制流 | 结束函数并返回值；省略值时为 `undefined`。 |
| `try` | 异常 | 开始异常处理结构。 |
| `catch` | 异常 | 捕获抛出的值，可将其绑定为局部名字。 |
| `finally` | 异常／资源 | 离开 `try`／`catch` 时执行清理语句。 |
| `throw` | 异常 | 抛出一个值作为异常。 |
| `async`〔上下文〕 | 异步 | 定义异步函数等语法；异步函数调用返回 Promise。 |
| `await`〔上下文限制〕 | 异步 | 等待值或 Promise；可用于异步函数，模块中也支持顶层使用。 |
| `yield`〔上下文限制〕 | 生成器 | 暂停生成器并产出值；`yield*` 委托给另一个迭代器。 |
| `debugger` | 调试 | 提供调试器可暂停的语句位置；无调试器时可能无可见效果。 |
| `using`〔上下文／现代实现扩展〕 | 资源 | 显式资源管理声明，退出作用域时调用同步释放协议；作为已获现代工具链支持的补充列出，不计入所引用的 ECMAScript 2026 固定版核心词法列表。 |
| `await using`〔组合／现代实现扩展〕 | 资源／异步 | 退出作用域时等待异步释放协议；`using` 不是任意位置都保留的词，同样与固定版核心列表分开。 |

### 运算、特殊值与保留词

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `in` | 判断／遍历 | 检查属性是否存在，包括原型链；用于 `for...in` 枚举可枚举字符串属性。 |
| `instanceof` | 判断 | 按实例检查机制判断关系，通常检查原型链；可由 `Symbol.hasInstance` 定制。 |
| `typeof` | 类型检查 | 返回描述操作数运行时类型的字符串；`typeof null` 的历史结果是 `"object"`。 |
| `void` | 运算 | 求值操作数，丢弃其值，并产生 `undefined`。 |
| `delete` | 对象／运算 | 尝试删除对象属性；不等同于手动释放对象内存。 |
| `true` | 值 | 布尔真。 |
| `false` | 值 | 布尔假。 |
| `null` | 值 | 显式的空值。 |
| `enum`〔保留未用〕 | 保留 | JavaScript 本身未提供该词对应的枚举声明。 |
| `implements`〔严格模式保留〕 | 保留 | JavaScript 中没有接口实现声明；TypeScript 扩展了它。 |
| `interface`〔严格模式保留〕 | 保留 | JavaScript 中没有接口声明；TypeScript 扩展了它。 |
| `package`〔严格模式保留〕 | 保留 | JavaScript 中没有对应包声明。 |
| `private`〔严格模式保留〕 | 保留 | 不用于 JavaScript 访问修饰；原生私有成员采用 `#name`。 |
| `protected`〔严格模式保留〕 | 保留 | JavaScript 中没有对应受保护访问修饰。 |
| `public`〔严格模式保留〕 | 保留 | JavaScript 中没有对应公开访问修饰。 |

`undefined`、`NaN`、`Infinity`、`Promise`、`console`、`arguments`、`eval`、`constructor` 不是通常意义上的保留关键词；其中有些名字或成员名有特殊限制或语义。`constructor` 是类构造方法的特殊名称。资源管理补充依据 [TC39 显式资源管理语法](https://github.com/tc39/proposal-explicit-resource-management)；普通语句见[声明规范](https://tc39.es/ecma262/2026/multipage/ecmascript-language-statements-and-declarations.html)，对象与函数见[函数和类规范](https://tc39.es/ecma262/2026/multipage/ecmascript-language-functions-and-classes.html)。

### 执行与生命周期摘要

脚本或模块由宿主进入求值，函数由普通调用或回调进入。执行上下文、闭包环境、Promise 和宿主任务承担不同职责；`async` 调用先运行同步前缀，`await` 后的继续通过异步机制推进。V8 执行代码，Node／浏览器安排各自的系统事件与应用入口。[JavaScript 完整分析](language-runtime-lifecycles.md#2-javascript) · [Node／Chromium](framework-runtime-lifecycles.md#node-与-chromium)

## 3. TypeScript

TypeScript 继承上一节 JavaScript 的关键词与运行时行为。下面逐项列出新增词，以及在 TypeScript 中获得新增含义的词；**完整集合按“JavaScript 全表 + 本表”阅读**，不要把这里当成独立的 JavaScript 替代列表。很多 TypeScript 词是上下文语法，不能简单说全部都禁止作变量名。基线为 5.9 的[编译器词法项](https://github.com/microsoft/TypeScript/blob/v5.9.3/src/compiler/types.ts)及[类型手册](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html)。

| 关键词／语法词 | 分类 | TypeScript 中的作用 |
| --- | --- | --- |
| `type`〔上下文〕 | 定义／类型 | 定义类型别名；`import type`／`export type` 表示只涉及类型的导入导出。 |
| `interface` | 定义／类型 | 定义结构化类型契约，可扩展和进行声明合并；不生成运行时接口对象。 |
| `enum` | 定义／类型 | 定义枚举，通常生成运行时代码；`const enum` 在常见编译配置下会内联引用。 |
| `namespace`〔上下文〕 | 模块 | 定义命名空间；非纯声明形式可能生成运行时对象。 |
| `module`〔上下文〕 | 模块 | 旧式命名空间写法；字符串模块名的 `declare module` 用于环境模块声明或模块补充。 |
| `declare`〔上下文〕 | 声明 | 描述外部存在的变量、函数、类或模块，不提供该声明的运行时实现。 |
| `abstract`〔上下文〕 | 对象 | 定义不能直接实例化的抽象类，或要求子类实现的抽象成员。 |
| `implements` | 对象／类型 | 检查类的实例结构是否满足接口或其他类型约束；不复制实现。 |
| `public` | 可见性 | 成员公开；通常是类成员的默认可见性。 |
| `private` | 可见性 | TypeScript 类型检查限制类外访问；不同于 JavaScript `#` 私有字段的运行时隔离。 |
| `protected` | 可见性 | 类型检查允许类及其子类访问。 |
| `readonly`〔上下文〕 | 声明／类型 | 限制字段、数组或元组的写入；通常是编译期限制，不保证运行时深度不可变。 |
| `override`〔上下文〕 | 继承 | 标明成员重写基类成员，并检查对应关系。 |
| `accessor`〔上下文〕 | 成员 | 声明自动访问器，由编译器提供其访问与存储实现。 |
| `constructor`〔特殊语法词〕 | 对象 | 声明类构造器；参数属性可结合访问修饰符或 `readonly`。 |
| `any`〔上下文〕 | 类型 | 大范围跳过静态类型检查，允许任意操作。 |
| `unknown`〔上下文〕 | 类型 | 表示未知类型；使用前通常需要检查并收窄。 |
| `never`〔上下文〕 | 类型 | 没有可能值的类型，例如必定抛出或永不返回的函数结果。 |
| `void` | 类型／运算 | 类型位置通常表示不使用返回值；表达式位置保留 JavaScript 的 `void` 运算。 |
| `undefined`〔类型上下文〕 | 类型／值 | 类型位置表示 `undefined` 的类型；值位置依旧是 JavaScript 内置名称。 |
| `null` | 类型／值 | 类型位置表示空值类型；是否可赋给其他类型受严格空值检查配置影响。 |
| `boolean`〔上下文〕 | 类型 | 布尔类型。 |
| `number`〔上下文〕 | 类型 | JavaScript 数字类型，不区分整数和浮点的独立静态类型。 |
| `bigint`〔上下文〕 | 类型 | 任意精度整数值的类型。 |
| `string`〔上下文〕 | 类型 | 字符串类型。 |
| `symbol`〔上下文〕 | 类型 | 符号值类型。 |
| `object`〔上下文〕 | 类型 | 非原始值的类型；不同于 `{}` 或大写 `Object`。 |
| `unique`〔上下文〕 | 类型 | 与 `symbol` 组合，表示特定符号身份的独特类型。 |
| `keyof`〔上下文〕 | 类型运算 | 得到某个类型允许的属性键的类型。 |
| `typeof` | 类型运算 | 类型位置取得值的静态类型；表达式位置仍返回运行时类型字符串。 |
| `infer`〔上下文〕 | 泛型 | 在条件类型的匹配位置引入待推断的类型参数。 |
| `extends` | 继承／泛型 | 扩展类或接口；约束类型参数；条件类型中判断可赋值关系。 |
| `in` | 泛型／运算 | 映射类型中遍历属性键；类型参数位置可标明逆变；运行时仍有 JavaScript 的含义。 |
| `out`〔上下文〕 | 泛型 | 在适用的类型参数声明中标明协变；`in out` 标明不变。 |
| `as`〔上下文〕 | 类型／模块 | 类型断言；`as const` 限制推断；映射类型中重映射键；也保留导入导出别名用途。 |
| `is`〔上下文〕 | 类型检查 | 构造返回类型中的类型谓词，如 `x is T`；本身不自动生成运行时检查。 |
| `asserts`〔上下文〕 | 类型检查 | 声明断言函数的类型效果，如 `asserts x is T`；运行时验证由函数实现。 |
| `satisfies`〔上下文〕 | 类型检查 | 验证表达式满足目标类型，同时保留比直接类型标注更具体的类型信息。 |
| `this` | 对象／类型 | 类型位置可表示当前类的多态 `this`，也可声明函数的 `this` 参数类型。 |
| `new` | 对象／类型 | 类型位置定义构造签名；表达式位置创建实例。 |
| `const` | 声明／泛型 | 除 JavaScript 声明外，还用于 `const` 类型参数、`const enum`、`as const`。 |
| `global`〔上下文〕 | 作用域 | `declare global` 补充全局类型声明。 |
| `require`〔特殊上下文〕 | 模块 | `import x = require(...)` 中的外部模块引用语法；普通 `require(...)` 是否存在取决于宿主环境。 |
| `intrinsic`〔内部类型语法〕 | 编译期 | 标记由编译器实现的内置类型转换，如内置字符串操作类型；普通业务代码一般不自行声明。 |
| `assert`〔旧／兼容〕 | 模块 | 旧导入断言语法中的词，不是普通断言语句；新代码依据工具链使用 `with` 导入属性。 |
| `using`〔上下文〕 | 资源 | 显式资源管理声明，作用域结束时释放；`await using` 对应异步释放。 |
| `defer`〔上下文〕 | 模块 | 5.9 支持 `import defer * as ns from ...` 的延迟模块求值语法；受运行环境支持限制，不是 Go 式退出清理。 |
| `package`〔保留〕 | 兼容 | 沿用 JavaScript 的保留限制，没有 TypeScript 包声明语句。 |

`get`、`set`、`static`、`async`、`await`、`of`、`from` 等沿用上一节语法；`String`、`Number`、`Array`、`Promise`、`Partial`、`Pick` 等是类型或库名称，不是新增关键词。进一步参阅[类型操作](https://www.typescriptlang.org/docs/handbook/2/types-from-types.html)、[类](https://www.typescriptlang.org/docs/handbook/2/classes.html)、[5.9 发布说明](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-9.html)。

### 执行与生命周期摘要

TypeScript 通常由工具处理为 JavaScript，再采用目标宿主的执行模型。类型信息与生成的运行时代码分别存续；`type`、`interface` 等通常擦除，普通 `enum`、`namespace` 则可能生成代码。TSX 转换不等于 React 已经执行，React 再组织组件、更新和清理。[TypeScript 完整分析](language-runtime-lifecycles.md#3-typescript) · [React 构建与运行](framework-runtime-lifecycles.md#路径五react)

## 4. Java

Java SE 26 的词法表包括 51 个保留关键词和 17 个上下文关键词；`true`、`false`、`null` 在规范中属于字面量，下面另行列出。[Java 词法规范](https://docs.oracle.com/en/java/javase/26/docs/specs/jls/jls-3.html#jls-3.9)

### 声明、类型与对象

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `class` | 定义 | 声明类；`T.class` 取得类字面量。 |
| `interface` | 定义／类型 | 声明接口；与 `@` 组合声明注解接口。 |
| `enum` | 定义／类型 | 声明枚举类型和其枚举常量。 |
| `record`〔上下文〕 | 定义 | 声明以数据组件为中心的记录类，生成常用访问与对象方法。 |
| `var`〔上下文〕 | 类型 | 在允许的位置推断局部变量或 lambda 参数类型；不是动态类型，也不是字段类型。 |
| `boolean` | 类型 | 布尔类型。 |
| `byte` | 类型 | 8 位有符号整数。 |
| `short` | 类型 | 16 位有符号整数。 |
| `int` | 类型 | 32 位有符号整数。 |
| `long` | 类型 | 64 位有符号整数。 |
| `char` | 类型 | 16 位 UTF-16 代码单元；不保证独自表示一个完整 Unicode 字符。 |
| `float` | 类型 | 32 位浮点类型。 |
| `double` | 类型 | 64 位浮点类型。 |
| `void` | 类型 | 表示方法不返回值。 |
| `new` | 对象／资源 | 创建对象或数组。 |
| `this` | 对象 | 当前实例；也用于调用同一类的另一个构造器。 |
| `super` | 继承／泛型 | 访问父类成员或构造器；泛型通配符中声明下界。 |
| `extends` | 继承／泛型 | 类继承、接口扩展或类型参数／通配符上界。 |
| `implements` | 继承 | 声明类实现的接口。 |
| `abstract` | 对象 | 声明抽象类或没有实现的方法。 |
| `final` | 声明／继承 | 变量只能赋值一次；方法不能重写；类不能继承。引用为 `final` 不意味着对象内容不可修改。 |
| `sealed`〔上下文〕 | 继承 | 限制可以直接继承或实现的类型。 |
| `permits`〔上下文〕 | 继承 | 列出封闭类型允许的直接子类型。 |
| `non-sealed`〔上下文〕 | 继承 | 允许封闭父类型的某个子类型继续开放继承。 |
| `static` | 成员／作用域 | 类级字段、方法、嵌套类型或初始化块；也参与静态导入。 |
| `native` | 互操作 | 声明由平台本地代码实现的方法。 |
| `transient` | 声明／序列化 | 字段不参与 Java 默认对象序列化机制；不等于一切序列化库都忽略它。 |
| `strictfp`〔旧／兼容〕 | 运算／兼容 | 旧版控制浮点表达式的严格语义；现代 Java 浮点始终严格，该修饰符已过时。 |

### 控制流、判断、异常与并发

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流 | 条件分支。 |
| `else` | 控制流 | 另一条件分支。 |
| `switch` | 控制流 | 多分支语句或表达式，也支持模式匹配。 |
| `case` | 控制流 | 指定值或模式分支。 |
| `default` | 控制流／成员 | `switch` 默认分支；接口默认方法。 |
| `when`〔上下文〕 | 模式 | 为模式 `case` 添加守卫条件。 |
| `for` | 控制流 | 普通计数循环或增强遍历循环。 |
| `while` | 控制流 | 先判断的循环。 |
| `do` | 控制流 | 与 `while` 组合，先执行后判断。 |
| `break` | 控制流 | 退出循环、`switch` 或带标签语句。 |
| `continue` | 控制流 | 继续当前或指定标签循环的下一轮。 |
| `return` | 控制流 | 从方法或其他允许返回的函数体返回。 |
| `yield`〔上下文〕 | 控制流 | 给 `switch` 表达式提供一个结果值；不是 Python 的生成器产出。 |
| `instanceof` | 类型检查 | 检查运行时类型关系，可结合模式绑定变量。 |
| `try` | 异常／资源 | 开始异常处理；带资源形式可自动关闭资源。 |
| `catch` | 异常 | 捕获指定类型的异常。 |
| `finally` | 异常／资源 | 离开异常处理结构时执行清理。 |
| `throw` | 异常 | 抛出异常对象。 |
| `throws` | 异常／声明 | 在方法或构造器声明中列出可能抛出的异常类型。 |
| `assert` | 断言 | 检查程序前提，启用断言且条件不满足时抛出 `AssertionError`。 |
| `synchronized` | 并发 | 获取对象监视器锁，用于方法或代码块同步。 |
| `volatile` | 并发 | 对字段读写提供内存可见性与排序保证；不让 `x++` 等复合操作自动原子化。 |
| `_` | 模式／声明 | 在允许的位置声明不使用的变量或模式绑定；不能当作普通可引用名字。 |

### 可见性、包与模块

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `public` | 可见性 | 公开访问，跨模块访问仍受模块导出等规则影响。 |
| `protected` | 可见性 | 同包访问，并在规则允许时向子类开放。 |
| `private` | 可见性 | 限制在相应顶层类型所包含的访问范围内。 |
| `package` | 模块 | 声明编译单元所属包；包级默认访问没有单独修饰关键词。 |
| `import` | 模块 | 使类型、静态成员或支持的模块导入名称可直接使用。 |
| `module`〔上下文〕 | 模块 | 声明命名模块。 |
| `requires`〔上下文〕 | 模块 | 声明依赖模块。 |
| `transitive`〔上下文〕 | 模块 | 让依赖本模块的模块也可读取相应依赖。 |
| `exports`〔上下文〕 | 模块 | 导出包，允许其他模块正常访问其公开 API。 |
| `opens`〔上下文〕 | 模块 | 开放包以支持深层反射访问。 |
| `open`〔上下文〕 | 模块 | 声明整体开放反射访问的模块。 |
| `to`〔上下文〕 | 模块 | 把导出或开放限制到指定目标模块。 |
| `uses`〔上下文〕 | 模块 | 声明本模块使用某个服务接口。 |
| `provides`〔上下文〕 | 模块 | 声明服务提供者。 |
| `with`〔上下文〕 | 模块 | 在服务提供声明中列出实现类。 |
| `const`〔保留未用〕 | 保留 | 不能作为普通标识符，但 Java 没有该声明语法。 |
| `goto`〔保留未用〕 | 保留 | 不能作为普通标识符，但没有跳转语句。 |
| `true`〔字面量〕 | 值 | 布尔真；规范不把它算作关键词。 |
| `false`〔字面量〕 | 值 | 布尔假；规范不把它算作关键词。 |
| `null`〔字面量〕 | 值 | 空引用字面量；规范不把它算作关键词。 |

`String`、`Object`、`System`、`Integer`、`main` 不是关键词。深入语义见[类型与类](https://docs.oracle.com/en/java/javase/26/docs/specs/jls/jls-8.html)、[语句](https://docs.oracle.com/en/java/javase/26/docs/specs/jls/jls-14.html)、[包与模块](https://docs.oracle.com/en/java/javase/26/docs/specs/jls/jls-7.html)。

### 执行与生命周期摘要

JVM 经加载、链接和必要初始化进入程序入口；每次方法调用有执行状态，实例与类元数据可跨调用存续。线程、执行器及框架决定额外工作怎样进入，`import` 不等于请求式执行。`return`、`throw` 结束调用，资源退出与 GC 分别处理。[Java 完整分析](language-runtime-lifecycles.md#4-java) · [Spring Boot](framework-runtime-lifecycles.md#路径三spring-boot)

## 5. C

C23 增加或标准化了 `constexpr`、`typeof`、`nullptr` 等拼写。这里同时解释仍被保留的旧拼写，避免将 C17 时代的宏与 C23 关键词混为一谈。参考 [WG14 的 C23 草案 N3096，§6.4.1](https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3096.pdf)。

### 声明、类型、限定与存储

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `char` | 类型 | 字符／小整数类型；普通 `char` 是否有符号由实现决定。 |
| `short` | 类型 | 修饰整数类型，表示短整数；具体位宽依实现。 |
| `int` | 类型 | 基本整数类型；C 不规定必须是 32 位。 |
| `long` | 类型 | 构造长整数，也可组成 `long long`、`long double`。 |
| `signed` | 类型 | 指定有符号整数类型。 |
| `unsigned` | 类型 | 指定无符号整数类型。 |
| `float` | 类型 | 基本浮点类型，通常采用单精度表示。 |
| `double` | 类型 | 通常精度高于 `float` 的浮点类型。 |
| `void` | 类型 | 表示无返回值、无参数列表的相关形式，或无具体对象类型的 `void*`。 |
| `bool` | 类型 | C23 布尔类型关键词；较早版本常通过 `<stdbool.h>` 的宏使用。 |
| `_Bool`〔旧／兼容〕 | 类型 | `bool` 的旧关键词拼写，C23 仍支持但已弃用。 |
| `_BitInt` | 类型 | 声明指定位数的整数，如 `_BitInt(17)`；可结合 `unsigned`。 |
| `_Complex` | 类型 | 构造复数浮点类型，如 `double _Complex`；支持受实现条件影响。 |
| `_Imaginary`〔保留〕 | 类型／保留 | 为虚数类型保留的拼写，不能据此假定普通实现支持该类型。 |
| `_Decimal32` | 类型 | 32 位十进制浮点类型，属于实现可选择支持的特性。 |
| `_Decimal64` | 类型 | 64 位十进制浮点类型，支持依实现。 |
| `_Decimal128` | 类型 | 128 位十进制浮点类型，支持依实现。 |
| `struct` | 定义／类型 | 声明结构体，各成员具有各自存储。 |
| `union` | 定义／类型 | 声明联合体，成员共享存储区域。 |
| `enum` | 定义／类型 | 声明枚举；C23 还允许规定底层类型的形式。 |
| `typedef` | 定义／类型 | 为已有类型建立别名；不同于声明新的独立类型。 |
| `const` | 类型／资源 | 限定通过相应左值不能修改对象；不自动成为编译期常量。 |
| `volatile` | 类型／资源 | 要求遵守对易变对象访问的语义，常用于设备寄存器；不提供线程同步或原子性。 |
| `restrict` | 类型／资源 | 指针相关的别名约束承诺，帮助优化；违反承诺可造成未定义行为。 |
| `_Atomic` | 类型／并发 | 声明原子类型或限定原子对象，提供规定的原子访问语义。 |
| `auto` | 声明／存储／类型 | 传统意义为自动存储期；C23 在符合条件的初始化声明中支持类型推断。 |
| `register` | 声明／存储 | 传统优化提示，也限制获取所声明对象的地址；不保证放入 CPU 寄存器。 |
| `static` | 存储／链接 | 块内对象拥有静态存储期；文件级声明可有内部链接；数组参数中还可表达最低长度要求。 |
| `extern` | 声明／链接 | 声明具有相应链接关系的对象或函数，常用于引用其他翻译单元的定义。 |
| `thread_local` | 存储／并发 | 每个线程拥有独立实例，具有线程存储期。 |
| `_Thread_local`〔旧／兼容〕 | 存储／并发 | `thread_local` 的旧关键词拼写，C23 已弃用。 |
| `inline` | 声明 | 声明内联函数并影响相关定义规则；不强制编译器实际展开调用。 |
| `constexpr` | 编译期／声明 | C23 声明满足常量表达式规则的常量对象；不等同于 C++ 的 `constexpr` 函数。 |
| `_Noreturn`〔旧／兼容〕 | 声明 | 声明函数不正常返回；C23 更推荐 `[[noreturn]]` 属性。 |

### 控制流、类型操作与值

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流 | 条件成立时执行。 |
| `else` | 控制流 | 条件不成立时执行。 |
| `switch` | 控制流 | 根据整数或枚举表达式选择分支。 |
| `case` | 控制流 | 标记 `switch` 的常量分支。 |
| `default` | 控制流 | 标记无匹配 `case` 时的分支。 |
| `for` | 控制流 | 初始化、条件测试、迭代更新组成的循环。 |
| `while` | 控制流 | 先判断条件的循环。 |
| `do` | 控制流 | 与 `while` 组合，先执行再判断。 |
| `break` | 控制流 | 退出最近的循环或 `switch`。 |
| `continue` | 控制流 | 跳到最近循环的下一次迭代。 |
| `goto` | 控制流 | 跳到同一函数内的标签。 |
| `return` | 控制流 | 结束函数，并在适用时返回值。 |
| `sizeof` | 类型／运算 | 获取类型或对象大小，以 C 字节为单位；通常不求值，但变长数组相关情况可求值。 |
| `alignas` | 资源／声明 | 指定对象的对齐要求。 |
| `_Alignas`〔旧／兼容〕 | 资源／声明 | `alignas` 的旧拼写，C23 已弃用。 |
| `alignof` | 类型／运算 | 获取类型的对齐要求。 |
| `_Alignof`〔旧／兼容〕 | 类型／运算 | `alignof` 的旧拼写，C23 已弃用。 |
| `typeof` | 类型 | 从表达式或类型名取得类型，保留相应限定信息。 |
| `typeof_unqual` | 类型 | 取得类型，并去掉顶层限定与原子限定。 |
| `_Generic` | 编译期／类型 | 根据控制表达式的类型选择一个表达式，用于类型泛化接口。 |
| `static_assert` | 编译期／断言 | 编译阶段验证常量条件。 |
| `_Static_assert`〔旧／兼容〕 | 编译期／断言 | `static_assert` 的旧拼写，C23 已弃用。 |
| `true` | 值 | C23 布尔真常量；此前常为头文件宏。 |
| `false` | 值 | C23 布尔假常量；此前常为头文件宏。 |
| `nullptr` | 值 | C23 类型为 `nullptr_t` 的空指针常量。 |

`printf`、`malloc`、`free`、`assert`、`size_t`、`NULL` 不是 C 语言关键词。`#include`、`#define`、`#if`、`#ifdef`、`#elif`、`#elifdef`、`#elifndef`、`#else`、`#endif`、`#undef`、`#pragma`、`#error`、`#warning`、`#line`、`#embed` 属于预处理指令；`defined` 是预处理条件中的特殊运算符。C 标准语言没有 `class`、`try`、`catch`、`new`、`delete`。旧拼写规则见 N3096 §6.4.1；存储类、类型与限定语义见 §6.7。

### 执行与生命周期摘要

hosted C 程序由启动流程进入 `main`，普通调用沿当前控制流执行；语言不要求应用事件循环。典型实现用机器码及 ABI 调用状态，自动、静态和分配存储期分别管理。`static` 等影响存储属性，函数指针只有被调用才运行；动态存储通常需明确释放。[C 完整分析](language-runtime-lifecycles.md#5-c) · [普通进程路径](framework-runtime-lifecycles.md#路径一c-普通进程)

## 6. C++

基线为 C++23；不把 C++26 草案中的新增关键词混入。C++ 与 C 是两门语言，不能直接把 C23 的全部新增词复制到 C++。词法基线见 [WG21 C++23 草案源码 n4950](https://github.com/cplusplus/draft/blob/n4950/source/lex.tex)。

### 基础类型、定义与泛型

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `bool` | 类型 | 布尔类型。 |
| `char` | 类型 | 基本字符类型，符号性由实现决定。 |
| `char8_t` | 类型 | UTF-8 代码单元类型。 |
| `char16_t` | 类型 | UTF-16 代码单元类型。 |
| `char32_t` | 类型 | UTF-32 代码单元类型。 |
| `wchar_t` | 类型 | 宽字符类型，大小和编码相关约定依平台。 |
| `short` | 类型 | 短整数类型修饰。 |
| `int` | 类型 | 基本整数类型，位宽依实现。 |
| `long` | 类型 | 长整数或 `long long`；与 `double` 组合为扩展浮点类型。 |
| `signed` | 类型 | 有符号整数修饰。 |
| `unsigned` | 类型 | 无符号整数修饰。 |
| `float` | 类型 | 基本浮点类型。 |
| `double` | 类型 | 通常精度更高的浮点类型。 |
| `void` | 类型 | 无返回值或无具体对象类型的指针基础类型。 |
| `auto` | 类型／定义 | 推断类型；也用于占位类型参数和尾置返回类型语法。 |
| `decltype` | 类型 | 按表达式形式和值类别推导类型，通常不求值操作数。 |
| `class` | 定义／对象 | 声明类，默认成员及继承访问为 `private`；也可声明类型模板参数。 |
| `struct` | 定义／对象 | 声明类，默认成员及继承访问为 `public`。 |
| `union` | 定义／资源 | 定义共享存储的联合体。 |
| `enum` | 定义／类型 | 声明枚举；`enum class`／`enum struct` 为有作用域枚举。 |
| `typedef` | 定义／类型 | 声明类型别名。 |
| `using` | 类型／作用域 | 类型别名、引入名字、命名空间指令、继承构造器等。 |
| `template` | 泛型 | 声明模板；依赖名语法中也用于指明后面的名字是模板。 |
| `typename` | 泛型／类型 | 声明类型模板参数，或把依赖限定名明确解释为类型。 |
| `concept` | 泛型 | 声明命名约束，用于限制模板参数。 |
| `requires` | 泛型／编译期 | 给模板添加约束，或构造检查表达式与类型要求的 `requires` 表达式。 |

### 对象、限定、访问与链接

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `this` | 对象 | 指向当前对象的指针；C++23 显式对象参数声明也使用此词。 |
| `public` | 可见性／继承 | 公开成员或公开继承。 |
| `protected` | 可见性／继承 | 受保护成员或继承访问。 |
| `private` | 可见性／继承 | 私有成员或私有继承。 |
| `virtual` | 继承 | 虚函数支持动态派发；虚继承共享同一基类子对象。 |
| `friend` | 可见性 | 授予指定函数或类访问非公开成员的权限。 |
| `explicit` | 对象／转换 | 限制构造器或转换函数参与隐式转换；可带常量条件。 |
| `operator` | 对象／运算 | 声明运算符重载、转换函数或字面量运算符。 |
| `const` | 类型／资源 | 限制通过相应接口修改对象；修饰成员函数时限制对当前对象的修改。 |
| `volatile` | 类型／资源 | 声明易变访问语义；不是线程同步工具。 |
| `mutable` | 成员／资源 | 允许特定成员在 `const` 对象中修改；lambda 中允许修改按值捕获的副本。 |
| `static` | 成员／存储／链接 | 声明类级成员、静态存储期局部对象或内部链接实体等。 |
| `extern` | 链接 | 外部声明、语言链接 `extern "C"`，也用于抑制模板的隐式实例化。 |
| `inline` | 定义／链接 | 支持符合 ODR 要求的跨翻译单元定义；用于函数、变量与内联命名空间，不强制调用展开。 |
| `thread_local` | 存储／并发 | 声明每线程独立实例。 |
| `namespace` | 模块／作用域 | 声明命名空间或命名空间别名。 |
| `export` | 模块 | 导出模块接口中的声明；C++23 不再支持旧的导出模板机制。 |
| `module`〔上下文〕 | 模块 | 声明模块或模块片段。 |
| `import`〔上下文〕 | 模块 | 导入模块、分区或头文件单元。 |
| `final`〔上下文〕 | 继承 | 禁止类被继续继承，或虚函数被进一步重写。 |
| `override`〔上下文〕 | 继承 | 检查成员函数确实重写基类虚函数。 |
| `register`〔保留未用〕 | 保留 | C++23 中已无旧存储类功能，但仍保留这个词。 |
| `asm` | 互操作 | 引入汇编相关声明；实际支持和语义取决于实现。 |

### 控制流、异常、资源与编译期

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流／编译期 | 普通条件分支；`if constexpr` 根据编译期条件选择；`if consteval` 按常量求值语境分支。 |
| `else` | 控制流 | 另一分支。 |
| `switch` | 控制流 | 按整数或枚举选择分支。 |
| `case` | 控制流 | 标记常量分支。 |
| `default` | 控制流／定义 | 默认分支；`= default` 让编译器生成支持该语法的函数实现。 |
| `for` | 控制流 | 计数循环或范围循环。 |
| `while` | 控制流 | 先判断条件的循环。 |
| `do` | 控制流 | 先执行后判断的循环。 |
| `break` | 控制流 | 退出循环或 `switch`。 |
| `continue` | 控制流 | 进入下一轮循环。 |
| `goto` | 控制流 | 跳至同一函数内标签，受跨越初始化等规则限制。 |
| `return` | 控制流 | 返回函数结果或结束函数。 |
| `try` | 异常 | 开始异常处理区或函数 try 块。 |
| `catch` | 异常 | 捕获匹配的异常。 |
| `throw` | 异常 | 抛出异常，或重新抛出正在处理的异常。 |
| `noexcept` | 异常／类型 | 声明不抛出异常的约束；也可检查表达式是否为非抛出表达式。 |
| `new` | 资源／对象 | 分配存储并构造对象；placement new 在指定存储中构造。 |
| `delete` | 资源／定义 | 销毁并释放 `new` 创建的对象；`= delete` 禁止某函数被使用。 |
| `sizeof` | 类型／运算 | 查询大小；`sizeof...` 查询参数包元素数量。 |
| `alignas` | 资源／定义 | 规定对齐要求。 |
| `alignof` | 类型／运算 | 查询类型对齐。 |
| `typeid` | 类型检查 | 获得类型信息；多态对象表达式可取得动态类型。 |
| `static_cast` | 类型转换 | 执行受规则限制的显式转换，如数值转换或相关类指针转换。 |
| `dynamic_cast` | 类型转换 | 对多态类型执行检查式转换；失败时指针为 null，引用转换抛出异常。 |
| `const_cast` | 类型转换 | 调整 `const`／`volatile` 限定；修改本来定义为 const 的对象仍可能是未定义行为。 |
| `reinterpret_cast` | 类型转换 | 执行低层表示相关转换；可否解引用仍受类型、对齐和对象生命周期规则约束。 |
| `constexpr` | 编译期 | 声明可参与常量求值的对象、函数等；函数也可能在运行时执行。 |
| `consteval` | 编译期 | 声明立即函数，要求相关调用满足编译期求值规则。 |
| `constinit` | 编译期／存储 | 要求静态或线程存储期变量进行常量初始化；不意味着此变量以后不可修改。 |
| `static_assert` | 编译期／断言 | 编译阶段验证常量条件。 |
| `co_await` | 异步／协程 | 使用等待器协议，可能暂停协程。 |
| `co_yield` | 协程 | 通过 promise 协议产出值并可能暂停。 |
| `co_return` | 协程 | 结束协程并向其 promise 提供结果；不同于普通 `return`。 |
| `true` | 值 | 布尔真。 |
| `false` | 值 | 布尔假。 |
| `nullptr` | 值 | 空指针字面量，类型为 `std::nullptr_t`。 |

### 运算符的单词拼写

这些是运算符的替代表示，也是保留的词法拼写，并非普通函数名。

| 单词 | 分类 | 等价含义 |
| --- | --- | --- |
| `and` | 运算 | `&&`，短路逻辑与。 |
| `or` | 运算 | `\|\|`，短路逻辑或。 |
| `not` | 运算 | `!`，逻辑非。 |
| `bitand` | 运算 | `&`，按位与；具体语境也可涉及引用或取地址拼写。 |
| `bitor` | 运算 | `\|`，按位或。 |
| `xor` | 运算 | `^`，按位异或。 |
| `compl` | 运算 | `~`，按位取反。 |
| `and_eq` | 运算 | `&=`，按位与后赋值。 |
| `or_eq` | 运算 | `\|=`，按位或后赋值。 |
| `xor_eq` | 运算 | `^=`，按位异或后赋值。 |
| `not_eq` | 运算 | `!=`，不等。 |

`std`、`string`、`vector`、`move`、`unique_ptr`、`shared_ptr` 不是关键词。`std::move` 主要执行值类别转换，本身不等于已经转移了资源。`#include`、`#define` 等是预处理指令；`[[nodiscard]]`、`[[deprecated]]` 等是属性，不是新增保留关键词。按固定版本查阅[声明草案](https://github.com/cplusplus/draft/blob/n4950/source/declarations.tex)、[表达式草案](https://github.com/cplusplus/draft/blob/n4950/source/expressions.tex)、[语句草案](https://github.com/cplusplus/draft/blob/n4950/source/statements.tex)。

### 执行与生命周期摘要

C++ 区分存储、对象构造、析构和释放，RAII 将清理关联到对象退出。协程另保存跨暂停状态，`co_await` 等通过 promise／awaiter 协议推进；首次是否暂停及谁调度由相应协议与库决定。协程完成不一定立即释放 frame，语言没有强制统一事件循环。[C++ 完整分析](language-runtime-lifecycles.md#6-c)

## 7. C#

以 C#14 为主；Microsoft 的关键词参考同时包含下一版预览，因此把 `closed`、`safe` 分开放在末尾。C# 上下文关键词包括 LINQ 查询词、模式词、属性访问器词等。[官方关键词表](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/)

### 定义、基础类型与泛型

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `class` | 定义 | 声明引用类型的类；泛型约束中也可要求引用类型。 |
| `struct` | 定义／泛型 | 声明值类型；约束中要求非可空值类型。 |
| `interface` | 定义 | 声明接口契约。 |
| `enum` | 定义 | 声明有整数底层类型的枚举。 |
| `delegate` | 定义 | 声明可调用引用类型；也用于匿名方法语法。 |
| `event` | 成员 | 声明事件，其订阅与触发访问受规则限制。 |
| `record`〔上下文〕 | 定义 | 声明具有数据比较等生成行为的记录类或记录结构体。 |
| `partial`〔上下文〕 | 定义 | 把类型或支持的成员声明拆分到多个部分；也出现在扩展相关语法中。 |
| `const` | 声明／编译期 | 声明编译期常量，支持的类型与表达式有规定限制。 |
| `readonly` | 声明／资源 | 限制字段赋值；也用于只读结构体、成员和只读引用。 |
| `var`〔上下文〕 | 类型 | 推断局部变量类型，也可用于捕获任意值的模式；不是动态类型。 |
| `dynamic`〔上下文〕 | 类型 | 使相应操作主要在运行时进行绑定。 |
| `bool` | 类型 | 布尔类型。 |
| `byte` | 类型 | 8 位无符号整数。 |
| `sbyte` | 类型 | 8 位有符号整数。 |
| `short` | 类型 | 16 位有符号整数。 |
| `ushort` | 类型 | 16 位无符号整数。 |
| `int` | 类型 | 32 位有符号整数。 |
| `uint` | 类型 | 32 位无符号整数。 |
| `long` | 类型 | 64 位有符号整数。 |
| `ulong` | 类型 | 64 位无符号整数。 |
| `char` | 类型 | UTF-16 代码单元类型。 |
| `float` | 类型 | 32 位二进制浮点。 |
| `double` | 类型 | 64 位二进制浮点。 |
| `decimal` | 类型 | 十进制数值类型，常用于需要十进制精确表示的计算。 |
| `string` | 类型 | `System.String` 的内置类型别名。 |
| `object` | 类型 | `System.Object` 的内置类型别名。 |
| `void` | 类型 | 表示不返回值；不安全语法中也用于 `void*`。 |
| `nint`〔上下文〕 | 类型 | 本机宽度有符号整数。 |
| `nuint`〔上下文〕 | 类型 | 本机宽度无符号整数。 |
| `where`〔上下文〕 | 泛型／查询 | 声明类型参数约束；查询中筛选元素。 |
| `notnull`〔上下文〕 | 泛型 | 要求类型实参为不可空类型的约束。 |
| `unmanaged`〔上下文〕 | 泛型／互操作 | 约束无托管引用的类型；函数指针语法中指定非托管调用约定。 |
| `allows`〔上下文〕 | 泛型／资源 | `allows ref struct` 反约束声明泛型可接受 `ref struct`，实现也必须遵守其安全限制。 |

### 对象、成员与可见性

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `this` | 对象 | 当前实例、索引器声明或扩展方法接收者参数。 |
| `base` | 继承 | 访问基类成员或调用基类构造器。 |
| `new` | 对象／成员／泛型 | 创建实例；显式隐藏继承成员；`new()` 泛型约束要求可访问的无参构造器。 |
| `abstract` | 对象 | 声明抽象类型或要求派生实现的成员。 |
| `virtual` | 继承 | 声明可被重写的成员。 |
| `override` | 继承 | 重写基类虚成员。 |
| `sealed` | 继承 | 禁止继续继承类；结合 `override` 禁止进一步重写。 |
| `static` | 成员 | 类型级成员、静态类等；静态局部函数和 lambda 禁止捕获局部状态。 |
| `public` | 可见性 | 公开访问。 |
| `private` | 可见性 | 限制为包含类型等规定范围。 |
| `protected` | 可见性 | 供包含类型及派生类型访问。 |
| `internal` | 可见性 | 同程序集访问，可能有友元程序集机制。 |
| `file`〔上下文〕 | 可见性 | 声明仅当前源文件可见的类型。 |
| `namespace` | 模块／作用域 | 声明命名空间，支持块形式与文件级形式。 |
| `using` | 模块／资源 | 导入命名空间、别名或静态成员；资源语句／声明在离开作用域时释放资源。 |
| `global`〔上下文〕 | 作用域 | `global::` 从全局命名空间解析；`global using` 为项目源文件提供全局导入。 |
| `alias`〔上下文〕 | 模块 | `extern alias` 为外部程序集引用定义别名。 |
| `extern` | 互操作／模块 | 声明外部实现的成员，或与 `alias` 组合。 |
| `get`〔上下文〕 | 成员 | 属性或索引器读取访问器。 |
| `set`〔上下文〕 | 成员 | 属性或索引器写入访问器。 |
| `init`〔上下文〕 | 成员 | 仅在允许的初始化阶段设置属性或索引器。 |
| `value`〔上下文〕 | 成员 | 写入、事件访问器中隐式提供的输入值名称。 |
| `field`〔上下文〕 | 成员 | C#14 属性访问器中引用编译器生成的后备字段。 |
| `add`〔上下文〕 | 成员 | 自定义事件订阅访问器。 |
| `remove`〔上下文〕 | 成员 | 自定义事件取消订阅访问器。 |
| `required`〔上下文〕 | 成员 | 要求对象构造流程满足成员初始化约定。 |
| `extension`〔上下文〕 | 成员 | C#14 声明扩展块，以集中声明扩展成员。 |
| `operator` | 运算／成员 | 声明运算符重载。 |
| `implicit` | 类型转换 | 声明用户定义的隐式转换。 |
| `explicit` | 类型转换 | 声明需要显式转换语法的用户定义转换。 |
| `with`〔上下文〕 | 对象 | 基于现有值创建修改了部分成员的副本，常用于记录，也支持其他规定类型。 |

`protected internal` 表示“同程序集或派生类型”；`private protected` 表示“同程序集中的包含类型或派生类型”。这两个组合的可见范围不同。

### 控制流、模式、异常与异步

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流 | 条件分支。 |
| `else` | 控制流 | 另一分支。 |
| `switch` | 控制流 | 多分支语句或表达式，支持模式匹配。 |
| `case` | 控制流／模式 | 标记分支值或模式。 |
| `default` | 控制流／值 | 默认分支；`default(T)` 或默认字面量产生类型默认值。 |
| `for` | 控制流 | 计数循环。 |
| `foreach` | 控制流 | 遍历可枚举对象，结合 `await` 支持异步枚举。 |
| `while` | 控制流 | 先判断条件的循环。 |
| `do` | 控制流 | 先执行后判断的循环。 |
| `break` | 控制流 | 退出循环或 `switch`。 |
| `continue` | 控制流 | 进入下一轮循环。 |
| `goto` | 控制流 | 跳至标签或适用的 `case`／`default`。 |
| `return` | 控制流 | 返回结果或结束成员／函数。 |
| `yield`〔上下文〕 | 生成器 | `yield return` 产出迭代值；`yield break` 结束迭代。 |
| `is` | 判断／模式 | 检查类型或匹配模式。 |
| `as` | 类型转换 | 尝试受支持的引用或可空转换，失败产生 null。 |
| `and`〔上下文〕 | 模式 | 组合必须同时匹配的模式。 |
| `or`〔上下文〕 | 模式 | 组合任意一个匹配即可的模式。 |
| `not`〔上下文〕 | 模式 | 否定模式。 |
| `when`〔上下文〕 | 模式／异常 | 分支守卫或异常过滤条件。 |
| `try` | 异常 | 开始异常处理。 |
| `catch` | 异常 | 捕获异常，可带 `when` 过滤。 |
| `finally` | 异常／资源 | 离开处理结构时执行清理。 |
| `throw` | 异常 | 抛出或重新抛出异常，也可用于 throw 表达式。 |
| `async`〔上下文〕 | 异步 | 声明采用异步状态机语义的函数等。 |
| `await`〔上下文〕 | 异步 | 等待支持 awaiter 协议的对象，也用于异步枚举与释放。 |
| `lock` | 并发 | 以规定锁机制执行互斥区域。 |
| `volatile` | 并发 | 对受支持字段提供特定读写排序语义，不让任意复合操作原子化。 |
| `true` | 值 | 布尔真。 |
| `false` | 值 | 布尔假。 |
| `null` | 值 | 空引用或可空值类型的空值。 |

### 参数、内存、检查与名称

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `ref` | 资源／参数 | 通过引用访问或返回变量；也用于 `ref struct` 等栈安全受限类型。 |
| `out` | 参数／泛型 | 输出引用参数；泛型接口或委托中表示协变。 |
| `in` | 参数／泛型／遍历 | 只读引用参数；泛型接口或委托中表示逆变；也连接 `foreach` 迭代源与查询源。 |
| `params` | 参数 | 声明可变数量参数；支持的参数集合形式随语言版本演进。 |
| `scoped`〔上下文〕 | 资源 | 限制引用或相关值的逃逸范围，防止引用超过允许生命周期。 |
| `unsafe` | 资源／内存 | 声明允许指针等不安全操作的上下文。 |
| `fixed` | 资源／内存 | 固定托管对象地址以供指针使用；也声明固定大小缓冲区。 |
| `stackalloc` | 资源／内存 | 在当前执行栈上分配一段存储，可用于指针或 Span 类语法。 |
| `sizeof` | 类型／运算 | 获取类型的存储大小；某些使用需要不安全上下文。 |
| `typeof` | 类型 | 获取代表某类型的 `System.Type` 对象。 |
| `nameof`〔上下文〕 | 编译期 | 生成符号名称字符串，通常用于可随重命名更新的名称引用。 |
| `checked` | 运算 | 启用适用整数运算／转换的溢出检查，也可参与运算符声明。 |
| `unchecked` | 运算 | 禁用适用整数运算／转换的溢出检查。 |
| `managed`〔上下文〕 | 互操作 | 函数指针语法中指定托管调用约定。 |
| `args`〔特殊名称〕 | 作用域 | 顶层语句可使用的命令行参数名称；不是一般禁止使用的保留词。 |

### LINQ 查询词

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `from`〔上下文〕 | 查询 | 引入查询源和范围变量。 |
| `select`〔上下文〕 | 查询 | 将元素投影为查询结果。 |
| `where`〔上下文〕 | 查询 | 筛选符合条件的元素；同词的泛型用途见前表。 |
| `let`〔上下文〕 | 查询 | 在查询中保存计算结果为范围变量。 |
| `join`〔上下文〕 | 查询 | 关联两个查询源。 |
| `on`〔上下文〕 | 查询 | 指定关联键表达式的开始。 |
| `equals`〔上下文〕 | 查询 | 连接两个等值关联键表达式。 |
| `into`〔上下文〕 | 查询 | 引入组关联结果，或继续一个投影／分组后的查询。 |
| `orderby`〔上下文〕 | 查询 | 指定排序键。 |
| `ascending`〔上下文〕 | 查询 | 升序排序。 |
| `descending`〔上下文〕 | 查询 | 降序排序。 |
| `group`〔上下文〕 | 查询 | 对元素分组。 |
| `by`〔上下文〕 | 查询 | 指定分组键。 |

### 参考文档中的下一版预览词

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `closed`〔上下文／预览〕 | 继承 | C#15 的封闭继承层级：直接子类型必须定义在规定的同程序集和模块内，支持穷尽匹配分析。 |
| `safe`〔上下文／预览〕 | 内存／互操作 | C#15 更新安全模型中的声明修饰，显式标明相应声明不要求调用方进入 unsafe 语义；不是任意代码的自动安全证明。 |

预览词依据 [`closed` 参考](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/closed)与[不安全代码参考](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/unsafe-code)，不属于本节 C#14 基线。`Console`、`Task`、`List`、`Span` 是库名称；`#if`、`#nullable` 等为指令。成员语义见[属性](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties)、[扩展成员](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/extension-methods)、[查询关键词](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/query-keywords)。

### 执行与生命周期摘要

常见 .NET 应用以程序集、方法调用状态、async 状态机和 Task 分别保存定义、进度及结果。`async Task` 调用通常先同步推进，未完成的 awaitable 才需要暂停；继续位置受上下文等规则影响。`using` 的释放与 GC 不同。Unity 另由引擎及 Mono／IL2CPP 后端组织阶段调用。[C# 完整分析](language-runtime-lifecycles.md#7-c) · [Unity](framework-runtime-lifecycles.md#路径四unity)

## 8. Go

Go 的正式关键词只有 25 个。内置类型与很多核心操作采用“预声明标识符”，这使得它的关键词列表较短。[Go 官方规范](https://go.dev/ref/spec#Keywords)

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `package` | 模块 | 声明源文件所属包。 |
| `import` | 模块 | 导入包，可设置本地别名、空白导入或点导入。 |
| `const` | 定义／编译期 | 声明常量，值必须符合常量表达式规则。 |
| `var` | 定义 | 声明变量，可显式类型或由初始化推断。 |
| `type` | 定义／类型 | 定义命名类型或类型别名。 |
| `func` | 定义 | 声明函数、方法、函数类型，或构造函数字面量。 |
| `struct` | 定义／类型 | 定义结构体类型。 |
| `interface` | 定义／类型 | 定义接口；泛型约束语境中还可描述类型集合。 |
| `map` | 类型 | 定义键值映射类型，键必须满足可比较要求。 |
| `chan` | 类型／并发 | 定义通道类型；结合 `<-` 指定方向。 |
| `if` | 控制流 | 条件分支，可带初始化语句。 |
| `else` | 控制流 | 另一分支。 |
| `switch` | 控制流 | 表达式 switch 或类型 switch。 |
| `case` | 控制流／并发 | 指定 switch 分支或 select 通道操作分支。 |
| `default` | 控制流／并发 | switch 默认分支；select 中表示其他通信都不能立即进行时执行。 |
| `for` | 控制流 | Go 唯一的循环关键词，支持条件、三段式、range 等形式。 |
| `range` | 控制流 | 遍历数组、切片、字符串、map、通道；现代 Go 还支持整数和迭代器函数。 |
| `break` | 控制流 | 退出 for、switch、select，可带标签。 |
| `continue` | 控制流 | 进入 for 下一轮，可带标签。 |
| `fallthrough` | 控制流 | 在表达式 switch 中无条件进入后续 case 主体，受位置限制。 |
| `goto` | 控制流 | 跳到同一函数中的标签，受作用域等限制。 |
| `return` | 控制流 | 返回结果并结束函数。 |
| `defer` | 资源／控制流 | 注册函数返回前执行的调用，通常后注册先执行；参数在注册时求值。 |
| `go` | 并发 | 在新 goroutine 中启动函数调用。 |
| `select` | 并发 | 从可进行的通道发送／接收中选择一个；没有可执行分支时通常阻塞。 |

Go 的 `bool`、`int`、`string`、`byte`、`rune`、`any`、`comparable`、`true`、`false`、`nil`、`iota`、`make`、`new`、`len`、`append`、`panic`、`recover` 等都是预声明名称，不属于这 25 个关键词。Go 通过名称首字母大写控制导出，没有 `public`／`private` 关键词；没有 `try`／`catch`，常规错误处理主要通过返回值。详细区分见[预声明标识符](https://go.dev/ref/spec#Predeclared_identifiers)。

### 执行与生命周期摘要

Go 按包初始化、`init` 和入口的关系启动，runtime 管理 goroutine、等待与恢复。`go` 求值调用信息后启动新的 goroutine，channel 等形成通信等待关系，`defer` 在外围函数退出时执行。G／M／P 是 runtime 实现模型，`main` 返回不等待其他 goroutine 全部完成。[Go 完整分析](language-runtime-lifecycles.md#8-go)

## 9. Rust

按 Rust 2024 edition 与稳定语言参考解释。Rust 的官方词法分类是 strict、reserved、weak；这与本文按功能划分是两个不同维度。[Rust 关键词参考](https://doc.rust-lang.org/reference/keywords.html)

### 定义、类型、模块与泛型

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `let` | 定义 | 引入局部绑定，通常默认不可重新赋值；也用于模式绑定语法。 |
| `fn` | 定义 | 定义函数、关联函数或函数指针类型。 |
| `struct` | 定义 | 定义结构体，包括具名字段、元组与单元形式。 |
| `enum` | 定义 | 定义可带不同数据的枚举变体。 |
| `trait` | 定义／泛型 | 定义类型可实现的行为契约和关联项。 |
| `impl` | 对象／泛型 | 实现类型或 trait；类型位置的 `impl Trait` 表达受约束的不透明类型或参数。 |
| `type` | 定义／类型 | 定义类型别名或关联类型。 |
| `const` | 定义／编译期 | 定义常量项；也用于 const 泛型参数、常量函数或常量块。 |
| `static` | 定义／存储 | 定义具有固定存储的静态项，与可被内联的常量项不同。 |
| `mod` | 模块 | 声明模块，内容可内联或位于对应文件中。 |
| `crate` | 模块／可见性 | 路径中指当前 crate 根；也用于 `pub(crate)`、`extern crate`。 |
| `use` | 模块／作用域 | 将路径中的项引入当前作用域，也用于导出别名。 |
| `pub` | 可见性 | 声明公开或受限制的可见性，如 `pub(crate)`。 |
| `super` | 模块 | 在路径中引用父模块。 |
| `self` | 对象／模块 | 方法接收者或当前模块路径；小写通常表示值或模块。 |
| `Self` | 类型 | 当前正在定义／实现的类型；大写表示类型。 |
| `where` | 泛型 | 在声明中书写类型或生命周期约束。 |
| `dyn` | 类型／派发 | 标记 trait object 类型，允许动态派发。 |
| `as` | 类型／模块 | 执行受支持转换，给导入项取别名，或用于限定关联项路径。 |
| `extern` | 互操作／模块 | 指定外部 ABI、声明外部块或导入外部 crate。 |

### 控制流、所有权、异步与值

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流 | 条件表达式；`if let` 使用模式判断。 |
| `else` | 控制流 | 另一分支；`let ... else` 在模式不匹配时执行必须发散的分支。 |
| `match` | 控制流／模式 | 穷尽模式匹配表达式。 |
| `for` | 控制流／泛型 | 遍历迭代器；也用于 trait 实现与高阶生命周期绑定语法。 |
| `in` | 控制流／可见性 | 连接 for 模式与迭代源；`pub(in path)` 指定可见范围。 |
| `while` | 控制流 | 条件循环，支持 `while let`。 |
| `loop` | 控制流 | 无限循环，可通过 `break value` 提供结果。 |
| `break` | 控制流 | 退出循环或允许的带标签块，在适用语境中返回值。 |
| `continue` | 控制流 | 进入下一轮循环，可指定标签。 |
| `return` | 控制流 | 返回函数结果并结束函数。 |
| `mut` | 资源／绑定 | 声明可变绑定或可变借用；也用于原始可变指针类型。 |
| `ref` | 资源／模式 | 在模式中按引用绑定，而不是移动匹配到的值。 |
| `move` | 资源／闭包 | 让闭包或异步块按值捕获外层变量；是否发生复制或移动取决于类型。 |
| `unsafe` | 资源／内存 | 声明安全契约或允许受限制操作的块；仍需遵守 Rust 的有效性和未定义行为规则。 |
| `async` | 异步 | 定义异步函数、异步块或支持的异步闭包，产生 Future。 |
| `await` | 异步 | 使用 `.await` 等待 Future 完成，并可能暂停当前异步任务。 |
| `true` | 值 | 布尔真。 |
| `false` | 值 | 布尔假。 |
| `_` | 模式／类型 | 匿名忽略模式、类型推断占位等，不引入可访问名字。 |

### 弱关键词与特殊生命周期

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `union`〔上下文〕 | 定义／资源 | 定义共享存储的联合体，字段读等操作有额外安全要求。 |
| `macro_rules`〔上下文〕 | 元编程 | 与 `!` 组合定义声明式宏。 |
| `raw`〔上下文〕 | 内存 | `&raw const`／`&raw mut` 直接构造原始指针，避免先建立普通引用。 |
| `safe`〔上下文〕 | 互操作 | 在外部块中显式标记允许安全调用或访问的函数／静态项。 |
| `'static`〔特殊生命周期〕 | 生命周期 | 表示静态生命周期；`T: 'static` 表示类型不包含较短生命周期的借用，不代表值一定活到进程结束。 |

### 保留但未在稳定语言中启用的词

不要因为某词拼写像其他语言的功能，就假定 Rust 已有该功能。下表各词均不能作为普通未转义标识符，但**不作为本手册基线的已启用语法讲解**。

| 保留词 | 分类 | 当前地位 |
| --- | --- | --- |
| `abstract` | 保留 | 未启用的保留词；不能按 Java 抽象类使用。 |
| `become` | 保留 | 未启用的保留词。 |
| `box` | 保留 | 未启用的保留词；普通装箱使用库类型 `Box`。 |
| `do` | 保留 | 未启用的保留词，没有普通 do-while 语句。 |
| `final` | 保留 | 未启用的保留词。 |
| `gen` | 保留 | 2024 edition 新保留，为生成器相关演进预留。 |
| `macro` | 保留 | 未启用的保留词；稳定声明式宏使用 `macro_rules!`。 |
| `override` | 保留 | 未启用的保留词。 |
| `priv` | 保留 | 未启用的保留词；默认私有不需要此修饰符。 |
| `try` | 保留 | 保留词；不能把不稳定 try-block 功能当成通用稳定语法。 |
| `typeof` | 保留 | 未启用的保留词。 |
| `unsized` | 保留 | 未启用的保留词；`Sized` 是 trait。 |
| `virtual` | 保留 | 未启用的保留词；动态派发由 trait object 等机制提供。 |
| `yield` | 保留 | 不能把不稳定协程相关用法当成通用稳定生成器语法。 |

Rust 的 `i32`、`u64`、`bool`、`str`、`String`、`Vec`、`Option`、`Result`、`Some`、`None`、`Ok`、`Err`、`drop` 都不是上述正式关键词。`panic!` 是宏，`?` 是传播失败等语义的运算符；常规错误处理使用 `Result`，没有 Java 式 `try`／`catch`。泛型、所有权与表达式语义参阅[Rust 类型系统](https://doc.rust-lang.org/reference/type-system.html)、[表达式](https://doc.rust-lang.org/reference/expressions.html)、[外部块](https://doc.rust-lang.org/reference/items/external-blocks.html)。

### 执行与生命周期摘要

Rust 用所有权及 Drop 管理值存续，生命周期注解主要表达编译期约束。`async fn` 调用创建 Future，随后由 await 或 executor 的 poll 推进；Future 状态与 Waker 支持等待后继续，`.await` 不自动 spawn。丢弃 Future 不能自动撤销已发生的外部效果。[Rust 完整分析](language-runtime-lifecycles.md#9-rust)

## 10. Swift

Swift 的关键词参考既列出保留词，也列出仅特定位置有意义的词；现代并发和泛型语法还有文档各章节中定义的上下文词。这里列出公开语法，不列编译器内部以下划线开头的实现词。基线见[词法结构](https://docs.swift.org/latest/documentation/the-swift-programming-language/lexicalstructure/)。

### 定义、类型、成员与可见性

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `let` | 定义 | 声明不可重新赋值的绑定；引用所指对象的可变成员仍可能改变。 |
| `var` | 定义 | 声明可重新赋值的变量或可变属性。 |
| `func` | 定义 | 定义函数或方法。 |
| `class` | 定义／成员 | 定义引用语义类；成员修饰语境中定义可被重写的类型级成员。 |
| `struct` | 定义 | 定义值语义结构体。 |
| `enum` | 定义 | 定义可包含关联值的枚举。 |
| `protocol` | 定义／类型 | 声明协议要求。 |
| `extension` | 定义／成员 | 为已有类型增加方法、计算属性、协议遵循等。 |
| `typealias` | 定义／类型 | 定义类型别名。 |
| `associatedtype` | 泛型／类型 | 在协议中声明关联类型。 |
| `init` | 对象 | 声明初始化器，可结合 `?`／`!` 表示可失败初始化。 |
| `deinit` | 资源 | 声明实例销毁前执行的去初始化逻辑，具体支持受类型规则影响。 |
| `subscript` | 成员 | 定义下标读取或写入接口。 |
| `operator` | 运算／定义 | 声明自定义运算符。 |
| `precedencegroup` | 运算／定义 | 定义运算符优先级及结合性分组。 |
| `static` | 成员 | 定义类型级成员；类中的静态成员不能被重写。 |
| `import` | 模块 | 导入模块或特定声明。 |
| `private` | 可见性 | 限制在声明所在的词法范围及规则允许的同文件扩展内。 |
| `fileprivate` | 可见性 | 同一源文件内访问。 |
| `internal` | 可见性 | 同一模块内访问，通常是默认级别。 |
| `public` | 可见性 | 向模块外公开；不自动允许外部继承或重写。 |
| `open` | 可见性／继承 | 允许模块外访问并继承类或重写相应成员。 |
| `package`〔上下文〕 | 可见性 | 同一 package 内跨模块访问。 |
| `Any` | 类型 | 可以表示任意类型的值；不同于要求某个具体协议。 |
| `Self` | 类型 | 当前类型的抽象名称，常用于协议和返回类型。 |
| `self` | 对象 | 当前实例或类型对象；`.self` 可取得相应值／元类型。 |
| `super` | 继承 | 访问父类实现或调用父类初始化器。 |
| `Type`〔上下文〕 | 类型 | `.Type` 构造元类型表达，表示类型本身的类型。 |
| `Protocol`〔上下文〕 | 类型 | `.Protocol` 表示协议本身的元类型相关语法，不是定义协议的关键词。 |
| `some`〔上下文〕 | 类型 | 声明满足约束的不透明类型，隐藏具体类型身份的实现细节。 |
| `any`〔上下文〕 | 类型 | 明确表示协议的存在类型，可容纳不同具体遵循类型的值。 |
| `where` | 泛型／控制流 | 声明泛型约束，或在遍历和模式分支中追加条件。 |
| `each`〔上下文〕 | 泛型 | 声明或引用泛型参数包中的元素。 |
| `repeat` | 泛型／控制流 | 包展开语法；与 `while` 组合时表示先执行后判断的循环。 |

### 控制流、异常、转换与值

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `if` | 控制流 | 条件语句；支持可选绑定、模式判断，现代 Swift 也支持 if 表达式。 |
| `else` | 控制流 | 另一分支；`guard` 不满足条件时必须执行退出路径。 |
| `guard` | 控制流 | 验证后续代码的前提；失败分支必须离开相应作用域。 |
| `switch` | 控制流 | 多分支模式匹配，通常需要穷尽；也支持 switch 表达式。 |
| `case` | 模式／定义 | 声明枚举变体，或出现在 switch、if case、for case 等模式语法中。 |
| `default` | 控制流 | switch 中处理剩余情况。 |
| `for` | 控制流 | 遍历序列，支持模式筛选和 `where`。 |
| `in` | 控制流／闭包 | 连接遍历目标与序列；闭包中分隔参数／签名与主体。 |
| `while` | 控制流 | 条件循环；也结束 `repeat` 循环。 |
| `break` | 控制流 | 退出循环、switch 或规定的带标签语句。 |
| `continue` | 控制流 | 继续下一轮循环。 |
| `fallthrough` | 控制流 | 进入 switch 的下一个分支主体，不重新测试其匹配条件。 |
| `return` | 控制流 | 结束函数或闭包并返回值。 |
| `do` | 控制流／异常 | 定义独立作用域代码块，也用于 do-catch 异常处理。 |
| `defer` | 资源 | 注册离开当前作用域时执行的清理，多项通常后注册先执行。 |
| `throw` | 异常 | 抛出符合错误协议的值。 |
| `throws` | 异常／声明 | 声明函数可能抛出错误，现代语法也可指定错误类型。 |
| `rethrows` | 异常／声明 | 声明函数仅在所调用的抛出型函数参数抛错时才可能抛错。 |
| `try` | 异常 | 标明可抛出的调用；`try?` 把失败转为可选空值，`try!` 在失败时触发运行时错误。 |
| `catch` | 异常 | 捕获错误，支持模式及条件。 |
| `as` | 类型转换 | 执行类型转换／强制类型表达；`as?` 为条件转换，`as!` 为强制转换。 |
| `is` | 类型检查 | 检查值是否满足指定类型关系。 |
| `true` | 值 | 布尔真。 |
| `false` | 值 | 布尔假。 |
| `nil` | 值 | 可选类型的无值状态。 |
| `_` | 模式／声明 | 忽略模式、省略外部参数标签等；不创建普通可引用名字。 |

### 属性、继承、运算符与所有权的上下文词

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `get`〔上下文〕 | 成员 | 定义读取访问器。 |
| `set`〔上下文〕 | 成员 | 定义写入访问器。 |
| `willSet`〔上下文〕 | 成员 | 属性存储新值之前执行观察器。 |
| `didSet`〔上下文〕 | 成员 | 属性存储新值之后执行观察器。 |
| `lazy`〔上下文〕 | 成员／资源 | 延迟到首次访问时初始化存储属性。 |
| `weak`〔上下文〕 | 生命周期 | 弱引用，不增加强引用计数，对象销毁后变为 nil。 |
| `unowned`〔上下文〕 | 生命周期 | 非拥有引用，不保持对象存活；安全形式访问已销毁对象会失败。 |
| `inout` | 参数／资源 | 将可修改参数访问传入函数，受独占访问规则约束。 |
| `borrowing` | 所有权 | 参数借用值，在调用期间使用而不获取其所有权。 |
| `consuming` | 所有权 | 参数／成员相关语法消费值，转移其所有权。 |
| `copy`〔上下文〕 | 所有权／表达式 | 显式复制支持复制的值。 |
| `consume`〔上下文〕 | 所有权／表达式 | 显式消费值，影响原绑定后续使用的有效性。 |
| `discard`〔特殊运算语法〕 | 所有权／生命周期 | `discard self` 在受限制的非复制类型消费方法中结束自身生命周期并跳过自身 deinit；不是任意值的普通释放函数。 |
| `mutating`〔上下文〕 | 成员 | 允许值类型实例方法修改自身。 |
| `nonmutating`〔上下文〕 | 成员 | 声明访问器／成员不修改值类型的自身值。 |
| `final`〔上下文〕 | 继承 | 禁止类或成员进一步继承／重写。 |
| `override`〔上下文〕 | 继承 | 声明重写父类成员。 |
| `required`〔上下文〕 | 继承 | 要求子类提供相应初始化器。 |
| `convenience`〔上下文〕 | 对象 | 声明类的便利初始化器，最终委托到指定初始化器。 |
| `indirect`〔上下文〕 | 类型／资源 | 让枚举或其变体使用间接存储，支持递归数据结构。 |
| `dynamic`〔上下文〕 | 成员／派发 | 要求支持的动态派发行为，具体机制取决于声明与互操作语境。 |
| `optional`〔上下文〕 | 成员 | 在支持的 Objective-C 协议语境中声明可选要求。 |
| `prefix`〔上下文〕 | 运算 | 前缀运算符。 |
| `postfix`〔上下文〕 | 运算 | 后缀运算符。 |
| `infix`〔上下文〕 | 运算 | 中缀运算符。 |
| `associativity`〔上下文〕 | 运算 | 在优先级组中声明结合性。 |
| `left`〔上下文〕 | 运算 | 左结合。 |
| `right`〔上下文〕 | 运算 | 右结合。 |
| `none`〔上下文〕 | 运算 | 无结合性；不要与可选值的 `.none` 混同。 |
| `precedence`〔上下文／兼容〕 | 运算 | 词法文档保留的运算符优先级相关拼写；现代代码通过 `precedencegroup` 表达优先级关系。 |
| `higherThan`〔语法字段〕 | 运算 | 优先级组声明中列出优先级低于当前组的其他组。 |
| `lowerThan`〔语法字段〕 | 运算 | 优先级组声明中列出优先级高于当前组的其他组，受跨模块引用规则限制。 |
| `assignment`〔语法字段〕 | 运算 | 优先级组中设置该组运算符是否采用赋值式的可选链分组规则。 |

### 并发及补充上下文语法

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `async`〔上下文〕 | 异步 | 声明可挂起函数、访问器等；`async let` 启动并发绑定。 |
| `await` | 异步 | 标记可能挂起的操作。 |
| `actor`〔上下文〕 | 并发／定义 | 声明隔离可变状态的 actor 类型。 |
| `isolated`〔上下文〕 | 并发 | 参数等语法中指定 actor 隔离关系，使主体在对应隔离域内使用状态。 |
| `nonisolated` | 并发 | 标记不受相应 actor 隔离限制的声明；允许的访问仍受安全检查。 |
| `distributed`〔上下文〕 | 并发 | 声明分布式 actor 或可参与远程调用的成员。 |
| `sending`〔上下文〕 | 并发／所有权 | 声明参数或结果跨隔离域转移时的约束。 |
| `nonsending`〔上下文〕 | 并发 | Swift 6.2 的 `nonisolated(nonsending)` 指定异步函数沿用调用者隔离域的相关行为。 |
| `macro`〔上下文〕 | 元编程／定义 | 声明宏，并连接到宏实现。 |

相关语义依据[声明参考](https://docs.swift.org/latest/documentation/the-swift-programming-language/declarations/)、[表达式参考](https://docs.swift.org/latest/documentation/the-swift-programming-language/expressions/)、[并发指南](https://docs.swift.org/swift-book/LanguageGuide/Concurrency.html)。`Sendable`、`Copyable`、`Int`、`String`、`Task` 等是协议或类型名称，`@MainActor`、`@escaping`、`@Sendable` 等属于属性／注解语法，不是一份全部禁止命名的关键词集合。

### 带 `#` 的公开特殊语法

所有权补充依据[非复制类型提案 SE-0390](https://github.com/swiftlang/swift-evolution/blob/main/proposals/0390-noncopyable-structs-and-enums.md)；并发补充依据[Swift 6.2 隔离行为说明](https://docs.swift.org/latest/documentation/diagnostics/nonisolated-nonsending-by-default/)。

| 语法 | 分类 | 作用 |
| --- | --- | --- |
| `#if` | 编译期 | 开始条件编译区域。 |
| `#elseif` | 编译期 | 另一编译条件。 |
| `#else` | 编译期 | 条件编译的其余分支。 |
| `#endif` | 编译期 | 结束条件编译。 |
| `#available` | 检查／控制流 | 在运行时判断平台 API 版本可用性。 |
| `#unavailable` | 检查／控制流 | 判断平台 API 版本不可用条件。 |
| `#sourceLocation` | 编译期 | 调整源文件与行号记录。 |
| `#selector` | 互操作 | 构造 Objective-C selector。 |
| `#keyPath` | 互操作 | 构造 Objective-C 兼容的属性路径字符串。 |
| `#colorLiteral` | 值／工具语法 | IDE 支持的颜色字面量。 |
| `#imageLiteral` | 值／工具语法 | IDE 支持的图像资源字面量。 |
| `#fileLiteral` | 值／工具语法 | IDE 支持的文件资源字面量。 |

`#file`、`#line`、`#function`、`#column`、`#fileID`、`#filePath`、`#dsohandle`、`#error`、`#warning` 在 Swift 5.9 起改由标准库宏实现，不宜继续算成保留关键词。条件编译中还会遇到 `os`、`arch`、`canImport` 等专用条件名称，也不等于一般保留词。

### 执行与生命周期摘要

Swift 区分普通调用、可暂停调用与独立任务；`await` 是潜在暂停点，不一定每次都暂停。Task、任务组及 executor 管理活动，actor 表达隔离而非专属线程；ARC 管理类实例引用关系，`defer` 和 `deinit` 各有退出范围。[Swift 完整分析](language-runtime-lifecycles.md#10-swift)

## 11. Kotlin

按官方的硬关键词、软关键词、修饰关键词和特殊标识符区分，再按用途归类。`as?`、`!in`、`!is` 在官方参考中与关键词一起列出，这里保留它们。[Kotlin 关键词参考](https://kotlinlang.org/docs/keyword-reference.html)

### 硬关键词及关键词式运算

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `class` | 定义 | 声明类。 |
| `interface` | 定义 | 声明接口。 |
| `object` | 定义／对象 | 定义单例对象，或通过对象表达式创建匿名对象。 |
| `fun` | 定义 | 声明函数；`fun interface` 声明函数式接口。 |
| `typealias` | 定义／类型 | 声明类型别名。 |
| `val` | 定义 | 声明只读绑定／属性；不意味着所引用对象深度不可变。 |
| `var` | 定义 | 声明可变绑定／属性。 |
| `package` | 模块 | 声明文件所属包。 |
| `this` | 对象 | 当前接收者；构造器委托中调用同类另一构造器。 |
| `super` | 继承 | 访问父类型实现；构造器中调用父类构造器。 |
| `if` | 控制流 | 条件表达式，可产生结果值。 |
| `else` | 控制流 | if 的另一分支，或 when 的默认分支。 |
| `when` | 控制流／模式 | 多分支表达式，可检查值、类型或成员关系。 |
| `for` | 控制流 | 遍历支持迭代协议的对象。 |
| `while` | 控制流 | 先判断条件的循环。 |
| `do` | 控制流 | 与 while 组合，先执行再判断。 |
| `break` | 控制流 | 退出循环，可带标签。 |
| `continue` | 控制流 | 进入下一轮循环，可带标签。 |
| `return` | 控制流 | 返回函数／匿名函数；带标签可从指定 lambda 返回，内联语境支持规定的非局部返回。 |
| `throw` | 异常 | 抛出异常，是类型为 Nothing 的表达式。 |
| `try` | 异常 | 异常处理表达式，可有结果值。 |
| `as` | 转换／模块 | 类型强制转换；也给导入项指定别名。 |
| `as?` | 类型转换 | 安全类型转换，不匹配时返回 null。 |
| `is` | 类型检查 | 检查运行时类型，满足条件后可能触发智能类型转换。 |
| `!is` | 类型检查 | 类型检查取反。 |
| `in` | 判断／遍历／泛型 | 检查成员关系，连接 for 迭代源，或声明逆变类型参数。 |
| `!in` | 判断 | 成员关系检查取反。 |
| `true` | 值 | 布尔真。 |
| `false` | 值 | 布尔假。 |
| `null` | 值 | 空值，仅可赋给允许空值的类型等适用位置。 |
| `typeof`〔保留未用〕 | 保留 | 为未来语法保留，没有当前常规功能。 |

### 软关键词与注解目标

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `import`〔上下文〕 | 模块 | 导入声明或给其设置别名。 |
| `by`〔上下文〕 | 对象／成员 | 类委托或属性委托，把实现交给其他对象。 |
| `constructor`〔上下文〕 | 对象 | 声明主构造器或次构造器。 |
| `init`〔上下文〕 | 对象 | 声明初始化代码块。 |
| `get`〔上下文〕 | 成员／注解 | 声明 getter，或指定注解应用到 getter。 |
| `set`〔上下文〕 | 成员／注解 | 声明 setter，或指定注解应用到 setter。 |
| `catch`〔上下文〕 | 异常 | 捕获某类异常。 |
| `finally`〔上下文〕 | 异常／资源 | 离开 try 时执行清理。 |
| `where`〔上下文〕 | 泛型 | 声明额外的类型参数约束。 |
| `context`〔上下文〕 | 参数／作用域 | 声明上下文参数，为函数或属性提供所需的上下文值。 |
| `dynamic`〔上下文〕 | 类型 | Kotlin/JS 动态类型，跳过常规静态成员检查。 |
| `value`〔上下文〕 | 定义 | 与 `class` 组合声明值类，也称内联类。 |
| `field`〔上下文／特殊名称〕 | 成员／注解 | 指定字段注解目标；访问器中引用后备字段；Kotlin 2.4 的稳定语法还可声明显式后备字段。 |
| `file`〔上下文〕 | 注解 | 把注解应用到文件。 |
| `property`〔上下文〕 | 注解 | 把注解应用到 Kotlin 属性本身。 |
| `param`〔上下文〕 | 注解 | 把注解应用到构造器参数等指定参数目标。 |
| `setparam`〔上下文〕 | 注解 | 把注解应用到 setter 参数。 |
| `receiver`〔上下文〕 | 注解 | 把注解应用到扩展接收者参数。 |
| `delegate`〔上下文〕 | 注解 | 把注解应用到保存委托对象的字段。 |
| `all`〔特殊注解目标〕 | 注解 | `@all:Annotation` 按适用规则把注解传播到属性相关的多个目标；这是元目标语法，不是硬保留词。 |

`all` 的传播范围和限制见[注解参考](https://kotlinlang.org/docs/annotations.html#all-meta-target)。

### 声明修饰关键词

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `public`〔上下文〕 | 可见性 | 公开，通常为默认可见性。 |
| `private`〔上下文〕 | 可见性 | 限制在包含声明的类或文件等范围。 |
| `protected`〔上下文〕 | 可见性 | 当前类及其子类访问。 |
| `internal`〔上下文〕 | 可见性 | 同模块内访问。 |
| `abstract`〔上下文〕 | 对象 | 抽象类或抽象成员。 |
| `open`〔上下文〕 | 继承 | 允许类被继承或成员被重写。 |
| `final`〔上下文〕 | 继承 | 禁止继承或重写；Kotlin 的类和成员常默认 final。 |
| `override`〔上下文〕 | 继承 | 标记实现／重写父类型成员。 |
| `sealed`〔上下文〕 | 继承 | 限制直接子类型，帮助编译器检查 when 的穷尽性。 |
| `data`〔上下文〕 | 定义 | 生成数据类的常用成员；`data object` 也提供规定的数据对象行为。 |
| `enum`〔上下文〕 | 定义 | 与 class 组合声明枚举类。 |
| `annotation`〔上下文〕 | 定义 | 与 class 组合声明注解类。 |
| `companion`〔上下文〕 | 对象 | 声明与类关联的伴生对象。 |
| `inner`〔上下文〕 | 对象 | 让嵌套类实例持有外层类实例引用。 |
| `const`〔上下文〕 | 编译期／声明 | 与 val 组合声明满足限制的编译期常量属性。 |
| `lateinit`〔上下文〕 | 声明 | 允许支持的非空属性稍后初始化；读取前未初始化会失败。 |
| `inline`〔上下文〕 | 编译期／函数 | 内联函数及允许内联的 lambda，并支持 reified 类型参数。 |
| `noinline`〔上下文〕 | 函数 | 某 lambda 参数不进行内联，允许把它按一般函数值使用。 |
| `crossinline`〔上下文〕 | 函数／控制流 | 禁止相应内联 lambda 的非局部返回，以支持其他执行位置的使用。 |
| `reified`〔上下文〕 | 泛型 | 让内联函数类型参数在调用展开后可用于某些运行时类型操作。 |
| `infix`〔上下文〕 | 运算 | 允许符合条件的函数使用中缀调用形式。 |
| `operator`〔上下文〕 | 运算 | 允许符合签名规则的函数参与运算符或约定调用。 |
| `out`〔上下文〕 | 泛型 | 声明协变类型参数或使用点的输出类型投影。 |
| `suspend`〔上下文〕 | 异步 | 声明可以挂起的函数或函数类型；不自动启动新线程或协程。 |
| `tailrec`〔上下文〕 | 编译期 | 对满足尾递归限制的函数进行迭代形式优化。 |
| `vararg`〔上下文〕 | 参数 | 声明可变数量参数。 |
| `expect`〔上下文〕 | 模块／多平台 | 声明期望各平台提供的 API。 |
| `actual`〔上下文〕 | 模块／多平台 | 声明平台对 expect API 的实际实现。 |
| `external`〔上下文〕 | 互操作 | 声明由 Kotlin 外部机制提供实现的实体，如 JNI 或 JavaScript。 |

`it` 是单参数 lambda 的隐式参数名，不是一般保留关键词；`Int`、`String`、`Unit`、`Nothing`、`Any`、`println`、`launch`、`async`、`withContext` 都是类型或库名称。`async` 在 Kotlin 中不是 JavaScript 式语言关键词。后备字段及版本情况参阅[属性](https://kotlinlang.org/docs/properties.html)、[特性状态](https://kotlinlang.org/docs/kotlin-language-features-and-proposals.html)；并发语义见[挂起函数](https://kotlinlang.org/docs/composing-suspending-functions.html)。

### 执行与生命周期摘要

Kotlin 的 `suspend` 不自行创建新协程；Continuation 与编译后的状态机保存继续关系，kotlinx.coroutines 的 Job、dispatcher 和 builder 管理活动。`launch` 等是库设施，启动模式影响首次执行；JVM、JS、Native 的执行与内存环境不能混为一个实现。[Kotlin 完整分析](language-runtime-lifecycles.md#11-kotlin)

## 12. Julia

按 Julia 1.11 文档解释。Julia 有硬保留词、两词组合，以及可作普通名字的特殊语法词／中缀运算符；`public` 从 1.11 加入。**Julia 函数的“keyword arguments”是关键字参数，不是另一份保留关键词列表。** [Julia 官方关键词说明](https://docs.julialang.org/en/v1.11/base/base/#Keywords)

### 定义、类型与绑定

| 关键词／组合 | 分类 | 作用 |
| --- | --- | --- |
| `function` | 定义 | 定义函数的方法；同一函数可拥有针对不同参数类型的多个方法，参与多重派发。 |
| `struct` | 定义／类型 | 定义复合类型，默认实例字段绑定不可重新赋值；字段引用的可变对象仍可修改。 |
| `mutable struct`〔组合〕 | 定义／资源 | 定义字段可以修改的复合类型；`mutable` 单独可作为普通名字。 |
| `abstract type`〔组合〕 | 定义／类型 | 定义不可直接实例化的抽象类型，用于类型层级和方法派发。`abstract`、`type` 单独不是硬保留词。 |
| `primitive type`〔组合〕 | 定义／类型 | 定义指定位数存储的原始类型，通常用于低层类型设计；`primitive` 单独不是硬保留词。 |
| `const` | 定义／绑定 | 声明常量绑定，便于类型稳定性与优化；绑定常量不使所指对象不可变。现代 Julia 还支持 mutable struct 的 const 字段。 |
| `local` | 作用域 | 显式声明局部绑定。 |
| `global` | 作用域 | 显式使名字引用全局绑定，而非新建局部绑定。 |
| `let` | 作用域／定义 | 创建硬局部作用域，并可创建新的局部绑定，常用于避免闭包共享同一外部绑定。 |
| `where`〔语法运算符〕 | 泛型 | 绑定类型参数及其约束，用于参数化方法或类型表达式，如 `f(x::T) where T`。 |

### 控制流与异常

| 关键词 | 分类 | 作用 |
| --- | --- | --- |
| `begin` | 控制流／分组 | 将多条表达式分组，通常返回最后表达式值；通常不创建新的局部作用域。索引中还可代表首个索引。 |
| `end` | 控制流／分组 | 结束 function、if、for、struct 等块；索引表达式中可代表该维度的最后索引。 |
| `if` | 控制流 | 条件分支，也可形成有结果值的表达式。 |
| `elseif` | 控制流 | 前面条件不满足时测试另一条件。 |
| `else` | 控制流／异常 | 条件剩余分支；try 中可在主体未抛错时执行相应分支。 |
| `for` | 控制流 | 遍历迭代对象；也用于推导式与生成器表达式，可组合多个迭代规格。 |
| `while` | 控制流 | 条件为真时重复执行。 |
| `break` | 控制流 | 退出当前循环。 |
| `continue` | 控制流 | 进入下一轮循环。 |
| `return` | 控制流 | 从函数返回值；省略值时返回 `nothing`。 |
| `do` | 函数／控制流 | 构造作为外层调用第一个参数传入的匿名函数，例如 `open(...) do io ... end`；资源释放由被调用函数的协议负责。 |
| `try` | 异常 | 开始异常处理结构，可产生结果。 |
| `catch` | 异常 | 捕获异常，可绑定异常对象。 |
| `finally` | 异常／资源 | 正常或异常离开 try 时执行清理。 |

Julia 的 `throw`、`error`、`rethrow` 是函数名称，不是关键词；与 Python、Java 等语言不同。异常的具体用法见[控制流](https://docs.julialang.org/en/v1.11/manual/control-flow/)，`do` 的函数参数语义见[函数](https://docs.julialang.org/en/v1.11/manual/functions/#Do-Block-Syntax-for-Function-Arguments)。

### 模块、可见性与元编程

| 关键词／语法词 | 分类 | 作用 |
| --- | --- | --- |
| `module` | 模块 | 定义独立的全局名字空间；通常自动引入 Base 并提供相应 eval／include 便利定义。 |
| `baremodule` | 模块 | 定义较精简的模块环境，默认引入 Core，不自动提供普通 module 的全部便利设置。 |
| `using` | 模块 | 加载模块，并按语法引入模块及其导出名称，或指定名称。 |
| `import` | 模块 | 加载模块或显式引入名字；显式导入函数后可按规定直接扩展其方法。 |
| `export` | 模块／API | 标记导出名称；常规 `using Module` 可直接使用这些名称。 |
| `public`〔上下文〕 | 模块／API | 标记公共 API，但不因常规 using 自动引入该名字；不构成私有访问封锁。 |
| `as`〔上下文〕 | 模块 | 在支持的 import／using 形式中为引入名字指定别名。 |
| `macro` | 元编程／定义 | 定义宏，在代码求值前接收语法并生成／变换表达式；调用一般写作 `@name`。 |
| `quote` | 元编程 | 把一组代码构造成表达式对象，而非立即执行；与 `$` 插值等配合。 |

`export` 和 `public` 是公共 API 的不同表达，不等同于 Java 的 `public`／`private` 访问权限体系。未导出名字通常仍可通过 `Module.name` 访问。[模块指南](https://docs.julialang.org/en/v1.11/manual/modules/)、[元编程指南](https://docs.julialang.org/en/v1.11/manual/metaprogramming/)

### 值、运算符与循环上下文词

| 关键词／语法词 | 分类 | 作用 |
| --- | --- | --- |
| `true` | 值 | Bool 真值。 |
| `false` | 值 | Bool 假值。 |
| `in`〔语法运算符〕 | 判断／遍历 | 成员关系中缀运算，也连接 for 的迭代变量和迭代源；可作为普通名字。 |
| `isa`〔语法运算符〕 | 类型检查 | 判断某值是否属于指定类型；可作为普通名字。 |
| `outer`〔上下文〕 | 作用域／循环 | 让 for 的迭代变量复用外层已有局部变量，避免通常的新迭代绑定。 |
| `var"name"`〔特殊标识符语法〕 | 名字／兼容 | 以特殊拼写引用包含特殊字符等情况的标识符；不是变量声明关键词。 |

`Int`、`Float64`、`String`、`Vector`、`Any`、`Nothing` 是类型名称；`nothing`、`missing` 是内置值名称；`include`、`eval`、`typeof`、`isa`、`throw` 等不是普通硬保留关键词，其中部分有前表所述特殊语法。`ccall`、`cglobal` 属于特殊内置调用语法，应与一般声明关键词分开。`@async`、`Threads.@spawn`、`@assert`、`@inbounds`、`@generated` 等是宏，不是关键词。作用域规则见[变量作用域](https://docs.julialang.org/en/v1.11/manual/variables-and-scoping/)。

### 执行与生命周期摘要

Julia 的顶层求值、方法定义与函数调用不同。运行时保存模块、方法与专门化表示，Task 保存可暂停活动；构造 Task 不立即执行函数体，宏或调度接口安排推进，Channel／wait 等连接等待关系。`jl_value_t` 等值表示不负责决定函数的执行时机。[Julia 完整分析](language-runtime-lifecycles.md#12-julia)

## 横向比较：哪些功能有关键词，哪些交给其他机制？

| 语言 | 定义方式举例 | 类型／泛型举例 | 模块与可见性举例 | 特别值得单独学习的类别 |
| --- | --- | --- | --- | --- |
| Python | def、class、lambda | type；许多类型是内置名称 | import、global、nonlocal | 上下文管理、生成器、软模式词 |
| JavaScript | let、const、function、class | typeof、instanceof；无 TS 式类型声明 | import、export | 原型、异步、资源管理 |
| TypeScript | interface、type、enum | keyof、infer、satisfies | namespace、declare、public | 编译期类型运算与运行时行为的区别 |
| Java | class、interface、record | 基础类型、extends、super | package、module、exports | 访问控制、异常、监视器同步 |
| C | struct、union、typedef | 基础类型、_Generic、typeof | extern、static；无标准模块关键词 | 存储期、指针别名、原子访问 |
| C++ | class、struct、template | concept、requires、decltype | namespace、module、import | 对象生命周期、编译期求值、协程 |
| C# | class、struct、record | where、dynamic、unmanaged | namespace、using、internal | 引用安全、异步、LINQ 查询 |
| Go | var、type、func | interface；基础类型是预声明名 | package、import；大写名称导出 | goroutine、通道、defer |
| Rust | let、fn、trait、impl | dyn、where、Self | mod、use、pub | 移动、借用、生命周期、不安全契约 |
| Swift | let、var、func、protocol | some、any、associatedtype | import、internal、package、open | 值／引用语义、所有权、actor 隔离 |
| Kotlin | val、var、fun、object | where、reified、in、out | package、import、internal | 委托、内联、挂起函数、平台实现 |
| Julia | function、struct、macro | where、abstract type | module、using、public、export | 多重派发、表达式对象、宏、作用域 |

学习建议：先掌握“定义—类型—控制流—模块”这四个基础维度，再按语言补上异常、资源、并发与元编程。**一个功能没有关键词，不表示语言没有该功能**：例如 Julia 并发常通过宏与函数表达；Go 的基础类型是预声明名称；Rust 的错误处理主要通过库类型与运算符表达。

[返回目录](../README.md)