GDScript 支持参考

GDCC 支持强类型和弱类型混合编写。可以给属性、局部变量、参数和返回值写显式类型，也可以省略类型让它们落到 Variant。Variant 表示运行时动态值，适合渐进迁移；显式类型适合让编译器尽早检查赋值、调用参数和返回值。

var typed_score: int = 10
var dynamic_payload

func mix(value, count: int) -> Variant:
    var local := count + 1
    dynamic_payload = value
    return local

类型系统

动态类型

支持 Variant。以下位置省略类型时通常按 Variant 处理：

函数参数。
函数返回值。
类属性。
部分局部变量。

func echo(value):
    return value

func reopen(seed: Variant) -> int:
    return int(seed)

支持的 Variant 边界：

具体类型赋给 Variant。
Variant 赋给具体目标类型。
Variant 作为动态调用目标来调用方法。
Variant 返回值赋给显式类型变量。

内建类型

支持以下类型标注：

类型组	支持类型
空值/动态/无返回	`Nil`、`null`、`Variant`、`void`、`Void`
标量	`bool`、`int`、`float`
字符串类	`String`、`StringName`、`NodePath`
几何/数学	`Vector2`、`Vector2i`、`Vector3`、`Vector3i`、`Vector4`、`Vector4i`、`Rect2`、`Rect2i`、`Transform2D`、`Transform3D`、`Plane`、`Quaternion`、`AABB`、`Basis`、`Projection`、`Color`
句柄/可调用	`RID`、`Callable`、`Signal`
容器	`Array`、`Dictionary`
PackedArray	`PackedByteArray`、`PackedInt32Array`、`PackedInt64Array`、`PackedFloat32Array`、`PackedFloat64Array`、`PackedStringArray`、`PackedVector2Array`、`PackedVector3Array`、`PackedVector4Array`、`PackedColorArray`
对象	`Object`、Godot 引擎类、GDCC 脚本类、词法可见内部类

类型化容器

支持 Array[T] 和 Dictionary[K, V]。

var nodes: Array[Node]
var workers: Array[Worker]
var payloads: Dictionary[StringName, Node]

支持规则：

Array 是普通动态数组。
Dictionary 是普通动态字典。
Array[T] 的 T 必须是可解析叶子类型。
Dictionary[K, V] 的 K 和 V 必须是可解析叶子类型。
Array[Array] 这类叶子为裸容器名的写法可用。

枚举

支持匿名枚举和命名枚举。

enum { MODE_IDLE, MODE_RUNNING }
enum State { IDLE, JUMP = 5, FALL }

func current_state() -> State:
    return State.JUMP

func state_values() -> Array:
    return State.values()

支持：

匿名枚举成员可直接用名字访问，类型为 int。
命名枚举通过 State.IDLE 访问成员。
命名枚举本身在值位置是一个 Dictionary，可调用 keys()、values()。
命名枚举可作类型标注，例如 var state: State、Array[State]，实际按 int 处理。
支持跨类访问，例如 Other.State.IDLE、Other.IDLE。
枚举成员值可使用整数常量表达式，包括 +、-、*、/、%、移位和位运算。
成员值可引用同一枚举中前面的成员，以及同一类中先前声明的枚举常量。

限制：

enum 只能声明在类体或内部类体中，不能写在函数体内。
成员值不能调用函数、访问属性、使用三元表达式或 **。
成员值不能引用父类声明的枚举常量。
命名枚举不是独立的运行时类型，不要依赖不同枚举之间的类型区分。

当前支持的类型兼容

Source	Target	状态
同类型	同类型	支持
`int`	`float`	支持
`Vector2i` / `Vector3i` / `Vector4i`	同维度 `Vector2` / `Vector3` / `Vector4`	支持
`String`	`StringName`	支持
`StringName`	`String`	支持
任意稳定类型	`Variant`	支持
`Variant`	具体类型	支持
对象子类	对象父类	支持
`null`	对象类型	支持
`Array[Child]`	`Array[Parent]`	有限支持
`Dictionary[K1, V1]`	`Dictionary[K2, V2]`	有限支持

int -> float 适用于需要 float 的显式类型位置，包括赋值、属性初始化、调用参数、返回值、内建构造函数的 float 参数，以及 Dictionary[float, V] 的 key。

同维度整数向量到浮点向量的规则也只在明确需要目标向量类型的位置生效，包括赋值、属性初始化、调用参数、返回值、内建构造函数、Dictionary[Vector3, V] 这类 key，以及 Dictionary[K, Vector3] 这类 value。通过 Godot 动态调用编译脚本时，也允许把 int 传给 float 参数，或把同维度整数向量传给浮点向量参数；对外显示的参数类型仍然是声明的目标类型。

String 与 StringName 在需要其中一种显式类型的位置可以互相转换，包括赋值、属性初始化、调用参数、返回值，以及 Dictionary[StringName, V] 和 Dictionary[String, V] 这类 key。通过 Godot 动态调用编译脚本时，Variant 入站包装也会把 String 传给 StringName 参数，反之亦然。

var ratio: float = 1
var offset: Vector3 = Vector3i(1, 2, 3)
var ready_name: StringName = "ready"

func take_float(value: float) -> float:
    return value

func take_vector(value: Vector3) -> float:
    return value.x + value.y + value.z

func take_name(value: StringName) -> StringName:
    return value

func compute(scores: Dictionary[float, int], vectors: Dictionary[Vector3, int], names: Dictionary[StringName, int]) -> float:
    scores[2] = 7
    vectors[Vector3i(1, 2, 3)] = 9
    names["ready"] = 1
    return take_float(3) + take_vector(Vector3i(4, 5, 6)) + take_name(ready_name) + names[&"ready"]

常见不支持转换：

float -> int。
bool -> int。
bool -> float。
String -> NodePath、NodePath -> String、NodePath -> StringName。
Vector2 -> Vector2i、Vector3 -> Vector3i、Vector4 -> Vector4i。
维度不匹配的向量转换，例如 Vector2i -> Vector3。
Rect2i -> Rect2、Rect2 -> Rect2i。
Array[int] -> Array[float]。
Array[Vector3i] -> Array[Vector3]。
Dictionary[int, V] -> Dictionary[float, V]。
Dictionary[Vector3i, V] -> Dictionary[Vector3, V]。
枚举作为独立的运行时类型参与兼容判断。

文件和类

顶层脚本类

每个 .gd 文件对应一个顶层脚本类。

class_name Player
extends Node

var hp: int = 100

支持写法：

class_name Player
class_name Player extends Node
单独顶层 extends Node
省略 class_name，类名从文件名推导。
省略 extends，默认父类为 RefCounted。

不支持写法：

extends "res://player_base.gd"
解释器按路径加载的父类绑定。
autoload 父类绑定。
跨模块父类绑定。
复杂父类表达式。
把 GDCC 脚本直接挂到已有节点上；需要把节点类型改为对应的 GDCC 类。

内部类

支持内部类和多层内部类。

class_name Outer
extends Node

class Worker extends RefCounted:
    var value: int

    func read_value() -> int:
        return value

func make_worker() -> Worker:
    return Worker.new()

支持写法：

class Worker:
class Worker extends RefCounted:
内部类继续包含内部类。
内部类作为类型标注使用。
内部类声明属性、信号、函数和静态函数。

静态变量

支持脚本类的 static var。

class_name Counter
extends RefCounted

static var total: int = 0
static var labels: Array[String] = []

static func add(amount: int) -> void:
    total += amount

支持：

类内裸标识符读写，例如 total。
Counter.total 限定读写。
通过实例访问 self.total、obj.total，操作的是声明类的共享存储；这种写法会产生警告。
子类访问父类 static var 时共享同一份存储。
内部类中的 static var。
static var 初始化器访问其他静态成员、全局常量、singleton 和已支持的调用。

限制：

@export、@onready 不能用于 static var。
不支持 static setter/getter。
不会自动调用 _static_init()。

继承、多态与 super

GDCC 脚本类可以继承任意引擎类或其他 GDExtension 提供的类，也可以继承同一模块内的其他 GDCC 脚本类。子类可以用相同签名覆盖父类实例方法，通过父类类型的引用调用时会分派到子类实现。

class_name Army
extends Node

class Unit extends RefCounted:
    func describe() -> String:
        return "unit"

class Soldier extends Unit:
    func describe() -> String:
        return "soldier:" + super.describe()

func describe_unit(unit: Unit) -> String:
    return unit.describe()

支持：

继承引擎类和其他 GDExtension 提供的类。
同一模块内 GDCC 类之间的继承。
相同签名的实例方法覆盖与多态调用；参数个数、参数类型和返回类型必须一致。
super.method(...) 调用父类实现。
裸 super(...) 调用父类同名方法。
lambda 内使用 super.method(...)，会隐式捕获当前实例。
引擎虚函数覆盖，见下文。

限制：

跨模块 GDCC 父类不支持。
super.property 和 super[index] 不支持。
显式 super(...) 构造调用和 super._init(...) 不支持；父类 _init 会由 GDCC 自动链式调用。
裸 super(...) 不能用在 lambda 内；lambda 内请使用 super.method(...)。
静态函数内不能使用 super。
不支持 final 或禁止覆盖语义。

注解

支持脚本级 @tool、@export 家族和 @onready。

@tool
class_name EditorProbe
extends Node

@export var speed: float = 1.0
@export_range(0, 100, 1) var health: int = 100
@export_enum("Warrior", "Mage") var job: int = 0
@export_file("*.png") var icon_path: String
@onready var target: Node

`@export` 家族

支持：

@export
@export_range
@export_enum
@export_flags
@export_flags_2d_render、@export_flags_2d_physics、@export_flags_2d_navigation
@export_flags_3d_render、@export_flags_3d_physics、@export_flags_3d_navigation
@export_flags_avoidance
@export_file、@export_file_path、@export_dir
@export_global_file、@export_global_dir
@export_multiline、@export_placeholder
@export_exp_easing
@export_color_no_alpha
@export_node_path

规则：

只能用于类属性 var，不能用于 static var。
注解参数只接受字面量，不接受常量名或运算表达式。
各 @export_* 变体对属性类型有要求，例如 @export_range 用于 int/float，@export_file 用于 String，@export_color_no_alpha 用于 Color，@export_node_path 用于 NodePath。
裸 @export 可用于内建类型、Resource、Node 和脚本枚举。导出 Node 派生类型时，所在类必须继承 Node。
用命名枚举作属性类型时，裸 @export 会生成编辑器枚举下拉。
容器属性不要叠加 @export_* 变体。

`@tool`

只能写在脚本顶部，位于 extends 和 class_name 之前。
不接受参数。
@tool 会传播到该脚本的顶层类和内部类。
非 @tool 类的 _process、_physics_process 在编辑器内不会执行；其他回调仍会执行。运行时不受影响。

`@onready`

只能用于类属性 var。
不能用于 static var。
owner 类必须继承 Node。

成员声明

属性

var score: int = 0
var payload: Variant
var values: Array[int]
var worker: Worker = Worker.new()

支持写法：

var name
var name = value
var name: Type
var name: Type = value
var name := value
@export var name: Type
@onready var name: Type
static var name: Type
static var name: Type = value

注意事项：

属性建议写显式类型。
未写显式类型的属性按 Variant 处理。
:= 属性当前也会作为 Variant 属性处理。
有初始值的属性支持常见表达式、构造调用、静态常量、静态调用和链式访问。
属性初始值不要读取当前实例的非静态属性、信号、实例方法或 self。
属性初始值中不能写 lambda。
属性初始值中不能使用 $Node 或 %UniqueName。
const 仍不支持。

信号

signal changed(value: int)
signal ready()

func announce() -> void:
    changed.emit(1)

func listen() -> void:
    changed.connect(func(value: int) -> void:
        print(value))

支持：

无参数信号和带类型参数信号。
信号作为一等 Signal 值读取，例如 changed、self.changed、obj.changed。
signal.emit(...)，可传任意数量参数。
signal.connect(callable)、signal.connect(callable, flags)、signal.disconnect(callable)。
实例方法、静态方法、utility 函数和 lambda 作为 Callable。
await signal。

注意：

信号声明中的参数用于编辑器和引擎元数据；emit 不按声明签名做参数数量和类型检查。
connect 的 flags 使用限定形式，例如 Object.CONNECT_ONE_SHOT。

函数

func add(a: int, b: int) -> int:
    return a + b

static func build() -> Worker:
    return Worker.new()

func _init() -> void:
    pass

支持写法：

实例函数。
static func。
显式参数类型。
省略参数类型，参数为 Variant。
显式返回类型。
省略返回类型，返回槽为 Variant。
零参数 _init。
参数默认值。
lambda 表达式和嵌套 lambda。

参数默认值规则：

支持 func f(a: int, b: int = 5) -> int: 这类尾部连续默认值。
有默认值的参数之后不能再出现无默认值参数。
默认值每次调用时重新求值。
默认值可以是字面量、容器字面量、构造调用、成员访问、函数调用等普通表达式。
实例方法的默认值可以引用 self 和实例成员；静态方法不可以。
默认值不能引用参数、局部变量或 lambda 捕获。
无类型参数不会因为默认值而推导类型，仍按 Variant 处理。
_init 参数默认值不支持。
lambda 参数默认值不支持。

不支持或受限写法：

GDCC 自定义类带参数 .new(...)。
依赖带参数 _init 被 .new(...) 自动调用。

引擎虚函数

支持引擎虚函数覆盖，签名必须精确。

func _ready() -> void:
    pass

func _process(delta: float) -> void:
    pass

func _physics_process(delta: float) -> void:
    pass

特别注意：

_process(delta) 不等价于 _process(delta: float)。
_physics_process(delta) 不等价于 _physics_process(delta: float)。
虚函数必须是实例函数。
参数数量、参数类型、返回类型必须匹配。

语句

`pass` 和注释

func noop() -> void:
    pass

支持：

pass
普通注释。

局部变量

func compute(seed: int) -> int:
    var value: int = seed + 1
    var dynamic_value = value
    var inferred := value * 2
    return inferred

支持写法：

var name
var name = value
var name: Type
var name: Type = value
var name := value

不支持写法：

const local_value = 1
同一作用域重复声明同名局部变量。

赋值

func update(values: Array) -> void:
    var local: int = 1
    local = local + 1
    values[0] = local
    self.hp = local

支持赋值目标：

局部变量。
参数。
类属性。
static var。
self.property。
属性链。
数组索引。
字典索引。
PackedArray 索引和支持的可写路径。

复合赋值

func run_once() -> int:
    var local: int = 3
    local += 4
    total *= local
    total -= 2
    return total

支持运算符：

+=
-=
*=
/=
%=
**=
<<=
>>=
&=
^=
|=

`return`

func read_value() -> int:
    return 1

func maybe_value(flag: bool):
    if flag:
        return 1
    return

支持：

return expr
bare return

规则：

return expr 必须兼容返回类型。
void 函数只能 bare return。
Variant 返回函数可以 bare return。
int、float、对象等具体返回类型不能 bare return。

`if` / `elif` / `else`

func branch_value(value: int) -> int:
    if value > 0:
        return 100
    elif value:
        return 10
    else:
        return 1

支持：

if condition:
elif condition:
else:
嵌套分支。
非 bool condition 的 truthiness。

`while`

func sum(limit: int) -> int:
    var index := 0
    var total := 0
    while index < limit:
        total += index
        index += 1
    return total

支持：

while condition:
嵌套 while。
循环内 break。
循环内 continue。

`for` / `range`

func sum_values(values: Array[int]) -> int:
    var total := 0
    for value in values:
        total += value
    return total

func count_down() -> void:
    for index in range(3, 0, -1):
        print(index)

支持：

for item in values:
for index in range(stop)、range(start, stop)、range(start, stop, step)。
整数简写，例如 for index in 3:。
遍历 String、Array、Dictionary（遍历 key）、所有 PackedArray。
嵌套循环，以及循环内 break、continue。
显式迭代变量类型，例如 for value: float in values:。

限制：

自定义对象的 _iter_* 迭代协议不支持。
不可迭代类型会产生类型错误。

`match`

func describe(value) -> String:
    match value:
        0:
            return "zero"
        1, 2:
            return "small"
        _:
            return "other"

支持：

字面量 pattern、通配符 _、绑定 var name。
表达式 pattern。
数组 pattern 和字典 pattern，包括 .. 尾部展开。
多 pattern 用逗号分隔。
when guard。
嵌套容器 pattern 和嵌套绑定。
枚举成员作为 pattern。
section body 内使用 break、continue，作用于外层循环。

注意：

match 是语句，不是表达式。
不要求穷尽所有分支；没有命中任何 section 时直接跳过。
.. 只能写在 pattern 末尾。
字典 pattern 需要键值对，例如 {"name": var value}；仅写键的 {"name", "hp"} 不支持。

`assert`

func set_limit(limit: int) -> void:
    assert(limit > 0, "limit must be positive")

支持：

assert(condition)
assert(condition, message)
condition 使用 truthiness 规则。
message 必须是可赋给 String 的表达式。

注意：

GDCC 目前不区分 debug 和 release 构建，assert 始终保留检查。
失败会输出运行时错误并结束当前函数。

`await` 与协程

signal finished(value: int)

func wait_for_finished() -> int:
    var value = await finished
    return int(value)

func run_job() -> int:
    var result = await compute_job()
    return result

func compute_job() -> int:
    await finished
    return 1

支持：

await signal：无参数恢复为 null，一个参数恢复为该参数，多参数恢复为 Array。
await 实例协程调用或静态协程调用。
动态 await：Signal、GDCC 协程状态对象、带 completed 信号的对象。
lambda body 内使用 await。
协程调用作为语句根表达式时直接启动，不等待完成。

限制：

协程调用如果作为普通值使用，必须写 await；不能把协程调用结果直接赋给变量、传参、返回或放进容器。
属性初始化器和参数默认值中不能使用 await。
对静态已知的普通非 Signal 值使用 await 会报错。

表达式

字面量

var n: int = 1
var f: float = 1.5
var ok: bool = true
var missing: Object = null
var text: String = "hello"
var name: StringName = &"Player"
var path: NodePath = ^"UI/Panel"

支持：

整数字面量。
浮点字面量。
true / false。
null。
字符串字面量。
StringName 字面量：&"name"。
NodePath 字面量：^"path"。
字符串转义：\"、\n、\t、\\、\uXXXX、\UXXXXXXXX。
UTF-8 字符串内容。
数组字面量：[1, 2, 3]。
字典字面量：{"key": value}，也支持 {key = value} 的 StringName 键写法。

标识符和 `self`

支持：

局部变量。
参数。
属性。
static var。
信号。
singleton。
全局枚举成员和全局常量，例如 TYPE_NIL、OK、KEY_A。
GDScript 语言常量，例如 PI、TAU、INF、NAN。
极值常量，例如 INT32_MAX、INT64_MIN。
类型名。
内部类名。
枚举成员和枚举组名。
self。
super，仅用于 super 调用。

self 使用限制：

实例函数中可用。
静态函数中不可用。
属性初始值中不要依赖。

属性链

func vector_y() -> float:
    var vector: Vector3 = Vector3(1.0, 2.0, 3.0)
    return vector.y

支持：

对象属性读取。
对象属性写入。
对象方法调用。
内建值属性读取，例如 Vector3.x、Color.a。
内建值属性写入，例如 vector.x = 1.0。
静态常量，例如 Vector3.ZERO、Color.RED。
静态变量，例如 Counter.total。
链式访问，例如 Node.new().get_class()。

不支持：

vector["x"] 形式的内建属性访问。使用 vector.x。

`$Node` 和 `%UniqueName`

func find_target() -> Node:
    var child: Node = $UI/Panel
    var unique: Node = %Player
    return child

支持：

$Child、$A/B、$"Path With Spaces"
%UniqueName、%"Unique Name"
^"path" 形式的 NodePath 字面量。
以 $Node 作为链头，例如 $UI/Panel.visible。

限制：

$ / % 只能用于继承 Node 的非静态函数体，以及这些函数体内的已记录 lambda。
静态函数、非 Node 派生类中不能使用 $ / %。
属性初始化器和参数默认值中不能使用 $ / %。
$ / % 的静态类型是 Node，需要具体类型时使用 as。

索引

func compute(values: Array) -> int:
    values[1] = 6
    var first: int = values[0]
    var second: int = values[1]
    return first * 10 + second

支持：

Array 读取和写入。
Dictionary 读取和写入。
PackedArray 读取和写入。
属性链中的索引，例如 holder.values[0]。
静态变量容器中的索引，例如 Counter.labels[0]。
类型化数组读取返回元素类型。

注意：

键和索引的类型转换较严格；当前 Dictionary[float, V] 的键可以接收 int，Dictionary[Vector3, V] 这类键和 Dictionary[K, Vector3] 这类值可以接收同维度整数向量。
字典 key 类型不明确时，优先显式放入 Variant。

调用

func helper(value: int) -> int:
    return value + 1

func compute(seed: int) -> int:
    return helper(seed)

支持：

裸函数调用。
实例方法调用。
静态方法调用。
super.method(...) 和裸 super(...)。
Godot utility function，例如 typeof(...)、len(...)、range(...)。
GDScript 语言函数 char、ord、load、is_instance_of。
引擎方法调用。
内建方法调用。
语句位置丢弃 void 调用返回值。
部分引擎默认参数调用。
部分引擎 vararg 调用。
Variant 动态调用目标。
部分实例方法、静态方法、utility 函数和 lambda 可作为 Callable。

可调用值限制：

len、range 等 GDScript 语言函数只能直接调用，不能当值引用。
构造器、内建类型的静态方法、Dictionary 的实例方法不能直接作为 Callable。

构造调用

var vector: Vector3 = Vector3(1, 2.0, 3)
var values: Array = Array()
var table: Dictionary = Dictionary()
var name: StringName = StringName("Player")
var node: Node = Node.new()
var worker: Worker = Worker.new()

支持：

内建类型裸构造。
int(value)、String(value)。
Array()、Dictionary()。
PackedArray 构造，包括从 Array 构造。
engine class .new()。
GDCC 自定义类零参数 .new()。
load(...) 和 preload("res://...")。

不支持：

GDCC 自定义类带参数 .new(...)。
用裸调用构造对象类型，例如 Node()。

`load` / `preload`

var scene: Resource = load("res://level.tscn")

func load_icon() -> Resource:
    return preload("res://icon.svg")

支持：

load(path)。
preload("path")，路径必须是字符串字面量。
返回值按 Resource 处理。

注意：

preload 在 GDCC 中也在运行时通过 ResourceLoader 加载，不是解释器的编译期预加载。
不加载 .gd 脚本资源。
路径不在编译期做相对路径归一化。
解释器按路径 preload 另一个 GDScript 脚本仍不支持。

lambda

signal pinged

func setup() -> void:
    pinged.connect(func() -> void:
        print("pinged"))

func make_adder(base: int) -> Callable:
    return func(value: int) -> int:
        return base + value

支持：

函数体中的 lambda 表达式，包括 if、while、for、match 和普通 block 内。
嵌套 lambda。
显式参数类型，以及显式或缺省返回类型。
捕获外层参数、局部变量、for 迭代器、外层 lambda 捕获和 self。
lambda 值赋给 var、Callable 参数、Signal.connect、Callable.call。
lambda body 内使用 await。
lambda body 内使用 match、$ / %。
return func(): ...、foo(func(): ...)、容器字面量元素中的 lambda。

限制：

属性初始化器和参数默认值中不能写 lambda。
lambda 自己的参数默认值不支持。
语句位置直接写裸 func(): ... 不支持。
lambda 内不能使用 block-local const。

三元表达式

func pick(flag: bool) -> int:
    return 10 if flag else 20

支持：

value1 if condition else value2
嵌套三元，右结合。
语句位置和 condition 位置使用三元。
分支类型按类型兼容规则合并；无法合并时结果为 Variant。

限制：

一个分支为 void、另一个为具体类型时不支持。

`as`

func find_node(value: Object) -> Node:
    return value as Node

func convert(value: Variant) -> int:
    return value as int

支持：

value as Type。
内建类型转换。
引擎对象和 GDCC 对象的运行时类型检查；失败时得到 null。
Array[T]、Dictionary[K, V] 的 cast；运行时只转换基础容器，不补写或改写元素类型元数据。
枚举名作为目标时按 int 处理。

注意：

从 Variant 或动态值转换到具体类型时，运行时可能失败。
宽泛的 Godot 运行时 cast 兼容性并不完整；遇到无法确定的转换时，写显式 as。

`is` / `is not`

func check(value: Variant) -> bool:
    if value is Node and value is not Sprite2D:
        return true
    return false

支持：

value is Type
value is not Type
内建类型、PackedArray、裸 Array / Dictionary、类型化容器、引擎对象。
null is Variant 为 true；null is 其他类型为 false。
Array / Dictionary 的运行时类型元数据检查。

限制：

对动态脚本继承链的运行时 is 检查不完整。能静态确定的 GDCC 类关系可以使用；不确定时优先对引擎类型做 is，或使用 as 后判空。

一元运算符

支持：

not expr
!expr
+expr
-expr
~expr

二元运算符

支持：

类型	运算符
逻辑短路	`and`、`&&`、`or`、`\|\|`
算术	`+`、`-`、``、`/`、`%`、`*`
位运算	`<<`、`>>`、`&`、`\|`、`^`
比较	`==`、`!=`、`<`、`<=`、`>`、`>=`
包含	`in`、`not in`
字符串格式化	`String % value`、`%=`

说明：

in 和 not in 支持数组、字典、字符串等已有的包含关系。
字符串左操作数的 % 执行格式化，例如 "%s=%d" % [name, hp]。
数值左操作数的 % 仍执行取模。
具名对象子类作为字符串格式化右操作数、以及 String % null 目前不支持。

表达式边界

以下写法仍不支持：

属性初始化器中的 lambda。
属性初始化器和参数默认值中的 $ / %。
内建 keyed 访问，例如 vector["x"]。
通用的编译期常量求值。

数组、字典与 PackedArray

数组和字典字面量

func build_values() -> Array[int]:
    return [2, 4, 6]

func build_scores() -> Dictionary[StringName, int]:
    return {&"alpha": 2, &"beta": 5}

支持：

Array()、Dictionary()。
数组字面量 [...]。
字典字面量 {...}。
类型化容器上下文中的字面量，例如 var values: Array[float] = [1, 2]。
空字面量 []、{}。
嵌套的非类型化容器。

注意：

字面量不会根据元素反推类型化容器；var values := [1, 2] 得到普通 Array。
嵌套类型化容器标注仍不支持。
普通数组字面量不会自动转换成 PackedArray。

数组和字典方法

func summarize(values: Array) -> int:
    values.push_back(8)
    values.resize(4)
    return values.size()

func lookup(scores: Dictionary) -> bool:
    return scores.has("alpha")

支持：

Array 的 push_back、size、resize 等常见方法。
Dictionary 的 size、has 等常见方法。
索引读写。
数组和字典是共享引用语义，赋值不会复制内容。

PackedArray

func build() -> PackedInt32Array:
    var values: PackedInt32Array = PackedInt32Array([4, 5, 6])
    var alias: PackedInt32Array = values
    alias.push_back(7)
    return values

支持：

PackedArray 构造，包括空构造和从 Array 构造。
常见方法调用。
索引读取和写入。
for 遍历。

PackedArray 使用引用语义：

赋值给另一个变量会共享同一份数据。
通过任一副本修改内容，其他副本都能看到。
+= 会创建新数组并重新绑定变量，旧副本不受影响。
duplicate() 返回独立副本。
同类型 as 转换会得到副本，而不是共享原数组。

完整示例

class_name Inventory
extends Node

signal item_added(name: StringName, amount: int)

enum Slot { WEAPON, ARMOR }

@export var capacity: int = 10

var totals: Dictionary[StringName, int] = {}

func add_item(name: StringName, amount: int = 1) -> void:
    var current: int = 0
    if totals.has(name):
        current = totals[name]
    totals[name] = current + amount
    item_added.emit(name, amount)

func count_items(names: Array[StringName]) -> int:
    var total := 0
    for name in names:
        if totals.has(name):
            total += totals[name]
    return total

func slot_name(slot: Slot) -> String:
    match slot:
        Slot.WEAPON:
            return "weapon"
        Slot.ARMOR:
            return "armor"
        _:
            return "unknown"

func setup() -> void:
    item_added.connect(func(name: StringName, amount: int) -> void:
        print(name, amount))

不支持写法速查

写法	状态
`const X = 1`（类或局部常量）	不支持
`extends "res://base.gd"`	不支持
解释器按路径加载父类、autoload 父类、跨模块父类	不支持
把 GDCC 脚本直接挂到节点	需要改为对应节点类
`Custom.new(arg)`、带参数 `_init`	不支持
属性初始化器中的 lambda	不支持
参数默认值中的 lambda、lambda 自己的参数默认值	不支持
语句位置裸 `func(): ...`	不支持
属性初始化器或参数默认值中的 `$` / `%`	不支持
`vector["x"]`	不支持
宽泛的 Godot 运行时 cast	不完整，必要时写显式 `as`
动态脚本继承链上的运行时 `is`	不完整
任意编译期常量求值	不支持
`@onready` 的 ready 时机语义	未实现
`@export` / `@onready` 用于 `static var`	不支持
函数体内的 `enum`	不支持
枚举成员值引用父类枚举、调用函数或访问属性	不支持
`Array[Array[int]]`、`Dictionary[String, Array[int]]`	不支持
自定义对象 `_iter_*` 迭代	不支持
`super.property`、`super[index]`	不支持
`super(...)` 构造调用、`super._init(...)`	不支持
属性初始化器或参数默认值中的 `await`	不支持
协程调用作为普通值且不写 `await`	不支持
对普通非 `Signal` 值使用 `await`	不支持
`preload` 的编译期预加载语义、按路径 `preload` GDScript	不支持
`static var` 的 setter/getter、`_static_init()` 自动调用	不支持
`String % 具名对象子类`、`String % null`	不支持

GDScript 支持参考

类型系统

动态类型

内建类型

类型化容器

枚举

当前支持的类型兼容

文件和类

顶层脚本类

内部类

静态变量

继承、多态与 super

注解

@export 家族

@tool

@onready

成员声明

属性

信号

函数

引擎虚函数

语句

pass 和注释

局部变量

赋值

复合赋值

return

if / elif / else

while

for / range

match

assert

await 与协程

表达式

字面量

标识符和 self

属性链

$Node 和 %UniqueName

索引

调用

构造调用

load / preload

lambda

三元表达式

as

is / is not

一元运算符

二元运算符

表达式边界

数组、字典与 PackedArray

数组和字典字面量

数组和字典方法

PackedArray

完整示例

不支持写法速查

`@export` 家族

`@tool`

`@onready`

`pass` 和注释

`return`

`if` / `elif` / `else`

`while`

`for` / `range`

`match`

`assert`

`await` 与协程

标识符和 `self`

`$Node` 和 `%UniqueName`

`load` / `preload`

`as`

`is` / `is not`