:github_url: hide .. _class_Array: Array ===== Una struttura di dati integrata che contiene una sequenza di elementi. .. rst-class:: classref-introduction-group Descrizione ---------------------- Una struttura dati che può contenere una sequenza di elementi di qualsiasi tipo di :ref:`Variant`. Gli elementi sono accessibili da un indice numerico a partire da ``0``. È possibile facoltativamente imporre i valori a un tipo specifico creando un *array tipizzato*. Gli indici negativi sono utilizzati per contare dalla fine (``-1`` è l'ultimo elemento, ``-2`` è il penultimo, ecc.). .. tabs:: .. code-tab:: gdscript var array = ["Primo", 2, 3, "Ultimo"] print(array[0]) # Stampa "Primo" print(array[2]) # Stampa 3 print(array[-1]) # Stampa "Ultimo" array[1] = "Secondo" print(array[1]) # Stampa "Secondo" print(array[-3]) # Stampa "Secondo" # Questo array tipizzato può contenere solo numeri interi. # Aggiungere un valore di qualunque altro tipo genererà un errore. var typed_array: Array[int] = [1, 2, 3] .. code-tab:: csharp Godot.Collections.Array array = ["Primo", 2, 3, "Ultimo"]; GD.Print(array[0]); // Stampa "Primo" GD.Print(array[2]); // Stampa 3 GD.Print(array[^1]);; // Stampa "Ultimo" array[2] = "Secondo"; GD.Print(array[1]); // Stampa "Secondo" GD.Print(array[^3]); // Stampa "Secondo" // Questo array tipizzato può contenere solo numeri interi. // Aggiungere un valore di qualunque altro tipo genererà un errore. Godot.Collections.Array typedArray = [1, 2, 3]; \ **Nota:** Gli array sono sempre passati per **riferimento**. Per ottenere una copia di un array che può essere modificato indipendentemente dall'array originale, utilizza :ref:`duplicate()`. \ **Nota:** Rimuovere elementi durante un'iterazione su un array **non** è supportato e risulterà in comportamento imprevedibile. \ **Differenze tra gli array impacchettati, gli array tipizzati e gli array non tipizzati:** Gli array impacchettati sono generalmente più veloci da iterare e modificare rispetto a un array tipizzato dello stesso tipo (ad esempio :ref:`PackedInt64Array` in confronto a ``Array[int]``). Inoltre, gli array impacchettati consumano meno memoria. Come svantaggio, i array impacchettati sono meno flessibili in quanto non offrono molti metodi di convenienza come :ref:`map()`. Gli array tipizzati sono anche loro più veloci da iterare e modificare in confronto ad array non tipizzati. .. note:: Ci sono differenze sostanziali quando si usa questa API con C#. Vedi :ref:`doc_c_sharp_differences` per maggiori informazioni. .. rst-class:: classref-reftable-group Costruttori ---------------------- .. table:: :widths: auto +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ base\: :ref:`Array`, type\: :ref:`int`, class_name\: :ref:`StringName`, script\: :ref:`Variant`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedByteArray`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedColorArray`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedFloat32Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedFloat64Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedInt32Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedInt64Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedStringArray`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedVector2Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedVector3Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedVector4Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Metodi ------------ .. table:: :widths: auto +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`all`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`any`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`append`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`append_array`\ (\ array\: :ref:`Array`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`assign`\ (\ array\: :ref:`Array`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`back`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bsearch`\ (\ value\: :ref:`Variant`, before\: :ref:`bool` = true\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bsearch_custom`\ (\ value\: :ref:`Variant`, func\: :ref:`Callable`, before\: :ref:`bool` = true\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`clear`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`count`\ (\ value\: :ref:`Variant`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`duplicate`\ (\ deep\: :ref:`bool` = false\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`duplicate_deep`\ (\ deep_subresources_mode\: :ref:`int` = 1\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`erase`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`fill`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`filter`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find`\ (\ what\: :ref:`Variant`, from\: :ref:`int` = 0\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find_custom`\ (\ method\: :ref:`Callable`, from\: :ref:`int` = 0\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`front`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`get`\ (\ index\: :ref:`int`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_typed_builtin`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`StringName` | :ref:`get_typed_class_name`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`get_typed_script`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has`\ (\ value\: :ref:`Variant`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`hash`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`insert`\ (\ position\: :ref:`int`, value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_empty`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_read_only`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_same_typed`\ (\ array\: :ref:`Array`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_typed`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`make_read_only`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`map`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`max`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`min`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pick_random`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pop_at`\ (\ position\: :ref:`int`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pop_back`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pop_front`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`push_back`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`push_front`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`reduce`\ (\ method\: :ref:`Callable`, accum\: :ref:`Variant` = null\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`remove_at`\ (\ position\: :ref:`int`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`resize`\ (\ size\: :ref:`int`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reverse`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind`\ (\ what\: :ref:`Variant`, from\: :ref:`int` = -1\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind_custom`\ (\ method\: :ref:`Callable`, from\: :ref:`int` = -1\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set`\ (\ index\: :ref:`int`, value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`shuffle`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`size`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`slice`\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647, step\: :ref:`int` = 1, deep\: :ref:`bool` = false\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`sort`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`sort_custom`\ (\ func\: :ref:`Callable`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Operatori ------------------ .. table:: :widths: auto +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`operator +`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator \<`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator \<=`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator >`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator >=`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`operator []`\ (\ index\: :ref:`int`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei costruttori ------------------------------------------------------ .. _class_Array_constructor_Array: .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ ) :ref:`🔗` Costruisce un **Array** vuoto. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ base\: :ref:`Array`, type\: :ref:`int`, class_name\: :ref:`StringName`, script\: :ref:`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 :ref:`Variant` integrato, come una delle costanti di :ref:`Variant.Type`. - ``class_name`` è il nome della classe integrata (vedi :ref:`Object.get_class()`). - ``script`` è lo script associato. Deve essere un'istanza di :ref:`Script` o ``null``. Se ``type`` non è :ref:`@GlobalScope.TYPE_OBJECT`, ``class_name`` deve essere uno :ref:`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] .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`Array`\ ) Restituisce lo stesso array di ``from``. Se hai bisogno di una copia dell'array, usa :ref:`duplicate()`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedByteArray`\ ) Costruisce un array da un :ref:`PackedByteArray`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedColorArray`\ ) Costruisce un array da un :ref:`PackedColorArray`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedFloat32Array`\ ) Costruisce un array da un :ref:`PackedFloat32Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedFloat64Array`\ ) Costruisce un array da un :ref:`PackedFloat64Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedInt32Array`\ ) Costruisce un array da un :ref:`PackedInt32Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedInt64Array`\ ) Costruisce un array da un :ref:`PackedInt64Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedStringArray`\ ) Costruisce un array da un :ref:`PackedStringArray`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedVector2Array`\ ) Costruisce un array da un :ref:`PackedVector2Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedVector3Array`\ ) Costruisce un array da un :ref:`PackedVector3Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedVector4Array`\ ) Costruisce un **Array** da un :ref:`PackedVector4Array`. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei metodi -------------------------------------------- .. _class_Array_method_all: .. rst-class:: classref-method :ref:`bool` **all**\ (\ method\: :ref:`Callable`\ ) |const| :ref:`🔗` Chiama il :ref:`Callable` fornito su ogni elemento nell'array e restituisce ``true`` se il :ref:`Callable` restituisce ``true`` per *tutti* gli elementi nell'array. Se il :ref:`Callable` restituisce ``false`` per uno o più elementi nell'array, questo metodo restituisce ``true``. Il ``method`` dovrebbe accettare un parametro :ref:`Variant` (l'elemento attuale dell'array) e restituire un :ref:`bool`. .. tabs:: .. code-tab:: gdscript 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 .. code-tab:: csharp private static bool GreaterThan5(int number) { return number > 5; } public override void _Ready() { // Stampa True (3/3 elementi sono valutati come true). GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(GreaterThan5)); // Stampa False (1/3 elementi sono valutati come true). GD.Print(new Godot.Collections.Array>int< { 4, 10, 4 }.All(GreaterThan5)); // Stampa False (0/3 elementi sono valutati come true). GD.Print(new Godot.Collections.Array>int< { 4, 4, 4 }.All(GreaterThan5)); // Stampa True (0/0 elementi sono valutati come true). GD.Print(new Godot.Collections.Array>int< { }.All(GreaterThan5)); // Come la prima riga sopra, ma usando una funzione lambda. GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(element => element > 5)); // Stampa True } Vedi anche :ref:`all()`, :ref:`filter()`, :ref:`map()` e :ref:`reduce()`. \ **Nota:** A differenza di basarsi sulla dimensione di un array restituito da :ref:`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``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_any: .. rst-class:: classref-method :ref:`bool` **any**\ (\ method\: :ref:`Callable`\ ) |const| :ref:`🔗` Chiama il :ref:`Callable` fornito su ogni elemento nell'array e restituisce ``true`` se il :ref:`Callable` restituisce ``true`` per *uno o più* elementi nell'array. Se il :ref:`Callable` restituisce ``false`` per tutti gli elementi nell'array, questo metodo restituisce ``false``. Il ``method`` dovrebbe accettare un parametro :ref:`Variant` (l'elemento attuale dell'array) e restituire un :ref:`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 :ref:`all()`, :ref:`filter()`, :ref:`map()` e :ref:`reduce()`. \ **Nota:** A differenza di basarsi sulla dimensione di un array restituito da :ref:`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``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_append: .. rst-class:: classref-method |void| **append**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` Appende ``value`` alla fine dell'array (alias di :ref:`push_back()`). .. rst-class:: classref-item-separator ---- .. _class_Array_method_append_array: .. rst-class:: classref-method |void| **append_array**\ (\ array\: :ref:`Array`\ ) :ref:`🔗` 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] .. rst-class:: classref-item-separator ---- .. _class_Array_method_assign: .. rst-class:: classref-method |void| **assign**\ (\ array\: :ref:`Array`\ ) :ref:`🔗` 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. .. rst-class:: classref-item-separator ---- .. _class_Array_method_back: .. rst-class:: classref-method :ref:`Variant` **back**\ (\ ) |const| :ref:`🔗` Restituisce l'ultimo elemento dell'array. Se l'array è vuoto, fallisce e restituisce ``null``. Vedi anche :ref:`front()`. \ **Nota:** A differenza dell'operatore ``[]`` (``array[-1]``), viene generato un errore senza interrompere l'esecuzione del progetto. .. rst-class:: classref-item-separator ---- .. _class_Array_method_bsearch: .. rst-class:: classref-method :ref:`int` **bsearch**\ (\ value\: :ref:`Variant`, before\: :ref:`bool` = true\ ) |const| :ref:`🔗` 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 :ref:`bsearch()` su un array *non ordinato* risulterà in comportamento inaspettato. Utilizza :ref:`sort()` prima di chiamare questo metodo. .. rst-class:: classref-item-separator ---- .. _class_Array_method_bsearch_custom: .. rst-class:: classref-method :ref:`int` **bsearch_custom**\ (\ value\: :ref:`Variant`, func\: :ref:`Callable`, before\: :ref:`bool` = true\ ) |const| :ref:`🔗` 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 :ref:`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 :ref:`bsearch_custom()` su un array *non ordinato* risulterà in comportamento inaspettato. Utilizza :ref:`sort_custom()` con ``func`` prima di chiamare questo metodo. .. rst-class:: classref-item-separator ---- .. _class_Array_method_clear: .. rst-class:: classref-method |void| **clear**\ (\ ) :ref:`🔗` Rimuove tutti gli elementi dall'array. Questo è equivalente a utilizzare :ref:`resize()` con una dimensione di ``0``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_count: .. rst-class:: classref-method :ref:`int` **count**\ (\ value\: :ref:`Variant`\ ) |const| :ref:`🔗` Restituisce il numero di volte in cui un elemento è presente nell'array. Per contare quanti elementi in un array soddisfano una condizione, vedi :ref:`reduce()`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_duplicate: .. rst-class:: classref-method :ref:`Array` **duplicate**\ (\ deep\: :ref:`bool` = false\ ) |const| :ref:`🔗` Restituisce una nuova copia dell'array. Normalmente, viene restituita una copia **superficiale**: tutti gli elementi annidati di tipo **Array**, :ref:`Dictionary` e :ref:`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 :ref:`Resource` rimane condiviso con l'array originale. .. rst-class:: classref-item-separator ---- .. _class_Array_method_duplicate_deep: .. rst-class:: classref-method :ref:`Array` **duplicate_deep**\ (\ deep_subresources_mode\: :ref:`int` = 1\ ) |const| :ref:`🔗` Duplicates this array, deeply, like :ref:`duplicate()` when passing ``true``, with extra control over how subresources are handled. \ ``deep_subresources_mode`` must be one of the values from :ref:`DeepDuplicateMode`. By default, only internal resources will be duplicated (recursively). .. rst-class:: classref-item-separator ---- .. _class_Array_method_erase: .. rst-class:: classref-method |void| **erase**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` 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 :ref:`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. .. rst-class:: classref-item-separator ---- .. _class_Array_method_fill: .. rst-class:: classref-method |void| **fill**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` Assegna il valore ``value`` a tutti gli elementi dell'array. Questo metodo può spesso essere combinato con :ref:`resize()` per creare un array con una certa dimensione ed elementi inizializzati: .. tabs:: .. code-tab:: gdscript var array = [] array.resize(5) array.fill(2) print(array) # Stampa [2, 2, 2, 2, 2] .. code-tab:: csharp Godot.Collections.Array array = []; array.Resize(5); array.Fill(2); GD.Print(array); // Stampa [2, 2, 2, 2, 2] \ **Nota:** Se ``value`` è un :ref:`Variant` passato per riferimento (derivato da :ref:`Object`, **Array**, :ref:`Dictionary`, ecc.), l'array sarà riempito con riferimenti allo stesso ``value``, che non sono duplicati. .. rst-class:: classref-item-separator ---- .. _class_Array_method_filter: .. rst-class:: classref-method :ref:`Array` **filter**\ (\ method\: :ref:`Callable`\ ) |const| :ref:`🔗` Chiama il :ref:`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 :ref:`any()`, :ref:`all()`, :ref:`map()` e :ref:`reduce()`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_find: .. rst-class:: classref-method :ref:`int` **find**\ (\ what\: :ref:`Variant`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` 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 :ref:`has()` (``Contains`` in C#). In GDScript, è anche possibile utilizzare l'operatore ``in``. \ **Nota:** Per motivi di prestazioni, la ricerca è influenzata dal tipo (:ref:`Variant.Type`) di ``what``. Ad esempio, ``7`` (:ref:`int`) e ``7.0`` (:ref:`float`)) non sono considerati uguali per questo metodo. .. rst-class:: classref-item-separator ---- .. _class_Array_method_find_custom: .. rst-class:: classref-method :ref:`int` **find_custom**\ (\ method\: :ref:`Callable`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` Restituisce l'indice del **primo** elemento nell'array che fa in modo che ``method`` restituisca ``true``, o ``-1`` se non ce ne sono. L'inizio della ricerca può essere specificato con ``from``, continuando fino alla fine dell'array. \ ``method`` è un chiamabile che accetta un elemento dell'array e restituisce un :ref:`bool`. \ **Nota:** Se vuoi solo sapere se l'array contiene *qualcosa* che soddisfa ``method``, usa :ref:`any()`. .. tabs:: .. code-tab:: gdscript func is_even(number): return number % 2 == 0 func _ready(): print([1, 3, 4, 7].find_custom(is_even.bind())) # Stampa 2 .. rst-class:: classref-item-separator ---- .. _class_Array_method_front: .. rst-class:: classref-method :ref:`Variant` **front**\ (\ ) |const| :ref:`🔗` Restituisce il primo elemento dell'array. Se l'array è vuoto, fallisce e restituisce ``null``. Vedi anche :ref:`back()`. \ **Nota:** A differenza dell'operatore ``[]`` (``array[0]``), viene generato un errore senza interrompere l'esecuzione del progetto. .. rst-class:: classref-item-separator ---- .. _class_Array_method_get: .. rst-class:: classref-method :ref:`Variant` **get**\ (\ index\: :ref:`int`\ ) |const| :ref:`🔗` 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. .. rst-class:: classref-item-separator ---- .. _class_Array_method_get_typed_builtin: .. rst-class:: classref-method :ref:`int` **get_typed_builtin**\ (\ ) |const| :ref:`🔗` Restituisce il tipo di :ref:`Variant` integrato dell'array tipizzato come constante di :ref:`Variant.Type`. Se l'array non è tipizzato, restituisce :ref:`@GlobalScope.TYPE_NIL`. Vedi anche :ref:`is_typed()`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_get_typed_class_name: .. rst-class:: classref-method :ref:`StringName` **get_typed_class_name**\ (\ ) |const| :ref:`🔗` Restituisce il nome della classe **integrata** dell'array tipizzato, se il tipo di :ref:`Variant` incorporato è :ref:`@GlobalScope.TYPE_OBJECT`. Altrimenti, restituisce un :ref:`StringName` vuoto. Vedi anche :ref:`is_typed()` e :ref:`Object.get_class()`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_get_typed_script: .. rst-class:: classref-method :ref:`Variant` **get_typed_script**\ (\ ) |const| :ref:`🔗` Restituisce l'istanza di :ref:`Script` associata a questo array tipizzato, o ``null`` se non esiste. Vedi anche :ref:`is_typed()`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_has: .. rst-class:: classref-method :ref:`bool` **has**\ (\ value\: :ref:`Variant`\ ) |const| :ref:`🔗` Restituisce ``true`` se l'array contiene il valore ``value``. .. tabs:: .. code-tab:: gdscript 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 .. code-tab:: csharp Godot.Collections.Array arr = ["dentro", 7]; // By C# convention, this method is renamed to `Contains`. GD.Print(arr.Contains("dentro")); // Stampa True GD.Print(arr.Contains("fuori")); // Stampa False GD.Print(arr.Contains(7)); // Stampa True GD.Print(arr.Contains("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 (:ref:`Variant.Type`) di ``value``. Ad esempio, ``7`` (:ref:`int`) e ``7.0`` (:ref:`float`)) non sono considerati uguali per questo metodo. .. rst-class:: classref-item-separator ---- .. _class_Array_method_hash: .. rst-class:: classref-method :ref:`int` **hash**\ (\ ) |const| :ref:`🔗` 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. .. rst-class:: classref-item-separator ---- .. _class_Array_method_insert: .. rst-class:: classref-method :ref:`int` **insert**\ (\ position\: :ref:`int`, value\: :ref:`Variant`\ ) :ref:`🔗` Inserisce un nuovo elemento (``value``) a un indice fornito (``position``) nell'array. ``position`` dovrebbe essere tra ``0`` e la dimensione dell'array (:ref:`size()`). Se negativo, ``position`` è considerato relativo alla fine dell'array. Restituisce :ref:`@GlobalScope.OK` al successo, o una delle altre costanti di :ref:`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. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_empty: .. rst-class:: classref-method :ref:`bool` **is_empty**\ (\ ) |const| :ref:`🔗` Restituisce ``true`` se l'array è vuoto (``[]``). Vedi anche :ref:`size()`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_read_only: .. rst-class:: classref-method :ref:`bool` **is_read_only**\ (\ ) |const| :ref:`🔗` Restituisce ``true`` se l'array è di sola lettura. Vedi :ref:`make_read_only()`. In GDScript, gli array diventano automaticamente di sola lettura se dichiarati con la parola chiave ``const``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_same_typed: .. rst-class:: classref-method :ref:`bool` **is_same_typed**\ (\ array\: :ref:`Array`\ ) |const| :ref:`🔗` Restituisce ``true`` se questo array è tipizzato lo stesso di ``array``. Vedi anche :ref:`is_typed()`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_typed: .. rst-class:: classref-method :ref:`bool` **is_typed**\ (\ ) |const| :ref:`🔗` 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 :ref:`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 .. rst-class:: classref-item-separator ---- .. _class_Array_method_make_read_only: .. rst-class:: classref-method |void| **make_read_only**\ (\ ) :ref:`🔗` 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``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_map: .. rst-class:: classref-method :ref:`Array