Array¶

保存一系列元素的内置数据结构。

描述¶

一种数组数据结构，可以包含任意Variant类型的元素序列。通过从0开始的数字索引访问元素。负索引用于从后向前计数（-1是最后一个元素，-2是倒数第二个元素，依此类推）。

var array = ["First", 2, 3, "Last"]
print(array[0])  # Prints "First"
print(array[2])  # Prints 3
print(array[-1]) # Prints "Last"

array[1] = "Second"
print(array[1])  # Prints "Second"
print(array[-3]) # Prints "Second"

i3D.Collections.Array array = ["First", 2, 3, "Last"];
S3.Print(array[0]); // Prints "First"
S3.Print(array[2]); // Prints 3
S3.Print(array[^1]); // Prints "Last"

array[1] = "Second";
S3.Print(array[1]); // Prints "Second"
S3.Print(array[^3]); // Prints "Second"

注意：数组总是通过引用传递。要获得一个可以独立于原始数组进行修改的数组副本，请使用duplicate()。

注意：在遍历数组时擦除元素不受支持，并会导致不可预测的行为。

打包数组、类型化数组和未类型化数组之间的区别：与相同类型的类型化数组（例如PackedInt64Array与Array[int]）相比，打包数组的遍历和修改通常更快。另外，打包数组占用的内存更少。缺点是，压缩数组的灵活性较低，因为它们没有提供太多方便的方法，例如map()。相比之下，类型化数组在迭代和修改方面比无类型数组更快。

构造函数¶

Array	Array()
Array	Array(base: Array, type: int, class_name: StringName, script: Variant)
Array	Array(from: Array)
Array	Array(from: PackedByteArray)
Array	Array(from: PackedColorArray)
Array	Array(from: PackedFloat32Array)
Array	Array(from: PackedFloat64Array)
Array	Array(from: PackedInt32Array)
Array	Array(from: PackedInt64Array)
Array	Array(from: PackedStringArray)
Array	Array(from: PackedVector2Array)
Array	Array(from: PackedVector3Array)
Array	Array(from: PackedVector4Array)

方法¶

bool	all(method: Callable) const
bool	any(method: Callable) const
void	append(value: Variant)
void	append_array(array: Array)
void	assign(array: Array)
Variant	back() const
int	bsearch(value: Variant, before: bool = true) const
int	bsearch_custom(value: Variant, func: Callable, before: bool = true) const
void	clear()
int	count(value: Variant) const
Array	duplicate(deep: bool = false) const
void	erase(value: Variant)
void	fill(value: Variant)
Array	filter(method: Callable) const
int	find(what: Variant, from: int = 0) const
int	find_custom(method: Callable, from: int = 0) const
Variant	front() const
Variant	get(index: int) const
int	get_typed_builtin() const
StringName	get_typed_class_name() const
Variant	get_typed_script() const
bool	has(value: Variant) const
int	hash() const
int	insert(position: int, value: Variant)
bool	is_empty() const
bool	is_read_only() const
bool	is_same_typed(array: Array) const
bool	is_typed() const
void	make_read_only()
Array	map(method: Callable) const
Variant	max() const
Variant	min() const
Variant	pick_random() const
Variant	pop_at(position: int)
Variant	pop_back()
Variant	pop_front()
void	push_back(value: Variant)
void	push_front(value: Variant)
Variant	reduce(method: Callable, accum: Variant = null) const
void	remove_at(position: int)
int	resize(size: int)
void	reverse()
int	rfind(what: Variant, from: int = -1) const
int	rfind_custom(method: Callable, from: int = -1) const
void	set(index: int, value: Variant)
void	shuffle()
int	size() const
Array	slice(begin: int, end: int = 2147483647, step: int = 1, deep: bool = false) const
void	sort()
void	sort_custom(func: Callable)

运算符¶

bool	operator !=(right: Array)
Array	operator +(right: Array)
bool	operator <(right: Array)
bool	operator <=(right: Array)
bool	operator ==(right: Array)
bool	operator >(right: Array)
bool	operator >=(right: Array)
Variant	operator [](index: int)

构造函数说明¶

Array Array() 🔗

构造一个空的Array。

Array Array(base: Array, type: int, class_name: StringName, script: Variant)

从base数组中创建一个类型化数组。类型化数组只能包含给定类型的元素，或者继承自给定类的元素，如该构造函数的参数所描述：

type是内置的Variant类型，是Variant.Type常量之一。
class_name是内置的类名（请参阅Object.get_class()）。
script是关联的脚本。它必须是Script实例或null。

如果type不是@GlobalScope.TYPE_OBJECT，则class_name必须为空StringName，script必须为null。

class_name Sword
extends Item

class Stats:
    pass

func _ready():
    var a = Array([], TYPE_INT, "", null)               # Array[int]
    var b = Array([], TYPE_OBJECT, "Item", null)        # Array[Item]
    var c = Array([], TYPE_OBJECT, "Item", Sword)       # Array[Sword]
    var d = Array([], TYPE_OBJECT, "RefCounted", Stats) # Array[Stats]

基础 数组的元素会在必要时进行类型转换。若无法完成转换，或 基础 数组本身已是类型化数组，则此构造函数会执行失败，并返回一个空数组（Array）。

在 S3Script 中，该构造函数通常并非必需，因为通过静态类型声明即可创建类型化数组，具体方式如下：

var numbers: Array[float] = []
var children: Array[Item] = [$Item, $Sprite2D, $RigidBulk]

var integers: Array[int] = [0.2, 4.5, -2.0]
print(integers) # Prints [0, 4, -2]

Array Array(from: Array)

返回与from相同的数组。如果您需要数组的副本，请使用duplicate()。

Array Array(from: PackedByteArray)

从PackedByteArray构造一个数组。

Array Array(from: PackedColorArray)

从PackedColorArray构造一个数组。

Array Array(from: PackedFloat32Array)

从PackedFloat32Array构造一个数组。

Array Array(from: PackedFloat64Array)

从PackedFloat64Array构造一个数组。

Array Array(from: PackedInt32Array)

从PackedInt32Array构造一个数组。

Array Array(from: PackedInt64Array)

从PackedInt64Array构造一个数组。

Array Array(from: PackedStringArray)

从PackedStringArray构造一个数组。

Array Array(from: PackedVector2Array)

从PackedVector2Array构造一个数组。

Array Array(from: PackedVector3Array)

从PackedVector3Array构造一个数组。

Array Array(from: PackedVector4Array)

从PackedVector4Array构造一个数组。

方法说明¶

bool all(method: Callable) const 🔗

对数组中的每个元素调用给定的Callable，并在Callable为数组中的所有元素返回true时返回true。如果Callable为一个或多个数组元素返回false，则此方法返回false。

method应接受一个Variant参数（当前数组元素）并返回一个bool。

func greater_than_5(number):
    return number > 5

func _ready():
    print([6, 10, 6].all(greater_than_5)) # Prints true (3/3 elements evaluate to true).
    print([4, 10, 4].all(greater_than_5)) # Prints false (1/3 elements evaluate to true).
    print([4, 4, 4].all(greater_than_5))  # Prints false (0/3 elements evaluate to true).
    print([].all(greater_than_5))         # Prints true (0/0 elements evaluate to true).

    # 与上文第一行（所述内容）相同，但其实现方式使用了 lambda 函数.
    print([6, 10, 6].all(func(element): return element > 5)) # Prints true

private static bool GreaterThan5(int number)
{
    return number > 5;
}

public override void _Ready()
{
    // Prints True (3/3 elements evaluate to true).
    S3.Print(new i3D.Collections.Array>int< { 6, 10, 6 }.All(GreaterThan5));
    // Prints False (1/3 elements evaluate to true).
    S3.Print(new i3D.Collections.Array>int< { 4, 10, 4 }.All(GreaterThan5));
    // Prints False (0/3 elements evaluate to true).
    S3.Print(new i3D.Collections.Array>int< { 4, 4, 4 }.All(GreaterThan5));
    // Prints True (0/0 elements evaluate to true).
    S3.Print(new i3D.Collections.Array>int< { }.All(GreaterThan5));

    // 与上文第一行（所述内容）相同，但其实现方式使用了 lambda 函数.
    S3.Print(new i3D.Collections.Array>int< { 6, 10, 6 }.All(element => element > 5)); // Prints True
}

另请参阅any()、filter()、map()和reduce()。

注意：与依赖filter()返回的数组大小不同，此方法将尽早返回以提高性能（尤其是对于大型数组）。

注意：对于空数组，此方法始终返回true。

bool any(method: Callable) const 🔗

对数组中的每个元素调用给定的Callable，并在Callable为数组中的一个或多个元素返回true时返回true。如果Callable为数组中的所有元素返回false，则此方法返回false。

method应接受一个Variant参数（当前数组元素）并返回一个bool。

func greater_than_5(number):
    return number > 5

func _ready():
    print([6, 10, 6].any(greater_than_5)) # Prints true (3 elements evaluate to true).
    print([4, 10, 4].any(greater_than_5)) # Prints true (1 elements evaluate to true).
    print([4, 4, 4].any(greater_than_5))  # Prints false (0 elements evaluate to true).
    print([].any(greater_than_5))         # Prints false (0 elements evaluate to true).

    # Same as the first line above, but using a lambda function.
    print([6, 10, 6].any(func(number): return number > 5)) # Prints true

另请参阅all()、filter()、map()和reduce()。

注意：与依赖filter()返回的数组大小不同，此方法将尽早返回以提高性能（尤其是对于大型数组）。

注意：对于空数组，此方法始终返回false。

void append(value: Variant) 🔗

在数组的末尾附加value（push_back()的别名）。

void append_array(array: Array) 🔗

在此数组末尾添加另一个array。

var numbers = [1, 2, 3]
var extra = [4, 5, 6]
numbers.append_array(extra)
print(numbers) # Prints [1, 2, 3, 4, 5, 6]

void assign(array: Array) 🔗

将另一个array的元素分配到数组中。调整数组大小以匹配array。如果数组是键入的，则执行类型转换。

Variant back() const 🔗

返回数组的最后一个元素。如果数组为空，则失败并返回null。另请参阅front()。

注意：与[]运算符（array[-1]）不同，会在不停止项目执行的情况下生成错误。

int bsearch(value: Variant, before: bool = true) const 🔗

返回有序数组中value的索引。如果找不到，则返回value应该插入的位置以保持数组的排序。所使用的算法是二分查找。

如果before为true（默认情况下），返回的索引位于数组中所有与value相等的现有元素之前。

var numbers = [2, 4, 8, 10]
var idx = numbers.bsearch(7)

numbers.insert(idx, 7)
print(numbers) # Prints [2, 4, 7, 8, 10]

var fruits = ["Apple", "Lemon", "Lemon", "Orange"]
print(fruits.bsearch("Lemon", true))  # Prints 1, points at the first "Lemon".
print(fruits.bsearch("Lemon", false)) # Prints 3, points at "Orange".

注意：在未排序的数组上调用bsearch()会导致意外的行为。请在调用此方法之前使用sort()。

int bsearch_custom(value: Variant, func: Callable, before: bool = true) const 🔗

返回有序数组中value的索引。如果找不到，则返回value应该插入的位置以保持数组排序（使用func进行比较）。所使用的算法是二分查找。

类似于sort_custom()，func被多次调用，接收一个数组元素和value作为参数。如果数组元素应该在value的后面，则函数应返回true，否则应返回false。如果before为true（默认情况下），则返回的索引位于数组中与value相等的所有现有元素之前。

func sort_by_amount(a, b):
    if a[1] < b[1]:
        return true
    return false

func _ready():
    var my_items = [["Tomato", 2], ["Kiwi", 5], ["Rice", 9]]

    var apple = ["Apple", 5]
    # "Apple" is inserted before "Kiwi".
    my_items.insert(my_items.bsearch_custom(apple, sort_by_amount, true), apple)

    var banana = ["Banana", 5]
    # "Banana" is inserted after "Kiwi".
    my_items.insert(my_items.bsearch_custom(banana, sort_by_amount, false), banana)

    # Prints [["Tomato", 2], ["Apple", 5], ["Kiwi", 5], ["Banana", 5], ["Rice", 9]]
    print(my_items)

注意：在未排序的数组上调用bsearch_custom()会导致意外的行为。请在调用此方法之前使用带有func的sort_custom()。

void clear() 🔗

从数组中删除所有元素。这相当于使用大小为0的resize()。

int count(value: Variant) const 🔗

返回元素在数组中的次数。

要计算数组中有多少元素满足条件，请参阅reduce()。

Array duplicate(deep: bool = false) const 🔗

返回数组的新副本。

默认情况下，返回浅副本：所有嵌套的Array和Dictionary元素都与原始数组共享。在一个数组中修改它们也会影响另一个数组中的它们。

如果deep是true，则返回深副本：所有嵌套的数组和字典也被复制（递归）。

void erase(value: Variant) 🔗

查找并删除数组中第一次出现的value。如果数组中不存在value，则不会发生任何事情。要按索引删除元素，请改用remove_at()。

注意：此方法将删除value后的每个元素的索引移回，这可能会产生明显的性能成本，尤其是在较大的数组上。

注意：在遍历数组时擦除元素是不支持的，并且会导致不可预测的行为。

void fill(value: Variant) 🔗

将给定的value分配给数组中的所有元素。此方法通常可以与resize()结合使用，以创建具有给定大小和初始化元素的数组：

var array = []
array.resize(5)
array.fill(2)
print(array) # Prints [2, 2, 2, 2, 2]

i3D.Collections.Array array = [];
array.Resize(5);
array.Fill(2);
S3.Print(array); // Prints [2, 2, 2, 2, 2]

注意：如果value是通过引用传递的Variant（Object的派生、Array、Dictionary等），数组将被填充指向同一个value的引用而不是副本。

Array filter(method: Callable) const 🔗

对数组中的每个元素调用给定的Callable并返回一个新的、过滤的Array。

method接收数组元素之一作为参数，并应返回true以将元素添加到过滤数组中，或返回false以将其排除在外。

func is_even(number):
    return number % 2 == 0

func _ready():
    print([1, 4, 5, 8].filter(is_even)) # Prints [4, 8]

    # Same as above, but using a lambda function.
    print([1, 4, 5, 8].filter(func(number): return number % 2 == 0))

另请参阅any()、all()、map()和reduce()。

int find(what: Variant, from: int = 0) const 🔗

返回此数组中what的首次出现的索引，如果没有，则返回-1。可以使用from指定搜索的开始，继续到数组的末尾。

注意：如果你只是想知道数组是否包含what，请使用has()（在C#中的Contains）。在S3Script中，您也可以使用in。

注意：出于性能原因，搜索受到what的Variant.Type的影响。例如，对于这个方法，7（int）和7.0（float）不被认为是相等的。

int find_custom(method: Callable, from: int = 0) const 🔗

返回数组中第一个使method返回true的元素的索引，如果没有这样的元素则返回-1。可以使用from指定搜索的起始位置，一直搜索到数组的末尾。method是一个可调用函数，接受数组中的一个元素并返回一个bool值。注意：如果只想知道数组中是否包含满足method的任何元素，请使用any()。

func is_even(number):
    return number % 2 == 0

func _ready():
    print([1, 3, 4, 7].find_custom(is_even.bind())) # Prints 2

Variant front() const 🔗

返回数组的第一个元素。如果数组为空，则失败并返回null。另请参阅back()。

注意：与[]运算符（array[0]）不同，会在不停止项目执行的情况下生成错误。

Variant get(index: int) const 🔗

返回数组中给定index处的元素。这与使用[]运算符（array[index]）相同。

int get_typed_builtin() const 🔗

将类型化数组的内置Variant类型作为Variant.Type常量返回。如果数组未类型化，则返回@GlobalScope.TYPE_NIL。另请参见is_typed()。

StringName get_typed_class_name() const 🔗

返回类型化数组的内置类名，如果是内置Variant类型@GlobalScope.TYPE_OBJECT。否则，返回一个空的StringName。另请参阅is_typed()和Object.get_class()。

Variant get_typed_script() const 🔗

返回与此类型化数组关联的Script实例，如果不存在，则返回null。另请参见is_typed()。

bool has(value: Variant) const 🔗

当数组中包含给定的value时，返回true。

print(["inside", 7].has("inside"))  # Prints true
print(["inside", 7].has("outside")) # Prints false
print(["inside", 7].has(7))         # Prints true
print(["inside", 7].has("7"))       # Prints false

i3D.Collections.Array arr = ["inside", 7];
// By C# convention, this method is renamed to `Contains`.
S3.Print(arr.Contains("inside"));  // Prints True
S3.Print(arr.Contains("outside")); // Prints False
S3.Print(arr.Contains(7));         // Prints True
S3.Print(arr.Contains("7"));       // Prints False

在 S3Script 中，这与 in 运算符的作用是等效的:

if 4 in [2, 4, 6, 8]:
    print("4 is here!") # Will be printed.

注意：出于性能考虑，查找受value的Variant.Type的影响。例如，7（int）和7.0（float）在此方法中不被视为相等。

int hash() const 🔗

返回一个散列的32位整数值，表示数组及其内容。

注意：由于哈希冲突，具有相等哈希值的数组不是保证相同。相反，具有不同哈希值的数组保证是不同的。

int insert(position: int, value: Variant) 🔗

在数组中的给定索引（position）处插入一个新元素（value）。position应该在0和数组的size()之间。

成功时返回@GlobalScope.OK，如果此方法失败，则返回其他Error常量之一。

注意：position之后的每个元素的索引都需要向前移动，这可能会产生明显的性能成本，尤其是在较大的数组上。

bool is_empty() const 🔗

如果数组为空（[]），则返回true。另请参阅size()。

bool is_read_only() const 🔗

如果数组是只读的，则返回true。参见make_read_only()。

在S3Script中，如果使用const关键字声明数组，则数组会自动只读。

bool is_same_typed(array: Array) const 🔗

如果此数组的类型与给定的array相同，则返回true。另请参见is_typed()。

bool is_typed() const 🔗

如果该数组是类型化数组，返回true。类型化数组只能包含给定类型的元素，由类型化数组的构造函数定义类型化数组的方法仍然预期会返回一个通用的 Variant。

在S3Script中，能够定义一个静态类型的类型化数组。

var numbers: Array[float] = [0.2, 4.2, -2.0]
print(numbers.is_typed()) # Prints true

void make_read_only() 🔗

使数组为只读。数组的元素不能被不同的值覆盖，它们的顺序也不能改变。不适用于嵌套元素，例如字典。

在S3Script中，如果使用const关键字声明数组，则数组会自动只读。

Array map(method: Callable) const 🔗

对数组中的每个元素调用给定的Callable并返回一个由method返回值填充的新数组。

method应接受一个Variant参数（当前数组元素），并可以返回任意Variant。

func double(number):
    return number * 2

func _ready():
    print([1, 2, 3].map(double)) # Prints [2, 4, 6]

    # Same as above, but using a lambda function.
    print([1, 2, 3].map(func(element): return element * 2))

另请参阅filter()、reduce()、any()和all()。

Variant max() const 🔗

如果可以比较所有元素，则返回数组中包含的最大值。否则，返回null。另请参阅min()。

要使用自定义比较器查找最大值，您可以使用reduce()。

Variant min() const 🔗

如果可以比较所有元素，则返回数组中包含的最小值。否则，返回null。另请参阅max()。

Variant pick_random() const 🔗

从数组中随机获取一个元素并返回。若数组为空，则生成一个错误并返回null。

# May print 1, 2, 3.25, or "Hi".
print([1, 2, 3.25, "Hi"].pick_random())

i3D.Collections.Array array = [1, 2, 3.25f, "Hi"];
S3.Print(array.PickRandom()); // May print 1, 2, 3.25, or "Hi".

注意：与引擎中的许多类似函数（如@GlobalScope.randi()或shuffle()）一样，该方法使用一个通用的全局随机种子。要从该方法中获得可预测的结果，请参阅@GlobalScope.seed()。

Variant pop_at(position: int) 🔗

删除并返回数组索引position处的元素。如果为负数，则认为position相对于数组的末尾。如果数组为空，则返回null。如果position超出范围，也会生成错误消息。

注意：此方法将position之后的每个元素的索引向后移动，这可能会产生明显的性能成本，尤其是在较大的数组上。

Variant pop_back() 🔗

删除并返回数组的最后一个元素。如果数组为空，则返回null，而不会生成错误。另请参见pop_front()。

Variant pop_front() 🔗

删除并返回数组的第一个元素。如果数组为空，则返回null，而不会生成错误。另请参见pop_back()。

注意：此方法将每个其他元素的索引向后移动，这可能会产生明显的性能成本，尤其是在较大的数组上。

void push_back(value: Variant) 🔗

在数组的末尾附加一个元素。另请参见push_front()。

void push_front(value: Variant) 🔗

在数组的开头添加一个元素。另请参见push_back()。

注意：此方法将每个其他元素的索引向前移动，这可能会产生明显的性能成本，尤其是在较大的数组上。

Variant reduce(method: Callable, accum: Variant = null) const 🔗

对数组中的每个元素调用给定的Callable，在accum中累加结果，之后将其返回。

method接受两个参数：accum的当前值和当前数组元素。如果accum为null（默认情况下），迭代将从第二个元素开始，第一个元素用作accum的初始值。

func sum(accum, number):
    return accum + number

func _ready():
    print([1, 2, 3].reduce(sum, 0))  # Prints 6
    print([1, 2, 3].reduce(sum, 10)) # Prints 16

    # 与上文第一行（所述内容）相同，但其实现方式使用了 lambda 函数.
    print([1, 2, 3].reduce(func(accum, number): return accum + number, 10))

如果 max() 不合乎需求，也可以使用此方法来实现一个自定义比较器。

func _ready():
    var arr = [Vector2i(5, 0), Vector2i(3, 4), Vector2i(1, 2)]

    var longest_vec = arr.reduce(func(max, vec): return vec if is_length_greater(vec, max) else max)
    print(longest_vec) # Prints (3, 4)

func is_length_greater(a, b):
    return a.length() > b.length()

此方法还可用于统计数组中满足特定条件的元素数量，与 count() 的作用类似。

func is_even(number):
    return number % 2 == 0

func _ready():
    var arr = [1, 2, 3, 4, 5]
    # 若当前元素为偶数，则将计数（count）加 1；否则保持计数不变。
    var even_count = arr.reduce(func(count, next): return count + 1 if is_even(next) else count, 0)
    print(even_count) # Prints 2

另请参阅map()、filter()、any()和all()。

void remove_at(position: int) 🔗

从数组中删除给定索引（position）处的元素。如果索引超出范围，则此方法失败。

如果需要返回删除的元素，请使用pop_at()。要按值删除元素，请改用erase()。

注意：此方法将position之后的每个元素的索引向后移动，这可能会产生明显的性能成本，尤其是在较大的数组上。

注意：position不能为负数。要删除相对于数组末尾的元素，请使用arr.remove_at（arr. size（）-（i+1））。要从数组中删除最后一个元素，请使用arr.resize（arr.size（）-1）。

int resize(size: int) 🔗

将数组的元素数设置为size。如果size小于数组的当前大小，则删除末尾的元素。如果size更大，则根据数组的类型添加新的默认元素（通常为null）。

成功时返回@GlobalScope.OK，如果此方法失败，则返回其他Error常量之一。

注意：调用此方法一次并分配新值比为每个新元素调用append()更快。

void reverse() 🔗

反转数组中所有元素的顺序。

int rfind(what: Variant, from: int = -1) const 🔗

返回此数组中what的最后出现的索引，如果没有，则返回-1。搜索的开始可以用from指定，继续到数组的开始。此方法与find()相反。

int rfind_custom(method: Callable, from: int = -1) const 🔗

返回导致method返回true的数组的last元素的索引，如果没有，则返回-1。可以使用from指定搜索的开始，继续到数组的开头。此方法与find_custom()相反。

void set(index: int, value: Variant) 🔗

将给定index处的元素值设置为给定value。这不会改变数组的大小，它只改变数组中已有索引处的值。这与使用[]运算符（array[index]=value）相同。

void shuffle() 🔗

以随机顺序洗牌数组的所有元素。

注意：与引擎中的许多类似函数（例如@GlobalScope.randi()或pick_random()）一样，此方法使用通用的、全局随机的种子。要从该方法中获得可预测的结果，请参阅@GlobalScope.seed()。

int size() const 🔗

返回数组中元素的数量。空数组（[]）总是返回0。另请参见is_empty()。

Array slice(begin: int, end: int = 2147483647, step: int = 1, deep: bool = false) const 🔗

返回一个包含该数组元素的新Array，从索引begin（包含在内）到end（不包含在内），每个元素索引相差step。

若begin或end为负，它们相对于数组的末尾计算。

若step为负，该方法反向遍历数组，返回一个倒序排列的切片。为此，begin必须大于end。

如果deep为true，则切片中的所有嵌套的Array和Dictionary元素将从原始数组中递归地复制。另请参阅duplicate()。

var letters = ["A", "B", "C", "D", "E", "F"]

print(letters.slice(0, 2))  # Prints ["A", "B"]
print(letters.slice(2, -2)) # Prints ["C", "D"]
print(letters.slice(-2, 6)) # Prints ["E", "F"]

print(letters.slice(0, 6, 2))  # Prints ["A", "C", "E"]
print(letters.slice(4, 1, -1)) # Prints ["E", "D", "C"]

void sort() 🔗

将数组按升序排序。最终的排序顺序取决于元素之间的“小于”比较（<）。

var numbers = [10, 5, 2.5, 8]
numbers.sort()
print(numbers) # Prints [2.5, 5, 8, 10]

i3D.Collections.Array numbers = [10, 5, 2.5, 8];
numbers.Sort();
S3.Print(numbers); // Prints [2.5, 5, 8, 10]

注意：所使用的排序算法不稳定。这意味着在调用sort()时，相等的元素（如2和2.0）的顺序可能会发生变化。

void sort_custom(func: Callable) 🔗

使用自定义Callable对数组进行排序。

func根据需要多次调用，接收两个数组元素作为参数。如果第一个元素应该在第二个元素之前移动，则该函数应该返回true，否则它应该返回false。

func sort_ascending(a, b):
    if a[1] < b[1]:
        return true
    return false

func _ready():
    var my_items = [["Tomato", 5], ["Apple", 9], ["Rice", 4]]
    my_items.sort_custom(sort_ascending)
    print(my_items) # Prints [["Rice", 4], ["Tomato", 5], ["Apple", 9]]

    # Sort descending, using a lambda function.
    my_items.sort_custom(func(a, b): return a[1] > b[1])
    print(my_items) # Prints [["Apple", 9], ["Tomato", 5], ["Rice", 4]]

有时可能还需要使用此方法，结合 String.naturalnocasecmp_to() ，按自然顺序对字符串进行排序，如下例所示：

var files = ["newfile1", "newfile2", "newfile10", "newfile11"]
files.sort_custom(func(a, b): return a.naturalnocasecmp_to(b) < 0)
print(files) # Prints ["newfile1", "newfile2", "newfile10", "newfile11"]

注意:C#不支持该方法。

注意:所使用的排序算法不稳定。这意味着在调用该方法时，相等的元素顺序可能会发生变化。

注意:不要随机化func的返回值，因为堆排序算法需要一致的结果。随机化返回值会导致意外的行为。

运算符说明¶

bool operator !=(right: Array) 🔗

如果数组的大小或元素与right不同，则返回true。

Array operator +(right: Array) 🔗

将 right 数组追加到左操作数，创建一个新的 Array。这也称为数组拼接。

var array1 = ["One", 2]
var array2 = [3, "Four"]
print(array1 + array2) # Prints ["One", 2, 3, "Four"]

// Note that concatenation is not possible with C#'s native Array type.
i3D.Collections.Array array1 = ["One", 2];
i3D.Collections.Array array2 = [3, "Four"];
S3.Print(array1 + array2); // Prints ["One", 2, 3, "Four"]

注意:对于现有数组来说，append_array()比使用+=运算符进行拼接和赋值的效率要高得多。

bool operator <(right: Array) 🔗

按顺序比较两个数组的元素，从index0开始，以两个数组之间公共的最后一个索引结束。对于每对元素，如果该数组的元素小于rights，则返回true，如果该元素更大，则返回false。否则，继续下一对。

如果所有搜索的元素相等，则返回true如果此数组的大小小于right，否则返回false。

bool operator <=(right: Array) 🔗

如果所有搜索的元素相等，则返回true如果此数组的大小小于或等于rights，否则返回false。

bool operator ==(right: Array) 🔗

将左操作数Array与rightArray进行比较。如果数组的大小和内容相等，则返回true，否则返回false。

bool operator >(right: Array) 🔗

按顺序比较两个数组的元素，从index0开始，以两个数组之间公共的最后一个索引结束。对于每对元素，如果该数组的元素大于right的，则返回true，如果该元素较小，则返回false。否则，继续下一对。

如果所有搜索的元素相等，则返回true如果此数组的大小大于right，否则返回false。

bool operator >=(right: Array) 🔗

如果所有搜索的元素相等，则返回true如果此数组的大小大于或等于rights，否则返回false。

Variant operator [](index: int) 🔗

返回指定index处的Variant元素。数组从索引0开始。如果index大于或等于0，则从数组的开头开始获取元素。如果index为负值，则从末尾开始获取元素。越界访问数组将导致运行时错误，如果从编辑器运行，将暂停项目执行。