Endorphin-Document/appendices/language-keywords.md

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

本文是其他语言的学习与比较参考。Endorphin 的词法与语法标记定义见词法结构，设计状态见规范状态。

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

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

分类框架

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

分类	回答的问题	例子
定义与声明	定义什么变量、函数、数据结构？	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 四个软关键词。词法参考

定义、作用域与模块

关键词	分类	作用
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 只是实例方法首个参数的常见命名约定。更详细的语义见简单语句、复合语句、表达式。

执行与生命周期摘要

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

2. JavaScript

下面区分正式保留词、严格模式或特定语境下受限制的词，以及语法中使用的上下文词。JavaScript 允许对象属性名使用许多保留词，因此“不能用作变量名”不等于“不能出现在任何名字位置”。基线见 ECMAScript 2026 词法规范。

声明、对象与模块

关键词	分类	作用
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 显式资源管理语法；普通语句见声明规范，对象与函数见函数和类规范。

执行与生命周期摘要

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

3. TypeScript

TypeScript 继承上一节 JavaScript 的关键词与运行时行为。下面逐项列出新增词，以及在 TypeScript 中获得新增含义的词；完整集合按“JavaScript 全表 + 本表”阅读，不要把这里当成独立的 JavaScript 替代列表。很多 TypeScript 词是上下文语法，不能简单说全部都禁止作变量名。基线为 5.9 的编译器词法项及类型手册。

关键词／语法词	分类	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 等是类型或库名称，不是新增关键词。进一步参阅类型操作、类、5.9 发布说明。

执行与生命周期摘要

TypeScript 通常由工具处理为 JavaScript，再采用目标宿主的执行模型。类型信息与生成的运行时代码分别存续；type、interface 等通常擦除，普通 enum、namespace 则可能生成代码。TSX 转换不等于 React 已经执行，React 再组织组件、更新和清理。TypeScript 完整分析 · React 构建与运行

4. Java

Java SE 26 的词法表包括 51 个保留关键词和 17 个上下文关键词；true、false、null 在规范中属于字面量，下面另行列出。Java 词法规范

声明、类型与对象

关键词	分类	作用
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 不是关键词。深入语义见类型与类、语句、包与模块。

执行与生命周期摘要

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

5. C

C23 增加或标准化了 constexpr、typeof、nullptr 等拼写。这里同时解释仍被保留的旧拼写，避免将 C17 时代的宏与 C23 关键词混为一谈。参考 WG14 的 C23 草案 N3096，§6.4.1。

声明、类型、限定与存储

关键词	分类	作用
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 完整分析 · 普通进程路径

6. C++

基线为 C++23；不把 C++26 草案中的新增关键词混入。C++ 与 C 是两门语言，不能直接把 C23 的全部新增词复制到 C++。词法基线见 WG21 C++23 草案源码 n4950。

基础类型、定义与泛型

关键词	分类	作用
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]] 等是属性，不是新增保留关键词。按固定版本查阅声明草案、表达式草案、语句草案。

执行与生命周期摘要

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

7. C#

以 C#14 为主；Microsoft 的关键词参考同时包含下一版预览，因此把 closed、safe 分开放在末尾。C# 上下文关键词包括 LINQ 查询词、模式词、属性访问器词等。官方关键词表

定义、基础类型与泛型

关键词	分类	作用
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 参考与不安全代码参考，不属于本节 C#14 基线。Console、Task、List、Span 是库名称；#if、#nullable 等为指令。成员语义见属性、扩展成员、查询关键词。

执行与生命周期摘要

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

8. Go

Go 的正式关键词只有 25 个。内置类型与很多核心操作采用“预声明标识符”，这使得它的关键词列表较短。Go 官方规范

关键词	分类	作用
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，常规错误处理主要通过返回值。详细区分见预声明标识符。

执行与生命周期摘要

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

9. Rust

按 Rust 2024 edition 与稳定语言参考解释。Rust 的官方词法分类是 strict、reserved、weak；这与本文按功能划分是两个不同维度。Rust 关键词参考

定义、类型、模块与泛型

关键词	分类	作用
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 类型系统、表达式、外部块。

执行与生命周期摘要

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

10. Swift

Swift 的关键词参考既列出保留词，也列出仅特定位置有意义的词；现代并发和泛型语法还有文档各章节中定义的上下文词。这里列出公开语法，不列编译器内部以下划线开头的实现词。基线见词法结构。

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

关键词	分类	作用
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〔上下文〕	元编程／定义	声明宏，并连接到宏实现。

相关语义依据声明参考、表达式参考、并发指南。Sendable、Copyable、Int、String、Task 等是协议或类型名称，@MainActor、@escaping、@Sendable 等属于属性／注解语法，不是一份全部禁止命名的关键词集合。

带 # 的公开特殊语法

所有权补充依据非复制类型提案 SE-0390；并发补充依据Swift 6.2 隔离行为说明。

语法	分类	作用
#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 完整分析

11. Kotlin

按官方的硬关键词、软关键词、修饰关键词和特殊标识符区分，再按用途归类。as?、!in、!is 在官方参考中与关键词一起列出，这里保留它们。Kotlin 关键词参考

硬关键词及关键词式运算

关键词	分类	作用
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 的传播范围和限制见注解参考。

声明修饰关键词

关键词	分类	作用
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 式语言关键词。后备字段及版本情况参阅属性、特性状态；并发语义见挂起函数。

执行与生命周期摘要

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

12. Julia

按 Julia 1.11 文档解释。Julia 有硬保留词、两词组合，以及可作普通名字的特殊语法词／中缀运算符；public 从 1.11 加入。Julia 函数的“keyword arguments”是关键字参数，不是另一份保留关键词列表。 Julia 官方关键词说明

定义、类型与绑定

关键词／组合	分类	作用
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 等语言不同。异常的具体用法见控制流，do 的函数参数语义见函数。

模块、可见性与元编程

关键词／语法词	分类	作用
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 访问。模块指南、元编程指南

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

关键词／语法词	分类	作用
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 等是宏，不是关键词。作用域规则见变量作用域。

执行与生命周期摘要

Julia 的顶层求值、方法定义与函数调用不同。运行时保存模块、方法与专门化表示，Task 保存可暂停活动；构造 Task 不立即执行函数体，宏或调度接口安排推进，Channel／wait 等连接等待关系。jl_value_t 等值表示不负责决定函数的执行时机。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 的错误处理主要通过库类型与运算符表达。

返回目录