1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

protocol Drawable { func draw() }          // protocol / func

struct Circle: Drawable {
    let r: Double                           // let
    lazy var cached: Double = r * 2          // lazy 是上下文关键字
    func draw() { }
}

final class Shape {                        // final 是上下文关键字
    weak var parent: Shape?                 // weak 也是
    deinit { }
}

enum Result { case ok, failed }
for i in 0..<3 where i > 0 { print(i) }     // for / where / in

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package main                                // package / import
import "fmt"

type Counter struct{ n int }                 // type / struct

func (c *Counter) Inc() { c.n++ }            // func

func main() {
    var c Counter                            // var
    const limit = 3                          // const
    for i := 0; i < limit; i++ {             // for
        switch {                             // switch
        case i == 0:
            continue                         // continue
        default:
            defer fmt.Println("done")        // defer
            go c.Inc()                       // go
            select {}                        // select
        }
        break                                // break
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import asyncio
from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

async def fetch(points):
    async with asyncio.TaskGroup() as tg:      # async / with
        for p in points:
            tg.create_task(handle(p))

def classify(value):
    match value:                               # match 是软关键字
        case int() as n if n > 0:              # case / as / if
            return "positive"
        case _:
            return "other"

try:
    assert classify(1) is not None
except AssertionError as e:
    raise RuntimeError from e

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package demo                              // package

import kotlin.math.PI                     // import

sealed interface Shape                    // sealed / interface
data class Circle(val r: Double) : Shape  // data / class / val
data object Empty : Shape                 // object

inline fun <reified T> nameOf(x: T): String = T::class.simpleName ?: "?"

fun area(s: Shape): Double = when (s) {    // fun / when / is
    is Circle -> PI * s.r * s.r
    Empty -> 0.0
}

fun main() {
    val list = listOf(Circle(1.0), Empty)
    for (s in list) {                      // for / in
        if (s !is Empty) println(area(s))   // if / !is
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package demo;                                  // package
import java.util.List;                         // import

public sealed interface Shape permits Circle { }   // public / sealed / interface / permits
record Circle(double r) implements Shape { }        // record / implements

public class Demo {
    public static void main(String[] args) {
        var list = List.of(new Circle(1.0));        // var 是上下文关键字
        for (var s : list) {                       // for
            switch (s) {                           // switch
                case Circle c when c.r() > 0 ->    // case / when（21+）
                    System.out.println(Math.PI * c.r() * c.r());
                default -> System.out.println("?");
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <concepts>
#include <cstdint>
#include <string>

template <typename T> concept Addable = requires(T a, T b) { a + b; };   // template/concept/requires

class Counter {                                     // class
public:                                             // public
    explicit Counter(int start) noexcept : n_{start} {}   // explicit/noexcept
    virtual ~Counter() = default;                   // virtual
    constexpr int get() const { return n_; }        // constexpr/const
private:                                            // private
    int n_{};
};

static_assert(Addable<int>);                        // static_assert

int main() {
    auto c = Counter{1};                            // auto
    if (c.get() > 0) { c = Counter{2}; }            // if/else
    while (false) { break; }                        // while/break/false
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdbool.h>
#include <stddef.h>

typedef struct { int x, y; } point_t;      /* typedef / struct */

static inline int area(point_t p) {        /* static / inline */
    return p.x * p.y;
}

int main(void) {
    constexpr int limit = 3;                /* C23: constexpr */
    typeof(limit) i = 0;                    /* C23: typeof */
    for (i = 0; i < limit; i++) {           /* for */
        if (i == 0) continue;               /* if / continue */
        else break;                         /* else / break */
    }
    bool ok = true;                         /* C23: bool / true */
    void *p = nullptr;                      /* C23: nullptr */
    _Static_assert(sizeof(point_t) >= 8, "size");   /* 旧拼写仍然有效 */
    return ok && p == NULL ? 1 : 0;         /* return / && */
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

module Demo                                  # module
export area                                  # export

abstract type Shape end                      # abstract / type

mutable struct Circle <: Shape               # mutable / struct
    r::Float64
end

area(c::Circle) = π * c.r^2                  # 函数定义（无 function 关键字）

function describe(s::Shape)                  # function
    if s isa Circle                          # if / isa（运算符）
        return "circle"
    elseif s isa Nothing
        return "none"
    else
        error("unknown")
    end
end

let c = Circle(1.0)                          # let
    try
        println(describe(c))
    catch err                                  # catch
        println(err)
    finally
        println("done")                        # finally
    end
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

namespace Demo;                                  // namespace

public abstract record Shape;                    // public / abstract / record
public sealed record Circle(double R) : Shape;   // sealed

public class Demo
{
    public static string Describe(Shape s) => s switch   // switch
    {
        Circle { R: > 0 } c => $"circle {c.R}",      // when 也可以写在这里
        _ => "unknown",
    };

    public static void Main()
    {
        var shapes = new[] { new Circle(1.0) };      // var 是上下文关键字
        foreach (var s in shapes)                    // foreach / in
        {
            checked                                    // checked
            {
                if (s is Circle c) Console.WriteLine(Describe(c));   // if / is
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

import 'dart:async';                     // import

mixin Drawable {                         // mixin
  void draw() => print('draw');
}

sealed class Shape with Drawable { }     // sealed（unrestricted）/ with
final class Circle extends Shape {       // final / extends
  final double r;
  const Circle(this.r);                  // const
}

Future<void> main() async {              // async（unrestricted）
  var shapes = <Shape>[Circle(1.0)];     // var
  for (final s in shapes) {              // for / in
    if (s is Circle) {                   // if / is
      print(s.r);
    } else if (s case Circle(r: var r)) { // 模式匹配里的 case
      print(r);
    }
  }
  await Future<void>.delayed(Duration.zero);   // await（context）
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

add <- function(a, b = 1) a + b          # function

describe <- function(x) {
  if (is.na(x)) {                        # if / is.na
    "missing"
  } else if (is.infinite(x)) {           # else / Inf 判断
    "infinite"
  } else {
    repeat {                             # repeat
      break                              # break
    }
    "value"
  }
}

for (i in 1:3) next                      # for / in / next

vals <- c(1, NA_integer_, Inf, NaN)      # NA_integer_ / Inf / NaN
stopifnot(TRUE, !FALSE, is.null(NULL))   # TRUE / FALSE / NULL

f <- function(...) sum(...)              # 特殊记号 ...
f(1, 2, 3)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

const std = @import("std");                     // const

const Direction = enum { north, south };         // enum

const Shape = union(enum) {                      // union(enum)
    circle: f64,
    rect: struct { w: f64, h: f64 },             // struct
};

pub fn area(s: Shape) f64 {                      // pub / fn
    return switch (s) {                           // switch
        .circle => |r| std.math.pi * r * r,
        .rect => |r| r.w * r.h,
    };
}

pub fn main() !void {                             // !void
    var i: u8 = 0;                                // var
    while (i < 3) : (i += 1) {                    // while
        if (i == 1) continue;                     // if / continue
        defer std.debug.print("i={d}\n", .{i});    // defer
    }
    const s = Shape{ .circle = 1.0 };
    std.debug.print("{d}\n", .{area(s)});
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

local function classify(v)              -- local / function
  if v == nil then                      -- if / nil
    return "nil"
  elseif v == false or v == 0 then      -- elseif / false / or
    return "falsey-ish"
  else
    return "other"
  end
end

global counter = 0                      -- Lua 5.5：显式声明全局变量

for i = 1, 3 do                         -- for / do
  if i == 2 then goto continue end      -- goto
  repeat                                -- repeat
    counter = counter + 1
  until counter % 2 == 0                -- until
  ::continue::                          -- 标签
end

while true do break end                 -- while / true / break
print(classify(counter), and)           -- 报错：and 不能当表达式

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import type { Shape } from "./shapes";          // import / type / from

declare const VERSION: string;                   // declare / const

namespace Geometry {                              // namespace
  export type Point = { x: number; y: number };    // export / type
  export interface Named { name: string }          // interface
  export class Circle implements Named {            // class / implements
    constructor(public name: string, public r: number) {}   // constructor / public
    get area(): number {                            // get
      return Math.PI * this.r ** 2;
    }
  }
}

function describe(s: Shape): string {
  if (s.kind === "circle") return `${s.r}`;        // if / return
  switch (s.kind) {                                 // switch / case
    case "rect": return `${s.w * s.h}`;
    default: return "?";
  }
}

const p = { x: 1, y: 2 } satisfies Geometry.Point;  // satisfies
type Keys = keyof Geometry.Point;                   // keyof

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import { readFile } from "node:fs/promises";     // import / from

class Counter {                                   // class
  static count = 0;                                // static（严格模式保留，但这里是合法用法）
  #value = 0;                                      // 私有字段
  constructor(start = 0) { this.#value = start; }   // constructor / this
  get value() { return this.#value; }               // get / return
  async load(path) {                                // async（不是保留字）
    const text = await readFile(path, "utf8");       // await（模块里保留字）/ const
    for (const line of text.split("\n")) {            // for / of
      if (line.trim()) this.#value += line.length;    // if / this
    }
    return this.#value;
  }
}

const obj = { class: "ok", if: 1, super: 2 };     // 保留字当属性名完全合法
console.log(obj.class, typeof obj.if);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php
declare(strict_types=1);                        // declare

namespace Demo;                                  // namespace

enum Status: string {                            // enum
    case Ok = 'ok';
    case Failed = 'failed';
}

readonly class Point {                           // readonly / class
    public function __construct(
        public readonly int $x = 0,
        public readonly int $y = 0,
    ) {}

    public function label(): string {             // public / function / return
        return match (true) {                      // match
            $this->x > 0 => 'right',
            default => 'other',
        };
    }
}

$p = new Point(1, 2);                            // new
foreach ([$p] as $item) {                        // foreach / as
    if ($item instanceof Point) {                 // if / instanceof
        echo $item->label();                      // echo
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

module Drawable                              # module
  def draw = "shape"                          # def
end

class Circle                                 # class
  include Drawable
  attr_reader :r
  def initialize(r) = @r = r                 # 3.0+ 无尽方法
  def valid? = r.positive?
end

def classify(x)                              # def
  case x                                     # case
  when nil then "nil"                        # when / nil
  when Integer then "int"
  in [Integer => n, *rest] then "array #{n}"  # in（3.0+ 模式匹配）
  else "other"                               # else
  end
end

begin                                        # begin
  raise ArgumentError, "bad" unless true      # raise / unless / true
rescue ArgumentError => e                     # rescue
  puts e.message
ensure                                        # ensure
  puts __method__                             # 特殊记号
end

puts classify(1) if defined?(classify)        # if / defined?

1
2
3
4
5
6
7
8

let `class` = 1          // 反引号：把关键字当标识符
print(`class`)

let final = 2            // final 是上下文关键字，本来就可以当名字
let lazy = 3
let some = 4

struct S { let `default` = 5 }   // 成员名也能这么写

1
2
3
4
5
6
7
8
9

// Go 没有软关键字，25 个关键字一律不能当标识符
// var if = 1        // 🛑 编译错误

func f() {
    int := 3         // ✅ 合法但危险：遮蔽了预声明类型名 int
    len := func() {} // ✅ 合法：len 不是关键字，只是内建函数
    _ = int
    _ = len
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

match = 1          # match 是软关键字，可以当变量
case = 2
type = 3           # type 也是软关键字
_ = 4

match match:       # 第一个 match 是语句，第二个是变量
    case 1:
        print("one")

type Alias = int   # 在语句开头，type 才被当成类型别名语法（3.12+）

1
2
3
4
5
6
7

val by = 1        // by 是软关键字
val get = 2
val data = 3      // data 是修饰符关键字，只在 class/data class 里生效
val `is` = 4      // 硬关键字要用反引号
println(`is`)

// val class = 5  // 🛑 class 是硬关键字

1
2
3
4
5
6

var var = 1;              // ✅ var 是上下文关键字，可以当变量名
int record = 2;           // ✅ record 也是
String sealed = "x";      // ✅ sealed 也是

// int class = 3;         // 🛑 class 是保留关键字
// int _ = 4;             // 🛑 _ 在 Java 22 之后不能当变量名

1
2
3
4
5
6

int final = 1;        // ✅ final 是上下文关键字（只在类/虚函数声明里生效）
int override = 2;     // ✅ 老代码里很常见
int import = 3;       // ✅ C++20 的模块关键字也是上下文相关的

// int class = 4;     // 🛑 class 是关键字
auto and_ = true and false;   // and / or / not 是替代记号（关键字）

1
2
3
4
5
6
7

/* C 没有软关键字：C23 的 44 个关键字一律不能当标识符 */
// int class = 1;        /* 不可移植：GCC 把 class 当扩展关键字 */
int typeof_x = 1;        /* 避开 C23 新增的 typeof */

/* 实现保留的标识符也不能乱用 */
// int _Foo = 1;         /* 下划线 + 大写：实现保留 */
// int __bar = 2;        /* 双下划线开头：实现保留 */

1
2
3
4
5
6
7
8

public = 1          # ✅ public 是上下文关键字（1.11+），可以当变量
mutable = 2         # ✅ 只在 mutable struct 里才特殊
where = 3           # ✅ 只在类型参数位置才特殊

in = 4              # ✅ in 是运算符，不是关键字
isa = 5             # ✅ 同上

# if = 6            # 🛑 if 是保留字

1
2
3
4
5
6
7

int var = 1;                 // ✅ var 是上下文关键字
string record = "x";          // ✅ record 也是
int when = 2;                 // ✅ when 也是

int @class = 3;               // ✅ 用 @ 前缀把保留字当标识符
Console.WriteLine(@class);
// int class = 4;             // 🛑 class 是保留关键字

1
2
3
4
5
6

var sealed = 1;      // ✅ sealed 属于 unrestricted 档
var when = 2;        // ✅ 同上
var late = 3;        // ✅ late 是 built-in identifier：不能当类型名，但能当变量名

// var class = 4;     // 🛑 reserved
// var await = 5;     // ⚠️ 在 async 函数体里，await 是 context 关键字

1
2
3
4
5
6
7
8

`if` <- 1            # 用反引号把保留字当变量名（合法但别这么写）
print(`if`)

for (i in 1:3) print(i)     # for / in 是保留字

x <- 1
x$if <- 2                    # 作为列表元素名（字段名）合法
names(x)

1
2
3
4
5
6
7
8

const @"if" = 1;             // @"..." 把关键字变成标识符
const @"align" = 2;

const S = struct {
    @"type": u8 = 0,          // 字段名同样支持
};

const x: u8 = S{}.@"type";

1
2
3
4
5
6
7
8
9

-- Lua 没有软关键字；23 个保留字不能当变量名
-- local if = 1        -- 🛑 语法错误

local t = {}
t.end = 1                 -- ✅ 字段名不受限
t["function"] = 2
print(t.end, t["function"])

local End = 3             -- ✅ 大小写敏感：End 不是保留字

1
2
3
4
5
6
7

const type = 1;        // ✅ type 是上下文关键字
const as = 2;          // ✅ as 只在断言/导入别名位置才特殊
const namespace = 3;   // ✅ 同上
const satisfies = 4;   // ✅ satisfies 只在类型位置特殊

// const enum = 5;     // 🛑 enum 是 JS 保留字
const obj = { class: 1, if: 2, delete: 3 };   // ✅ 属性名不受限

1
2
3
4
5
6
7
8
9

// 普通保留字不能当变量名
// const class = 1;          // 🛑

const obj = { class: 1, if: 2, delete: 3 };   // ✅ 属性名可以
obj.class;

// let / static / yield / await 视上下文而定
function f() { "use strict"; /* let x = 1; 合法 */ }
async function g() { /* await 在这里是关键字 */ }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 关键字不能当函数名/类名，但可以是方法名、属性名、常量名
class Demo {
    public const DEFAULT = 1;        // ✅ 常量名
    public function list(): array {  // ✅ 方法名用关键字
        return [];
    }
}

$d = new Demo();
echo $d->list()[0] ?? '';

// function class() {}             // 🛑 class 不能当函数名
// class if {}                     // 🛑

1
2
3
4
5
6
7
8
9

# 关键字不能当局部变量名
# if = 1          # 🛑 语法错误

obj = Object.new
obj.class            # ✅ class 作为方法名（Object#class）完全合法
obj.send(:if) rescue nil   # ✅ 反射调用

h = { if: 1, class: 2 }     # ✅ 哈希键（符号）不受限
h[:if]

1
2
3

// Swift 5.9 之前 #file 是保留记号，现在它只是一个宏：
let file = #file          // 仍然能用，但实现方式变了
let path = #filePath       // 也是宏

1
2

func min(a, b int) int { return a }   // 仍然合法：遮蔽了内建 min
var x = min(1, 2)

1
2
3
4
5

match = 1        # 老代码照常运行
type = 2
case = 3
_ = 4
print(match, type, case, _)

1
2

// val typeof = 1     // 🛑 编译错误：typeof 是硬关键字
val `typeof` = 1      // ✅ 反引号可以绕开

1
2
3

// int const = 1;        // 🛑 保留关键字
// int goto = 2;         // 🛑 保留关键字
int _ = 3;                // ⚠️ Java 21 及以前可以（有警告），Java 22+ 不行

1
2

export module demo;        // C++20：export/module 成了真语法
// atomic_cancel { }       // TM TS：主流编译器不支持

1
2
3

// _Decimal64 x = 0.1;      /* 大多数编译器不支持 */
[[noreturn]] void die(void);
// int _Foo;                /* 实现保留：自己别用 */

1
2
3
4
5
6
7
8

# 0.6 的写法（现在会报错）
# type Point; x::Int; end

struct Point            # ✅ 现在的写法
    x::Int
end

type = 1                # ✅ type 现在是普通名字