:github_url: hide .. _class_PackedByteArray: PackedByteArray =============== Упакованный массив байтов. .. rst-class:: classref-introduction-group Описание ---------------- Массив, специально разработанный для хранения байтов. Плотно упаковывает данные, поэтому экономит память для больших размеров массива. \ **PackedByteArray** также предоставляет методы для кодирования/декодирования различных типов в/из байтов. Способ кодирования значений является деталью реализации и не должен использоваться при взаимодействии с внешними приложениями. \ **Примечание:** Упакованные массивы всегда передаются по ссылке. Чтобы получить копию массива, которую можно изменять независимо от исходного массива, используйте :ref:`duplicate()`. Это *не* касается встроенных свойств и методов. В этих случаях возвращаемый упакованный массив является копией, и его изменение *не* повлияет на исходное значение. Чтобы обновить встроенное свойство этого типа, измените возвращаемый массив, а затем снова назначьте его свойству. .. note:: Существуют заметные различия при использовании данного API с C#. Подробнее см. :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`\ ) Создает **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:`🔗` Меняет порядок байтов ``count`` 16-битных сегментов массива, начиная с ``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:`🔗` Меняет порядок байтов ``count`` 32-битных сегментов массива, начиная с ``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:`🔗` Меняет порядок байтов ``count`` 64-битных сегментов массива, начиная с ``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:`🔗` Декодирует 8-битное целое число со знаком из байтов, начиная с ``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:`🔗` Декодирует 32-битное целое число со знаком из байтов, начиная с ``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`, а ``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, например, если данные, сжатые с помощью режима сжатия deflate, не имеют контрольной суммы или заголовка. .. 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-битное целое число без знака как байты по индексу ``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`, не допускаются и будут сериализованы как только идентификаторы. .. 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`, а ``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 == size()``). .. 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** от ``begin`` (включительно) до ``end`` (исключительно) как новый **PackedByteArray**. Абсолютное значение ``begin`` и ``end`` будет ограничено размером массива, поэтому значение по умолчанию для ``end`` делает его срезом по размеру массива по умолчанию (т. е. ``arr.slice(1)`` является сокращением для ``arr.slice(1, arr.size())``). Если ``begin`` или ``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-битного числа с плавающей точкой). Размер нового массива будет ``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-битное :ref:`int`. .. |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 (Нет возвращаемого значения.)`