:github_url: hide .. _class_PackedStringArray: PackedStringArray ================= Un array compatto di :ref:`String`. .. rst-class:: classref-introduction-group Descrizione ---------------------- Un array progettato specificamente per contenere :ref:`String`. Impacchetta i dati in modo compatto, in modo da risparmiare memoria per array di grandi dimensioni. Se si desidera unire le stringhe nell'array, usa :ref:`String.join()`. :: var string_array = PackedStringArray(["ciao", "mondo"]) var string = " ".join(string_array) print(string) # "ciao mondo" \ **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 **PackedStringArray** in confronto a ``Array[String]``). 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:`Array.map()`. Gli array tipizzati sono anche loro più veloci da iterare e modificare in confronto ad array non tipizzati. \ **Nota:** Gli array impacchettati sono sempre passati per riferimento. Per ottenere una copia di un array che si può modificare indipendentemente dall'array originale, usare :ref:`duplicate()`. Questo *non* è il caso per le proprietà e per i metodi integrati. In tali casi l'array impacchettato restituito è una copia, e modificarlo *non* influenzerà il valore originale. Per aggiornare una proprietà integrata di questo tipo è necessario modificare l'array restituito e poi riassegnarlo alla proprietà. .. note:: Ci sono differenze sostanziali quando si usa questa API con C#. Vedi :ref:`doc_c_sharp_differences` per maggiori informazioni. .. rst-class:: classref-introduction-group Tutorial ---------------- - `Demo di test di sistema operativo `__ .. rst-class:: classref-reftable-group Costruttori ---------------------- .. table:: :widths: auto +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`PackedStringArray`\ (\ ) | +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`PackedStringArray`\ (\ from\: :ref:`PackedStringArray`\ ) | +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`PackedStringArray`\ (\ from\: :ref:`Array`\ ) | +---------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Metodi ------------ .. table:: :widths: auto +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`append`\ (\ value\: :ref:`String`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`append_array`\ (\ array\: :ref:`PackedStringArray`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bsearch`\ (\ value\: :ref:`String`, before\: :ref:`bool` = true\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`clear`\ (\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`count`\ (\ value\: :ref:`String`\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`duplicate`\ (\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`erase`\ (\ value\: :ref:`String`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`fill`\ (\ value\: :ref:`String`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find`\ (\ value\: :ref:`String`, from\: :ref:`int` = 0\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get`\ (\ index\: :ref:`int`\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has`\ (\ value\: :ref:`String`\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`insert`\ (\ at_index\: :ref:`int`, value\: :ref:`String`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_empty`\ (\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`push_back`\ (\ value\: :ref:`String`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`remove_at`\ (\ index\: :ref:`int`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`resize`\ (\ new_size\: :ref:`int`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reverse`\ (\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind`\ (\ value\: :ref:`String`, from\: :ref:`int` = -1\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set`\ (\ index\: :ref:`int`, value\: :ref:`String`\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`size`\ (\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`slice`\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`sort`\ (\ ) | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_byte_array`\ (\ ) |const| | +---------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Operatori ------------------ .. table:: :widths: auto +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`PackedStringArray`\ ) | +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`operator +`\ (\ right\: :ref:`PackedStringArray`\ ) | +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`PackedStringArray`\ ) | +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`operator []`\ (\ index\: :ref:`int`\ ) | +---------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei costruttori ------------------------------------------------------ .. _class_PackedStringArray_constructor_PackedStringArray: .. rst-class:: classref-constructor :ref:`PackedStringArray` **PackedStringArray**\ (\ ) :ref:`🔗` Costruisce un **PackedStringArray** vuoto. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`PackedStringArray` **PackedStringArray**\ (\ from\: :ref:`PackedStringArray`\ ) Costruisce un **PackedStringArray** come copia del **PackedStringArray** specificato. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`PackedStringArray` **PackedStringArray**\ (\ from\: :ref:`Array`\ ) Costruisce un nuovo **PackedStringArray**. È possibile passare un :ref:`Array` generico che sarà convertito. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni dei metodi -------------------------------------------- .. _class_PackedStringArray_method_append: .. rst-class:: classref-method :ref:`bool` **append**\ (\ value\: :ref:`String`\ ) :ref:`🔗` Aggiunge un elemento alla fine dell'array (pseudonimo di :ref:`push_back()`). .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_append_array: .. rst-class:: classref-method |void| **append_array**\ (\ array\: :ref:`PackedStringArray`\ ) :ref:`🔗` Accoda un **PackedStringArray** alla fine di questo array. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_bsearch: .. rst-class:: classref-method :ref:`int` **bsearch**\ (\ value\: :ref:`String`, before\: :ref:`bool` = true\ ) |const| :ref:`🔗` Trova l'indice di un valore esistente (o l'indice di inserimento che mantiene l'ordine di ordinamento, se il valore non è ancora presente nell'array) utilizzando la ricerca binaria. Facoltativamente, è possibile passare uno specificatore ``before``. Se ``false``, l'indice restituito viene dopo tutte le voci esistenti del valore nell'array. \ **Nota:** Chiamare :ref:`bsearch()` su un array non ordinato provoca un comportamento imprevisto. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_clear: .. rst-class:: classref-method |void| **clear**\ (\ ) :ref:`🔗` Cancella l'array. Ciò equivale a usare :ref:`resize()` con una dimensione di ``0``. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_count: .. rst-class:: classref-method :ref:`int` **count**\ (\ value\: :ref:`String`\ ) |const| :ref:`🔗` Restituisce il numero di volte che un elemento è presente nell'array. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_duplicate: .. rst-class:: classref-method :ref:`PackedStringArray` **duplicate**\ (\ ) |const| :ref:`🔗` Crea una copia dell'array, e la restituisce. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_erase: .. rst-class:: classref-method :ref:`bool` **erase**\ (\ value\: :ref:`String`\ ) :ref:`🔗` Rimuove la prima occorrenza di un valore dall'array e restituisce ``true``. Se il valore non esiste nell'array, nulla accade e viene restituito ``false``. Per rimuovere un elemento in base all'indice, utilizzare invece :ref:`remove_at()`. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_fill: .. rst-class:: classref-method |void| **fill**\ (\ value\: :ref:`String`\ ) :ref:`🔗` Assegna il valore specificato a tutti gli elementi nell'array. Questo può solitamente essere usato insieme a :ref:`resize()` per creare un array con una determinata dimensione ed elementi inizializzati. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_find: .. rst-class:: classref-method :ref:`int` **find**\ (\ value\: :ref:`String`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` Cerca un valore nell'array e restituisce il suo indice o ``-1`` se non trovato. Facoltativamente, può essere passato l'indice di ricerca iniziale. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_get: .. rst-class:: classref-method :ref:`String` **get**\ (\ index\: :ref:`int`\ ) |const| :ref:`🔗` Returns the :ref:`String` at the given ``index`` in the array. If ``index`` is out-of-bounds or negative, this method fails and returns an empty string. 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_PackedStringArray_method_has: .. rst-class:: classref-method :ref:`bool` **has**\ (\ value\: :ref:`String`\ ) |const| :ref:`🔗` Restituisce ``true`` se l'array contiene ``value``. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_insert: .. rst-class:: classref-method :ref:`int` **insert**\ (\ at_index\: :ref:`int`, value\: :ref:`String`\ ) :ref:`🔗` Inserisce un nuovo elemento in una determinata posizione nell'array. La posizione deve essere valida o alla fine dell'array (``idx == size()``). .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_is_empty: .. rst-class:: classref-method :ref:`bool` **is_empty**\ (\ ) |const| :ref:`🔗` Restituisce ``true`` se l'array è vuoto. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_push_back: .. rst-class:: classref-method :ref:`bool` **push_back**\ (\ value\: :ref:`String`\ ) :ref:`🔗` Accoda un elemento di stringa alla fine dell'array. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_remove_at: .. rst-class:: classref-method |void| **remove_at**\ (\ index\: :ref:`int`\ ) :ref:`🔗` Rimuove un elemento dall'array in base all'indice. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_resize: .. rst-class:: classref-method :ref:`int` **resize**\ (\ new_size\: :ref:`int`\ ) :ref:`🔗` Imposta la dimensione dell'array. Se l'array viene ingrandito, riserva gli elementi alla fine dell'array. Se l'array viene rimpicciolito, tronca l'array alla nuova dimensione. Chiamare :ref:`resize()` una sola volta e assegnare i nuovi valori è più veloce che aggiungere nuovi elementi uno alla volta. Restituisce :ref:`@GlobalScope.OK` in caso di successo, oppure una delle seguenti costanti di :ref:`Error` se questo metodo fallisce: :ref:`@GlobalScope.ERR_INVALID_PARAMETER` se la dimensione è negativa, oppure :ref:`@GlobalScope.ERR_OUT_OF_MEMORY` se le allocazioni falliscono. Usare :ref:`size()` per trovare la dimensione effettiva dell'array dopo il ridimensionamento. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_reverse: .. rst-class:: classref-method |void| **reverse**\ (\ ) :ref:`🔗` Inverte l'ordine degli elementi nell'array. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_rfind: .. rst-class:: classref-method :ref:`int` **rfind**\ (\ value\: :ref:`String`, from\: :ref:`int` = -1\ ) |const| :ref:`🔗` Cerca nell'array in ordine inverso. Facoltativamente, può essere passato un indice di ricerca iniziale. Se negativo, l'indice di inizio è considerato relativo alla fine dell'array. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_set: .. rst-class:: classref-method |void| **set**\ (\ index\: :ref:`int`, value\: :ref:`String`\ ) :ref:`🔗` Modifica la :ref:`String` all'indice specificato. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_size: .. rst-class:: classref-method :ref:`int` **size**\ (\ ) |const| :ref:`🔗` Restituisce il numero di elementi nell'array. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_slice: .. rst-class:: classref-method :ref:`PackedStringArray` **slice**\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647\ ) |const| :ref:`🔗` Restituisce la sezione del **PackedStringArray**, da ``begin`` (incluso) a ``end`` (escluso), sotto forma di un nuovo **PackedStringArray**. Il valore assoluto di ``begin`` e ``end`` sarà limitato alla dimensione dell'array, quindi il valore predefinito per ``end`` lo suddivide alla dimensione dell'array per impostazione predefinita (ad esempio, ``arr.slice(1)`` è un'abbreviazione per ``arr.slice(1, arr.size())``). Se ``begin`` o ``end`` sono negativi, saranno relativi alla fine dell'array (ad esempio, ``arr.slice(0, -2)`` è un'abbreviazione per ``arr.slice(0, arr.size() - 2)``). .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_sort: .. rst-class:: classref-method |void| **sort**\ (\ ) :ref:`🔗` Ordina gli elementi dell'array in ordine crescente. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_method_to_byte_array: .. rst-class:: classref-method :ref:`PackedByteArray` **to_byte_array**\ (\ ) |const| :ref:`🔗` Restituisce un :ref:`PackedByteArray` con ogni stringa codificata come UTF8. Le stringhe vengono terminate con ``null``. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Descrizioni degli operatori ------------------------------------------------------ .. _class_PackedStringArray_operator_neq_PackedStringArray: .. rst-class:: classref-operator :ref:`bool` **operator !=**\ (\ right\: :ref:`PackedStringArray`\ ) :ref:`🔗` Restituisce ``true`` se i contenuti degli array differiscono. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_operator_sum_PackedStringArray: .. rst-class:: classref-operator :ref:`PackedStringArray` **operator +**\ (\ right\: :ref:`PackedStringArray`\ ) :ref:`🔗` Restituisce un nuovo **PackedStringArray** con il contenuto di ``right`` accodato alla fine di questo array. Per prestazioni migliori, considera invece di usare :ref:`append_array()`. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_operator_eq_PackedStringArray: .. rst-class:: classref-operator :ref:`bool` **operator ==**\ (\ right\: :ref:`PackedStringArray`\ ) :ref:`🔗` Restituisce ``true`` se il contenuto di entrambi gli array è lo stesso, ovvero hanno tutte le :ref:`String` uguali agli indici corrispondenti. .. rst-class:: classref-item-separator ---- .. _class_PackedStringArray_operator_idx_int: .. rst-class:: classref-operator :ref:`String` **operator []**\ (\ index\: :ref:`int`\ ) :ref:`🔗` Restituisce la :ref:`String` all'indice ``index``. Gli indici negativi possono essere utilizzati per accedere agli elementi partendo dalla fine. Utilizzare un indice fuori dai limiti dell'array genererà un errore. .. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)` .. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)` .. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)` .. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)` .. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)` .. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)` .. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)` .. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)` .. |void| replace:: :abbr:`void (Nessun valore restituito.)`