Array

Встроенная структура данных, содержащая последовательность элементов.

Описание

Структура данных массива, которая по умолчанию может содержать последовательность элементов любого типа Variant. При необходимости значения можно ограничить определённым типом, создав массив с типом. Доступ к элементам осуществляется по числовому индексу, начиная с 0. Отрицательные индексы используются для отсчёта от конца (-1 — последний элемент, -2 — предпоследний и т. д.).

var array = ["First", 2, 3, "Last"]
print(array[0])  # Выводит "First"
print(array[2])  # Выводит 3
print(array[-1]) # Выводит "Last"

array[1] = "Second"
print(array[1])  # Выводит "Second"
print(array[-3]) # Выводит "Second"

# Этот типизированный массив может содержать только целые числа.
# Попытка добавить любой другой тип приведет к ошибке.
var typed_array: Array[int] = [1, 2, 3]

Godot.Collections.Array array = ["First", 2, 3, "Last"];
GD.Print(array[0]); // Выводит "First"
GD.Print(array[2]); // Выводит 3
GD.Print(array[^1]); // Выводит "Last"

array[1] = "Second";
GD.Print(array[1]); // Выводит "Second"
GD.Print(array[^3]); // Выводит "Second"

// Этот типизированный массив может содержать только целые числа.
// Попытка добавить любой другой тип приведет к ошибке.
Godot.Collections.Array<int> typedArray = [1, 2, 3];

Примечание: Массивы всегда передаются по ссылке. Чтобы получить копию массива, которую можно изменять независимо от исходного, используйте duplicate().

Примечание: Удаление элементов при итерации по массивам не поддерживается и приведёт к непредсказуемому поведению.

Различия между упакованными, типизированными и нетипизированными массивами: Упакованные массивы, как правило, быстрее итерируются и изменяются по сравнению с типизированными массивами того же типа (например, PackedInt64Array против Array[int]). Кроме того, упакованные массивы потребляют меньше памяти. Недостатком упакованных массивов является их меньшая гибкость, поскольку они не предлагают столько удобных методов, как map(). Типизированные массивы, в свою очередь, быстрее итерируются и изменяются, чем нетипизированные массивы.

Примечание

Существуют заметные различия при использовании данного API с C#. Подробнее см. API различия C# и GDScript.

Конструкторы

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
Array	duplicate_deep(deep_subresources_mode: int = 1) 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 Node

class Stats:
    pass

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

Элементы массива base преобразуются при необходимости. Если это невозможно или base уже типизирован, этот конструктор завершается ошибкой и возвращает пустой Array.

В GDScript этот конструктор обычно не нужен, так как можно создать типизированный массив посредством статической типизации:

var numbers: Array[float] = []
var children: Array[Node] = [$Node, $Sprite2D, $RigidBody3D]

var integers: Array[int] = [0.2, 4.5, -2.0]
print(integers) # Выводит [0, 4, -2]

Array Array(from: Array)

Возвращает тот же массив, что и from. Если вам нужна копия массива, используйте duplicate().

Array Array(from: PackedByteArray)

Создает массив из PackedByteArray.

Array Array(from: PackedColorArray)

Создает массив из PackedColorArray.

Array Array(from: PackedFloat32Array)

Создает массив из Packed Float32Array.

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 для каждого элемента массива и возвращает true, если Callable возвращает 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)) # Выводит true (3/3 элементы оцениваются как true).
    print([4, 10, 4].all(greater_than_5)) # Выводит false (1/3 элементы оцениваются как true).
    print([4, 4, 4].all(greater_than_5))  # Выводит false (0/3 элементы оцениваются как true).
    print([].all(greater_than_5))         # Выводит true (0/0 элементы оцениваются как true).

    # То же, что и в первой строке выше, но с использованием лямбда-функции.
    print([6, 10, 6].all(func(element): return element > 5)) # Выводит true

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

public override void _Ready()
{
    // Выводит True (3/3 элементы оцениваются как true).
    GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(GreaterThan5));
    // Выводит False (1/3 элементы оцениваются как true).
    GD.Print(new Godot.Collections.Array>int< { 4, 10, 4 }.All(GreaterThan5));
    // Выводит False (0/3 элементы оцениваются как true).
    GD.Print(new Godot.Collections.Array>int< { 4, 4, 4 }.All(GreaterThan5));
    // Выводит True (0/0 элементы оцениваются как true).
    GD.Print(new Godot.Collections.Array>int< { }.All(GreaterThan5));

    // То же, что и в первой строке выше, но с использованием лямбда-функции.
    GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(element => element > 5)); // Выводит True
}

См. также any(), filter(), map() и reduce().

Примечание: В отличие от использования размера массива, возвращаемого filter(), этот метод вернет управление как можно раньше, чтобы повысить производительность (особенно с большими массивами).

Примечание: Для пустого массива этот метод всегда возвращает true.

bool any(method: Callable) const 🔗

Вызывает заданный Callable для каждого элемента в массиве и возвращает true, если Callable возвращает 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)) # Выводит true (3 элементы оцениваются как true).
    print([4, 10, 4].any(greater_than_5)) # Выводит true (1 элементы оцениваются как true).
    print([4, 4, 4].any(greater_than_5))  # Выводит false (0 элементы оцениваются как true).
    print([].any(greater_than_5))         # Выводит false (0 элементы оцениваются как true).

    # То же, что и в первой строке выше, но с использованием лямбда-функции.
    print([6, 10, 6].any(func(number): return number > 5)) # Выводит 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))  # Печатает 1, указывает на первый "Lemon".
print(fruits.bsearch("Lemon", false)) # Печатает 3, указывают на "Lemon".

Примечание: Вызов bsearch() для unsorted (несортированного) массива приведет к неожиданному поведению. Используйте sort() перед вызовом этого метода.

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

Возвращает индекс value в отсортированном массиве. Если его не удается найти, возвращает, куда следует вставить value, чтобы сохранить массив отсортированным (используя func для сравнений). Используемый алгоритм — бинарный поиск.

Подобно sort_custom(), func вызывается столько раз, сколько необходимо, получая один элемент массива и value в качестве аргументов. Функция должна возвращать true, если элемент массива должен быть behind (позади) value, в противном случае она должна возвращать 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" вставляется перед "Kiwi".
    my_items.insert(my_items.bsearch_custom(apple, sort_by_amount, true), apple)

    var banana = ["Banana", 5]
    # "Banana" вставляется после "Kiwi".
    my_items.insert(my_items.bsearch_custom(banana, sort_by_amount, false), banana)

    # Выводит [["Tomato", 2], ["Apple", 5], ["Kiwi", 5], ["Banana", 5], ["Rice", 9]]
    print(my_items)

Примечание: Вызов bsearch_custom() для несортированного массива приведет к неожиданному поведению. Используйте sort_custom() с func перед вызовом этого метода.

void clear() 🔗

Удаляет все элементы из массива. Это эквивалентно использованию resize() с размером 0.

int count(value: Variant) const 🔗

Возвращает количество раз, когда элемент встречается в массиве.

Чтобы подсчитать, сколько элементов в массиве удовлетворяют условию, см. reduce().

Array duplicate(deep: bool = false) const 🔗

Возвращает новую копию массива.

По умолчанию возвращается неглубокая копия: все вложенные элементы Array, Dictionary и Resource используются совместно с исходным массивом. Изменение любого из них в одном массиве также повлияет на них в другом.

Если deep равен true, возвращается глубокая копия: все вложенные массивы и словари также дублируются (рекурсивно). Однако любой Resource по-прежнему используется совместно с исходным массивом.

Array duplicate_deep(deep_subresources_mode: int = 1) const 🔗

Дублирует этот массив, глубоко, как duplicate() при передаче true, с дополнительным контролем над обработкой подресурсов.

deep_subresources_mode должен быть одним из значений из DeepDuplicateMode. По умолчанию дублируются только внутренние ресурсы (рекурсивно).

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]

Godot.Collections.Array array = [];
array.Resize(5);
array.Fill(2);
GD.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)) # Выводит [4, 8]

    # То же, что и выше, но с использованием лямбда-функции.
    print([1, 4, 5, 8].filter(func(number): return number % 2 == 0))

См. также any(), all(), map() и reduce().

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

Возвращает индекс first (первого) вхождения what в этом массиве или -1, если их нет. Начало поиска можно указать с помощью from, продолжая до конца массива.

Примечание: Если вы просто хотите узнать, содержит ли массив what, используйте has() (Contains в C#). В GDScript вы также можете использовать оператор in.

Примечание: Из соображений производительности на поиск влияет Variant.Type what. Например, 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 в массиве. Если index выходит за пределы массива или имеет отрицательное значение, этот метод завершается с ошибкой и возвращает null.

Этот метод похож (но не идентичен) оператору []. Наиболее примечательно то, что при сбое этого метода выполнение проекта не приостанавливается, если он запускается из редактора.

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 🔗

Возвращает true, если массив содержит указанное value.

print(["inside", 7].has("inside"))  # Выводит true
print(["inside", 7].has("outside")) # Выводит false
print(["inside", 7].has(7))         # Выводит true
print(["inside", 7].has("7"))       # Выводит false

Godot.Collections.Array arr = ["inside", 7];
// По соглашению C# этот метод переименован в `Contains`.
GD.Print(arr.Contains("inside"));  // Выводит True
GD.Print(arr.Contains("outside")); // Выводит False
GD.Print(arr.Contains(7));         // Выводит True
GD.Print(arr.Contains("7"));       // Выводит False

В GDScript это эквивалентно оператору in:

if 4 in [2, 4, 6, 8]:
    print("4 уже здесь!") # Будет напечатано.

Примечание: Из соображений производительности на поиск влияет value Variant.Type. Например, 7 (int) и 7.0 (float) не считаются равными для этого метода.

int hash() const 🔗

Возвращает хешированное 32-битное целое число, представляющее массив и его содержимое.

Примечание: Массивы с одинаковыми хеш-значениями не гарантированно будут одинаковыми из-за коллизий хеширования. Напротив, массивы с разными хеш-значениями гарантированно будут разными.

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

Вставляет новый элемент (value) по указанному индексу (position) в массиве. position должен быть между 0 и size() массива. Если отрицательно, position считается относительно конца массива.

Возвращает @GlobalScope.OK в случае успеха или одну из других констант Error, если этот метод не выполняется.

Примечание: Индекс каждого элемента после position необходимо сместить вперед, что может иметь заметные потери производительности, особенно в больших массивах.

bool is_empty() const 🔗

Возвращает true, если массив пуст ([]). См. также size().

bool is_read_only() const 🔗

Возвращает true, если массив доступен только для чтения. См. make_read_only().

В GDScript массивы автоматически доступны только для чтения, если объявлены с ключевым словом const.

bool is_same_typed(array: Array) const 🔗

Возвращает true, если этот массив типизирован так же, как заданный array. См. также is_typed().

bool is_typed() const 🔗

Возвращает true, если массив типизирован. Типизированные массивы могут содержать только элементы определенного типа, как определено конструктором типизированного массива. Методы типизированного массива по-прежнему должны возвращать обобщенный Variant.

В GDScript можно определить типизированный массив со статической типизацией:

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

void make_read_only() 🔗

Делает массив доступным только для чтения. Элементы массива не могут быть переопределены другими значениями, и их порядок не может быть изменен. Не применяется к вложенным элементам, таким как словари.

В GDScript массивы автоматически доступны только для чтения, если объявлены с ключевым словом 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]

    # То же, что и выше, но с использованием лямбда-функции.
    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, если массив пуст.

# Может печатать 1, 2, 3.25 или "Привет".
print([1, 2, 3.25, "Привет"].pick_random())

Godot.Collections.Array array = [1, 2, 3.25f, "Привет"];
GD.Print(array.PickRandom()); // Может печатать 1, 2, 3.25 или "Привет".

Примечание: Как и многие подобные функции в движке (например, @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))  # Выводит 6
    print([1, 2, 3].reduce(sum, 10)) # Выводит 16

    # То же, что и выше, но с использованием лямбда-функции.
    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) # Выводит (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, в противном случае оставляем count прежним.
    var even_count = arr.reduce(func(count, next): return count + 1 if is_even(next) else count, 0)
    print(even_count) # Выводит 2

См. также map(), filter(), any() и all().

void remove_at(position: int) 🔗

Удаляет элемент из массива по заданному индексу (position). Если индекс выходит за пределы массива, этот метод завершается ошибкой. Если индекс отрицательный, position считается относительным к концу массива.

Если вам нужно вернуть удаленный элемент, используйте pop_at(). Для удаления элемента по значению используйте erase() вместо этого.

Примечание: Этот метод сдвигает индекс каждого элемента после position назад, что может заметно снизить производительность, особенно в больших массивах.

int resize(size: int) 🔗

Устанавливает количество элементов массива равным size. Если size меньше текущего размера массива, элементы в конце удаляются. Если size больше, добавляются новые элементы по умолчанию (обычно null) в зависимости от типа массива.

Возвращает @GlobalScope.OK в случае успеха или одну из следующих констант Error, если этот метод не срабатывает: @GlobalScope.ERR_LOCKED, если массив доступен только для чтения, @GlobalScope.ERR_INVALID_PARAMETER, если размер отрицательный, или @GlobalScope.ERR_OUT_OF_MEMORY, если выделение памяти не удается. Используйте size(), чтобы узнать фактический размер массива после изменения размера.

Примечание: Вызов этого метода один раз и назначение новых значений выполняется быстрее, чем вызов 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 или -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))  # Выводит ["A", "B"]
print(letters.slice(2, -2)) # Выводит ["C", "D"]
print(letters.slice(-2, 6)) # Выводит ["E", "F"]

print(letters.slice(0, 6, 2))  # Выводит ["A", "C", "E"]
print(letters.slice(4, 1, -1)) # Выводит ["E", "D", "C"]

void sort() 🔗

Сортирует массив в порядке возрастания. Окончательный порядок зависит от сравнения "меньше" (<) между элементами.

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

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

Примечание: Используемый алгоритм сортировки не является стабильным. Это означает, что эквивалентные элементы (такие как 2 и 2.0) могут иметь измененный порядок при вызове sort().

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]]

    #Сортировка по убыванию с использованием лямбда-функции.
    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) 🔗

Возвращает true, если размер массива или его элементов отличается от right.

Array operator +(right: Array) 🔗

Добавляет массив right к левому операнду, создавая новый Array. Это также известно как конкатенация массивов.

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

// Обратите внимание, что конкатенация невозможна с собственным типом массива C#.
Godot.Collections.Array array1 = ["One", 2];
Godot.Collections.Array array2 = [3, "Four"];
GD.Print(array1 + array2); // Prints ["One", 2, 3, "Four"]

Примечание: Для существующих массивов append_array() гораздо эффективнее, чем конкатенация и присваивание с помощью оператора +=.

bool operator <(right: Array) 🔗

Сравнивает элементы обоих массивов по порядку, начиная с индекса 0 и заканчивая последним общим индексом для обоих массивов. Для каждой пары элементов возвращает true, если элемент этого массива меньше, чем right, false, если этот элемент больше. В противном случае переходит к следующей паре.

Если все искомые элементы равны, возвращает true, если размер этого массива меньше, чем right, в противном случае возвращает false.

bool operator <=(right: Array) 🔗

Сравнивает элементы обоих массивов по порядку, начиная с индекса 0 и заканчивая последним общим индексом для обоих массивов. Для каждой пары элементов возвращает true, если элемент этого массива меньше, чем right, false, если этот элемент больше. В противном случае переходит к следующей паре.

Если все искомые элементы равны, возвращает true, если размер этого массива меньше или равен right, в противном случае возвращает false.

bool operator ==(right: Array) 🔗

Сравнивает левый операнд Array с right Array. Возвращает true, если размеры и содержимое массивов равны, в противном случае false .

bool operator >(right: Array) 🔗

Сравнивает элементы обоих массивов по порядку, начиная с индекса 0 и заканчивая последним общим индексом для обоих массивов. Для каждой пары элементов возвращает true, если элемент этого массива больше, чем right, false, если этот элемент меньше. В противном случае переходит к следующей паре.

Если все искомые элементы равны, возвращает true, если размер этого массива больше, чем right, в противном случае возвращает false.

bool operator >=(right: Array) 🔗

Сравнивает элементы обоих массивов по порядку, начиная с индекса 0 и заканчивая последним общим индексом для обоих массивов. Для каждой пары элементов возвращает true, если элемент этого массива больше, чем right, false, если этот элемент меньше. В противном случае переходит к следующей паре.

Если все искомые элементы равны, возвращает true, если размер этого массива больше или равен right, в противном случае возвращает false.

Variant operator [](index: int) 🔗

Возвращает элемент Variant по указанному index. Массивы начинаются с индекса 0. Если index больше или равен 0, элемент извлекается, начиная с начала массива. Если index — отрицательное значение, элемент извлекается, начиная с конца. Доступ к массиву за пределами границ вызовет ошибку времени выполнения, приостанавливая выполнение проекта, если он запущен из редактора.