godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/it/class_packedbytearray.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

1204 lines
80 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_PackedByteArray:
PackedByteArray
===============
Un array compatto di byte.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
Un array specificamente progettato per contenere byte. Impacchetta i dati in modo compatto, in modo da risparmiare memoria per array di grandi dimensioni.
\ **PackedByteArray** fornisce anche metodi per codificare/decodificare vari tipi da/a byte. Il modo in cui i valori sono codificati è un dettaglio di implementazione e non ci si dovrebbe dipendere quando si interagisce con applicazioni esterne.
\ **Nota:** Gli array impacchettati sono sempre passati per riferimento. Per ottenere una copia di un array che può essere modificata indipendentemente dall'array originale, usa :ref:`duplicate()<class_PackedByteArray_method_duplicate>`. Questo *non* è il caso per le proprietà e per i metodi integrati. L'array impacchettato restituito da essi è una copia e modificarlo *non* influenzerà il valore originale. Per aggiornare una proprietà integrata è necessario modificare l'array restituito e successivamente 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-reftable-group
Costruttori
----------------------
.. table::
:widths: auto
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`PackedByteArray<class_PackedByteArray_constructor_PackedByteArray>`\ (\ ) |
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`PackedByteArray<class_PackedByteArray_constructor_PackedByteArray>`\ (\ from\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`PackedByteArray<class_PackedByteArray_constructor_PackedByteArray>`\ (\ from\: :ref:`Array<class_Array>`\ ) |
+-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Metodi
------------
.. table::
:widths: auto
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`append<class_PackedByteArray_method_append>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`append_array<class_PackedByteArray_method_append_array>`\ (\ array\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`bsearch<class_PackedByteArray_method_bsearch>`\ (\ value\: :ref:`int<class_int>`, before\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bswap16<class_PackedByteArray_method_bswap16>`\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bswap32<class_PackedByteArray_method_bswap32>`\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`bswap64<class_PackedByteArray_method_bswap64>`\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`clear<class_PackedByteArray_method_clear>`\ (\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`compress<class_PackedByteArray_method_compress>`\ (\ compression_mode\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`count<class_PackedByteArray_method_count>`\ (\ value\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`decode_double<class_PackedByteArray_method_decode_double>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`decode_float<class_PackedByteArray_method_decode_float>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`decode_half<class_PackedByteArray_method_decode_half>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_s8<class_PackedByteArray_method_decode_s8>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_s16<class_PackedByteArray_method_decode_s16>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_s32<class_PackedByteArray_method_decode_s32>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_s64<class_PackedByteArray_method_decode_s64>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_u8<class_PackedByteArray_method_decode_u8>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_u16<class_PackedByteArray_method_decode_u16>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_u32<class_PackedByteArray_method_decode_u32>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_u64<class_PackedByteArray_method_decode_u64>`\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`Variant<class_Variant>` | :ref:`decode_var<class_PackedByteArray_method_decode_var>`\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`decode_var_size<class_PackedByteArray_method_decode_var_size>`\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`decompress<class_PackedByteArray_method_decompress>`\ (\ buffer_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`decompress_dynamic<class_PackedByteArray_method_decompress_dynamic>`\ (\ max_output_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`duplicate<class_PackedByteArray_method_duplicate>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_double<class_PackedByteArray_method_encode_double>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_float<class_PackedByteArray_method_encode_float>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_half<class_PackedByteArray_method_encode_half>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_s8<class_PackedByteArray_method_encode_s8>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_s16<class_PackedByteArray_method_encode_s16>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_s32<class_PackedByteArray_method_encode_s32>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_s64<class_PackedByteArray_method_encode_s64>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_u8<class_PackedByteArray_method_encode_u8>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_u16<class_PackedByteArray_method_encode_u16>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_u32<class_PackedByteArray_method_encode_u32>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`encode_u64<class_PackedByteArray_method_encode_u64>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`encode_var<class_PackedByteArray_method_encode_var>`\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`erase<class_PackedByteArray_method_erase>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`fill<class_PackedByteArray_method_fill>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`find<class_PackedByteArray_method_find>`\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get<class_PackedByteArray_method_get>`\ (\ index\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_string_from_ascii<class_PackedByteArray_method_get_string_from_ascii>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_string_from_multibyte_char<class_PackedByteArray_method_get_string_from_multibyte_char>`\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_string_from_utf8<class_PackedByteArray_method_get_string_from_utf8>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_string_from_utf16<class_PackedByteArray_method_get_string_from_utf16>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_string_from_utf32<class_PackedByteArray_method_get_string_from_utf32>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_string_from_wchar<class_PackedByteArray_method_get_string_from_wchar>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has<class_PackedByteArray_method_has>`\ (\ value\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`has_encoded_var<class_PackedByteArray_method_has_encoded_var>`\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`hex_encode<class_PackedByteArray_method_hex_encode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`insert<class_PackedByteArray_method_insert>`\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_PackedByteArray_method_is_empty>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`push_back<class_PackedByteArray_method_push_back>`\ (\ value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`remove_at<class_PackedByteArray_method_remove_at>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`resize<class_PackedByteArray_method_resize>`\ (\ new_size\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`reverse<class_PackedByteArray_method_reverse>`\ (\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfind<class_PackedByteArray_method_rfind>`\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`set<class_PackedByteArray_method_set>`\ (\ index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`size<class_PackedByteArray_method_size>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`slice<class_PackedByteArray_method_slice>`\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| |void| | :ref:`sort<class_PackedByteArray_method_sort>`\ (\ ) |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedColorArray<class_PackedColorArray>` | :ref:`to_color_array<class_PackedByteArray_method_to_color_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedFloat32Array<class_PackedFloat32Array>` | :ref:`to_float32_array<class_PackedByteArray_method_to_float32_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedFloat64Array<class_PackedFloat64Array>` | :ref:`to_float64_array<class_PackedByteArray_method_to_float64_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt32Array<class_PackedInt32Array>` | :ref:`to_int32_array<class_PackedByteArray_method_to_int32_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedInt64Array<class_PackedInt64Array>` | :ref:`to_int64_array<class_PackedByteArray_method_to_int64_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector2Array<class_PackedVector2Array>` | :ref:`to_vector2_array<class_PackedByteArray_method_to_vector2_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector3Array<class_PackedVector3Array>` | :ref:`to_vector3_array<class_PackedByteArray_method_to_vector3_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedVector4Array<class_PackedVector4Array>` | :ref:`to_vector4_array<class_PackedByteArray_method_to_vector4_array>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Operatori
------------------
.. table::
:widths: auto
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_PackedByteArray_operator_neq_PackedByteArray>`\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`operator +<class_PackedByteArray_operator_sum_PackedByteArray>`\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_PackedByteArray_operator_eq_PackedByteArray>`\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) |
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator []<class_PackedByteArray_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei costruttori
------------------------------------------------------
.. _class_PackedByteArray_constructor_PackedByteArray:
.. rst-class:: classref-constructor
:ref:`PackedByteArray<class_PackedByteArray>` **PackedByteArray**\ (\ ) :ref:`🔗<class_PackedByteArray_constructor_PackedByteArray>`
Costruisce un **PackedByteArray** vuoto.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`PackedByteArray<class_PackedByteArray>` **PackedByteArray**\ (\ from\: :ref:`PackedByteArray<class_PackedByteArray>`\ )
Costruisce un **PackedByteArray** come copia del **PackedByteArray** specificato.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`PackedByteArray<class_PackedByteArray>` **PackedByteArray**\ (\ from\: :ref:`Array<class_Array>`\ )
Costruisce un nuovo **PackedByteArray**. È possibile passare un :ref:`Array<class_Array>` generico che sarà convertito.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _class_PackedByteArray_method_append:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **append**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_append>`
Aggiunge un elemento alla fine dell'array (pseudonimo di :ref:`push_back()<class_PackedByteArray_method_push_back>`).
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_append_array:
.. rst-class:: classref-method
|void| **append_array**\ (\ array\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_method_append_array>`
Accoda un **PackedByteArray** alla fine di questo array.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_bsearch:
.. rst-class:: classref-method
:ref:`int<class_int>` **bsearch**\ (\ value\: :ref:`int<class_int>`, before\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_PackedByteArray_method_bsearch>`
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()<class_PackedByteArray_method_bsearch>` su un array non ordinato provoca un comportamento imprevisto.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_bswap16:
.. rst-class:: classref-method
|void| **bswap16**\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_PackedByteArray_method_bswap16>`
Scambia l'ordine dei byte di ``count`` segmenti a 16 bit nell'array a partire da ``offset``. Lo scambio viene eseguito sul posto. Se ``count`` è minore di zero, vengono elaborati tutti i segmenti fino alla fine dell'array; se la dimensione dei dati elaborati non è un multiplo di 2, il byte successivo all'ultimo segmento a 16 bit elaborato non viene modificato.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_bswap32:
.. rst-class:: classref-method
|void| **bswap32**\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_PackedByteArray_method_bswap32>`
Scambia l'ordine dei byte di ``count`` segmenti a 32 bit nell'array a partire da ``offset``. Lo scambio viene eseguito sul posto. Se ``count`` è minore di zero, vengono elaborati tutti i segmenti fino alla fine dell'array; se la dimensione dei dati elaborati non è un multiplo di 4, il byte successivo all'ultimo segmento a 32 bit elaborato non viene modificato.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_bswap64:
.. rst-class:: classref-method
|void| **bswap64**\ (\ offset\: :ref:`int<class_int>` = 0, count\: :ref:`int<class_int>` = -1\ ) :ref:`🔗<class_PackedByteArray_method_bswap64>`
Scambia l'ordine dei byte di ``count`` segmenti a 64 bit nell'array a partire da ``offset``. Lo scambio viene eseguito sul posto. Se ``count`` è minore di zero, vengono elaborati tutti i segmenti fino alla fine dell'array; se la dimensione dei dati elaborati non è un multiplo di 8, il byte successivo all'ultimo segmento a 64 bit elaborato non viene modificato.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_clear:
.. rst-class:: classref-method
|void| **clear**\ (\ ) :ref:`🔗<class_PackedByteArray_method_clear>`
Cancella l'array. Ciò equivale a usare :ref:`resize()<class_PackedByteArray_method_resize>` con una dimensione di ``0``.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_compress:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **compress**\ (\ compression_mode\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_compress>`
Restituisce un nuovo **PackedByteArray** con i dati compressi. Imposta la modalità di compressione utilizzando una delle costanti di :ref:`CompressionMode<enum_FileAccess_CompressionMode>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **count**\ (\ value\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_count>`
Restituisce il numero di volte che un elemento è presente nell'array.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_double:
.. rst-class:: classref-method
:ref:`float<class_float>` **decode_double**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_double>`
Decodifica un numero in virgola mobile a 64 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_float:
.. rst-class:: classref-method
:ref:`float<class_float>` **decode_float**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_float>`
Decodifica un numero in virgola mobile a 32 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_half:
.. rst-class:: classref-method
:ref:`float<class_float>` **decode_half**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_half>`
Decodifica un numero in virgola mobile a 16 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_s8:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_s8**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s8>`
Decodifica un numero intero con segno a 8 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_s16:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_s16**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s16>`
Decodifica un numero intero con segno a 16 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_s32:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_s32**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s32>`
Decodifica un numero intero con segno a 32 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_s64:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_s64**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_s64>`
Decodifica un numero intero con segno a 64 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_u8:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_u8**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u8>`
Decodifica un numero intero senza segno a 8 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_u16:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_u16**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u16>`
Decodifica un numero intero senza segno a 16 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_u32:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_u32**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u32>`
Decodifica un numero intero senza segno a 32 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_u64:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_u64**\ (\ byte_offset\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_u64>`
Decodifica un numero intero senza segno a 64 bit dai byte che iniziano da ``byte_offset``. Fallisce se il numero dei byte è insufficiente. Restituisce ``0.0`` se non è possibile decodificare un numero valido.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_var:
.. rst-class:: classref-method
:ref:`Variant<class_Variant>` **decode_var**\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_var>`
Decodifica una :ref:`Variant<class_Variant>` dai byte che iniziano da ``byte_offset``. Restituisce ``null`` se una variante valida non può essere decodificata o se il valore deriva da :ref:`Object<class_Object>` e ``allow_objects`` è ``false``.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decode_var_size:
.. rst-class:: classref-method
:ref:`int<class_int>` **decode_var_size**\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_PackedByteArray_method_decode_var_size>`
Decodifica la dimensione di una :ref:`Variant<class_Variant>` dai byte che iniziano da ``byte_offset``. Richiede almeno 4 byte di dati che iniziano dall'offset, altrimenti fallisce.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decompress:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **decompress**\ (\ buffer_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_decompress>`
Restituisce un nuovo **PackedByteArray** con i dati decompressi. Imposta ``buffer_size`` sulla dimensione dei dati non compressi. Imposta la modalità di compressione usando una delle costanti di :ref:`CompressionMode<enum_FileAccess_CompressionMode>`.
\ **Nota:** Non è garantito che la decompressione funzioni con dati non compressi da Godot, ad esempio se i dati compressi con la modalità di compressione deflate non hanno un checksum o un'intestazione.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_decompress_dynamic:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **decompress_dynamic**\ (\ max_output_size\: :ref:`int<class_int>`, compression_mode\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_decompress_dynamic>`
Restituisce un nuovo **PackedByteArray** con i dati decompressi. Imposta la modalità di compressione usando una delle costanti di :ref:`CompressionMode<enum_FileAccess_CompressionMode>`. **Questo metodo accetta solo le modalità di compressione brotli, gzip e deflate.**\
Questo metodo è potenzialmente più lento di :ref:`decompress()<class_PackedByteArray_method_decompress>`, poiché potrebbe dover riallocare il suo buffer di output più volte durante la decompressione, mentre :ref:`decompress()<class_PackedByteArray_method_decompress>` conosce la dimensione del suo buffer di output dall'inizio.
GZIP ha un rapporto di compressione massimo di 1032:1, il che significa che è molto probabile che un piccolo payload compresso si decomprima in un output potenzialmente molto grande. Per proteggersi da questo, puoi fornire una dimensione massima che questa funzione può allocare in byte tramite ``max_output_size``. Passando -1 sarà consentito un output illimitato. Se viene passato un valore positivo e la decompressione supera tale quantità in byte, verrà restituito un errore.
\ **Nota:** Non è garantito che la decompressione funzioni con dati non compressi da Godot, ad esempio se i dati compressi con la modalità di compressione deflate non hanno un checksum o un'intestazione.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_duplicate:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **duplicate**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_duplicate>`
Crea una copia dell'array, e la restituisce.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_double:
.. rst-class:: classref-method
|void| **encode_double**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_double>`
Codifica un numero in virgola mobile a 64 bit come byte all'indice di ``byte_offset`` byte. L'array deve avere almeno 8 byte di spazio allocato, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_float:
.. rst-class:: classref-method
|void| **encode_float**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_float>`
Codifica un numero in virgola mobile a 32 bit come byte all'indice di ``byte_offset`` byte. L'array deve avere almeno 4 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_half:
.. rst-class:: classref-method
|void| **encode_half**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`float<class_float>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_half>`
Codifica un numero in virgola mobile a 16 bit come byte all'indice di ``byte_offset`` byte. L'array deve avere almeno 2 byte di spazio allocato, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_s8:
.. rst-class:: classref-method
|void| **encode_s8**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s8>`
Codifica un numero intero con segno a 8 bit (byte con segno) all'indice di ``byte_offset`` byte. L'array deve avere almeno 1 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_s16:
.. rst-class:: classref-method
|void| **encode_s16**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s16>`
Codifica un numero intero con segno a 16 bit all'indice di ``byte_offset`` byte. L'array deve avere almeno 2 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_s32:
.. rst-class:: classref-method
|void| **encode_s32**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s32>`
Codifica un numero intero con segno a 32 bit all'indice di ``byte_offset`` byte. L'array deve avere almeno 4 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_s64:
.. rst-class:: classref-method
|void| **encode_s64**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_s64>`
Codifica un numero intero con segno a 64 bit all'indice di ``byte_offset`` byte. L'array deve avere almeno 8 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_u8:
.. rst-class:: classref-method
|void| **encode_u8**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u8>`
Codifica un numero intero senza segno a 8 bit (byte) all'indice di ``byte_offset`` byte. L'array deve avere almeno 1 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_u16:
.. rst-class:: classref-method
|void| **encode_u16**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u16>`
Codifica un numero intero senza segno a 16 bit all'indice di ``byte_offset`` byte. L'array deve avere almeno 2 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_u32:
.. rst-class:: classref-method
|void| **encode_u32**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u32>`
Codifica un numero intero senza segno a 32 bit all'indice di ``byte_offset`` byte. L'array deve avere almeno 4 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_u64:
.. rst-class:: classref-method
|void| **encode_u64**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_encode_u64>`
Codifica un numero intero senza segno a 64 bit all'indice di ``byte_offset`` byte. L'array deve avere almeno 8 byte di spazio, a partire dall'offset.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_encode_var:
.. rst-class:: classref-method
:ref:`int<class_int>` **encode_var**\ (\ byte_offset\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) :ref:`🔗<class_PackedByteArray_method_encode_var>`
Codifica una :ref:`Variant<class_Variant>` all'indice di ``byte_offset`` byte. Deve essere allocato uno spazio sufficiente, a seconda della dimensione della variante codificata. Se ``allow_objects`` è ``false``, i valori derivati da :ref:`Object<class_Object>` non sono consentiti e soltanto i loro ID saranno serializzati.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_erase:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **erase**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_erase>`
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()<class_PackedByteArray_method_remove_at>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_fill:
.. rst-class:: classref-method
|void| **fill**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_fill>`
Assegna il valore specificato a tutti gli elementi nell'array. Questo può solitamente essere usato insieme a :ref:`resize()<class_PackedByteArray_method_resize>` per creare un array con una determinata dimensione ed elementi inizializzati.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_find:
.. rst-class:: classref-method
:ref:`int<class_int>` **find**\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_PackedByteArray_method_find>`
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_PackedByteArray_method_get:
.. rst-class:: classref-method
:ref:`int<class_int>` **get**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_get>`
Returns the byte at the given ``index`` in the array. If ``index`` is out-of-bounds or negative, this method fails and returns ``0``.
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_PackedByteArray_method_get_string_from_ascii:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_string_from_ascii**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_ascii>`
Converte un array codificato con ASCII/Latin-1 in :ref:`String<class_String>`. Alternativa veloce a :ref:`get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>` se il contenuto è solo ASCII/Latin-1. A differenza della funzione UTF-8, questa funzione mappa ogni byte a un carattere nell'array. Le sequenze multibyte non saranno interpretate correttamente. Per elaborare l'input dell'utente, utilizza sempre :ref:`get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>`. Questo è l'inverso di :ref:`String.to_ascii_buffer()<class_String_method_to_ascii_buffer>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_get_string_from_multibyte_char:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_string_from_multibyte_char**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_multibyte_char>`
Converte un array codificato con code page multibyte di sistema in :ref:`String<class_String>`. Se la conversione fallisce, viene restituita una stringa vuota. Questo è l'inverso di :ref:`String.to_multibyte_char_buffer()<class_String_method_to_multibyte_char_buffer>`.
I valori consentiti per ``encoding`` dipendono dal sistema. Se ``encoding`` è una stringa vuota, viene utilizzata la codifica predefinita del sistema.
- Per Windows, consultare i nomi .NET per i `Code Page Identifiers <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__.
- Per macOS e Linux/BSD, consultare la documentazione della libreria ``libiconv`` e ``iconv --list`` per un elenco delle codifiche supportate.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_get_string_from_utf8:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_string_from_utf8**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_utf8>`
Converte un array codificato con UTF-8 in :ref:`String<class_String>`. Più lento di :ref:`get_string_from_ascii()<class_PackedByteArray_method_get_string_from_ascii>` ma supporta dati codificati con UTF-8. Usa questa funzione se non si è sicuri dell'origine dei dati. Per l'input dell'utente questa funzione dovrebbe sempre essere preferita. Restituisce una stringa vuota se l'array sorgente non è una stringa UTF-8 valida. Questo è l'inverso di :ref:`String.to_utf8_buffer()<class_String_method_to_utf8_buffer>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_get_string_from_utf16:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_string_from_utf16**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_utf16>`
Converte un array codificato in UTF-16 in :ref:`String<class_String>`. Se il BOM manca, si presume l'ordine dei byte "little" . Restituisce una stringa vuota se l'array sorgente non è una stringa UTF-16 valida. Questo è l'inverso di :ref:`String.to_utf16_buffer()<class_String_method_to_utf16_buffer>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_get_string_from_utf32:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_string_from_utf32**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_utf32>`
Converte un array codificato con UTF-32 in :ref:`String<class_String>`. Restituisce una stringa vuota se l'array sorgente non è una stringa UTF-32 valida. Questo è l'inverso di :ref:`String.to_utf32_buffer()<class_String_method_to_utf32_buffer>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_get_string_from_wchar:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_string_from_wchar**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_get_string_from_wchar>`
Converte un array codificato con caratteri estesi (``wchar_t``, UTF-16 su Windows, UTF-32 su altre piattaforme) in :ref:`String<class_String>`. Restituisce una stringa vuota se l'array sorgente non è una stringa estesa valida. Questo è l'inverso di :ref:`String.to_wchar_buffer()<class_String_method_to_wchar_buffer>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_has:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has**\ (\ value\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_PackedByteArray_method_has>`
Restituisce ``true`` se l'array contiene ``value``.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_has_encoded_var:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **has_encoded_var**\ (\ byte_offset\: :ref:`int<class_int>`, allow_objects\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_PackedByteArray_method_has_encoded_var>`
Restituisce ``true`` se un valore :ref:`Variant<class_Variant>` valido può essere decodificato nell'offset ``byte_offset``. Restituisce ``false`` in caso contrario o quando il valore è derivato da :ref:`Object<class_Object>` e ``allow_objects`` è ``false``.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_hex_encode:
.. rst-class:: classref-method
:ref:`String<class_String>` **hex_encode**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_hex_encode>`
Restituisce una rappresentazione esadecimale di questo array come :ref:`String<class_String>`.
.. tabs::
.. code-tab:: gdscript
var array = PackedByteArray([11, 46, 255])
print(array.hex_encode()) # Stampa "0b2eff"
.. code-tab:: csharp
var array = new byte[] {11, 46, 255};
GD.Print(array.HexEncode()); // Stampa "0b2eff"
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_insert:
.. rst-class:: classref-method
:ref:`int<class_int>` **insert**\ (\ at_index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_insert>`
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_PackedByteArray_method_is_empty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_is_empty>`
Restituisce ``true`` se l'array è vuoto.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_push_back:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **push_back**\ (\ value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_push_back>`
Appende un elemento alla fine dell'array.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_remove_at:
.. rst-class:: classref-method
|void| **remove_at**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_remove_at>`
Rimuove un elemento dall'array in base all'indice.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_resize:
.. rst-class:: classref-method
:ref:`int<class_int>` **resize**\ (\ new_size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_resize>`
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()<class_PackedByteArray_method_resize>` una sola volta e assegnare i nuovi valori è più veloce che aggiungere nuovi elementi uno alla volta.
Restituisce :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` in caso di successo, oppure una delle seguenti costanti di :ref:`Error<enum_@GlobalScope_Error>` se questo metodo fallisce: :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` se la dimensione è negativa, oppure :ref:`@GlobalScope.ERR_OUT_OF_MEMORY<class_@GlobalScope_constant_ERR_OUT_OF_MEMORY>` se le allocazioni falliscono. Usare :ref:`size()<class_PackedByteArray_method_size>` per trovare la dimensione effettiva dell'array dopo il ridimensionamento.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_reverse:
.. rst-class:: classref-method
|void| **reverse**\ (\ ) :ref:`🔗<class_PackedByteArray_method_reverse>`
Inverte l'ordine degli elementi nell'array.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_rfind:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfind**\ (\ value\: :ref:`int<class_int>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_PackedByteArray_method_rfind>`
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_PackedByteArray_method_set:
.. rst-class:: classref-method
|void| **set**\ (\ index\: :ref:`int<class_int>`, value\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_method_set>`
Modifica il byte all'indice specificato.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_size:
.. rst-class:: classref-method
:ref:`int<class_int>` **size**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_size>`
Restituisce il numero di elementi nell'array.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_slice:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **slice**\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647\ ) |const| :ref:`🔗<class_PackedByteArray_method_slice>`
Restituisce la sezione del **PackedByteArray**, da ``begin`` (incluso) a ``end`` (escluso), sotto forma di un nuovo **PackedByteArray**.
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_PackedByteArray_method_sort:
.. rst-class:: classref-method
|void| **sort**\ (\ ) :ref:`🔗<class_PackedByteArray_method_sort>`
Ordina gli elementi dell'array in ordine crescente.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_color_array:
.. rst-class:: classref-method
:ref:`PackedColorArray<class_PackedColorArray>` **to_color_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_color_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedColorArray<class_PackedColorArray>`, dove ogni blocco di 16 byte è stato convertito in un variante di tipo :ref:`Color<class_Color>`\
\ **Nota:** La dimensione dell'array in input deve essere un multiplo di 16 (dimensione di quattro float a 32 bit). La dimensione del nuovo array sarà ``byte_array.size() / 16``. Se non è possibile convertire i dati originali in varianti :ref:`Color<class_Color>`, i dati risultanti sono indefiniti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_float32_array:
.. rst-class:: classref-method
:ref:`PackedFloat32Array<class_PackedFloat32Array>` **to_float32_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_float32_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedFloat32Array<class_PackedFloat32Array>`, dove ogni blocco di 4 byte è stato convertito in un float a 32 bit (``float`` in C++).
La dimensione dell'array in input deve essere un multiplo di 4 (dimensione di float a 32 bit). La dimensione del nuovo array sarà ``byte_array.size() / 4``.
Se non è possibile convertire i dati originali convertiti in float a 32 bit, i dati risultanti sono indefiniti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_float64_array:
.. rst-class:: classref-method
:ref:`PackedFloat64Array<class_PackedFloat64Array>` **to_float64_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_float64_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedFloat32Array<class_PackedFloat32Array>`, dove ogni blocco di 8 byte è stato convertito in un float a 64 bit (``double`` in C++).
La dimensione dell'array in input deve essere un multiplo di 8 (dimensione di double a 64 bit). La dimensione del nuovo array sarà ``byte_array.size() / 8``.
Se non è possibile convertire i dati originali in float a 64 bit, i dati risultanti sono indefiniti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_int32_array:
.. rst-class:: classref-method
:ref:`PackedInt32Array<class_PackedInt32Array>` **to_int32_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_int32_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedInt32Array<class_PackedInt32Array>`, dove ogni blocco di 4 byte è stato convertito in un intero con segno a 32 bit (``int32_t`` in C++).
La dimensione dell'array in input deve essere un multiplo di 4 (dimensione di intero a 32 bit). La dimensione del nuovo array sarà ``byte_array.size() / 4``.
Se non è possibile convertire i dati originali in interi con segno a 32 bit, i dati risultanti sono indefiniti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_int64_array:
.. rst-class:: classref-method
:ref:`PackedInt64Array<class_PackedInt64Array>` **to_int64_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_int64_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedInt32Array<class_PackedInt32Array>`, dove ogni blocco di 8 byte è stato convertito in un intero con segno a 64 bit (``int64_t`` in C++).
La dimensione dell'array in input deve essere un multiplo di 8 (dimensione di intero a 64 bit). La dimensione del nuovo array sarà ``byte_array.size() / 8``.
Se non è possibile convertire i dati originali in interi con segno a 64 bit, i dati risultanti sono indefiniti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_vector2_array:
.. rst-class:: classref-method
:ref:`PackedVector2Array<class_PackedVector2Array>` **to_vector2_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_vector2_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedVector2Array<class_PackedVector2Array>`, dove ogni blocco di 8 o 16 byte (32 bit o 64 bit) è stato convertito in un variante di tipo :ref:`Vector2<class_Vector2>`\
\ **Nota:** La dimensione dell'array in input deve essere un multiplo di 8 o 16 (a seconda della configurazione della build, vedi :ref:`Vector2<class_Vector2>` per più dettagli). La dimensione del nuovo array sarà ``byte_array.size() / (8 o 16)``. Se non è possibile convertire i dati originali in varianti :ref:`Vector2<class_Vector2>`, i dati risultanti sono indefiniti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_vector3_array:
.. rst-class:: classref-method
:ref:`PackedVector3Array<class_PackedVector3Array>` **to_vector3_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_vector3_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedVector3Array<class_PackedVector3Array>`, dove ogni blocco di 12 o 24 byte (32 bit o 64 bit) è stato convertito in un variante di tipo :ref:`Vector3<class_Vector3>`\
\ **Nota:** La dimensione dell'array in input deve essere un multiplo di 12 o 24 (a seconda della configurazione della build, vedi :ref:`Vector3<class_Vector3>` per più dettagli). La dimensione del nuovo array sarà ``byte_array.size() / (12 o 24)``. Se non è possibile convertire i dati originali in varianti :ref:`Vector3<class_Vector3>`, i dati risultanti sono indefiniti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_method_to_vector4_array:
.. rst-class:: classref-method
:ref:`PackedVector4Array<class_PackedVector4Array>` **to_vector4_array**\ (\ ) |const| :ref:`🔗<class_PackedByteArray_method_to_vector4_array>`
Restituisce una copia dei dati convertiti in un :ref:`PackedVector4Array<class_PackedVector4Array>`, dove ogni blocco di 16 o 32 byte (32 bit o 64 bit) è stato convertito in un variante di tipo :ref:`Vector4<class_Vector4>`\
\ **Nota:** La dimensione dell'array in input deve essere un multiplo di 16 o 32 (a seconda della configurazione della build, vedi :ref:`Vector4<class_Vector4>` per più dettagli). La dimensione del nuovo array sarà ``byte_array.size() / (16 o 32)``. Se non è possibile convertire i dati originali in varianti :ref:`Vector4<class_Vector4>`, i dati risultanti sono indefiniti.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni degli operatori
------------------------------------------------------
.. _class_PackedByteArray_operator_neq_PackedByteArray:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_operator_neq_PackedByteArray>`
Restituisce ``true`` se i contenuti degli array differiscono.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_operator_sum_PackedByteArray:
.. rst-class:: classref-operator
:ref:`PackedByteArray<class_PackedByteArray>` **operator +**\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_operator_sum_PackedByteArray>`
Restituisce un nuovo **PackedByteArray** con il contenuto di ``right`` accodato alla fine di questo array. Per prestazioni migliori, considera invece di usare :ref:`append_array()<class_PackedByteArray_method_append_array>`.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_operator_eq_PackedByteArray:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`PackedByteArray<class_PackedByteArray>`\ ) :ref:`🔗<class_PackedByteArray_operator_eq_PackedByteArray>`
Restituisce ``true`` se il contenuto di entrambi gli array è lo stesso, ovvero hanno tutti i byte uguali agli indici corrispondenti.
.. rst-class:: classref-item-separator
----
.. _class_PackedByteArray_operator_idx_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_PackedByteArray_operator_idx_int>`
Restituisce il byte 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.
Nota che il byte è restituito come un :ref:`int<class_int>` a 64 bit.
.. |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.)`
Reference in New Issue View Git Blame Copy Permalink