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 struttura di dati integrata che contiene una sequenza di elementi.

Descrizione

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.).

GDScriptC#

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]

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

Ci sono differenze sostanziali quando si usa questa API con C#. Vedi Differenze dell'API C# rispetto a GDScript per maggiori informazioni.

Costruttori

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)

Metodi

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)

Operatori

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)

---

Descrizioni dei costruttori

Array Array() 🔗

Costruisce un Array vuoto.

---

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

Crea un array tipizzato dall'array base. Un array tipizzato può contenere solo elementi del tipo specificato o che ereditano dalla classe specificata, come descritto dai parametri di questo costruttore:

• type è il tipo di Variant integrato, come una delle costanti di Variant.Type.

• class_name è il nome della classe integrata (vedi Object.get_class()).

• script è lo script associato. Deve essere un'istanza di Script o null.

Se type non è @GlobalScope.TYPE_OBJECT, class_name deve essere uno StringName vuoto e script deve essere 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]

Gli elementi dell'array base vengono convertiti quando necessario. Se ciò non è possibile o base è già tipizzato, questo costruttore fallisce e restituisce un Array vuoto.

In GDScript, questo costruttore di solito non è necessario, poiché è possibile creare un array tipizzato tramite tipizzazione statica:

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

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

---

Array Array(from: Array)

Restituisce lo stesso array di from. Se hai bisogno di una copia dell'array, usa duplicate().

---

Array Array(from: PackedByteArray)

Costruisce un array da un PackedByteArray.

---

Array Array(from: PackedColorArray)

Costruisce un array da un PackedColorArray.

---

Array Array(from: PackedFloat32Array)

Costruisce un array da un PackedFloat32Array.

---

Array Array(from: PackedFloat64Array)

Costruisce un array da un PackedFloat64Array.

---

Array Array(from: PackedInt32Array)

Costruisce un array da un PackedInt32Array.

---

Array Array(from: PackedInt64Array)

Costruisce un array da un PackedInt64Array.

---

Array Array(from: PackedStringArray)

Costruisce un array da un PackedStringArray.

---

Array Array(from: PackedVector2Array)

Costruisce un array da un PackedVector2Array.

---

Array Array(from: PackedVector3Array)

Costruisce un array da un PackedVector3Array.

---

Array Array(from: PackedVector4Array)

Costruisce un Array da un PackedVector4Array.

---

Descrizioni dei metodi

bool all(method: Callable) const 🔗

Chiama il Callable fornito su ogni elemento nell'array e restituisce true se il Callable restituisce true per tutti gli elementi nell'array. Se il Callable restituisce false per uno o più elementi nell'array, questo metodo restituisce true.

Il method dovrebbe accettare un parametro Variant (l'elemento attuale dell'array) e restituire un bool.

GDScriptC#

func greater_than_5(number):
    return number > 5

func _ready():
    print([6, 10, 6].all(greater_than_5)) # Stampa true (3/3 elementi sono valutati come true).
    print([4, 10, 4].all(greater_than_5)) # Stampa false (1/3 elementi sono valutati come true).
    print([4, 4, 4].all(greater_than_5))  # Stampa false (0/3 elementi sono valutati come true).
    print([].all(greater_than_5))         # Stampa true (0/0 elementi sono valutati come true).

    # Come la prima riga sopra, ma usando una funzione lambda.
    print([6, 10, 6].all(func(element): return element > 5)) # Stampa true

Vedi anche all(), filter(), map() e reduce().

Nota: A differenza di basarsi sulla dimensione di un array restituito da filter(), questo metodo restituirà il prima possibile per migliorare le prestazioni (soprattutto con array di grandi dimensioni).

Nota: Per un array vuoto, questo metodo restituisce sempre true.

---

bool any(method: Callable) const 🔗

Chiama il Callable fornito su ogni elemento nell'array e restituisce true se il Callable restituisce true per uno o più elementi nell'array. Se il Callable restituisce false per tutti gli elementi nell'array, questo metodo restituisce false.

Il method dovrebbe accettare un parametro Variant (l'elemento attuale dell'array) e restituire un bool.

func greater_than_5(number):
    return number > 5

func _ready():
    print([6, 10, 6].any(greater_than_5)) # Stampa true (3 elementi sono valutati come true).
    print([4, 10, 4].any(greater_than_5)) # Stampa true (1 elements è valutato come to true).
    print([4, 4, 4].any(greater_than_5))  # Stampa false (0 elementi sono valutati come true).
    print([].any(greater_than_5))         # Stampa false (0 elements sono valutati come true).

    # Come la prima riga sopra, ma usando una funzione lambda.
    print([6, 10, 6].any(func(number): return number > 5)) # Stampa true

Vedi anche all(), filter(), map() e reduce().

Nota: A differenza di basarsi sulla dimensione di un array restituito da filter(), questo metodo restituirà il prima possibile per migliorare le prestazioni (soprattutto con array di grandi dimensioni).

Nota: Per un array vuoto, questo metodo restituisce sempre false.

---

void append(value: Variant) 🔗

Appende value alla fine dell'array (alias di push_back()).

---

void append_array(array: Array) 🔗

Accoda un altro array alla fine di questo array.

numeri = [1, 2, 3]
var aggiuntivi = [4, 5, 6]
numeri.append_array(aggiuntivi)
print(numeri) # Stampa [1, 2, 3, 4, 5, 6]

---

void assign(array: Array) 🔗

Assegna elementi di un altro array in questo array. Ridimensiona l'array per corrispondere a array. Esegue le conversioni di tipo se l'array è tipizzato.

---

Variant back() const 🔗

Restituisce l'ultimo elemento dell'array. Se l'array è vuoto, fallisce e restituisce null. Vedi anche front().

Nota: A differenza dell'operatore [] (array[-1]), viene generato un errore senza interrompere l'esecuzione del progetto.

---

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

Restituisce l'indice del valore value nell'array ordinato. Se non può essere trovato, restituisce dove value dovrebbe essere inserito per mantenere l'array ordinato. L'algoritmo utilizzato è la ricerca dicotomica.

Se before è true (come per impostazione predefinita), l'indice restituito viene prima di tutti gli elementi esistenti uguali a value nell'array.

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

numeri.insert(indice, 7)
print(numeri) # Stampa [2, 4, 7, 8, 10]

var frutta = ["Mela", "Limone", "Limone", "Arancia"]
print(frutta.bsearch("Limone", true))  # Stampa 1, punta al primo "Limone".
print(frutta.bsearch("Limone", false)) # Stampa 3, punta ad "Arancia".

Nota: Chiamare bsearch() su un array non ordinato risulterà in comportamento inaspettato. Utilizza sort() prima di chiamare questo metodo.

---

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

Restituisce l'indice del valore value nell'array ordinato. Se non può essere trovato, restituisce dove value dovrebbe essere inserito per mantenere l'array ordinato (utilizzando func per i confronti). L'algoritmo utilizzato è la ricerca dicotomica.

Simile a sort_custom(), func è chiamato quante volte è necessario, ricevendo un elemento dell'array e value come argomenti. La funzione dovrebbe restituire true se l'elemento dell'array dovrebbe apparire dietro value, altrimenti dovrebbe restituire false.

Se before è true (come per impostazione predefinita), l'indice restituito viene prima di tutti gli elementi esistenti uguali a value nell'array.

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

func _ready():
    var elementi = [["Pomodoro", 2], ["Kiwi", 5], ["Riso", 9]]

    var mela = ["Mela", 5]
    # "Mela" è inserito prima di "Kiwi".
    elementi.insert(elementi.bsearch_custom(mela, ordina_per_quantità, true), mela)

    var banana = ["Banana", 5]
    # "Banana" è inserito dopo di "Kiwi".
    elementi.insert(elementi.bsearch_custom(banana, ordina_per_quantità, false), banana)

    # Stampa [["Pomodoro", 2], ["Mela", 5], ["Kiwi", 5], ["Banana", 5], ["Riso", 9]]
    print(elementi)

Nota: Chiamare bsearch_custom() su un array non ordinato risulterà in comportamento inaspettato. Utilizza sort_custom() con func prima di chiamare questo metodo.

---

void clear() 🔗

Rimuove tutti gli elementi dall'array. Questo è equivalente a utilizzare resize() con una dimensione di 0.

---

int count(value: Variant) const 🔗

Restituisce il numero di volte in cui un elemento è presente nell'array.

Per contare quanti elementi in un array soddisfano una condizione, vedi reduce().

---

Array duplicate(deep: bool = false) const 🔗

Restituisce una nuova copia dell'array.

Normalmente, viene restituita una copia superficiale: tutti gli elementi annidati di tipo Array, Dictionary e Resource sono condivisi con l'array originale. Modificarli in un array li influenzerà anche nell'altro.

Se deep è true, viene restituita una copia profonda: anche tutti gli array e i dizionari annidati sono duplicati (ricorsivamente). Tuttavia, qualsiasi oggetto Resource rimane condiviso con l'array originale.

---

Array duplicate_deep(deep_subresources_mode: int = 1) const 🔗

Duplicates this array, deeply, like duplicate() when passing true, with extra control over how subresources are handled.

deep_subresources_mode must be one of the values from DeepDuplicateMode. By default, only internal resources will be duplicated (recursively).

---

void erase(value: Variant) 🔗

Trova e rimuove la prima occorrenza del valore value dall'array. Se value non esiste nell'array, non succede nulla. Per rimuovere un elemento per indice, utilizza remove_at() invece.

Nota: Questo metodo sposta l'indice di ogni elemento dopo il value rimosso, il che potrebbe avere un costo notevole sulle prestazioni, soprattutto sugli array più grandi.

Nota: Rimuovere elementi durante un'iterazione su un array non è supportato e risulterà in comportamento imprevedibile.

---

void fill(value: Variant) 🔗

Assegna il valore value a tutti gli elementi dell'array.

Questo metodo può spesso essere combinato con resize() per creare un array con una certa dimensione ed elementi inizializzati:

GDScriptC#

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

Nota: Se value è un Variant passato per riferimento (derivato da Object, Array, Dictionary, ecc.), l'array sarà riempito con riferimenti allo stesso value, che non sono duplicati.

---

Array filter(method: Callable) const 🔗

Chiama il Callable indicato su ogni elemento nell'array e restituisce un nuovo Array filtrato.

method riceve uno degli elementi dell'array come argomento, e dovrebbe restituire true per aggiungere l'elemento all'array filtrato, o false per escluderlo.

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

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

    # Stesso di sopra, ma usando una funzione lambda.
    print([1, 4, 5, 8].filter(func(number): return number % 2 == 0))

Vedi anche any(), all(), map() e reduce().

---

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

Restituisce l'indice della prima occorrenza di what in questo array, o -1 se non ne esistono. L'inizio della ricerca può essere specificato con from, la quale continua fino alla fine dell'array.

Nota: Se si desidera solo sapere se l'array contiene what, utilizza has() (Contains in C#). In GDScript, è anche possibile utilizzare l'operatore in.

Nota: Per motivi di prestazioni, la ricerca è influenzata dal tipo (Variant.Type) di what. Ad esempio, 7 (int) e 7.0 (float)) non sono considerati uguali per questo metodo.

---

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().

GDScript

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 🔗

Restituisce il primo elemento dell'array. Se l'array è vuoto, fallisce e restituisce null. Vedi anche back().

Nota: A differenza dell'operatore [] (array[0]), viene generato un errore senza interrompere l'esecuzione del progetto.

---

Variant get(index: int) const 🔗

Returns the element at the given index in the array. If index is out-of-bounds or negative, this method fails and returns null.

This method is similar (but not identical) to the [] operator. Most notably, when this method fails, it doesn't pause project execution if run from the editor.

---

int get_typed_builtin() const 🔗

Restituisce il tipo di Variant integrato dell'array tipizzato come constante di Variant.Type. Se l'array non è tipizzato, restituisce @GlobalScope.TYPE_NIL. Vedi anche is_typed().

---

StringName get_typed_class_name() const 🔗

Restituisce il nome della classe integrata dell'array tipizzato, se il tipo di Variant incorporato è @GlobalScope.TYPE_OBJECT. Altrimenti, restituisce un StringName vuoto. Vedi anche is_typed() e Object.get_class().

---

Variant get_typed_script() const 🔗

Restituisce l'istanza di Script associata a questo array tipizzato, o null se non esiste. Vedi anche is_typed().

---

bool has(value: Variant) const 🔗

Restituisce true se l'array contiene il valore value.

GDScriptC#

print(["inside", 7].has("dentro"))  # Stampa true
print(["inside", 7].has("fuori")) # Stampa false
print(["inside", 7].has(7))         # Stampa true
print(["inside", 7].has("7"))       # Stampa false

In GDScript, questo metodo equivale all'operatore in:

if 4 in [2, 4, 6, 8]:
    print("4 è qui!") # Sarà stampato.

Nota: Per motivi di prestazioni, la ricerca è influenzata dal tipo (Variant.Type) di value. Ad esempio, 7 (int) e 7.0 (float)) non sono considerati uguali per questo metodo.

---

int hash() const 🔗

Returns a hashed 32-bit integer value representing the array and its contents.

Note: Arrays with equal hash values are not guaranteed to be the same, as a result of hash collisions. On the contrary, arrays with different hash values are guaranteed to be different.

---

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

Inserisce un nuovo elemento (value) a un indice fornito (position) nell'array. position dovrebbe essere tra 0 e la dimensione dell'array (size()). Se negativo, position è considerato relativo alla fine dell'array.

Restituisce @GlobalScope.OK al successo, o una delle altre costanti di Error se questo metodo fallisce.

Nota: Ogni indice degli elementi dopo l'indice position deve essere spostato in avanti, il che potrebbe avere un impatto notevole sulle prestazioni, soprattutto sugli array più grandi.

---

bool is_empty() const 🔗

Restituisce true se l'array è vuoto ([]). Vedi anche size().

---

bool is_read_only() const 🔗

Restituisce true se l'array è di sola lettura. Vedi make_read_only().

In GDScript, gli array diventano automaticamente di sola lettura se dichiarati con la parola chiave const.

---

bool is_same_typed(array: Array) const 🔗

Restituisce true se questo array è tipizzato lo stesso di array. Vedi anche is_typed().

---

bool is_typed() const 🔗

Restituisce true se l'array è tipizzato. Gli array tipizzati possono contenere solo elementi di un tipo specifico, come definito dal costruttore di array tipizzato. I metodi di un array tipizzato si aspettano comunque di restituire un Variant generico.

In GDScript, è possibile definire un array tipizzato con la tipizzazione statica:

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

---

void make_read_only() 🔗

Rende l'array di sola lettura. Gli elementi dell'array non possono essere sovrascritti con valori diversi, e il loro ordine non può cambiare. Non si applica agli elementi annidati, come i dizionari.

In GDScript, gli array diventano automaticamente di sola lettura se dichiarati con la parola chiave const.

---

Array map(method: Callable) const 🔗

Chiama il Callable fornito per ogni elemento nell'array e restituisce un nuovo array riempito di valori restituiti da method.

method dovrebbe prendere un parametro Variant (l'elemento attuale dell'array) e può restituire un qualsiasi Variant.

func doppio(numero):
    return numero * 2

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

    # Stesso di sopra, ma usando una funzione lambda.
    print([1, 2, 3].map(func(elemento): return elemento * 2))

Vedi anche filter(), reduce(), any() e all().

---

Variant max() const 🔗

Restituisce il valore massimo contenuto nell'array, se tutti gli elementi possono essere confrontati. Altrimenti, restituisce null. Vedi anche min().

Per trovare il valore massimo utilizzando un comparatore personalizzato, è possibile utilizzare reduce().

---

Variant min() const 🔗

Restituisce il valore minimo contenuto nell'array, se tutti gli elementi possono essere confrontati. Altrimenti, restituisce null. Vedi anche max().

---

Variant pick_random() const 🔗

Restituisce un elemento a caso dall'array. Genera un errore e restituisce null se l'array è vuoto.

GDScriptC#

# Potrebbe stampare 1, 2, 3.25, o "Ciao".
print([1, 2, 3.25, "Ciao"].pick_random())

Nota: Come molte funzioni simili nel motore (come ad esempio @GlobalScope.randi() o shuffle()), questo metodo utilizza un seed casuale, comune e globale. Per ottenere un risultato prevedibile da questo metodo, vedi @GlobalScope.seed().

---

Variant pop_at(position: int) 🔗

Rimuove e restituisce l'elemento dell'array all'indice position. Se negativo, position è considerato relativo alla fine dell'array. Restituisce null se l'array è vuoto. Se position è fuori dai limiti, viene generato anche un messaggio di errore.

Nota: Questo metodo sposta indietro gli indici di ogni elemento dopo position, il che potrebbe avere un costo notevole sulle prestazioni, soprattutto sugli array più grandi.

---

Variant pop_back() 🔗

Rimuove e restituisce l'ultimo elemento dell'array. Restituisce null se l'array è vuoto, senza generare un errore. Vedi anche pop_front().

---

Variant pop_front() 🔗

Rimuove e restituisce il primo elemento dell'array. Restituisce null se l'array è vuoto, senza generare un errore. Vedi anche pop_back().

Nota: Questo metodo sposta indietro l'indice di ogni altro elemento, il che può avere un notevole costo sulle prestazioni, soprattutto su array più grandi.

---

void push_back(value: Variant) 🔗

Appende un elemento alla fine dell'array. Vedi anche push_front().

---

void push_front(value: Variant) 🔗

Aggiunge un elemento all'inizio dell'array. Vedi anche push_back().

Nota: Questo metodo sposta in avanti l'indice di ogni altro elemento, il che può avere un notevole costo sulle prestazioni, soprattutto su array più grandi.

---

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

Chiama il Callable fornito per ogni elemento nell'array, accumula il risultato in accum, quindi lo restituisce.

Il method prende due argomenti: il valore attuale di accum e l'elemento attuale dell'array. Se accum è null (come per impostazione predefinita), l'iterazione inizierà dal secondo elemento, con il primo utilizzato come valore iniziale di accum.

func somma(accum, numero):
    return accum + numero

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

    # Stesso di sopra, ma usando una funzione lambda.
    print([1, 2, 3].reduce(func(accum, numero): return accum + numero, 10))

Se max() non è desiderato, questo metodo può anche essere utilizzato per implementare un comparatore personalizzato:

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

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

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

Questo metodo può essere utilizzato anche per contare quanti elementi in un array soddisfano una determinata condizione, in modo simile al metodo count():

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

func _ready():
    var arr = [1, 2, 3, 4, 5]
    # Se l'elemento attuale è pari, incrementa il conteggio, altrimenti lascialo invariato.
    var even_count = arr.reduce(func(count, next): return count + 1 if is_even(next) else count, 0)
    print(even_count) # Stampa 2

Vedi anche map(), filter(), any() e all().

---

void remove_at(position: int) 🔗

Removes the element from the array at the given index (position). If the index is out of bounds, this method fails. If the index is negative, position is considered relative to the end of the array.

If you need to return the removed element, use pop_at(). To remove an element by value, use erase() instead.

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

---

int resize(size: int) 🔗

Imposta il numero di elementi dell'array a size. Se size è più piccolo della dimensione corrente dell'array, gli elementi alla fine sono rimossi. Se size è maggiore, sono aggiunti nuovi elementi predefiniti (di solito null), a seconda del tipo dell'array.

Restituisce @GlobalScope.OK in caso di successo, o una delle seguenti costanti di Error se questo metodo fallisce: @GlobalScope.ERR_LOCKED se l'array è di sola lettura, @GlobalScope.ERR_INVALID_PARAMETER se la dimensione è negativa o @GlobalScope.ERR_OUT_OF_MEMORY se le allocazioni falliscono. Usare size() per trovare la dimensione effettiva dell'array dopo il ridimensionamento.

Nota: Chiamare questo metodo una volta e assegnare i nuovi valori è più veloce di chiamare append() per ogni nuovo elemento.

---

void reverse() 🔗

Inverte l'ordine di tutti gli elementi nell'array.

---

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

Restituisce l'indice dell'ultima occorrenza di what in questo array, o -1 se non ne esistono. L'inizio della ricerca può essere specificato con from, la quale continua fino all'inizio dell'array. Questo metodo è l'inverso di find().

---

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

Restituisce l'indice dell'ultima occorrenza nell'array che provoca method a ritornare true, o -1 se non ne esistono. L'inizio della ricerca può essere specificato con from, la quale continua fino all'inizio dell'array. Questo metodo è l'inverso di find_custom().

---

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

Imposta il valore dell'elemento all'indice index sul valore value. Ciò non modificherà la dimensione dell'array, ma modificherà solo il valore in un indice già presente nell'array. Questo equivale a usare l'operatore [] (array[index] = value).

---

void shuffle() 🔗

Rimescola tutti gli elementi dell'array in un ordine casuale.

Nota: Come molte funzioni simili nel motore (come ad esempio @GlobalScope.randi() o pick_random()), questo metodo utilizza un seed casuale, comune e globale. Per ottenere un risultato prevedibile da questo metodo, vedi @GlobalScope.seed().

---

int size() const 🔗

Restituisce il numero di elementi nell'array. Gli array vuoti ([]) restituiscono sempre 0. Vedi anche is_empty().

---

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

Restituisce un nuovo Array contenente gli elementi di questo array, dall'indice begin (inclusivo) a end (esclusivo), ogni numero di elementi (step).

Se begin o end sono negativi, il loro valore è relativo alla fine dell'array.

Se step è negativo, questo metodo itera attraverso l'array al rovescio, restituendo una sezione ordinata all'indietro. Affinché funzioni, begin deve essere maggiore di end.

Se deep è true, tutti gli elementi annidati di tipo Array e Dictionary nella sezione sono duplicati dall'originale, ricorsivamente. Vedi anche duplicate()).

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

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

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

---

void sort() 🔗

Ordina l'array in ordine crescente. L'ordine finale dipende dal confronto "minore di" (<) tra gli elementi.

GDScriptC#

var numeri = [10, 5, 2.5, 8]
numeri.sort()
print(numeri) # Stampa [2.5, 5, 8, 10]

Nota: L'algoritmo di selezione utilizzato non è stabile. Ciò significa che gli elementi equivalenti (come 2 e 2.0) potrebbero avere il loro ordine cambiato quando viene chiamato sort().

---

void sort_custom(func: Callable) 🔗

Ordina l'array utilizzando un Callable personalizzato.

func è chiamato quante più volte è necessario, ricevendo due elementi dell'array come argomenti. La funzione dovrebbe restituire true se il primo elemento deve essere spostato dietro al secondo, altrimenti dovrebbe restituire false.

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

func _ready():
    var my_items = [["Pomodoro", 5], ["Mela", 9], ["Riso", 4]]
    my_items.sort_custom(sort_ascending)
    print(my_items) # Stampa [["Riso", 4], ["Pomodoro", 5], ["Mela", 9]]

    # Ordina in ordine decrescente, usando una funzione lambda.
    my_items.sort_custom(func(a, b): return a[0] > b[0])
    print(my_items) # Stampa [["Mela", 9], ["Pomodoro", 5], ["Riso", 4]]

Può anche essere necessario utilizzare questo metodo per ordinare le stringhe per ordine naturale, con String.naturalnocasecmp_to(), come nell'esempio seguente:

var file_array = ["nuovofile1", "nuovofile2", "nuovofile10", "nuovofile11"]
file_array.sort_custom(func(a, b): return a.naturalnocasecmp_to(b) < 0)
print(file_array) # Stampa ["newfile1", "newfile2", "newfile10", "newfile11"]

Nota: In C#, questo metodo non è supportato.

Nota: L'algoritmo di selezione utilizzato non è stabile. Ciò significa che gli elementi considerati equivalenti potrebbero avere il loro ordine cambiato quando si chiama sort().

Nota: Non si dovrebbe randomizzare il valore di ritorno di func, poiché l'algoritmo di heapsort si aspetta un risultato coerente. Randomizzare il valore restituito risulterà in comportamento inaspettato.

---

Descrizioni degli operatori

bool operator !=(right: Array) 🔗

Restituisce true se la dimensione dell'array o i suoi elementi sono diversi da quelli di right.

---

Array operator +(right: Array) 🔗

Appende l'array right all'operando sinistro, creando un nuovo Array. Questa è anche conosciuta come una concatenazione di array.

GDScriptC#

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

Nota: Per gli array esistenti, append_array() è molto più efficiente della concatenazione e dell'assegnazione con l'operatore +=.

---

bool operator <(right: Array) 🔗

Confronta gli elementi di entrambi gli array in ordine, a partire dall'indice 0 e terminando all'ultimo indice in comune tra entrambi gli array. Per ogni coppia di elementi, restituisce true se l'elemento di questo array è minore di quello di right, false se questo elemento è maggiore. Altrimenti, continua alla prossima coppia.

Se tutti gli elementi cercati sono uguali, restituisce true se la dimensione di questo array è minore di quella di right, altrimenti restituisce false.

---

bool operator <=(right: Array) 🔗

Confronta gli elementi di entrambi gli array in ordine, a partire dall'indice 0 e terminando all'ultimo indice in comune tra entrambi gli array. Per ogni coppia di elementi, restituisce true se l'elemento di questo array è minore di quello di right, false se questo elemento è maggiore. Altrimenti, continua alla prossima coppia.

Se tutti gli elementi cercati sono uguali, restituisce true se la dimensione di questo array è minore o uguale a quella di right, altrimenti restituisce false.

---

bool operator ==(right: Array) 🔗

Confronta l'operando sinistro Array contro l'Array right. Restituisce true se le dimensioni e il contenuto degli array sono uguali, altrimenti false.

---

bool operator >(right: Array) 🔗

Confronta gli elementi di entrambi gli array in ordine, a partire dall'indice 0 e terminando all'ultimo indice in comune tra entrambi gli array. Per ogni coppia di elementi, restituisce true se l'elemento di questo array è maggiore di quello di right, false se questo elemento è minore. Altrimenti, continua alla prossima coppia.

Se tutti gli elementi cercati sono uguali, restituisce true se la dimensione di questo array è maggiore di quella di right, altrimenti restituisce false.

---

bool operator >=(right: Array) 🔗

Confronta gli elementi di entrambi gli array in ordine, a partire dall'indice 0 e terminando all'ultimo indice in comune tra entrambi gli array. Per ogni coppia di elementi, restituisce true se l'elemento di questo array è maggiore di quello di right, false se questo elemento è minore. Altrimenti, continua alla prossima coppia.

Se tutti gli elementi cercati sono uguali, restituisce true se la dimensione di questo array è maggiore o uguale a quella di right, altrimenti restituisce false.

---

Variant operator [](index: int) 🔗

Restituisce l'elemento Variant all'indice specificato da index. Gli array iniziano all'indice 0. Se index è maggiore o uguale a 0, l'elemento è recuperato a partire dall'inizio dell'array. Se index è un valore negativo, l'elemento è recuperato a partire dalla fine. Accedere a un array fuori dai limiti causerà un errore durante l'esecuzione, mettendo in pausa l'esecuzione del progetto se eseguito dall'editor.