@GDScript

内置 GDScript 函数。

描述

GDScript 核心内置函数列表。包含数学函数及其他实用工具，其他都由继承自对象的类提供。（关键词：内置、内建、全局函数。）

方法

常量

• PI = 3.141593 —- 常量，表示圆的周长是直径的多少倍。等价于 TAU / 2。

• TAU = 6.283185 —- 圆常量，单位圆的周长，单位为弧度。等价于 PI * 2，即 360 度的旋转值。

• INF = inf —- 浮点数正无穷。浮点数除法中使用 0.0 作为除数时的计算结果。使用 -INF 可以得到负无穷。如果分子是正数，除以 -0.0 将得到负无穷，所以除以 0.0 与除以 -0.0 不同（尽管 0.0 == -0.0 返回 true）。

注意：数字无穷大只是浮点数的概念，整数中没有对应的概念。整数除以 0 不会产生 INF，而是会产生一个运行时错误。

• NAN = nan —- “Not a Number”（不是一个数），一个无效的浮点数值。NAN 有许多特殊的性质，比如它不等于自己（NAN == NAN 返回 false）。一些无效的操作会输出这个值，比如用浮点数 0.0 除以 0.0。

注意：“不是一个数”只是浮点数的概念，整数中没有对应的概念。整数 0 除以 0 不会产生 NAN，而是会产生一个运行时错误。

方法说明

• Color Color8 ( int r8, int g8, int b8, int a8=255 )

返回由整数红色、绿色、蓝色和 alpha 通道构成的颜色。每个通道应具有 8 位，包含范围从 0 到 255 的信息。

r8 红色通道

g8 绿色通道

b8 蓝色通道

a8 alpha通道

red = Color8(255, 0, 0)

• Color ColorN ( String name, float alpha=1.0 )

根据标准名称 name 和值在 0 到 1 区间的 alpha 返回一个颜色。

red = ColorN("red", 1)

支持的颜色名称与 Color 中定义的常量相同。

• float abs ( float s )

返回参数 s 的绝对值（即正值）。

a = abs(-1) # a 是 1

• float acos ( float s )

以弧度单位，返回 s 的反余弦值。用于求余弦值为 s 的角度。s 必须在 -1.0 到 1.0 之间（闭区间），否则 acos 将返回 NAN。

# 运算后 c 是 0.523599（弧度），对应角度30度（可用 rad2deg(s) 转换求得）。
c = acos(0.866025)

• float asin ( float s )

以弧度单位，返回 s 的反正弦值。用于求正弦值为 s 的角度。s 必须在 -1.0 到 1.0 之间（闭区间），否则 asin 将返回 NAN。

# s 运算后是 0.523599（弧度），对应角度30度（可用 rad2deg(s) 转换）。
s = asin(0.5)

• void assert ( bool condition, String message=”” )

断言条件 condition 为 true。如果条件 condition 为 false ，则会生成一个错误。如果是从编辑器运行的，正在运行的项目还会被暂停，直到手动恢复。该函数可以作为 push_error 的加强版，用于向项目开发者或插件用户报错。

注意： 出于对性能的考虑，assert 中的代码只会在调试版本或者从编辑器运行项目时执行。所以不要在 assert 调用中加入具有副作用的代码。否则，项目在以发行模式导出后将有不一致的行为。

如果给出了可选的 message 参数，在通用的“Assertion failed”消息之外，还会显示该信息。你可以使用它来提供关于断言失败原因的其他详细信息。

# 比如说我们希望 speed 始终在 0 和 20 之间
speed = -10
assert(speed < 20) # True，程序会继续执行
assert(speed >= 0) # False，程序会停止
assert(speed >= 0 && speed < 20) # 你还可以在单次断言中合并两个条件语句
assert(speed < 20, "speed = %f, but the speed limit is 20" % speed) # 在消息中显示详情

• float atan ( float s )

以弧度返回 s 的反正切值。在三角函数中，使用它可以由一个角的正切值得到这个角：atan(tan(angle)) == angle。

该方法无法确定这个角应该落在哪个象限。如果同时已知 y 和 x 值，可参考 atan2。

a = atan(0.5) # a 为 0.463648

• float atan2 ( float y, float x )

以弧度返回 y/x 的反正切。用于获取正切值为 y/x 的角度。为了求解该值，该方法考虑两个参数的符号以确定象限。

重要说明：按照惯例，Y 坐标为第一个参数。

a = atan2(0, -1) # a 为 3.141593

• Variant bytes2var ( PoolByteArray bytes, bool allow_objects=false )

将字节数组解码返回一个值。当 allow_objects 为 true 时，允许解码对象。

警告：反序列化得到的对象可能包含可执行的代码。如果序列化的对象的来源不可信，请不要激活此选项，以避免潜在的安全威胁（远程执行代码）。

• Vector2 cartesian2polar ( float x, float y )

将 2D 点的坐标表示，从笛卡尔坐标系（X 和 Y 轴）转换为极坐标系（到原点的距离和角度）。

• float ceil ( float s )

将 s 向上舍入（朝正无穷大），返回不小于 s 的最小整数。

a = ceil(1.45)  # a 是 2.0
a = ceil(1.001) # a 是 2.0

参阅 floor、round、stepify、以及 int。

• String char ( int code )

返回一个单字符字符串，该字符为给定 Unicode 码位（与 ASCII 码兼容）。

a = char(65)      # a 是 "A"
a = char(65 + 32) # a 是 "a"
a = char(8364)    # a 是 "€"

这是 ord 的逆操作。

• float clamp ( float value, float min, float max )

钳制 value ，返回一个不小于 min 且不大于 max 的值。

a = clamp(1000, 1, 20) # a 为 20
a = clamp(-10, 1, 20)  # a 为 1
a = clamp(15, 1, 20)   # a 为 15

• Variant convert ( Variant what, int type )

尽可能以最佳方式将一种类型转换为另一种类型。type 参数应使用 Variant.Type 作为值。

a = Vector2(1, 0)
# 输出 1
print(a.length())
a = convert(a, TYPE_STRING)
# 输出 6，因为 "(1, 0)" 一共 6 个字符
print(a.length())

• float cos ( float s )

返回弧度角 s 的正弦值。

a = cos(TAU) # a = 1.0
a = cos(PI) # a = -1.0

• float cosh ( float s )

返回弧度角 s 的双曲余弦值。

print(cosh(1)) # 打印 1.543081

• float db2linear ( float db )

从分贝转换为线性能量（音频）。

• int decimals ( float step )

step_decimals 的弃用的别名。

• float dectime ( float value, float amount, float step )

注意：dectime 已被废弃，将在 Godot 4.0 中删除，请使用 move_toward 代替。

返回 value 减去 step * amount 的结果。

a = dectime(60, 10, 0.1)) # a 是 59.0

• bool deep_equal ( Variant a, Variant b )

Compares two values by checking their actual contents, recursing into any Array or Dictionary up to its deepest level.

This compares to == in a number of ways:

• For null, int, float, String, Object and RID both deep_equal and == work the same.

• For Dictionary, == considers equality if, and only if, both variables point to the very same Dictionary, with no recursion or awareness of the contents at all.

• For Array, == considers equality if, and only if, each item in the first Array is equal to its counterpart in the second Array, as told by == itself. That implies that == recurses into Array, but not into Dictionary.

In short, whenever a Dictionary is potentially involved, if you want a true content-aware comparison, you have to use deep_equal.

• float deg2rad ( float deg )

将角度值转换为弧度值。

r = deg2rad(180) # r = 3.141593

• Object dict2inst ( Dictionary dict )

将（之前使用 inst2dict 创建的）字典转换回实例。适用于反序列化。

• float ease ( float s, float curve )

返回 x “缓动后”的值，结果基于使用 curve 值定义的缓动函数。该缓动函数是基于指数的。curve 值可以是任意浮点数，具体数值会导致以下行为：

- 低于 -1.0（开区间）：缓入缓出
- -1.0：线性
- 在 -1.0 和 0.0 之间（开区间）：缓出缓入
- 0.0：恒定
- 在 0.0 到 1.0 之间（开区间）：缓出
- 1.0：线性
- 大于 1.0（开区间）：缓入

ease() 曲线值速查表

请参阅 smoothstep。如果你需要执行更高级的过渡，请使用 Tween 或 AnimationPlayer。

• float exp ( float s )

自然指数函数。返回 e 的 s 次幂。

e 的近似值为 2.71828，可以使用 exp(1) 获得。

求其他底数的指数应使用 pow 方法。

a = exp(2) # 大约是 7.39

• float floor ( float s )

向下舍入 s （朝负无穷大），返回不大于 s 的最大整数。

a = floor(2.45) # a = 2.0
a = floor(2.99) # a = 2.0
a = floor(-2.99) # a = -3.0

请参阅 ceil、round、stepify 和 int。

注意：该方法返回一个浮点数。如果你需要整数，而 s 是非负数，你可以直接使用 int(s)。

• float fmod ( float a, float b )

返回 a/b 的浮点型余数， 符号与 a一致。

r = fmod(7, 5.5) # r = 1.5

对整数取余请使用操作符 %。

• float fposmod ( float a, float b )

返回 a/b 的浮点模数，对正负数进行一致的循环。

for i in 7:
    var x = 0.5 * i - 1.5
    print("%4.1f %4.1f %4.1f" % [x, fmod(x, 1.5), fposmod(x, 1.5)] )

产生的结果：

-1.5 -0.0  0.0
-1.0 -1.0  0.5
-0.5 -0.5  1.0
 0.0   0.0  0.0
 0.5   0.5  0.5
 1.0   1.0  1.0
 1.5   0.0  0.0

• FuncRef funcref ( Object instance, String funcname )

返回对 instance 节点中指定函数 funcname 的引用。由于函数在GDScript中不是一级对象，因此请使用 funcref 将 FuncRef 存储在变量中，然后再调用它。

func foo():
    return("bar")
a = funcref(self, "foo")
print(a.call_func()) # 输出 bar

• Array get_stack ( )

返回一个表示当前调用堆栈的字典数组。

func _ready():
    foo()
func foo():
    bar()
func bar():
    print(get_stack())

会输出

[{function:bar, line:12, source:res://script.gd}, {function:foo, line:9, source:res://script.gd}, {function:_ready, line:6, source:res://script.gd}]

• int hash ( Variant var )

返回传入的变量的整数哈希值。

print(hash("a")) # 输出 177670

• Dictionary inst2dict ( Object inst )

返回传入的实例转换为的字典（可用于序列化）。

var foo = "bar"
func _ready():
    var d = inst2dict(self)
    print(d.keys())
    print(d.values())

输出：

[@subpath, @path, foo]
[, res://test.gd, bar]

• Object instance_from_id ( int instance_id )

返回 instance_id 所对应的对象。所有对象都有独有的实例 ID。

var foo = "bar"
func _ready():
    var id = get_instance_id()
    var inst = instance_from_id(id)
    print(inst.foo) # 输出 bar

• float inverse_lerp ( float from, float to, float weight )

考虑给定范围，返回归一化值。这是 lerp 的逆运算。

var middle = lerp(20, 30, 0.75)
# `middle` 现在是 27.5
# 现在，我们假装忘记了原来的比例，想把它找回来。
var ratio = inverse_lerp(20, 30, 27.5)
# `ratio` 现在是 0.75。

• bool is_equal_approx ( float a, float b )

如果 a 和 b 彼此近似相等，则返回 true。

这里，近似相等意味着 a 和 b 相互之间在一个小的内部 ε 里，这个内部 ε 随着数字的大小而变化。

相同符号的无穷大值被认为是相等的。

• bool is_inf ( float s )

返回 s 是否为无穷大值（正无穷大或负无穷大）。

• bool is_instance_valid ( Object instance )

返回 instance 是否为有效对象（例如尚未从内存中删除）。

• bool is_nan ( float s )

返回 s 是否为 NaN（“不是数字”或无效）值。

• bool is_zero_approx ( float s )

如果 s 为零或几乎为零，则返回 true。

此方法比使用 is_equal_approx（其中一个值为零）要快。

• int len ( Variant var )

返回 Variant var 的长度。长度是字符串的字符数、数组的元素数、字典的大小等。

注意：如果 Variant 无法提供长度，则会产生致命错误。

a = [1, 2, 3, 4]
len(a) # 返回 4

• Variant lerp ( Variant from, Variant to, float weight )

用一个归一化的值在两个值之间进行线性插值。这是 inverse_lerp 的逆运算。

如果 from 和 to 参数类型是 int 或 float，返回值都是 float。

如果两者都是相同的向量类型（Vector2、Vector3或Color），返回值将是相同的类型（lerp 然后调用该向量类型的 linear_interpolate 方法）。

lerp(0, 4, 0.75) # 返回 3.0
lerp(Vector2(1, 5), Vector2(3, 2), 0.5) # 返回 Vector2(2, 3.5)

• float lerp_angle ( float from, float to, float weight )

通过归一化值在两个角度之间（以弧度为单位）进行线性插值。

与 lerp 相似，但是当角度环绕 TAU 时会准确插值。

extends Sprite
var elapsed = 0.0
func _process(delta):
    var min_angle = deg2rad(0.0)
    var max_angle = deg2rad(90.0)
    rotation = lerp_angle(min_angle, max_angle, elapsed)
    elapsed += delta

• float linear2db ( float nrg )

从线性能量转换为分贝（音频）。这可用于实现按预期运行的音量滑块（因为音量不是线性的）。例如：

# “Slider”引用的是 HSlider、VSlider 等继承自 Range 的节点。
# 必须将其范围配置为 0 到 1。
# 如果只想修改特定总线的音量，请修改总线名称。
AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Master"), linear2db($Slider.value))

• Resource load ( String path )

从位于 path 的文件系统中加载一个资源。该资源在方法调用时被加载（除非它已经在其他地方被引用了，例如在另一个脚本或场景中），这可能会导致轻微的延迟，特别是在加载场景时。为了避免在多次加载东西时出现不必要的延迟，可以将资源存储在一个变量中，或者使用预加载 preload。

注意：资源路径可以通过右键单击文件系统停靠区中的资源并选择“复制路径”或将文件从文件系统停靠区拖到脚本中获得。

# 加载位于项目目录根部的一个名为 main 的场景，并将其缓存在一个变量中。
var main = load("res://main.tscn") # main 将包含一个 PackedScene 资源。

重要提示：路径必须是绝对的，本地路径将直接返回 null。

这个方法是 ResourceLoader.load 的简化版，它可以用于更高级的场景。

• float log ( float s )

自然对数。持续增长到一定程度所需的时间。

注意：这个函数与大多数计算器上的对数“log”函数不同，他们适用的底数是 10。

log(10) # 返回 2.302585

注意：0 的对数返回 -inf ，负值返回 -nan 。

• float max ( float a, float b )

返回两个值的最大值。

max(1, 2) # 返回 2
max(-3.99, -4) # 返回 -3.99

• float min ( float a, float b )

返回两个值的最小值。

min(1, 2) # 返回 1
min(-3.99, -4) # 返回 -4

• float move_toward ( float from, float to, float delta )

将 from 向 to 移动，移动的长度是 delta。

使用负的 delta 值则向远离的方向移动。

move_toward(5, 10, 4) # 返回 9
move_toward(10, 5, 4) # 返回 6
move_toward(10, 5, -1.5) # 返回 11.5

• int nearest_po2 ( int value )

返回最接近且不小于整数 value 的 2 的幂。

换句话说，返回最小值 a，其中 a = pow(2, n)，某些非负整数 n 使得值 value <= a。

nearest_po2(3) # 返回 4
nearest_po2(4) # 返回 4
nearest_po2(5) # 返回 8
nearest_po2(0) # 返回 0（可能出乎意料）
nearest_po2(-1) # 返回 0（可能出乎意料）

警告：由于其实现方式，此函数会对非正数的 value 返回 0 而不是 1 （实际上 1 是 2 的最小整数幂）。

• int ord ( String char )

返回一个整数，该整数表示给定 Unicode 字符 char 的 Unicode 码位。

a = ord("A") # a 是 65
a = ord("a") # a 是 97
a = ord("€") # a 是 8364

这是 char 的逆运算。

• Variant parse_json ( String json )

将 JSON 文本解析为 Variant。（使用 typeof 检查 Variant 的类型是否符合您的期望。）

注意：JSON 规范未定义整数或浮点类型，仅定义了 number 类型。 因此，解析 JSON 文本会将所有数值转换为 float 类型。

注意：JSON 对象不会像 Godot 字典那样保留键顺序，因此，如果字典是由 JSON 构造的，则不应依赖于特定顺序的键。相反，JSON 数组保留其元素的顺序：

var p = JSON.parse('["hello", "world", "!"]')
if typeof(p.result) == TYPE_ARRAY:
    print(p.result[0]) # 输出 "hello"
else:
    push_error("出乎意料的结果。")

另请参阅 JSON 以获取解析 JSON 文本的另一种方法。

• Vector2 polar2cartesian ( float r, float th )

将 2D 点从极坐标系（与原点 r 的距离和角度 th）转换为笛卡尔坐标系（X 和 Y 轴）。

• int posmod ( int a, int b )

返回 a/b 的整数模，对正负数进行一致的循环。

for i in range(-3, 4):
    print("%2d %2d %2d" % [i, i % 3, posmod(i, 3)] )

结果：

-3  0   0
-2 -2  1
-1 -1  2
 0   0  0
 1   1  1
 2   2  2
 3   0  0

• float pow ( float base, float exp )

返回 base 的 exp 次幂的结果。

pow(2, 5) # 返回 32.0

• Resource preload ( String path )

返回位于文件系统中 path 位置的 Resource。资源是在脚本解析期间加载的，即随脚本一同加载，preload 实际上充当了对该资源的引用。请注意，该方法需要常量路径。如果要从动态/变量路径加载资源，请使用 load。

注意：可以通过右键单击素材面板中的资源并选择“复制路径”，或者将文件从文件系统面板拖到脚本中来获得资源路径。

# 实例化场景。
var diamond = preload("res://diamond.tscn").instance()

• void print ( … ) vararg

以最佳方式将一个或多个任意类型的参数转换为字符串，并将其打印到控制台。

a = [1, 2, 3]
print("a", "=", a) # 输出 a=[1, 2, 3]

注意：请考虑使用 push_error 和 push_warning 来打印错误和警告信息而不是 print。这将它们与用于调试的打印信息区分开来，同时在打印错误或警告时还会显示堆栈跟踪。

• void print_debug ( … ) vararg

与 print 类似，但仅在调试模式下使用时才打印。

• void print_stack ( )

在代码位置打印堆栈轨迹，仅在打开调试器的情况下运行。

控制台中的输出如下所示：

Frame 0 - res://test.gd:16 in function '_process'

• void printerr ( … ) vararg

以可能的最佳方式将一个或多个参数作为字符串输出到标准错误行。

printerr("prints to stderr")

• void printraw ( … ) vararg

以最佳的方式将一个或多个参数作为字符串输出到控制台。末尾没有添加换行符。

printraw("A")
printraw("B")
# 输出 AB

注意：由于 Godot 内置控制台的限制，此内容仅会打印到终端上。如果需要在编辑器中打印，请使用其他方法，例如 print。

• void prints ( … ) vararg

将一个或多个参数打印到控制台，每个参数之间有一个空格。

prints("A", "B", "C") # 输出 A B C

• void printt ( … ) vararg

将一个或多个参数打印到控制台，每个参数之间有一个制表符。

printt("A", "B", "C") # 输出 A       B       C

• void push_error ( String message )

将错误消息推送到 Godot 的内置调试器和 OS 终端。

push_error("test error") # 向调试器和终端打印 "test error" 作为错误调用

注意：以该方式打印的错误不会暂停项目的运行。要在调试版本中打印错误消息并暂停项目运行，请使用 assert(false, "test error")。

• void push_warning ( String message )

将警告消息推送到 Godot 的内置调试器和 OS 终端。

push_warning("test warning") # 以警告的形式向调试器和终端输出 "test warning"

• float rad2deg ( float rad )

将以弧度表示的角度转换为度。

rad2deg(0.523599) # 返回 30.0

• float rand_range ( float from, float to )

随机范围，from 和 to 之间的任何浮点值。

prints(rand_range(0, 1), rand_range(0, 1)) # 输出举例 0.135591 0.405263

• Array rand_seed ( int seed )

来自种子的随机数：传入种子 seed，返回同时包含数字和新种子的数组。这里的“种子”是指伪随机数生成器的内部状态。当前实现的内部状态为 64 位。

• float randf ( )

返回区间 [0, 1] 上的随机浮点值。

randf() # 返回举例 0.375671

• int randi ( )

返回一个随机的无符号 32 位整数。使用余数获得区间 [0, N - 1] （其中 N 小于 2^32）的随机值。

randi()           # 返回介于 0 到 2^32 - 1 之间的随机整数
randi() % 20      # 返回介于 0 到 19之间的随机整数
randi() % 100     # 返回介于 0 到 99 之间的随机整数
randi() % 100 + 1 # 返回介于 0 到 100 之间的随机整数

• void randomize ( )

随机化随机数生成器的种子（或内部状态）。当前的实现使用基于时间的数字来重新设定种子。

func _ready():
   randomize()

• Array range ( … ) vararg

返回一个具有给定范围的数组。范围可以是一个参数N（0 到 N - 1），两个参数（初始 initial、最终 final -1）或三个参数（初始 initial、最终 final -1、增量 increment）。范围无效时返回一个空数组（例如 range(2, 5, -1) 或 range(5, 5, 1)）。

返回一个具有给定范围的数组。range() 可以是一个参数 N（0 到 N - 1），两个参数（初始 initial、最终 final -1）或三个参数（初始initial、最终 final -1、增量 increment）。增量 increment 可以是负数。如果增量 increment 是负的，final-1 将变成 final+1。另外，初始值必须大于最终值，循环才能运行。

print(range(4))
print(range(2, 5))
print(range(0, 6, 2))

输出：

[0, 1, 2, 3]
[2, 3, 4]
[0, 2, 4]

要对一个数组 Array 进行逆序迭代，请使用：

var array = [3, 6, 9]
var i := array.size() - 1
while i >= 0:
    print(array[i])
    i -= 1

输出：

9
6
3

• float range_lerp ( float value, float istart, float istop, float ostart, float ostop )

将 value 从范围 [istart, istop] 映射到 [ostart, ostop]。

range_lerp(75, 0, 100, -1, 1) # 返回 0.5

• float round ( float s )

将 s 舍入到最接近的整数，中间情况向远离零的方向舍入。

a = round(2.49) # a 是 2.0
a = round(2.5)  # a 是 3.0
a = round(2.51) # a 是 3.0

请参阅 floor、ceil、stepify、以及 int。

• void seed ( int seed )

为随机数生成器设置种子。

my_seed = "Godot Rocks"
seed(my_seed.hash())

• float sign ( float s )

返回 s 的符号：-1 或 1。s 为 0 时返回 0。

sign(-6) # 返回 -1
sign(0)  # 返回 0
sign(6)  # 返回 1

• float sin ( float s )

返回弧度角 s 的正弦值。

sin(0.523599) # 返回 0.5

• float sinh ( float s )

返回 s 的双曲正弦值。

a = log(2.0) # 返回 0.693147
sinh(a) # 返回 0.75

• float smoothstep ( float from, float to, float s )

返回 s 在 0 和 1 之间平滑插值的结果，基于 s 相对于边从 from 和到 to 的位置。

如果 s <= from，返回值为 0；如果 s >= to，返回值为 1。如果 s 位于 from 和 to 之间，返回值遵循一个 S 型曲线，将 s 映射到 0 和 1 之间。

这条 S 形曲线是立方 Hermite 插值器，由 f(y)=3*y^2-2*y^3 给出，其中 y = (x-from) / (to-from)。

smoothstep(0, 2, -5.0) # 返回 0.0
smoothstep(0, 2, 0.5) # 返回 0.15625
smoothstep(0, 2, 1.0) # 返回 0.5
smoothstep(0, 2, 2.0) # 返回1.0

与曲线值为 -1.6521 的 ease 相比，smoothstep 返回最平滑的曲线，导数没有突然变化。如果你需要执行更高级的过渡，请使用 Tween 或 AnimationPlayer。

smoothstep() 与 ease(x, -1.6521) 返回值的比较

• float sqrt ( float s )

返回 s 的平方根，其中 s 是非负数。

sqrt(9) # 返回 3

注意：负数的 s 会返回 NaN。如果你需要负数输入，请在 C# 中使用 System.Numerics.Complex。

• int step_decimals ( float step )

返回小数点后第一个非零数字的位置。注意最大返回值是 10，这是实现中的设计决定。

n = step_decimals(5)           # n = 0
n = step_decimals(1.0005)      # n = 4
n = step_decimals(0.000000005) # n = 9

• float stepify ( float s, float step )

将浮点值 s 按照给定的 step 对齐。也可以用于将浮点数四舍五入为任意的小数位数。

stepify(100, 32) # 返回 96
stepify(3.14159, 0.01) # 返回 3.14

参阅 ceil、floor、round、以及 int。

• String str ( … ) vararg

以最佳方式将一个或多个任意类型的参数转换为字符串。

var a = [10, 20, 30]
var b = str(a);
len(a) # 返回 3
len(b) # 返回 12

• Variant str2var ( String string )

将 var2str 返回的格式化字符串转换为原始值。

a = '{ "a": 1, "b": 2 }'
b = str2var(a)
print(b["a"]) # 输出 1

• float tan ( float s )

返回弧度角 s 的正切。

tan(deg2rad(45)) # 返回 1

• float tanh ( float s )

返回s的双曲正切。

a = log(2.0) # a = 0.693147
b = tanh(a) # b = 0.6

• String to_json ( Variant var )

将 Variant var 转换为JSON文本并返回结果。对于序列化数据以通过网络存储或发送很有用。

# 下面的两个数组都是整数。
a = { "a": 1, "b": 2 }
b = to_json(a)
print(b) # {"a":1, "b":2}
# 上面的两个数都是浮点数，尽管没有显示小数部分。

注意：JSON 规范未定义整数或浮点类型，而仅定义了数字类型。因此，将 Variant 转换为 JSON 文本会将所有数值转换为 float 类型。

另请参阅 JSON，以将 Variant 转换为 JSON 文本的另一种方法。

• bool type_exists ( String type )

返回给定的类在 ClassDB 中是否存在。

type_exists("Sprite") # 返回 true
type_exists("Variant") # 返回 false

• int typeof ( Variant what )

使用 Variant.Type 值返回给定 Variant 对象的内部类型。

p = parse_json('["a", "b", "c"]')
if typeof(p) == TYPE_ARRAY:
    print(p[0]) # Prints a
else:
    print("unexpected results")

• String validate_json ( String json )

检查 json 是有效的JSON数据。如果有效，则返回空字符串，否则返回错误消息。

j = to_json([1, 2, 3])
v = validate_json(j)
if not v:
    print("Valid JSON.")
else:
    push_error("Invalid JSON: " + v)

• PoolByteArray var2bytes ( Variant var, bool full_objects=false )

将变量值编码为一个字节数组。当 full_objects 为 true 时，允许对对象进行编码（并且可能包含代码）。

• String var2str ( Variant var )

将 Variant var 转换为格式化的字符串，以后可以使用 str2var 对其进行解析。

a = { "a": 1, "b": 2 }
print(var2str(a))

prints

{
"a": 1,
"b": 2
}

• WeakRef weakref ( Object obj )

返回一个对对象的弱引用。

一个对对象的弱引用不足以使对象保持活动状态：当仅剩余的对引用对象的引用是弱引用时，垃圾回收可以随意销毁该引用并将其内存重用于其他用途。但是，直到没有实际破坏对象为止，弱引用仍可能会返回该对象，即使没有强引用也是如此。

• float wrapf ( float value, float min, float max )

在 min 和 max 之间将 value 循环。

可用于创建类似循环的行为或无限曲面。

# Infinite loop between 5.0 and 9.9
value = wrapf(value + 0.1, 5.0, 10.0)

# Infinite rotation (in radians)
angle = wrapf(angle + 0.1, 0.0, TAU)

# Infinite rotation (in radians)
angle = wrapf(angle + 0.1, -PI, PI)

注意： 如果 min 为 0，则等价于 fposmod，因此请改用它。

通过让用户控制最小值，wrapf 比使用 fposmod 方法更灵活。

• int wrapi ( int value, int min, int max )

在 min 和 max 之间环绕整数 value。

可用于创建类似循环的行为或无限曲面。

# 在 5 和 9 之间无限循环
frame = wrapi(frame + 1, 5, 10)

# result 是 -2
var result = wrapi(-6, -5, -1)

注意：如果 min 为 0，则等价于 posmod，因此建议改用它。

通过让用户控制最小值，wrapi 比使用 posmod 方法更灵活。

• GDScriptFunctionState yield ( Object object=null, String signal=”” )

停止函数的执行并将当前的暂停状态返回给调用函数。

从调用者那里，对该状态调用 GDScriptFunctionState.resume 来恢复执行。这将使该状态无效。在恢复的函数中，yield() 返回传递给 resume() 函数调用的东西。

如果传递了对象和信号，当该对象发出给定的信号时，就会恢复执行。此时，如果该信号只有一个参数，yield() 会返回传递给 emit_signal() 的参数，如果该信号有多个参数，则返回一个包含传递给 emit_signal() 的所有参数的数组。

你还可以使用 yield 来等待函数的完成：

func _ready():
    yield(countdown(), "completed") # 等待 countdown() 函数的完成
    print('Ready')
func countdown():
    yield(get_tree(), "idle_frame") # 返回一个 GDScriptFunctionState 对象给 _ready()
    print(3)
    yield(get_tree().create_timer(1.0), "timeout")
    print(2)
    yield(get_tree().create_timer(1.0), "timeout")
    print(1)
    yield(get_tree().create_timer(1.0), "timeout")
# 输出：
# 3
# 2
# 1
# Ready

当对一个函数处于让步等待时，completed 信号将在函数返回时自动发出。因此，它可以作为 signal 的参数用于 yield 方法的恢复。

为了在一个函数上让步等待，产生的函数也应该返回一个 GDScriptFunctionState。注意上面的例子中 yield(get_tree(), "idle_frame")。