:github_url: hide .. _class_PackedByteArray: PackedByteArray =============== Упакований масив байтів. .. rst-class:: classref-introduction-group Опис -------- Масив, спеціально розроблений для зберігання байтів. Щільно упаковує дані, що економить пам'ять для масивів великого розміру. \ **PackedByteArray** також надає методи для кодування/декодування різних типів у/з байтів. Спосіб кодування значень є деталлю реалізації і не повинен використовуватися під час взаємодії із зовнішніми програмами. \ **Примітка:** Упаковані масиви завжди передаються за посиланням. Щоб отримати копію масиву, яку можна змінювати незалежно від оригінального масиву, використовуйте :ref:`duplicate()`. Це *не* стосується вбудованих властивостей і методів. У цих випадках повернений упакований масив є копією, і його зміна *не* вплине на оригінальне значення. Щоб оновити вбудовану властивість цього типу, змініть повернений масив, а потім знову призначте його властивості. .. note:: Існують значні відмінності при використанні цього API із С#. Більше інформації: ref:`doc_c_sharp_differences`. .. rst-class:: classref-reftable-group Конструктори ------------------------ .. table:: :widths: auto +-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`PackedByteArray`\ (\ ) | +-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`PackedByteArray`\ (\ from\: :ref:`PackedByteArray`\ ) | +-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`PackedByteArray`\ (\ from\: :ref:`Array`\ ) | +-----------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Методи ------------ .. table:: :widths: auto +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`append`\ (\ value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`append_array`\ (\ array\: :ref:`PackedByteArray`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bsearch`\ (\ value\: :ref:`int`, before\: :ref:`bool` = true\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`bswap16`\ (\ offset\: :ref:`int` = 0, count\: :ref:`int` = -1\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`bswap32`\ (\ offset\: :ref:`int` = 0, count\: :ref:`int` = -1\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`bswap64`\ (\ offset\: :ref:`int` = 0, count\: :ref:`int` = -1\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`clear`\ (\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`compress`\ (\ compression_mode\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`count`\ (\ value\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`decode_double`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`decode_float`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`decode_half`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_s8`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_s16`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_s32`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_s64`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_u8`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_u16`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_u32`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_u64`\ (\ byte_offset\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`decode_var`\ (\ byte_offset\: :ref:`int`, allow_objects\: :ref:`bool` = false\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`decode_var_size`\ (\ byte_offset\: :ref:`int`, allow_objects\: :ref:`bool` = false\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`decompress`\ (\ buffer_size\: :ref:`int`, compression_mode\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`decompress_dynamic`\ (\ max_output_size\: :ref:`int`, compression_mode\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`duplicate`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_double`\ (\ byte_offset\: :ref:`int`, value\: :ref:`float`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_float`\ (\ byte_offset\: :ref:`int`, value\: :ref:`float`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_half`\ (\ byte_offset\: :ref:`int`, value\: :ref:`float`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_s8`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_s16`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_s32`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_s64`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_u8`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_u16`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_u32`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`encode_u64`\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`encode_var`\ (\ byte_offset\: :ref:`int`, value\: :ref:`Variant`, allow_objects\: :ref:`bool` = false\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`erase`\ (\ value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`fill`\ (\ value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find`\ (\ value\: :ref:`int`, from\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get`\ (\ index\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_string_from_ascii`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_string_from_multibyte_char`\ (\ encoding\: :ref:`String` = ""\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_string_from_utf8`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_string_from_utf16`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_string_from_utf32`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_string_from_wchar`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has`\ (\ value\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has_encoded_var`\ (\ byte_offset\: :ref:`int`, allow_objects\: :ref:`bool` = false\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`hex_encode`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`insert`\ (\ at_index\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_empty`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`push_back`\ (\ value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`remove_at`\ (\ index\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`resize`\ (\ new_size\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reverse`\ (\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind`\ (\ value\: :ref:`int`, from\: :ref:`int` = -1\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set`\ (\ index\: :ref:`int`, value\: :ref:`int`\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`size`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`slice`\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`sort`\ (\ ) | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedColorArray` | :ref:`to_color_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedFloat32Array` | :ref:`to_float32_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedFloat64Array` | :ref:`to_float64_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedInt32Array` | :ref:`to_int32_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedInt64Array` | :ref:`to_int64_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector2Array` | :ref:`to_vector2_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector3Array` | :ref:`to_vector3_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedVector4Array` | :ref:`to_vector4_array`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Оператори ------------------ .. table:: :widths: auto +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`PackedByteArray`\ ) | +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`operator +`\ (\ right\: :ref:`PackedByteArray`\ ) | +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`PackedByteArray`\ ) | +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`operator []`\ (\ index\: :ref:`int`\ ) | +-----------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи конструкторів -------------------------------------- .. _class_PackedByteArray_constructor_PackedByteArray: .. rst-class:: classref-constructor :ref:`PackedByteArray` **PackedByteArray**\ (\ ) :ref:`🔗` Будуємо порожній **PackedByteArray**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`PackedByteArray` **PackedByteArray**\ (\ from\: :ref:`PackedByteArray`\ ) Constructs a **PackedByteArray** як копія даної **PackedByteArray**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`PackedByteArray` **PackedByteArray**\ (\ from\: :ref:`Array`\ ) Будуємо новий **PackedByteArray**. Додатково ви можете пройти в загальній :ref:`Array`, яка буде перетворена. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи методів -------------------------- .. _class_PackedByteArray_method_append: .. rst-class:: classref-method :ref:`bool` **append**\ (\ value\: :ref:`int`\ ) :ref:`🔗` Додає елемент у кінець масиву (псевдонім :ref:`push_back()`). .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_append_array: .. rst-class:: classref-method |void| **append_array**\ (\ array\: :ref:`PackedByteArray`\ ) :ref:`🔗` Додаток **PackedByteArray** в кінці цього масиву. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_bsearch: .. rst-class:: classref-method :ref:`int` **bsearch**\ (\ value\: :ref:`int`, before\: :ref:`bool` = true\ ) |const| :ref:`🔗` Знаходить індекс існуючого значення (або індекс вставки, який підтримує порядок сортування, якщо значення ще не присутнє в масиві) за допомогою бінарного пошуку. За бажанням можна передати специфікатор ``before``. Якщо ``false``, індекс, що повертається, йде після всіх існуючих записів значення в масиві. \ **Примітка:** Виклик :ref:`bsearch()` на невідсортованому масиві призводить до неочікуваної поведінки. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_bswap16: .. rst-class:: classref-method |void| **bswap16**\ (\ offset\: :ref:`int` = 0, count\: :ref:`int` = -1\ ) :ref:`🔗` Міняє місцями порядок байтів 16-бітних сегментів масиву з параметром ``count``, починаючи з параметра ``offset``. Заміна виконується на місці. Якщо параметр ``count`` менше нуля, обробляються всі сегменти до кінця масиву, якщо розмір оброблених даних не кратний 2, байт після останнього обробленого 16-бітного сегмента не змінюється. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_bswap32: .. rst-class:: classref-method |void| **bswap32**\ (\ offset\: :ref:`int` = 0, count\: :ref:`int` = -1\ ) :ref:`🔗` Міняє місцями порядок байтів 32-бітних сегментів масиву з параметром ``count``, починаючи з параметра ``offset``. Заміна виконується на місці. Якщо параметр ``count`` менше нуля, обробляються всі сегменти до кінця масиву, якщо розмір оброблених даних не кратний 4, байти після останнього обробленого 32-бітного сегмента не змінюються. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_bswap64: .. rst-class:: classref-method |void| **bswap64**\ (\ offset\: :ref:`int` = 0, count\: :ref:`int` = -1\ ) :ref:`🔗` Міняє місцями порядок байтів 64-бітних сегментів масиву з параметром ``count``, починаючи з параметра ``offset``. Заміна виконується на місці. Якщо параметр ``count`` менше нуля, обробляються всі сегменти до кінця масиву, якщо розмір оброблених даних не кратний 8, байти після останнього обробленого 64-бітного сегмента не змінюються. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_clear: .. rst-class:: classref-method |void| **clear**\ (\ ) :ref:`🔗` Очищає масив. Еквівалентно використанню :ref:`resize()` з розміром ``0``. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_compress: .. rst-class:: classref-method :ref:`PackedByteArray` **compress**\ (\ compression_mode\: :ref:`int` = 0\ ) |const| :ref:`🔗` Повертає нову **PackedByteArray** з стисненими даними. Встановіть режим стиснення за допомогою одного з :ref:`CompressionMode`. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_count: .. rst-class:: classref-method :ref:`int` **count**\ (\ value\: :ref:`int`\ ) |const| :ref:`🔗` Повертає кількість повторень елемента в масиві. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_double: .. rst-class:: classref-method :ref:`float` **decode_double**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Декодує 64-розрядний плаваючий номер точки від байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0.0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_float: .. rst-class:: classref-method :ref:`float` **decode_float**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Коди 32-розрядного діапазону від байтів від ``byte_offset``. Недостатня кількість байтів. Повернення ``0.0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_half: .. rst-class:: classref-method :ref:`float` **decode_half**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Декодує 16-бітовий плаваючий номер точки від байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0.0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_s8: .. rst-class:: classref-method :ref:`int` **decode_s8**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Decodes a 8-bit підписано ціле число з байтів від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_s16: .. rst-class:: classref-method :ref:`int` **decode_s16**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Коди 16-біту підписано ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_s32: .. rst-class:: classref-method :ref:`int` **decode_s32**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Decodes a 32-bit підписано ціле число з байтів від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_s64: .. rst-class:: classref-method :ref:`int` **decode_s64**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Видаляє 64-біт, підписаний ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_u8: .. rst-class:: classref-method :ref:`int` **decode_u8**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Видаляє 8-біт не позначений число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_u16: .. rst-class:: classref-method :ref:`int` **decode_u16**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Коди 16-біту не позначено ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_u32: .. rst-class:: classref-method :ref:`int` **decode_u32**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Коди 32-розрядного цілого числа від байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_u64: .. rst-class:: classref-method :ref:`int` **decode_u64**\ (\ byte_offset\: :ref:`int`\ ) |const| :ref:`🔗` Видаляє 64-розрядне ціле число з байтів, починаючи від ``byte_offset``. Недостатня кількість байтів. Повернення ``0`` якщо дійсний номер не може бути декодований. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_var: .. rst-class:: classref-method :ref:`Variant` **decode_var**\ (\ byte_offset\: :ref:`int`, allow_objects\: :ref:`bool` = false\ ) |const| :ref:`🔗` Видаляє :ref:`Variant` від байтів від ``byte_offset``. Повернення ``null`` якщо дійсний варіант не може бути декодовано або значення :ref:`Object`-derived і ``allow_objects`` ``false``. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decode_var_size: .. rst-class:: classref-method :ref:`int` **decode_var_size**\ (\ byte_offset\: :ref:`int`, allow_objects\: :ref:`bool` = false\ ) |const| :ref:`🔗` Видаляє розмір :ref:`Variant` від байтів, починаючи від ``byte_offset``. Вимагає принаймні 4 байти даних, починаючи від офсету, інакше не виходить. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decompress: .. rst-class:: classref-method :ref:`PackedByteArray` **decompress**\ (\ buffer_size\: :ref:`int`, compression_mode\: :ref:`int` = 0\ ) |const| :ref:`🔗` Повертає нову **PackedByteArray** з декомпресованими даними. Встановіть ``buffer_size`` на розмір некомпресованих даних. Встановіть режим стиснення за допомогою одного з :ref:`CompressionMode`\ \ **Примітка:** Декомпресія не гарантує роботу з даними, які не стиснені Godot, наприклад, якщо дані стиснені з режимом стиснення Deflate не вистачає чекусу або заголовка. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_decompress_dynamic: .. rst-class:: classref-method :ref:`PackedByteArray` **decompress_dynamic**\ (\ max_output_size\: :ref:`int`, compression_mode\: :ref:`int` = 0\ ) |const| :ref:`🔗` Повертає нову **PackedByteArray** з декомпресованими даними. Встановіть режим стиснення за допомогою одного з :ref:`CompressionMode` **Цей метод приймає тільки brotli, gzip, і deflate стиснення режимів **\ Цей метод є потенційно повільним, ніж :ref:`decompress()`, оскільки він може мати можливість перерозподілити його вихідний буфер кілька разів при декомппресуванні, тоді як :ref:`decompress()` знає його вихідний розмір буфера від початку. GZIP має максимальний коефіцієнт стиснення 1032:1, що означає, що це дуже можливо для невеликого компресованого корисного навантаження, щоб декомпресувати потенційно дуже великий вихід. Щоб охороняти це, ви можете забезпечити максимальний розмір цієї функції можна виділити в байтах за допомогою ``max_output_size``. Передача -1 дозволить непідйомний вихід. Якщо пропущено позитивне значення, а декомпресія перевищує суму в байтах, після чого буде повернена помилка. \ **Примітка:** Декомпресія не гарантує роботу з даними, що не стиснені Godot, наприклад, якщо дані стиснені з режимом стиснення дефлата не вистачає чекусу або заголовка. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_duplicate: .. rst-class:: classref-method :ref:`PackedByteArray` **duplicate**\ (\ ) |const| :ref:`🔗` Створює копію масиву і повертає його. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_double: .. rst-class:: classref-method |void| **encode_double**\ (\ byte_offset\: :ref:`int`, value\: :ref:`float`\ ) :ref:`🔗` Кодує 64-розрядний плаваючий номер точки як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 8 байтів виділеного простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_float: .. rst-class:: classref-method |void| **encode_float**\ (\ byte_offset\: :ref:`int`, value\: :ref:`float`\ ) :ref:`🔗` Кодує 32-розрядний плаваючий номер точки як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 4 байти простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_half: .. rst-class:: classref-method |void| **encode_half**\ (\ byte_offset\: :ref:`int`, value\: :ref:`float`\ ) :ref:`🔗` Кодує 16-бітовий плаваючий номер точки як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 2 байти простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_s8: .. rst-class:: classref-method |void| **encode_s8**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Кодує 8-біт, підписаний цілковитим числом (призначений байт) в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 1 байт простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_s16: .. rst-class:: classref-method |void| **encode_s16**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Кодує 16-біт, підписаний цілим числом, як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 2 байти простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_s32: .. rst-class:: classref-method |void| **encode_s32**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Коди 32-розрядного підписаного цілого числа як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 4 байти простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_s64: .. rst-class:: classref-method |void| **encode_s64**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Коди 64-розрядного підписаного цілого числа як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 8 байтів простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_u8: .. rst-class:: classref-method |void| **encode_u8**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Кодує 8-бітний не позначений число цілого (байт) в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 1 байт простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_u16: .. rst-class:: classref-method |void| **encode_u16**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Коди 16-біту не позначено ціле число як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 2 байти простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_u32: .. rst-class:: classref-method |void| **encode_u32**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Коди 32-bit не позначено ціле число як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 4 байти простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_u64: .. rst-class:: classref-method |void| **encode_u64**\ (\ byte_offset\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Коди 64-розрядного цілого числа як байтів в індексі ``byte_offset`` байтів. масив повинен мати щонайменше 8 байтів простору, починаючи від офсету. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_encode_var: .. rst-class:: classref-method :ref:`int` **encode_var**\ (\ byte_offset\: :ref:`int`, value\: :ref:`Variant`, allow_objects\: :ref:`bool` = false\ ) :ref:`🔗` Коди :ref:`Variant` в індексі ``byte_offset`` байтів. Приблизний простір повинен бути виділений в залежності від розміру закодованого варіанту. Якщо ``allow_objects`` є ``false``, :ref:`Object`-derived значення не дозволені, а замість того, як він послідовний як ID-only. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_erase: .. rst-class:: classref-method :ref:`bool` **erase**\ (\ value\: :ref:`int`\ ) :ref:`🔗` Видаляє перше входження значення з масиву та повертає ``true``. Якщо значення не існує в масиві, нічого не відбувається, і повертається ``false``. Щоб видалити елемент за індексом, використовуйте метод :ref:`remove_at()`. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_fill: .. rst-class:: classref-method |void| **fill**\ (\ value\: :ref:`int`\ ) :ref:`🔗` Присвоює задане значення всім елементам масиву. Зазвичай це можна використовувати разом з :ref:`resize()` для створення масиву заданого розміру та ініціалізованих елементів. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_find: .. rst-class:: classref-method :ref:`int` **find**\ (\ value\: :ref:`int`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` Шукає в масиві значення і повертає його індекс або ``-1``, якщо таке не знайдено. За бажанням можна передати початковий індекс пошуку. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_get: .. rst-class:: classref-method :ref:`int` **get**\ (\ index\: :ref:`int`\ ) |const| :ref:`🔗` 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` **get_string_from_ascii**\ (\ ) |const| :ref:`🔗` Перетворює ASCII/Latin-1 кодований масив :ref:`String`. Швидка альтернатива :ref:`get_string_from_utf8()` якщо вміст ASCII/Latin-1 тільки. На відміну від функції UTF-8, ця функція малює кожну байт до персонажа в масиві. Багатобайтні послідовності не будуть тлумачені правильно. Для входу користувача завжди використовуйте :ref:`get_string_from_utf8()`. Це вірші :ref:`String.to_ascii_buffer()`. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_get_string_from_multibyte_char: .. rst-class:: classref-method :ref:`String` **get_string_from_multibyte_char**\ (\ encoding\: :ref:`String` = ""\ ) |const| :ref:`🔗` Перетворює системний масив, закодований багатобайтовими кодовими сторінками, на :ref:`String`. Якщо перетворення не вдається, повертається порожній рядок. Це обернена дія до :ref:`String.to_multibyte_char_buffer()`. Дозволені значення для ``encoding`` залежать від системи. Якщо ``encoding`` є порожнім рядком, використовується системне кодування за замовчуванням. - Для Windows див. `Ідентифікатори кодових сторінок `__ імена .NET. - Для macOS та Linux/BSD див. документацію до бібліотеки ``libiconv`` та ``iconv --list`` для списку підтримуваних кодувань. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_get_string_from_utf8: .. rst-class:: classref-method :ref:`String` **get_string_from_utf8**\ (\ ) |const| :ref:`🔗` Перетворює масив у кодуванні UTF-8 на :ref:`String`. Повільніше, ніж :ref:`get_string_from_ascii()`, але підтримує дані в кодуванні UTF-8. Використовуйте цю функцію, якщо ви не впевнені щодо джерела даних. Для введення користувачем цій функції завжди слід надавати перевагу. Повертає порожній рядок, якщо вихідний масив не є дійсним рядком UTF-8. Це зворотний метод :ref:`String.to_utf8_buffer()`. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_get_string_from_utf16: .. rst-class:: classref-method :ref:`String` **get_string_from_utf16**\ (\ ) |const| :ref:`🔗` Перетворює масив у кодуванні UTF-16 на :ref:`String`. Якщо BOM відсутній, передбачається прямий порядок байтів. Повертає порожній рядок, якщо вихідний масив не є коректним рядком UTF-16. Це інверсія методу :ref:`String.to_utf16_buffer()`. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_get_string_from_utf32: .. rst-class:: classref-method :ref:`String` **get_string_from_utf32**\ (\ ) |const| :ref:`🔗` Перетворює масив у кодуванні UTF-32 на :ref:`String`. Повертає порожній рядок, якщо вихідний масив не є коректним рядком UTF-32. Це обернена дія. :ref:`String.to_utf32_buffer()`. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_get_string_from_wchar: .. rst-class:: classref-method :ref:`String` **get_string_from_wchar**\ (\ ) |const| :ref:`🔗` Перетворює широкий характер (``wchar_t``, UTF-16 на Windows, UTF-32 на інших платформах) закодовано масив :ref:`String`. Повертає порожній рядок, якщо вихідний масив не діє широкий рядок. Це інверс :ref:`String.to_wchar_buffer()`. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_has: .. rst-class:: classref-method :ref:`bool` **has**\ (\ value\: :ref:`int`\ ) |const| :ref:`🔗` Повертає ``true``, якщо масив містить ``value``. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_has_encoded_var: .. rst-class:: classref-method :ref:`bool` **has_encoded_var**\ (\ byte_offset\: :ref:`int`, allow_objects\: :ref:`bool` = false\ ) |const| :ref:`🔗` Повернення ``true``, якщо дійсна :ref:`Variant` значення може бути вилучена в ``byte_offset``. ``false`` інакше або коли значення :ref:`Object`-derived і ``allow_objects`` ``false``. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_hex_encode: .. rst-class:: classref-method :ref:`String` **hex_encode**\ (\ ) |const| :ref:`🔗` Повертає шістнадцяткове представлення цього масиву як :ref:`String`. .. tabs:: .. code-tab:: gdscript var array = PackedByteArray([11, 46, 255]) print(array.hex_encode()) # Виводить "0b2eff" .. code-tab:: csharp byte[] array = [11, 46, 255]; GD.Print(array.HexEncode()); // Виводить "0b2eff" .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_insert: .. rst-class:: classref-method :ref:`int` **insert**\ (\ at_index\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Вставте новий елемент на даній позиції в масиві. Посада повинна бути дійсна, або в кінці масиву (``idx == розмір()``). .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_is_empty: .. rst-class:: classref-method :ref:`bool` **is_empty**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо масив порожній. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_push_back: .. rst-class:: classref-method :ref:`bool` **push_back**\ (\ value\: :ref:`int`\ ) :ref:`🔗` Додаток елемента в кінці масиву. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_remove_at: .. rst-class:: classref-method |void| **remove_at**\ (\ index\: :ref:`int`\ ) :ref:`🔗` Видаляє елемент з масиву за індексом. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_resize: .. rst-class:: classref-method :ref:`int` **resize**\ (\ new_size\: :ref:`int`\ ) :ref:`🔗` Встановлює розмір масиву. Якщо масив збільшується, резервує елементи в кінці масиву. Якщо масив скорочується, обрізає масив до нового розміру. Виклик методу :ref:`resize()` один раз і призначення нових значень відбувається швидше, ніж додавання нових елементів по одному. Повертає :ref:`@GlobalScope.OK` у разі успіху або одну з наступних констант :ref:`Error`, якщо цей метод не працює: :ref:`@GlobalScope.ERR_INVALID_PARAMETER`, якщо розмір від'ємний, або :ref:`@GlobalScope.ERR_OUT_OF_MEMORY`, якщо розподіл пам'яті не вдається. Використовуйте метод :ref:`size()`, щоб знайти фактичний розмір масиву після зміни розміру. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_reverse: .. rst-class:: classref-method |void| **reverse**\ (\ ) :ref:`🔗` Змінює порядок елементів у масиві на протилежний. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_rfind: .. rst-class:: classref-method :ref:`int` **rfind**\ (\ value\: :ref:`int`, from\: :ref:`int` = -1\ ) |const| :ref:`🔗` Здійснює пошук у масиві у зворотному порядку. За бажанням можна передати початковий індекс пошуку. Якщо він від'ємний, то початковий індекс береться відносно кінця масиву. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_set: .. rst-class:: classref-method |void| **set**\ (\ index\: :ref:`int`, value\: :ref:`int`\ ) :ref:`🔗` Змінює байт за вказаним індексом. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_size: .. rst-class:: classref-method :ref:`int` **size**\ (\ ) |const| :ref:`🔗` Повертає кількість елементів у масиві. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_slice: .. rst-class:: classref-method :ref:`PackedByteArray` **slice**\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647\ ) |const| :ref:`🔗` Повертає розріз **PackedByteArray**, з ``start`` (включно) до ``end`` (виключно), як новий **PackedByteArray**. Абсолютне значення ``start`` і ``end`` буде зафіксовано до розміру масиву, тому значення за замовчуванням для ``end`` робить кінець розрізу кінцем масиву за замовчуванням (тобто ``arr.slice(1)`` є скороченим записом для ``arr.slice(1, arr.size())``). Якщо ж ``start`` або ``end`` є негативними, вони будуть відносно кінця масиву (тобто ``arr.slice(0, -2)`` є скороченим записом для ``arr.slice(0, arr.size() - 2)``). .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_sort: .. rst-class:: classref-method |void| **sort**\ (\ ) :ref:`🔗` Сорти елементів масиву в порядку закріплення. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_color_array: .. rst-class:: classref-method :ref:`PackedColorArray` **to_color_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, перетворених на :ref:`PackedColorArray`, де кожен блок з 16 байтів було перетворено на варіант :ref:`Color`. \ **Примітка:** Розмір вхідного масиву має бути кратним 16 (розмір чотирьох 32-бітних змінних з плаваючою комою). Розмір нового масиву буде ``byte_array.size() / 16``. Якщо вихідні дані неможливо перетворити на варіанти :ref:`Color`, результуючі дані будуть невизначеними. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_float32_array: .. rst-class:: classref-method :ref:`PackedFloat32Array` **to_float32_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, що перетворюються на :ref:`PackedFloat32Array`, де кожен блок 4 байтів перетворений на 32-бітну плавку (C++ ``]float``). Розмір вхідного масиву повинен бути декількома з 4 (розмір 32-bit float). Розмір нового масиву буде ``byte_array.size() / 4``. Якщо оригінальні дані не можуть бути перетворені на 32-розрядні плавки, отримані дані не визначені. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_float64_array: .. rst-class:: classref-method :ref:`PackedFloat64Array` **to_float64_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, що перетворюються на :ref:`PackedFloat64Array`, де кожен блок 8 байтів перетворений на 64-бітну плавучу (C++ ``double``, Godot :ref:`float`). Розмір вхідного масиву повинен бути декількома з 8 (розмір 64-розрядного подвійний). Розмір нового масиву буде ``byte_array.size() / 8``. Якщо оригінальні дані не можуть бути перетворені на 64-розрядні плавки, отримані дані не визначені. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_int32_array: .. rst-class:: classref-method :ref:`PackedInt32Array` **to_int32_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, що перетворюються на :ref:`PackedInt32Array`, де кожен блок 4 байтів перетворений на підписане 32-бітне ціле (C++ ``int32_t``). Розмір вхідного масиву повинен бути декількома з 4 (розмір 32-бітного цілого). Розмір нового масиву буде ``byte_array.size() / 4``. Якщо оригінальні дані не можуть бути перетворені на підписані 32-бітні цілі, отримані дані не визначені. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_int64_array: .. rst-class:: classref-method :ref:`PackedInt64Array` **to_int64_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, що перетворюються на :ref:`PackedInt64Array`, де кожен блок 8 байтів перетворено на підписане число 64-біт (C++ ``int64_t``, Godot :ref:`int`. Розмір вхідного масиву повинен бути декількома з 8 (розмір 64-бітного цілого). Розмір нового масиву буде ``byte_array.size() / 8``. Якщо оригінальні дані не можуть бути перетворені на підписані 64-розрядні цілі, отримані дані не визначені. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_vector2_array: .. rst-class:: classref-method :ref:`PackedVector2Array` **to_vector2_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, перетворених на :ref:`PackedVector2Array`, де кожен блок з 8 байт або 16 байт (32-бітний або 64-бітний) був перетворений на варіант :ref:`Vector2`. \ **Примітка:** Розмір вхідного масиву має бути кратним 8 або 16 (залежно від налаштувань збірки, див. :ref:`Vector2` для отримання додаткової інформації). Розмір нового масиву буде ``byte_array.size() / (8 або 16)``. Якщо вихідні дані не можна перетворити на варіанти :ref:`Vector2`, результуючі дані будуть невизначеними. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_vector3_array: .. rst-class:: classref-method :ref:`PackedVector3Array` **to_vector3_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, перетворених на :ref:`PackedVector3Array`, де кожен блок з 12 або 24 байтів (32-бітний або 64-бітний) був перетворений на варіант :ref:`Vector3`. \ **Примітка:** Розмір вхідного масиву має бути кратним 12 або 24 (залежно від налаштувань збірки, див. :ref:`Vector3` для отримання додаткової інформації). Розмір нового масиву буде ``byte_array.size() / (12 або 24)``. Якщо вихідні дані не можна перетворити на варіанти :ref:`Vector3`, результуючі дані є невизначеними. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_method_to_vector4_array: .. rst-class:: classref-method :ref:`PackedVector4Array` **to_vector4_array**\ (\ ) |const| :ref:`🔗` Повертає копію даних, перетворених на :ref:`PackedVector4Array`, де кожен блок з 16 або 32 байтів (32-бітний або 64-бітний) був перетворений на варіант :ref:`Vector4`. \ **Примітка:** Розмір вхідного масиву має бути кратним 16 або 32 (залежно від налаштувань збірки, див. :ref:`Vector4` для отримання додаткової інформації). Розмір нового масиву буде ``byte_array.size() / (16 або 32)``. Якщо вихідні дані не можна перетворити на варіанти :ref:`Vector4`, результуючі дані є невизначеними. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи операторів -------------------------------- .. _class_PackedByteArray_operator_neq_PackedByteArray: .. rst-class:: classref-operator :ref:`bool` **operator !=**\ (\ right\: :ref:`PackedByteArray`\ ) :ref:`🔗` Повертає ``true``, якщо вміст масивів відрізняється. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_operator_sum_PackedByteArray: .. rst-class:: classref-operator :ref:`PackedByteArray` **operator +**\ (\ right\: :ref:`PackedByteArray`\ ) :ref:`🔗` Повертає новий **PackedByteArray** з вмістом ``right`` додано в кінці цього масиву. Для кращої роботи розглянемо використання :ref:`append_array()` замість. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_operator_eq_PackedByteArray: .. rst-class:: classref-operator :ref:`bool` **operator ==**\ (\ right\: :ref:`PackedByteArray`\ ) :ref:`🔗` Повертає ``true``, якщо вміст обох масивів однаково, тобто вони мають всі рівні байти за відповідними показниками. .. rst-class:: classref-item-separator ---- .. _class_PackedByteArray_operator_idx_int: .. rst-class:: classref-operator :ref:`int` **operator []**\ (\ index\: :ref:`int`\ ) :ref:`🔗` Повернення байтів за індексом ``index``. Негативні індекси можуть використовуватися для доступу до елементів з кінця. Використання індексу з меж масиву призведе до помилки. Зауважте, що байт повертається як 64-розрядний. .. |virtual| replace:: :abbr:`virtual (Зазвичай, цей метод перевизначається користувачем, щоб він мав вплив.)` .. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)` .. |const| replace:: :abbr:`const (Цей метод не має побічних ефектів. Не змінює ніяку змінну екземпляра об'єкта.)` .. |vararg| replace:: :abbr:`vararg (Цей метод приймає будь-яке число аргументів після описаних тут.)` .. |constructor| replace:: :abbr:`constructor (Цей метод використовується для побудови типів.)` .. |static| replace:: :abbr:`static (Цей метод не потребує екземпляра для виклику, його можна викликати безпосередньо за допомогою назви класу.)` .. |operator| replace:: :abbr:`operator (Цей метод описує дійсний оператор для взаємодії з цим типом як з лівим операндом.)` .. |bitfield| replace:: :abbr:`BitField (Це значення є цілим числом, складеним у вигляді бітової маски з наступних прапорів.)` .. |void| replace:: :abbr:`void (Значення не повертається.)`