Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Array

Una estructura de datos incorporada que contiene una secuencia de elementos.

Descripción

An array data structure that can contain a sequence of elements of any Variant type by default. Values can optionally be constrained to a specific type by creating a typed array. Elements are accessed by a numerical index starting at 0. Negative indices are used to count from the back (-1 is the last element, -2 is the second to last, etc.).

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"

# This typed array can only contain integers.
# Attempting to add any other type will result in an error.
var typed_array: Array[int] = [1, 2, 3]

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

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

// This typed array can only contain integers.
// Attempting to add any other type will result in an error.
Godot.Collections.Array<int> typedArray = [1, 2, 3];

Note: Arrays are always passed by reference. To get a copy of an array that can be modified independently of the original array, use duplicate().

Note: Erasing elements while iterating over arrays is not supported and will result in unpredictable behavior.

Note: In a boolean context, an array will evaluate to false if it's empty ([]). Otherwise, an array will always evaluate to true.

Differences between packed arrays, typed arrays, and untyped arrays: Packed arrays are generally faster to iterate on and modify compared to a typed array of the same type (e.g. PackedInt64Array versus Array[int]). Also, packed arrays consume less memory. As a downside, packed arrays are less flexible as they don't offer as many convenience methods such as map(). Typed arrays are in turn faster to iterate on and modify than untyped arrays.

Nota

Hay diferencias notables cuando usa esta API con C#. Véase Diferencias de la API de C# con GDScript para más información.

Constructores

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)

Métodos

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)

Operadores

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)

Descripciones de Constructores

Array Array() 🔗

Construye un Array vacío.

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

Crea un arreglo tipado a partir del arreglo base. Un arreglo tipado solo puede contener elementos del tipo indicado, o que hereden de la clase especificada, según lo descrito por los parámetros de este constructor:

type es el tipo incorporado de Variant, como una de las constantes de Variant.Type.
class_name es el nombre de la clase incorporada (ver Object.get_class()).
script es el script asociado. Debe ser una instancia de Script o null.

Si type no es @GlobalScope.TYPE_OBJECT, class_name debe ser un StringName vacío y script debe ser 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]

Los elementos del arreglo base se convierten cuando es necesario. Si esto no es posible o si base ya es tipado, este constructor falla y devuelve un Array vacío.

En GDScript, este constructor normalmente no es necesario, ya que es posible crear un arreglo tipado mediante tipado estático:

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

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

Array Array(from: Array)

Devuelve la misma matriz que from. Si necesitas una copia de la matriz, utiliza duplicate().

Array Array(from: PackedByteArray)

Construye un array a partir de un PackedByteArray.

Array Array(from: PackedColorArray)

Construye un array a partir de un PackedColorArray.

Array Array(from: PackedFloat32Array)

Construye un array a partir de un PackedInt64Array.

Array Array(from: PackedFloat64Array)

Construye un array a partir de un PackedInt64Array.

Array Array(from: PackedInt32Array)

Construye un array a partir de un PackedInt64Array.

Array Array(from: PackedInt64Array)

Construye un array a partir de un PackedInt64Array.

Array Array(from: PackedStringArray)

Construye un array a partir de un PackedStringArray.

Array Array(from: PackedVector2Array)

Construye un array a partir de un PackedVector2Array.

Array Array(from: PackedVector3Array)

Construye un array a partir de un PackedVector3Array.

Array Array(from: PackedVector4Array)

Construye un array a partir de un PackedVector2Array.

Descripciones de Métodos

bool all(method: Callable) const 🔗

Llama al Callable dado para cada elemento del arreglo y devuelve true si el Callable devuelve true para todos los elementos del arreglo. Si el Callable devuelve false para uno o más elementos, este método devuelve false.

El parámetro method debe recibir un parámetro Variant (el elemento actual del arreglo) y devolver un bool.

func greater_than_5(number):
    return number > 5

func _ready():
    print([6, 10, 6].all(greater_than_5)) # Imprime true (3/3 elementos evalúan a true).
    print([4, 10, 4].all(greater_than_5)) # Imprime false (1/3 elementos evalúan a true).
    print([4, 4, 4].all(greater_than_5))  # Imprime false (0/3 elementos evalúan a true).
    print([].all(greater_than_5))         # Imprime true (0/0 elementos evalúan a true).

    # Igual que la primera línea de arriba, pero usando una función lambda.
    print([6, 10, 6].all(func(element): return element > 5)) # Imprime true

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

public override void _Ready()
{
    // Imprime True (3/3 elementos evalúan a true).
    GD.Print(new Godot.Collections.Array<int> { 6, 10, 6 }.All(GreaterThan5));
    // Imprime False (1/3 elementos evalúan a true).
    GD.Print(new Godot.Collections.Array<int> { 4, 10, 4 }.All(GreaterThan5));
    // Imprime False (0/3 elementos evalúan a true).
    GD.Print(new Godot.Collections.Array<int> { 4, 4, 4 }.All(GreaterThan5));
    // Imprime True (0/0 elementos evalúan a true).
    GD.Print(new Godot.Collections.Array<int> { }.All(GreaterThan5));

    // Igual que la primera línea de arriba, pero usando una función lambda.
    GD.Print(new Godot.Collections.Array<int> { 6, 10, 6 }.All(element => element > 5)); // Imprime True
}

Véase también any(), filter(), map() y reduce().

Nota: A diferencia de depender del tamaño de un arreglo devuelto por filter(), este método devuelve el resultado lo antes posible para mejorar el rendimiento (especialmente con arreglos grandes).

Nota: Para un arreglo vacío, este método siempre devuelve true.

bool any(method: Callable) const 🔗

Llama al Callable dado para cada elemento del arreglo y devuelve true si el Callable devuelve true para uno o más elementos del arreglo. Si el Callable devuelve false para todos los elementos, este método devuelve false.

El parámetro method debe recibir un parámetro Variant (el elemento actual del arreglo) y devolver un bool.

func greater_than_5(number):
    return number > 5

func _ready():
    print([6, 10, 6].any(greater_than_5)) # Imprime true (3 elementos evalúan a true).
    print([4, 10, 4].any(greater_than_5)) # Imprime true (1 elemento evalúa a true).
    print([4, 4, 4].any(greater_than_5))  # Imprime false (0 elementos evalúan a true).
    print([].any(greater_than_5))         # Imprime false (0 elementos evalúan a true).

    # Igual que la primera línea de arriba, pero usando una función lambda.
    print([6, 10, 6].any(func(number): return number > 5)) # Imprime true

Véase también all(), filter(), map() y reduce().

Nota: A diferencia de depender del tamaño de un arreglo devuelto por filter(), este método devuelve el resultado lo antes posible para mejorar el rendimiento (especialmente con arreglos grandes).

Nota: Para un arreglo vacío, este método siempre devuelve false.

void append(value: Variant) 🔗

Concatena value al final del array (alias de push_back()).

void append_array(array: Array) 🔗

Añade otro array al final de este array.

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

void assign(array: Array) 🔗

Asigna los elementos de otro array en el array. Cambia el tamaño del array para que coincida con array. Realiza conversiones de tipo si el array está tipado.

Variant back() const 🔗

Devuelve el último elemento del array. Si el array está vacío, falla y devuelve null. Véase también front().

Nota: A diferencia del [] operador (array[-1]), se genera un error sin detener la ejecución del proyecto.

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

Devuelve el índice de value en el arreglo ordenado. Si no se encuentra, devuelve la posición en la que se debería insertar value para mantener el arreglo ordenado. El algoritmo utilizado es la búsqueda binaria.

Si el parámetro before es true (como por defecto), el índice devuelto estará antes de todos los elementos existentes iguales a value en el arreglo.

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

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

var fruits = ["Limón", "Manzana", "Manzana", "Naranja"]
print(fruits.bsearch("Manzana", true)) # Imprime 1, apunta al primer "Manzana".
print(fruits.bsearch("Manzana", false)) # Imprime 3, apunta a "Naranja".

Nota: Llamar a bsearch() sobre un arreglo no ordenado dará lugar a un comportamiento inesperado. Utilice sort() antes de llamar a este método.

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

Devuelve el índice de value en el arreglo ordenado. Si no se encuentra, devuelve la posición en la que se debería insertar value para mantener el arreglo ordenado (utilizando func para las comparaciones). El algoritmo utilizado es la búsqueda binaria.

De manera similar a sort_custom(), func se llama tantas veces como sea necesario, recibiendo un elemento del arreglo y value como argumentos. La función debe devolver true si el elemento del arreglo debe colocarse detrás de value, de lo contrario debe devolver false.

Si before es true (como por defecto), el índice devuelto estará antes de todos los elementos existentes iguales a value en el arreglo.

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" se inserta antes de "Kiwi".
    my_items.insert(my_items.bsearch_custom(apple, sort_by_amount, true), apple)

    var banana = ["Banana", 5]
    # "Banana" se inserta después de "Kiwi".
    my_items.insert(my_items.bsearch_custom(banana, sort_by_amount, false), banana)

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

Nota: Llamar a bsearch_custom() sobre un arreglo no ordenado dará lugar a un comportamiento inesperado. Use sort_custom() con func antes de llamar a este método.

void clear() 🔗

Elimina todos los elementos del array. Esto es equivalente a usar resize() con un tamaño de 0.

int count(value: Variant) const 🔗

Devuelve el número de veces que un elemento está en el array.

Para contar cuántos elementos de un array satisfacen una condición, véase reduce().

Array duplicate(deep: bool = false) const 🔗

Devuelve una copia nueva del array.

Por defecto, una copia superficial: todos los elementos anidados Array, Dictionary, y Resource son compartidos con el array original. Modificar cualquiera de estos en un array también los afectará en el otro.

Si deep es true, se devuelve una copia profunda: Todos los arrays y dictionaries son también duplicados (recursivamente). Sin embargo, Cualquier Resource es todavía compartido con el array original.

Array duplicate_deep(deep_subresources_mode: int = 1) const 🔗

Duplica este array profundamente, como duplicate() al pasar true, con control adicional sobre cómo se manejan los subrecursos.

deep_subresources_mode debe ser uno de los valores de DeepDuplicateMode. Por defecto, solo se duplicarán los recursos internos (recursivamente).

void erase(value: Variant) 🔗

Encuentra y elimina la primera aparición de value del array. Si value no existe en el array, no ocurre nada. Para eliminar un elemento por índice, usa remove_at() en su lugar.

Nota: Este método desplaza hacia atrás el índice de cada elemento después del value eliminado, lo que puede tener un coste de rendimiento notable, especialmente en arrays grandes.

Nota: Eliminar elementos mientras se itera sobre arrays no está soportado y resultará en un comportamiento impredecible.

void fill(value: Variant) 🔗

Asigna el value dado a todos los elementos del arreglo.

Este método se puede combinar a menudo con resize() para crear un arreglo de un tamaño determinado y con elementos inicializados:

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

Godot.Collections.Array array = [];
array.Resize(5);
array.Fill(2);
GD.Print(array); // Imprime [2, 2, 2, 2, 2]

Nota: Si value es un Variant pasado por referencia (derivado de Object, Array, Dictionary, etc.), el arreglo se llenará con referencias al mismo value, las cuales no son duplicados.

Array filter(method: Callable) const 🔗

Llama al Callable dado para cada elemento del arreglo y devuelve un nuevo Array filtrado.

El parámetro method recibe como argumento uno de los elementos del arreglo y debe devolver true para agregar el elemento al arreglo filtrado, o false para excluirlo.

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

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

    # Igual que arriba, pero usando una función lambda.
    print([1, 4, 5, 8].filter(func(number): return number % 2 == 0))

Véase también any(), all(), map() y reduce().

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

Devuelve el índice de la primera aparición de what en este arreglo, o -1 si no existe ninguna. El inicio de la búsqueda puede especificarse con from, continuando hasta el final del arreglo.

Nota: Si solo desea comprobar si el arreglo contiene what, utilice has() (Contains en C#). En GDScript, también puede usar el operador in.

Nota: Por razones de rendimiento, la búsqueda está influenciada por el Variant.Type de what. Por ejemplo, 7 (int) y 7.0 (float) no se consideran iguales para este método.

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

Returns the index of the first element in the array that causes method to return true, or -1 if there are none. The search's start can be specified with from, continuing to the end of the array.

method is a callable that takes an element of the array, and returns a bool.

Note: If you just want to know whether the array contains anything that satisfies method, use any().

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

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

# Another example using `bind()` to pass an additional parameter:
func is_specific_number(number, expected):
    return number == expected

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

Variant front() const 🔗

Devuelve el primer elemento del Arreglo. Imprime un error y retorna null si el array está vacío. Véase también back().

Note: Llamar esta función [] no es lo mismo que poner array[0]. Si el array está vacío, acceder por el índice detendrá el la ejecución del proyecto si se ejecuta desde el Editor.

Variant get(index: int) const 🔗

Devuelve el elemento en el index dado en el array. Si index está fuera de los límites o es negativo, este método falla y devuelve null.

Este método es similar (pero no idéntico) al operador []. Lo más notable es que, cuando este método falla, no pausa la ejecución del proyecto si se ejecuta desde el editor.

int get_typed_builtin() const 🔗

Devuelve el tipo Variant incorporado del array tipado como una constante Variant.Type. Si el array no está tipado, devuelve @GlobalScope.TYPE_NIL. Véase también is_typed().

StringName get_typed_class_name() const 🔗

Devuelve el nombre de la clase incorporada del array tipado, si el tipo Variant incorporado es @GlobalScope.TYPE_OBJECT. De lo contrario, devuelve un StringName vacío. Véase también is_typed() y Object.get_class().

Variant get_typed_script() const 🔗

Devuelve la instancia de Script asociada con este array tipado, o null si no existe. Véase también is_typed().

bool has(value: Variant) const 🔗

Devuelve true si el array contiene el value dado.

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

Godot.Collections.Array arr = ["inside", 7];
// Por convención de C#, este método se renombra a `Contains`.
GD.Print(arr.Contains("inside"));  // Imprime True
GD.Print(arr.Contains("outside")); // Imprime False
GD.Print(arr.Contains(7));         // Imprime True
GD.Print(arr.Contains("7"));       // Imprime False

En GDScript, esto es equivalente al operador in:

if 4 in [2, 4, 6, 8]:
    print("¡4 está aquí!") # Se imprimirá.

Nota: Por razones de rendimiento, la búsqueda se ve afectada por el Variant.Type del value. Por ejemplo, 7 (int) y 7.0 (float) no se consideran iguales para este método.

int hash() const 🔗

Devuelve un valor entero hash de 32 bits que representa el array y su contenido.

Nota: No se garantiza que los arrays con valores hash iguales sean idénticos, como resultado de las colisiones hash. Por el contrario, se garantiza que los arrays con valores hash diferentes sean distintos.

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

Inserta un nuevo elemento (value) en un índice dado (position) en el array. position debe estar entre 0 y el size() del array. Si es negativo, position se considera relativo al final del array.

Devuelve @GlobalScope.OK si tiene éxito, o una de las otras constantes Error si este método falla.

Nota: El índice de cada elemento después de position necesita ser desplazado hacia adelante, lo que puede tener un costo de rendimiento notable, especialmente en arrays más grandes.

bool is_empty() const 🔗

Devuelve true si el array está vacío ([]). Véase también size().

bool is_read_only() const 🔗

Devuelve true si el array es de solo lectura. Véase make_read_only().

En GDScript, los arrays son automáticamente de solo lectura si se declaran con la palabra clave const.

bool is_same_typed(array: Array) const 🔗

Devuelve true si este array tiene el mismo tipo que el array dado. Véase también is_typed().

bool is_typed() const 🔗

Devuelve true si el array está tipado. Los arrays tipados solo pueden contener elementos de un tipo específico, tal como lo define el constructor de array tipado. Se espera que los métodos de un array tipado devuelvan un Variant genérico.

En GDScript, es posible definir un array tipado con tipado estático:

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

void make_read_only() 🔗

Hace que el array sea de solo lectura. Los elementos del array no pueden ser sobrescritos con diferentes valores, y su orden no puede cambiar. No se aplica a los elementos anidados, como los diccionarios.

En GDScript, los arrays son automáticamente de solo lectura si se declaran con la palabra clave const.

Array map(method: Callable) const 🔗

Llama al Callable dado para cada elemento del arreglo y devuelve un nuevo arreglo con los valores devueltos por method.

El method debe recibir un parámetro Variant (el elemento actual del arreglo) y puede devolver cualquier Variant.

func double(number):
    return number * 2

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

    # Igual que arriba, pero usando una función lambda.
    print([1, 2, 3].map(func(element): return element * 2))

Véase también filter(), reduce(), any() y all().

Variant max() const 🔗

Devuelve el valor máximo contenido en el array, si todos los elementos se pueden comparar. De lo contrario, devuelve null. Véase también min().

Para encontrar el valor máximo utilizando un comparador personalizado, puedes usar reduce().

Variant min() const 🔗

Devuelve el valor mínimo contenido en el array, si todos los elementos se pueden comparar. De lo contrario, devuelve null. Véase también max().

Variant pick_random() const 🔗

Devuelve un elemento aleatorio del arreglo. Genera un error y devuelve null si el arreglo está vacío.

# Puede imprimir 1, 2, 3.25 o "Hi".
print([1, 2, 3.25, "Hi"].pick_random())

Godot.Collections.Array array = [1, 2, 3.25f, "Hi"];
GD.Print(array.PickRandom()); // Puede imprimir 1, 2, 3.25 o "Hi".

Nota: Al igual que muchas funciones similares en el motor (como @GlobalScope.randi() o shuffle()), este método utiliza una semilla aleatoria global común. Para obtener un resultado predecible con este método, véase @GlobalScope.seed().

Variant pop_at(position: int) 🔗

Elimina y devuelve el elemento del array en el índice position. Si es negativo, position se considera relativo al final del array. Devuelve null si el array está vacío. Si position está fuera de los límites, también se genera un mensaje de error.

Nota: Este método desplaza hacia atrás el índice de cada elemento después de position, lo que puede tener un costo de rendimiento notable, especialmente en arrays grandes.

Variant pop_back() 🔗

Elimina y devuelve el ultimo elemento del array. Devuelve null si el array esta vacío, sin generar un error. Véase también pop_front().

Variant pop_front() 🔗

Elimina y devuelve el primer elemento del array. Devuelve null si el array está vacío, sin mostrar un mensaje de error. Véase también pop_back().

Note: En arrays largos, este método es mucho más lento que pop_back() debido a que tiene que re-indexar todos los elementos del array cada vez que es llamado. Mientras más largo el array, más lento será pop_front().

void push_back(value: Variant) 🔗

Agrega un elemento al final del array (alias de push_back()).

void push_front(value: Variant) 🔗

Adds an element at the beginning of the array. See also push_back().

Note: This method shifts every other element's index forward, which may have a noticeable performance cost, especially on larger arrays.

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

Llama al Callable dado para cada elemento del arreglo, acumula el resultado en accum y luego lo devuelve.

El method recibe dos argumentos: el valor actual de accum y el elemento actual del arreglo. Si accum es null (como por defecto), la iteración comenzará desde el segundo elemento, utilizando el primero como valor inicial de accum.

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

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

    # Igual que arriba, pero usando una función lambda.
    print([1, 2, 3].reduce(func(accum, number): return accum + number, 10))

Si max() no es adecuado, este método también puede utilizarse para implementar un comparador personalizado:

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) # Imprime (3, 4)

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

Este método también puede utilizarse para contar cuántos elementos de un arreglo cumplen cierta condición, de forma similar a count():

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

func _ready():
    var arr = [1, 2, 3, 4, 5]
    # Si el elemento actual es par, incrementa el contador; de lo contrario, lo deja igual.
    var even_count = arr.reduce(func(count, next): return count + 1 if is_even(next) else count, 0)
    print(even_count) # Imprime 2

Véase también map(), filter(), any() y all().

void remove_at(position: int) 🔗

Elimina el elemento del array en el índice dado (position). Si el índice está fuera de los límites, este método falla. Si el índice es negativo, position se considera relativo al final del array.

Si necesitas devolver el elemento eliminado, usa pop_at(). Para eliminar un elemento por valor, usa erase() en su lugar.

Nota: Este método desplaza hacia atrás el índice de cada elemento después de position, lo que puede tener un coste de rendimiento notable, especialmente en arrays grandes.

int resize(size: int) 🔗

Establece el número de elementos del array a size. Si size es menor que el tamaño actual del array, se eliminan los elementos al final. Si size es mayor, se añaden nuevos elementos predeterminados (usualmente null), dependiendo del tipo del array.

Devuelve @GlobalScope.OK si tiene éxito, o una de las siguientes constantes Error si este método falla: @GlobalScope.ERR_LOCKED si el array es de solo lectura, @GlobalScope.ERR_INVALID_PARAMETER si el tamaño es negativo, o @GlobalScope.ERR_OUT_OF_MEMORY si fallan las asignaciones. Usa size() para encontrar el tamaño real del array después de redimensionar.

Nota: Llamar a este método una vez y asignar los nuevos valores es más rápido que llamar a append() para cada nuevo elemento.

void reverse() 🔗

Invierte el orden de todos los elementos del array.

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

Devuelve el índice de la última aparición de what en este arreglo, o -1 si no existe ninguna. El inicio de la búsqueda puede especificarse con from, continuando hacia el comienzo del arreglo. Este método es el inverso de find().

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

Devuelve el índice del último elemento que produce que method devuelva true, o -1 si no existe ninguno. El inicio de la búsqueda puede especificarse con from, continuando hacia el comienzo del arreglo. Este método es el inverso de find_custom().

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

Asigna el value al elemento en el index indicado. Esto no cambia el tamaño del arreglo; únicamente modifica el valor en un índice que ya existe. Es equivalente a usar el operador [] (array[index] = value).

void shuffle() 🔗

Reordena todos los elementos del arreglo en un orden aleatorio.

Nota: Al igual que muchas funciones similares en el motor (como @GlobalScope.randi() o pick_random()), este método utiliza una semilla aleatoria global compartida. Para obtener un resultado predecible con este método, véase @GlobalScope.seed().

int size() const 🔗

Devuelve el número de elementos en el array. Si el array está vacío ([]), devuelve 0. Ver también is_empty().

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

Devuelve un nuevo Array que contiene los elementos de este arreglo, desde el índice begin (inclusive) hasta end (exclusivo), saltando tanto elementos como se indique en step.

Si begin o end son negativos, su valor se interpreta relativo al final del arreglo.

Si step es negativo, este método recorre el arreglo en orden inverso, devolviendo una porción en orden descendente. Para que esto funcione, begin debe ser mayor que end.

Si deep es true, todos los elementos anidados de tipo Array y Dictionary en la porción se duplican recursivamente a partir del original. Véase también duplicate().

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

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

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

void sort() 🔗

Ordena el arreglo en orden ascendente. El orden final depende de la comparación "menor que" (<) entre los elementos.

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

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

Nota: El algoritmo de ordenamiento usado no es estable. Esto significa que elementos equivalentes (como 2 y 2.0) pueden cambiar de orden al llamar a sort().

void sort_custom(func: Callable) 🔗

Ordena el arreglo usando un Callable personalizado.

func se llama tantas veces como sea necesario, recibiendo dos elementos del arreglo como argumentos. La función debe devolver true si el primer elemento debe colocarse antes del segundo, de lo contrario debe devolver 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) # Imprime [["Rice", 4], ["Tomato", 5], ["Apple", 9]]

    # Orden descendente usando una función lambda.
    my_items.sort_custom(func(a, b): return a[1] > b[1])
    print(my_items) # Imprime [["Apple", 9], ["Tomato", 5], ["Rice", 4]]

También puede ser necesario usar este método para ordenar cadenas por orden natural, con String.naturalnocasecmp_to(), como en el siguiente ejemplo:

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

Nota: En C#, este método no está soportado.

Nota: El algoritmo de ordenamiento usado no es estable. Esto significa que valores considerados iguales pueden cambiar de orden al usar este método.

Nota: No se debe aleatorizar el valor devuelto por func, ya que el algoritmo heapsort espera un resultado consistente. Aleatorizarlo puede producir comportamientos inesperados.

Descripciones de Operadores

bool operator !=(right: Array) 🔗

Devuelve true si el tamaño del arreglo o sus elementos son diferentes a los de right.

Array operator +(right: Array) 🔗

Agrega el arreglo right al operando izquierdo, creando un nuevo Array. Esto también se conoce como concatenación de arreglos.

var array1 = ["Uno", 2]
var array2 = [3, "Cuatro"]
print(array1 + array2) # Imprime ["Uno", 2, 3, "Cuatro"]

// Nota: La concatenación no es posible con el tipo nativo Array de C#.
Godot.Collections.Array array1 = ["Uno", 2];
Godot.Collections.Array array2 = [3, "Cuatro"];
GD.Print(array1 + array2); // Imprime ["Uno", 2, 3, "Cuatro"]

Nota: Para arreglos existentes, append_array() es mucho más eficiente que concatenar y asignar usando el operador +=.

bool operator <(right: Array) 🔗

Compara los elementos de ambos arreglos en orden, comenzando desde el índice 0 y hasta el último índice que tengan en común ambos arreglos. Para cada par de elementos, devuelve true si el elemento de este arreglo es menor que el correspondiente en right, y false si es mayor. De lo contrario, continúa con el siguiente par.

Si todos los elementos comparados son iguales, devuelve true si el tamaño de este arreglo es menor que el de right; de lo contrario, devuelve false.

bool operator <=(right: Array) 🔗

Compara los elementos de ambos arrays en orden, empezando desde el índice 0 y terminando en el último índice en común entre ambos arrays. Para cada par de elementos, devuelve true si el elemento de este array es menor que el de right, false si este elemento es mayor. De lo contrario, continúa con el siguiente par.

Si todos los elementos buscados son iguales, devuelve true si el tamaño de este array es menor o igual que el de right, de lo contrario devuelve false.

bool operator ==(right: Array) 🔗

Compara el operando izquierdo Array contra el Array en right . Devuelve true si los tamaños y contenidos de los arrays son iguales, false en caso contrario.

bool operator >(right: Array) 🔗

Compara los elementos de ambos arrays en orden, empezando desde el índice 0 y terminando en el último índice en común entre ambos arrays. Para cada par de elementos, devuelve true si el elemento de este array es mayor que el de right, false si este elemento es menor. De lo contrario, continúa con el siguiente par.

Si todos los elementos buscados son iguales, devuelve true si el tamaño de este array es mayor que el de right, de lo contrario devuelve false.

bool operator >=(right: Array) 🔗

Compara los elementos de ambos arrays en orden, empezando desde el índice 0 y terminando en el último índice en común entre ambos arrays. Para cada par de elementos, devuelve true si el elemento de este array es mayor que el de right, false si este elemento es menor. De lo contrario, continúa con el siguiente par.

Si todos los elementos buscados son iguales, devuelve true si el tamaño de este array es mayor o igual que el de right, de lo contrario devuelve false.

Variant operator [](index: int) 🔗

Devuelve el elemento Variant en el index especificado. Los arrays comienzan en el índice 0. Si index es mayor o igual que 0, el elemento se obtiene comenzando desde el principio del array. Si index es un valor negativo, el elemento se obtiene comenzando desde el final. El acceso a un array fuera de los límites provocará un error en tiempo de ejecución, pausando la ejecución del proyecto si se ejecuta desde el editor.