:github_url: hide

.. _class_Array:

Array
=====

Вбудована структура даних, яка містить послідовність елементів.

.. rst-class:: classref-introduction-group

Опис
--------

Масив даних, який за замовчуванням може містити послідовність елементів будь-якого типу :ref:`Variant<class_Variant>`. Значення можна обмежити певним типом, створивши *типізований масив*. Доступ до елементів здійснюється за допомогою числового індексу, що починається з ``0``. Негативні індекси використовуються для підрахунку з кінця (``-1`` — останній елемент, ``-2`` — передостанній тощо).


.. tabs::

 .. code-tab:: gdscript

    var array = ["First", 2, 3, "Last"]
    print(array[0])  # Виводить «First»
    print(array[2])  # Виводить 3
    print(array[-1]) # Виводить «Last»

    array[1] = «Second»
    print(array[1])  # Виводить «Second»
    print(array[-3]) # Виводить «Second»

    # Цей типізований масив може містити тільки цілі числа.
    # Спроба додати будь-який інший тип призведе до помилки.
    var typed_array: Array[int] = [1, 2, 3]

 .. code-tab:: csharp

    Godot.Collections.Array array = ["First", 2, 3, "Last"];
    GD.Print(array[0]); // Виводить "Перший"
    GD.Print(array[2]); // Виводить 3
    GD.Print(array[^1]); // Виводить "Останній"

    array[1] = "Другий";
    GD.Print(array[1]); // Виводить "Second"
    GD.Print(array[^3]); // Виводить "Second"

    // Цей типізований масив може містити тільки цілі числа.
    // Спроба додати будь-який інший тип призведе до помилки.
    Godot.Collections.Array<int> typedArray = [1, 2, 3];



\ **Примітка:** Масиви завжди передаються за **посиланням**. Щоб отримати копію масиву, яку можна модифікувати незалежно від оригінального масиву, використовуйте ``метод duplicate``.

\ **Примітка:** Видалення елементів під час ітерації масивів **не** підтримується і призведе до непередбачуваної поведінки.

\ **Відмінності між упакованими масивами, типізованими масивами та нетипізованими масивами:** Упаковані масиви, як правило, швидше ітераються та модифікуються порівняно з типізованими масивами того ж типу (наприклад, :ref:`PackedInt64Array<class_PackedInt64Array>` проти ``Array[int]``). Крім того, упаковані масиви споживають менше пам'яті. Недоліком упакованих масивів є менша гнучкість, оскільки вони не пропонують стільки зручних методів, як :ref:`map()<class_Array_method_map>`. Типізовані масиви, в свою чергу, швидше ітеруються та модифікуються, ніж нетипізовані масиви.

.. note::

	Існують значні відмінності при використанні цього API із С#. Більше інформації: ref:`doc_c_sharp_differences`.

.. rst-class:: classref-reftable-group

Конструктори
------------------------

.. table::
   :widths: auto

   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ )                                                                                                                                                           |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ base\: :ref:`Array<class_Array>`, type\: :ref:`int<class_int>`, class_name\: :ref:`StringName<class_StringName>`, script\: :ref:`Variant<class_Variant>`\ ) |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`Array<class_Array>`\ )                                                                                                                         |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedByteArray<class_PackedByteArray>`\ )                                                                                                     |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedColorArray<class_PackedColorArray>`\ )                                                                                                   |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedFloat32Array<class_PackedFloat32Array>`\ )                                                                                               |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedFloat64Array<class_PackedFloat64Array>`\ )                                                                                               |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedInt32Array<class_PackedInt32Array>`\ )                                                                                                   |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedInt64Array<class_PackedInt64Array>`\ )                                                                                                   |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedStringArray<class_PackedStringArray>`\ )                                                                                                 |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ )                                                                                               |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedVector3Array<class_PackedVector3Array>`\ )                                                                                               |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>` | :ref:`Array<class_Array_constructor_Array>`\ (\ from\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ )                                                                                               |
   +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

.. rst-class:: classref-reftable-group

Методи
------------

.. table::
   :widths: auto

   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`             | :ref:`all<class_Array_method_all>`\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const|                                                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`             | :ref:`any<class_Array_method_any>`\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const|                                                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`append<class_Array_method_append>`\ (\ value\: :ref:`Variant<class_Variant>`\ )                                                                                                                   |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`append_array<class_Array_method_append_array>`\ (\ array\: :ref:`Array<class_Array>`\ )                                                                                                           |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`assign<class_Array_method_assign>`\ (\ array\: :ref:`Array<class_Array>`\ )                                                                                                                       |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`back<class_Array_method_back>`\ (\ ) |const|                                                                                                                                                      |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`bsearch<class_Array_method_bsearch>`\ (\ value\: :ref:`Variant<class_Variant>`, before\: :ref:`bool<class_bool>` = true\ ) |const|                                                                |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`bsearch_custom<class_Array_method_bsearch_custom>`\ (\ value\: :ref:`Variant<class_Variant>`, func\: :ref:`Callable<class_Callable>`, before\: :ref:`bool<class_bool>` = true\ ) |const|          |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`clear<class_Array_method_clear>`\ (\ )                                                                                                                                                            |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`count<class_Array_method_count>`\ (\ value\: :ref:`Variant<class_Variant>`\ ) |const|                                                                                                             |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`           | :ref:`duplicate<class_Array_method_duplicate>`\ (\ deep\: :ref:`bool<class_bool>` = false\ ) |const|                                                                                                    |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`           | :ref:`duplicate_deep<class_Array_method_duplicate_deep>`\ (\ deep_subresources_mode\: :ref:`int<class_int>` = 1\ ) |const|                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`erase<class_Array_method_erase>`\ (\ value\: :ref:`Variant<class_Variant>`\ )                                                                                                                     |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`fill<class_Array_method_fill>`\ (\ value\: :ref:`Variant<class_Variant>`\ )                                                                                                                       |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`           | :ref:`filter<class_Array_method_filter>`\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const|                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`find<class_Array_method_find>`\ (\ what\: :ref:`Variant<class_Variant>`, from\: :ref:`int<class_int>` = 0\ ) |const|                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`find_custom<class_Array_method_find_custom>`\ (\ method\: :ref:`Callable<class_Callable>`, from\: :ref:`int<class_int>` = 0\ ) |const|                                                            |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`front<class_Array_method_front>`\ (\ ) |const|                                                                                                                                                    |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`get<class_Array_method_get>`\ (\ index\: :ref:`int<class_int>`\ ) |const|                                                                                                                         |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`get_typed_builtin<class_Array_method_get_typed_builtin>`\ (\ ) |const|                                                                                                                            |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`StringName<class_StringName>` | :ref:`get_typed_class_name<class_Array_method_get_typed_class_name>`\ (\ ) |const|                                                                                                                      |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`get_typed_script<class_Array_method_get_typed_script>`\ (\ ) |const|                                                                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`             | :ref:`has<class_Array_method_has>`\ (\ value\: :ref:`Variant<class_Variant>`\ ) |const|                                                                                                                 |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`hash<class_Array_method_hash>`\ (\ ) |const|                                                                                                                                                      |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`insert<class_Array_method_insert>`\ (\ position\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`\ )                                                                                 |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`             | :ref:`is_empty<class_Array_method_is_empty>`\ (\ ) |const|                                                                                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`             | :ref:`is_read_only<class_Array_method_is_read_only>`\ (\ ) |const|                                                                                                                                      |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`             | :ref:`is_same_typed<class_Array_method_is_same_typed>`\ (\ array\: :ref:`Array<class_Array>`\ ) |const|                                                                                                 |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`             | :ref:`is_typed<class_Array_method_is_typed>`\ (\ ) |const|                                                                                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`make_read_only<class_Array_method_make_read_only>`\ (\ )                                                                                                                                          |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`           | :ref:`map<class_Array_method_map>`\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const|                                                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`max<class_Array_method_max>`\ (\ ) |const|                                                                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`min<class_Array_method_min>`\ (\ ) |const|                                                                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`pick_random<class_Array_method_pick_random>`\ (\ ) |const|                                                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`pop_at<class_Array_method_pop_at>`\ (\ position\: :ref:`int<class_int>`\ )                                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`pop_back<class_Array_method_pop_back>`\ (\ )                                                                                                                                                      |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`pop_front<class_Array_method_pop_front>`\ (\ )                                                                                                                                                    |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`push_back<class_Array_method_push_back>`\ (\ value\: :ref:`Variant<class_Variant>`\ )                                                                                                             |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`push_front<class_Array_method_push_front>`\ (\ value\: :ref:`Variant<class_Variant>`\ )                                                                                                           |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>`       | :ref:`reduce<class_Array_method_reduce>`\ (\ method\: :ref:`Callable<class_Callable>`, accum\: :ref:`Variant<class_Variant>` = null\ ) |const|                                                          |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`remove_at<class_Array_method_remove_at>`\ (\ position\: :ref:`int<class_int>`\ )                                                                                                                  |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`resize<class_Array_method_resize>`\ (\ size\: :ref:`int<class_int>`\ )                                                                                                                            |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`reverse<class_Array_method_reverse>`\ (\ )                                                                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`rfind<class_Array_method_rfind>`\ (\ what\: :ref:`Variant<class_Variant>`, from\: :ref:`int<class_int>` = -1\ ) |const|                                                                           |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`rfind_custom<class_Array_method_rfind_custom>`\ (\ method\: :ref:`Callable<class_Callable>`, from\: :ref:`int<class_int>` = -1\ ) |const|                                                         |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`set<class_Array_method_set>`\ (\ index\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`\ )                                                                                          |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`shuffle<class_Array_method_shuffle>`\ (\ )                                                                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`               | :ref:`size<class_Array_method_size>`\ (\ ) |const|                                                                                                                                                      |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`           | :ref:`slice<class_Array_method_slice>`\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647, step\: :ref:`int<class_int>` = 1, deep\: :ref:`bool<class_bool>` = false\ ) |const| |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`sort<class_Array_method_sort>`\ (\ )                                                                                                                                                              |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | |void|                              | :ref:`sort_custom<class_Array_method_sort_custom>`\ (\ func\: :ref:`Callable<class_Callable>`\ )                                                                                                        |
   +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

.. rst-class:: classref-reftable-group

Оператори
------------------

.. table::
   :widths: auto

   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`       | :ref:`operator !=<class_Array_operator_neq_Array>`\ (\ right\: :ref:`Array<class_Array>`\ )  |
   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`Array<class_Array>`     | :ref:`operator +<class_Array_operator_sum_Array>`\ (\ right\: :ref:`Array<class_Array>`\ )   |
   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`       | :ref:`operator \<<class_Array_operator_lt_Array>`\ (\ right\: :ref:`Array<class_Array>`\ )   |
   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`       | :ref:`operator \<=<class_Array_operator_lte_Array>`\ (\ right\: :ref:`Array<class_Array>`\ ) |
   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`       | :ref:`operator ==<class_Array_operator_eq_Array>`\ (\ right\: :ref:`Array<class_Array>`\ )   |
   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`       | :ref:`operator ><class_Array_operator_gt_Array>`\ (\ right\: :ref:`Array<class_Array>`\ )    |
   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`       | :ref:`operator >=<class_Array_operator_gte_Array>`\ (\ right\: :ref:`Array<class_Array>`\ )  |
   +-------------------------------+----------------------------------------------------------------------------------------------+
   | :ref:`Variant<class_Variant>` | :ref:`operator []<class_Array_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ )        |
   +-------------------------------+----------------------------------------------------------------------------------------------+

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Описи конструкторів
--------------------------------------

.. _class_Array_constructor_Array:

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ ) :ref:`🔗<class_Array_constructor_Array>`

Створює пустий **Array**.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ base\: :ref:`Array<class_Array>`, type\: :ref:`int<class_int>`, class_name\: :ref:`StringName<class_StringName>`, script\: :ref:`Variant<class_Variant>`\ )

Створює типізований масив із масиву ``base``. Типізований масив може містити лише елементи заданого типу або ті, що успадковуються від заданого класу, як описано в параметрах цього конструктора:

 - ``type`` є вбудованим типом :ref:`Variant<class_Variant>`, як одна з констант :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`.

 - ``class_name`` — вбудоване ім’я класу (див. :ref:`Object.get_class()<class_Object_method_get_class>`).

 - ``script`` пов’язаний скрипти. Це має бути екземпляр :ref:`Script<class_Script>` або ``null``.

 Якщо ``type`` не є :ref:`@GlobalScope.TYPE_OBJECT<class_@GlobalScope_constant_TYPE_OBJECT>`, ``class_name`` має бути порожнім :ref:`StringName<class_StringName>`, а ``script`` має мати значення ``null``.

::

    class_name Sword
    extends Node

    class Stats:
         pass

    func _ready():
         var a = Array([], TYPE_INT, "", null) # Array[int]
         var b = Array([], TYPE_OBJECT, "Node", null) # Array[Node]
         var c = Array([], TYPE_OBJECT, "Node", Sword) # Array[Sword]
         var d = Array([], TYPE_OBJECT, "RefCounted", Stats) # Array[Stats]

 За потреби елементи масиву ``base`` перетворюються. Якщо це неможливо або ``base`` уже введено, цей конструктор завершується помилкою та повертає порожній **Array**.

 У GDScript цей конструктор зазвичай не потрібний, оскільки можна створити типізований масив за допомогою статичної типізації:

::

    var numbers: Array[float] = []
    var children: Array[Node] = [$Node, $Sprite2D, $RigidBody3D]

    var integers: Array[int] = [0.2, 4.5, -2.0]
    print(integers) # Виводить [0, 4, -2]

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`Array<class_Array>`\ )

Повертає той самий масив, що й ``from``. Якщо вам потрібна копія масиву, використовуйте :ref:`duplicate()<class_Array_method_duplicate>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedByteArray<class_PackedByteArray>`\ )

Створює масив із :ref:`PackedByteArray<class_PackedByteArray>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedColorArray<class_PackedColorArray>`\ )

Створює масив із :ref:`PackedColorArray<class_PackedColorArray>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedFloat32Array<class_PackedFloat32Array>`\ )

Створює масив із :ref:`PackedFloat32Array<class_PackedFloat32Array>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedFloat64Array<class_PackedFloat64Array>`\ )

Створює масив із :ref:`PackedFloat64Array<class_PackedFloat64Array>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedInt32Array<class_PackedInt32Array>`\ )

Створює масив із :ref:`PackedInt32Array<class_PackedInt32Array>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedInt64Array<class_PackedInt64Array>`\ )

Створює масив із :ref:`PackedInt64Array<class_PackedInt64Array>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedStringArray<class_PackedStringArray>`\ )

Створює масив із :ref:`PackedStringArray<class_PackedStringArray>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedVector2Array<class_PackedVector2Array>`\ )

Створює масив із :ref:`PackedVector2Array<class_PackedVector2Array>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedVector3Array<class_PackedVector3Array>`\ )

Створює масив із :ref:`PackedVector3Array<class_PackedVector3Array>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`Array<class_Array>` **Array**\ (\ from\: :ref:`PackedVector4Array<class_PackedVector4Array>`\ )

Створює масив із :ref:`PackedVector4Array<class_PackedVector4Array>`.

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Описи методів
--------------------------

.. _class_Array_method_all:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **all**\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const| :ref:`🔗<class_Array_method_all>`

Викликає заданий :ref:`Callable<class_Callable>` для кожного елемента в масиві та повертає ``true``, якщо :ref:`Callable<class_Callable>` повертає ``true`` для *всіх* елементів у масиві. Якщо :ref:`Callable<class_Callable>` повертає ``false`` для одного або більше елементів масиву, цей метод повертає ``false``. 

\ ``method`` має приймати один параметр :ref:`Variant<class_Variant>` (поточний елемент масиву) і повертати :ref:`bool<class_bool>`. 


.. tabs:: 

 .. code-tab:: gdscript
 
    func greater_than_5(number):
        return number > 5

    func _ready(): 
        print([6, 10, 6].all(greater_than_5)) # Виводить true (3/3 елементів оцінюються як true). 
        print([4, 10, 4].all(greater_than_5)) # Виводить false (1/3 елементів оцінюється як true). 
        print([4, 4, 4].all(greater_than_5)) # Виводить false (0/3 елементів оцінюються як true). 
        print([].all(greater_than_5)) # Виводить true (0/0 елементів оцінюється як true). 

        # Те саме, що й перший рядок вище, але з використанням лямбда-функції. 
        print([6, 10, 6].all(func(element): return element > 5)) # Виводить true  

 .. code-tab:: csharp
 
    private static bool GreaterThan5(int number) 
    {
        return number  > 5; 
    }

    public override void _Ready() 
    {
        // Виводить True (3/3 елементів оцінюються як true). 
        GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(GreaterThan5)); 
        // Виводить False (1/3 елементів оцінюється як true). 
        GD.Print(new Godot.Collections.Array>int< { 4, 10, 4 }.All(GreaterThan5)); 
        // Виводить False (0/3 елементів оцінюються як true). 
        GD.Print(new Godot.Collections.Array>int< { 4, 4, 4 }.All(GreaterThan5)); 
        // Виводить True (0/0 елементів оцінюється як true). 
        GD.Print(new Godot.Collections.Array>int< { }.All(GreaterThan5)); 

        // Те саме, що й перший рядок вище, але з використанням лямбда-функції. 
        GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(element => element > 5)); // Виводить True 
    } 

 

Дивіться також :ref:`any()<class_Array_method_any>`, :ref:`filter()<class_Array_method_filter>`, :ref:`map()<class_Array_method_map>` і :ref:`reduce()<class_Array_method_reduce>`. 

\ **Примітка:** На відміну від перевірки розміру масиву після :ref:`filter()<class_Array_method_filter>`, цей метод поверне значення якмога швидше для поліпшення швидкодії (особливо на великих масивах)

\ **Примітка:** Для порожнього масиву цей метод `завжди <https://en.wikipedia.org/wiki/Vacuous_truth>`__ повертає ``true``.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_any:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **any**\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const| :ref:`🔗<class_Array_method_any>`

Викликає наданий :ref:`Callable<class_Callable>` на кожному елементі в масиві та повертає ``true``, якщо :ref:`Callable<class_Callable>` повертає ``true`` для *одного чи більше* елементів у масиві. Якщо :ref:`Callable<class_Callable>` повертає ``false`` для всіх елементів в масиві, цей метод повертає ``false``.

\ ``method`` повинен прийняти один параметр :ref:`Variant<class_Variant>` (поточний елемент масиву) і повернути :ref:`bool<class_bool>`.

::

    func more_than_5(number):
        return number > 5

    func _ready():
        print([6, 10, 6].any(greater_than_5)) # Виведе true (3 елементи, для яких greater_than_5 - true).
        print([4, 10, 4].any(greater_than_5)) # Виведе true (1 елемент, для якого greater_than_5 - true).
        print([4, 4, 4].any(greater_than_5)) # Виведе false (0 елементів, для яких greater_than_5 - true).
        print([].any(greater_than_5) # Виведе false (0 елементів, для яких greater_than_5 - true).
        
        # Те ж, що й вище, тільки через лямбду.
        print([6, 10, 6].any(func(number): return number > 5)) # Виведе true

Дивись також :ref:`all()<class_Array_method_all>`, :ref:`filter()<class_Array_method_filter>`, :ref:`map()<class_Array_method_map>` і :ref:`reduce()<class_Array_method_reduce>`.

\ **Примітка:** На відміну від перевірки розміру масиву після :ref:`filter()<class_Array_method_filter>`, цей метод поверне значення якмога швидше для поліпшення швидкодії (особливо на великих масивах)

\ **Примітка:** Для порожніх масивів цей метод завжди повертає ``false``.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_append:

.. rst-class:: classref-method

|void| **append**\ (\ value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_Array_method_append>`

Додає ``value`` в кінець масиву (псевдонім :ref:`push_back()<class_Array_method_push_back>`).

.. rst-class:: classref-item-separator

----

.. _class_Array_method_append_array:

.. rst-class:: classref-method

|void| **append_array**\ (\ array\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_method_append_array>`

Додає ще один ``array`` у кінець цього масиву.

::

    var numbers = [1, 2, 3]
    var extra = [4, 5, 6]
    numbers.append_array(extra)
    print(numbers) # Виводить [1, 2, 3, 4, 5, 6]

.. rst-class:: classref-item-separator

----

.. _class_Array_method_assign:

.. rst-class:: classref-method

|void| **assign**\ (\ array\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_method_assign>`

Присвоює цьому масиву елементи іншого ``array``. Змінює розмір масиву відповідно до ``array``. Виконує перетворення типів, якщо масив є типізованим.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_back:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **back**\ (\ ) |const| :ref:`🔗<class_Array_method_back>`

Повертає останній елемент масиву. Якщо масив порожній, не вдається і повертає ``null``. Дивись також :ref:`front()<class_Array_method_front>`.

\ **Примітка:** На відміну від ```` оператор (``array[-1]``), помилка генерується без виконання проекту.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_bsearch:

.. rst-class:: classref-method

:ref:`int<class_int>` **bsearch**\ (\ value\: :ref:`Variant<class_Variant>`, before\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_Array_method_bsearch>`

Повертає індекс ``value`` у відсортованому масиві. Якщо його неможливо знайти, повертає місце, куди слід вставити ``value``, щоб зберегти масив упорядкованим. Використовується `алгоритм бінарного пошуку <https://uk.wikipedia.org/wiki/%D0%94%D0%B2%D1%96%D0%B9%D0%BA%D0%BE%D0%B2%D0%B8%D0%B9_%D0%BF%D0%BE%D1%88%D1%83%D0%BA>`__.

Якщо ``before`` має значення ``true`` (як за замовчуванням), повернутий індекс стоїть перед усіма існуючими елементами, що дорівнюють ``value`` у масиві.

::

    var numbers = [2, 4, 8, 10]
    var idx = numbers.bsearch(7)

    numbers.insert(idx, 7)
    print(numbers) # Виводить [2, 4, 7, 8, 10]

    var fruits = ["Апельсин", "Лимон", "Лимон", "Яблуко"]
    print(fruits.bsearch("Лимон", true)) # Виводить 1, вказуючи на перший "Лимон".
    print(fruits.bsearch("Лимон", false)) # Виводить 3, вказує на "Яблуко".

\ **Примітка:** Виклик :ref:`bsearch()<class_Array_method_bsearch>` для *несортованого* масиву призведе до неочікуваної поведінки. Використовуйте :ref:`sort()<class_Array_method_sort>` перед викликом цього методу.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_bsearch_custom:

.. rst-class:: classref-method

:ref:`int<class_int>` **bsearch_custom**\ (\ value\: :ref:`Variant<class_Variant>`, func\: :ref:`Callable<class_Callable>`, before\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_Array_method_bsearch_custom>`

Повертає індекс ``value`` у відсортованому масиві. Якщо його неможливо знайти, повертає місце, куди слід вставити ``value``, щоб зберегти масив упорядкованим (використовуючи ``func`` для порівняння). Використовується такий алгоритм: `бінарний пошук <https://en.wikipedia.org/wiki/Binary_search_algorithm>`__.

 Подібно до :ref:`sort_custom()<class_Array_method_sort_custom>`, ``func`` викликається необхідну кількість разів, отримуючи один елемент масиву та ``value`` як аргументи. Функція має повернути ``true``, якщо елемент масиву має бути *позаду* ``value``, інакше вона має повернути ``false``.

 Якщо ``before`` має значення ``true`` (як за замовчуванням), повернутий індекс стоїть перед усіма існуючими елементами, що дорівнюють ``value`` у масиві.

::

    func sort_by_amount(a, b):
         If a[1] < b[1]:
             return true
         return false

    func _ready():
         var my_items = [["Помідор", 2], ["Ківі", 5], ["Рис", 9]]

         var apple = ["Яблуко", 5]
         # "Яблуко" вставляється перед "Ківі".
         my_items.insert(my_items.bsearch_custom(apple, sort_by_amount, true), apple)

         var banana = ["Банан", 5]
         # "Банан" вставляється після "Ківі".
         my_items.insert(my_items.bsearch_custom(banana, sort_by_amount, false), banana)

         # Відбитки [["Помідор", 2], ["Яблуко", 5], ["Ківі", 5], ["Банан", 5], ["Рис", 9]]
         print (мої_предмети)

\ **Примітка.** Виклик :ref:`bsearch_custom()<class_Array_method_bsearch_custom>` для *несортованого* масиву призведе до неочікуваної поведінки. Використовуйте :ref:`sort_custom()<class_Array_method_sort_custom>` з ``func`` перед викликом цього методу.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_clear:

.. rst-class:: classref-method

|void| **clear**\ (\ ) :ref:`🔗<class_Array_method_clear>`

Видаляє всі елементи з масиву. Це еквівалентно використанню :ref:`resize()<class_Array_method_resize>` із розміром ``0``.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_count:

.. rst-class:: classref-method

:ref:`int<class_int>` **count**\ (\ value\: :ref:`Variant<class_Variant>`\ ) |const| :ref:`🔗<class_Array_method_count>`

Повертає кількість разів, коли елемент є в масиві.

Щоб підрахувати, скільки елементів у масиві задовольняє умову, див. :ref:`reduce()<class_Array_method_reduce>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_duplicate:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **duplicate**\ (\ deep\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Array_method_duplicate>`

Повертає нову копію масиву.

За замовчуванням повертається **неглибока** копія: усі вкладені елементи **Array**, :ref:`Dictionary<class_Dictionary>` та :ref:`Resource<class_Resource>` спільно використовуються з оригінальним масивом. Зміна будь-якого з них в одному масиві також вплине на них в іншому.

Якщо ``deep`` має значення ``true``, повертається копія **deep**: усі вкладені масиви та словники також дублюються (рекурсивно). Однак будь-який :ref:`Resource<class_Resource>` все ще використовується спільно з вихідним масивом.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_duplicate_deep:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **duplicate_deep**\ (\ deep_subresources_mode\: :ref:`int<class_int>` = 1\ ) |const| :ref:`🔗<class_Array_method_duplicate_deep>`

Duplicates this array, deeply, like :ref:`duplicate()<class_Array_method_duplicate>` when passing ``true``, with extra control over how subresources are handled.

\ ``deep_subresources_mode`` must be one of the values from :ref:`DeepDuplicateMode<enum_Resource_DeepDuplicateMode>`. By default, only internal resources will be duplicated (recursively).

.. rst-class:: classref-item-separator

----

.. _class_Array_method_erase:

.. rst-class:: classref-method

|void| **erase**\ (\ value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_Array_method_erase>`

Знаходить і видаляє перший елемент ``value`` з масиву. Якщо ``value`` не існує в масиві, нічого не відбувається. Щоб видалити елемент за індексом, скористайтеся :ref:`remove_at()<class_Array_method_remove_at>`.

\ **Примітка:** Цей метод пересуває індекс кожного елемента після вилученого ``value`` лівіше, що може призвести до помітної втрати швидкодії, особливо на більших масивах.

\ **Примітка:** Видалення елементів під час ітерації над масивами **не** підтримується і призведе до непередбачуваної поведінки.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_fill:

.. rst-class:: classref-method

|void| **fill**\ (\ value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_Array_method_fill>`

Призначає задане ``value`` всім елементам у масиві. 

Цей метод часто можна комбінувати з :ref:`resize()<class_Array_method_resize>` для створення масиву заданого розміру та ініціалізованих елементів: 


.. tabs:: 

 .. code-tab:: gdscript
 
    var Array = [] 
    array.resize(5) 
    array.fill(2) 
    print(array) # Виводить [2, 2, 2, 2, 2]  

 .. code-tab:: csharp
 
    Godot.Collections.Array array = []; 
    array.Resize(5); 
    array.Fill(2); 
    GD.Print(масив); // Виводить [2, 2, 2, 2, 2]  

 

\ **Примітка:** Якщо ``значення параметра`` є :ref:`Variant<class_Variant>`, що передається за посиланням (похідним від ``об’єкта``, **Array**, :ref:`Dictionary<class_Dictionary>` тощо), масив буде заповнено посиланнями на те саме ``value``, які не є дублікатами.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_filter:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **filter**\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const| :ref:`🔗<class_Array_method_filter>`

Викликає задане :ref:`Callable<class_Callable>` для кожного елемента масиву та повертає нове, відфільтроване значення **Array**.

Метод ``method`` отримує один з елементів масиву як аргумент і повинен повернути ``true``, щоб додати елемент до відфільтрованого масиву, або ``false``, щоб виключити його.

::

    func is_even(number):
        return number % 2 == 0

    func _ready():
        print([1, 4, 5, 8].filter(is_even)) # Prints [4, 8]

        # Same as above, but using a lambda function.
        print([1, 4, 5, 8].filter(func(number): return number % 2 == 0))

Див. також :ref:`any()<class_Array_method_any>`, :ref:`all()<class_Array_method_all>`, :ref:`map()<class_Array_method_map>` and :ref:`reduce()<class_Array_method_reduce>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_find:

.. rst-class:: classref-method

:ref:`int<class_int>` **find**\ (\ what\: :ref:`Variant<class_Variant>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_Array_method_find>`

Повертає індекс **першого** входження ``what`` у цьому масиві або ``-1``, якщо їх немає. Початок пошуку можна вказати за допомогою ``from``, продовжуючи до кінця масиву.

\ **Примітка.** Якщо ви просто хочете дізнатися, чи містить масив ``what``, використовуйте :ref:`has()<class_Array_method_has>` (``Contains`` у C#). У GDScript ви також можете використовувати оператор ``in``.

\ **Примітка:** З міркувань продуктивності на пошук впливає ``what`` :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`. Наприклад, ``7`` (:ref:`int<class_int>`) і ``7.0`` (:ref:`float<class_float>`) не вважаються однаковими для цього методу.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_find_custom:

.. rst-class:: classref-method

:ref:`int<class_int>` **find_custom**\ (\ method\: :ref:`Callable<class_Callable>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_Array_method_find_custom>`

Повертає індекс **першого** елемента в масиві, який змушує ``method`` повертати ``true`` або ``-1``, якщо їх немає. Початок пошуку можна вказати за допомогою ``from``, продовжуючи до кінця масиву. 

\ ``method`` — це виклик, який приймає елемент масиву та повертає :ref:`bool<class_bool>`. 

\ **Примітка:** Якщо ви просто хочете знати, чи містить масив *щось*, що задовольняє ``method``, використовуйте :ref:`any()<class_Array_method_any>`. 


.. tabs:: 

 .. code-tab:: gdscript
 
    func is_even(число): 
        return number% 2 == 0 

    func _ready(): 
        print([1, 3, 4, 7].find_custom(is_even.bind())) # Виводить 2  



.. rst-class:: classref-item-separator

----

.. _class_Array_method_front:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **front**\ (\ ) |const| :ref:`🔗<class_Array_method_front>`

Повертає перший елемент масиву. Якщо масив порожній, не вдається і повертає ``null``. Дивитися також :ref:`back()<class_Array_method_back>`.

\ **Примітка:** На відміну від ```` оператор (``array[0]``), помилка генерується без виконання проекту.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_get:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **get**\ (\ index\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_Array_method_get>`

Returns the element at the given ``index`` in the array. If ``index`` is out-of-bounds or negative, this method fails and returns ``null``.

This method is similar (but not identical) to the ``[]`` operator. Most notably, when this method fails, it doesn't pause project execution if run from the editor.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_get_typed_builtin:

.. rst-class:: classref-method

:ref:`int<class_int>` **get_typed_builtin**\ (\ ) |const| :ref:`🔗<class_Array_method_get_typed_builtin>`

Повертає вбудований тип :ref:`Variant<class_Variant>` типізованого масиву як константу :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>`. Якщо масив нетипізований, повертає :ref:`@GlobalScope.TYPE_NIL<class_@GlobalScope_constant_TYPE_NIL>`. Дивіться також :ref:`is_typed()<class_Array_method_is_typed>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_get_typed_class_name:

.. rst-class:: classref-method

:ref:`StringName<class_StringName>` **get_typed_class_name**\ (\ ) |const| :ref:`🔗<class_Array_method_get_typed_class_name>`

Повертає **вбудовану** назву класу введеного масиву, якщо вбудований :ref:`Variant<class_Variant>` тип :ref:`@GlobalScope.TYPE_OBJECT<class_@GlobalScope_constant_TYPE_OBJECT>`. В іншому випадку повертає порожній :ref:`StringName<class_StringName>`. Дивіться також :ref:`is_typed()<class_Array_method_is_typed>` і :ref:`Object.get_class()<class_Object_method_get_class>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_get_typed_script:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **get_typed_script**\ (\ ) |const| :ref:`🔗<class_Array_method_get_typed_script>`

Повертає екземпляр :ref:`Script<class_Script>`, пов’язаний із цим введеним масивом, або ``null``, якщо він не існує. Дивіться також :ref:`is_typed()<class_Array_method_is_typed>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_has:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **has**\ (\ value\: :ref:`Variant<class_Variant>`\ ) |const| :ref:`🔗<class_Array_method_has>`

Повертає ``true``, якщо масив містить задане ``value``.

::

    [gdscript]
    print(["усередині", 7].has("усередині")) # Виводить true
    print(["усередині", 7].has("ззовні")) # Виводить false
    print(["усередині", 7].has(7)) # Виводить true
    print(["усередині", 7].has("7")) # Виводить false
    [/gdscript]
    [csharp]
    var arr = new Godot.Collections.Array { "усередині", 7 };
     // За конвенціями C# цей метод перейменовано на `Contains`.
    GD.Print(arr.Contains("усередині"));   // Виводить true
    GD.Print(arr.Contains("ззовні"));  // Виводить false
    GD.Print(arr.Contains(7));          // Виводить true
    GD.Print(arr.Contains("7"));        // Виводить false
    [/csharp][/codeblocks]

 У GDScript це еквівалентно оператору [code]in[/code]:
[codeblock]
    if 4 in [2, 4, 6, 8]:
         print("4 тут!") # Буде надруковано.

\ **Примітка:** З міркувань продуктивності на пошук впливає тип :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` для ``value``. Наприклад, ``7`` (:ref:`int<class_int>`) і ``7.0`` (:ref:`float<class_float>`) не вважаються однаковими для цього методу.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_hash:

.. rst-class:: classref-method

:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_Array_method_hash>`

Returns a hashed 32-bit integer value representing the array and its contents.

\ **Note:** Arrays with equal hash values are *not* guaranteed to be the same, as a result of hash collisions. On the contrary, arrays with different hash values are guaranteed to be different.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_insert:

.. rst-class:: classref-method

:ref:`int<class_int>` **insert**\ (\ position\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_Array_method_insert>`

Вставляє новий елемент (``value``) в даний індекс (``position``) у масів. ``позиція параметра`` повинна бути між ``0`` і величиною методу матри. Якщо негативний, ``позиція параму`` розглядається відносно кінця масіва.

Повертає :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` на успіх, або одну з інших :ref:`Error<enum_@GlobalScope_Error>` константи в разі невдачі цього методу.

\ **Приміток:** Індекс кожного елементу після ``position`` повинен бути перенесений вперед, що може привести до помітних витрат на ефективність, особливо на більших масівах.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_is_empty:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_Array_method_is_empty>`

Повертає ``true``, якщо масив порожній (``[]``). Дивіться також :ref:`size()<class_Array_method_size>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_is_read_only:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_read_only**\ (\ ) |const| :ref:`🔗<class_Array_method_is_read_only>`

Повертає ``true``, якщо масив прочитаний. Переглянути :ref:`make_read_only()<class_Array_method_make_read_only>`.

У GDScript, масиви автоматично читаються, якщо заявлені з ``const`` ключове слово.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_is_same_typed:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_same_typed**\ (\ array\: :ref:`Array<class_Array>`\ ) |const| :ref:`🔗<class_Array_method_is_same_typed>`

Повертає ``true``, якщо цей масив введено так само, як заданий ``array``. Дивіться також :ref:`is_typed()<class_Array_method_is_typed>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_is_typed:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_typed**\ (\ ) |const| :ref:`🔗<class_Array_method_is_typed>`

Повертає ``true``, якщо масив введено. Типізовані масиви можуть містити елементи лише певного типу, визначеного конструктором типізованого масиву. Очікується, що методи типізованого масиву повертатимуть загальний :ref:`Variant<class_Variant>`.

 У GDScript можна визначити типізований масив за допомогою статичної типізації:

::

    var number: Array[float] = [0,2, 4,2, -2,0]
    print(numbers.is_typed()) # Виводить true

.. rst-class:: classref-item-separator

----

.. _class_Array_method_make_read_only:

.. rst-class:: classref-method

|void| **make_read_only**\ (\ ) :ref:`🔗<class_Array_method_make_read_only>`

Робить масив доступним лише для читання. Елементи масиву не можуть бути перевизначені іншими значеннями, а їх порядок не може змінитися. Не застосовується до вкладених елементів, таких як словники.

 У GDScript масиви автоматично стають доступними лише для читання, якщо вони оголошені за допомогою ключового слова ``const``.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_map:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **map**\ (\ method\: :ref:`Callable<class_Callable>`\ ) |const| :ref:`🔗<class_Array_method_map>`

Дзвінки надані :ref:`Callable<class_Callable>` для кожного елемента в масиві і повертає новий масив, наповнений значеннями, подані методом ``method``.

\ ``method`` повинен прийняти один параметр :ref:`Variant<class_Variant>` (поточний елемент масиву) і може повернути будь-який :ref:`Variant<class_Variant>`.

::

    func double(number):
    return number* 2

    func _ready():
    print ([1, 2, 3].map(double)) # Друки [2, 4, 6]

    # Так, як вище, але за допомогою функції лямбда.
    print ([1, 2, 3].map(func): зворотний елемент * 2))

Дивись також :ref:`filter()<class_Array_method_filter>`, :ref:`reduce()<class_Array_method_reduce>`, :ref:`any()<class_Array_method_any>` і :ref:`all()<class_Array_method_all>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_max:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **max**\ (\ ) |const| :ref:`🔗<class_Array_method_max>`

Повертає максимальне значення, що міститься в масиві, якщо всі елементи можна порівняти. В іншому випадку повертає ``null``. Дивіться також :ref:`min()<class_Array_method_min>`.

 Щоб знайти максимальне значення за допомогою спеціального компаратора, ви можете використовувати :ref:`reduce()<class_Array_method_reduce>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_min:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **min**\ (\ ) |const| :ref:`🔗<class_Array_method_min>`

Повертає мінімальне значення, що міститься в масиві, якщо всі елементи можна порівняти. В іншому випадку повертається ``null``. Дивитися також :ref:`max()<class_Array_method_max>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_pick_random:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **pick_random**\ (\ ) |const| :ref:`🔗<class_Array_method_pick_random>`

Повертає випадковий елемент із масиву. Генерує помилку та повертає ``null``, якщо масив порожній.

::

    [gdscript]
     # Може друкувати 1, 2, 3.25 або «Привіт».
    print([1, 2, 3.25, "Привіт"].pick_random())
    [/gdscript]
    [csharp]
    var array = new Godot.Collections.Array { 1, 2, 3.25f, "Привіт" };
    GD.Print(array.PickRandom()); // Може друкувати 1, 2, 3.25 або "Hi".
    [/csharp][/codeblocks]

[b]Примітка: [/b] Подібно до багатьох подібних функцій у системі (таких як [method @GlobalScope.randi] або [method shuffle]), цей метод використовує звичайне глобальне випадкове початкове число. Щоб отримати передбачуваний результат від цього методу, перегляньте [method @GlobalScope.seed].

.. rst-class:: classref-item-separator

----

.. _class_Array_method_pop_at:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **pop_at**\ (\ position\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Array_method_pop_at>`

Вилучає та повертає елемент масиву за індексом ``position``. Якщо значення від’ємне, ``position`` вважається відносно кінця масиву. Повертає ``null``, якщо масив порожній. Якщо ``position`` виходить за межі, також генерується повідомлення про помилку.

\ **Примітка: ** Цей метод зсуває індекс кожного елемента після ``position`` назад, що може призвести до помітних витрат на продуктивність, особливо у великих масивах.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_pop_back:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **pop_back**\ (\ ) :ref:`🔗<class_Array_method_pop_back>`

Вилучає та повертає останній елемент масиву. Повертає ``null``, якщо масив порожній, без генерування помилки. Дивіться також :ref:`pop_front()<class_Array_method_pop_front>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_pop_front:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **pop_front**\ (\ ) :ref:`🔗<class_Array_method_pop_front>`

Вилучає та повертає перший елемент масиву. Повертає ``null``, якщо масив порожній, без генерування помилки. Дивіться також :ref:`pop_back()<class_Array_method_pop_back>`.

\ **Примітка.** Цей метод зміщує індекс кожного іншого елемента назад, що може призвести до помітних витрат на продуктивність, особливо для великих масивів.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_push_back:

.. rst-class:: classref-method

|void| **push_back**\ (\ value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_Array_method_push_back>`

Додає елемент в кінець масиву. Дивіться також :ref:`push_front()<class_Array_method_push_front>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_push_front:

.. rst-class:: classref-method

|void| **push_front**\ (\ value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_Array_method_push_front>`

Додає елемент на початку масиву. Дивіться також :ref:`push_back()<class_Array_method_push_back>`.

\ **Примітка.** Цей метод зміщує індекси кожного іншого елемента вперед, що може призвести до помітних витрат на продуктивність, особливо для великих масивів.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_reduce:

.. rst-class:: classref-method

:ref:`Variant<class_Variant>` **reduce**\ (\ method\: :ref:`Callable<class_Callable>`, accum\: :ref:`Variant<class_Variant>` = null\ ) |const| :ref:`🔗<class_Array_method_reduce>`

Викликає заданий :ref:`Callable<class_Callable>` для кожного елемента в масиві, накопичує результат у ``accum``, а потім повертає його. 

Метод ``method`` приймає два аргументи: поточне значення ``accum`` і поточний елемент масиву. Якщо ``accum`` дорівнює ``null`` (як за замовчуванням), ітерація почнеться з другого елемента, а перший використовується як початкове значення ``accum``. 

::
 
    func sum(accnum number): 
        return accnum + number 

    func _ready(): 
        print([1, 2, 3].reduce(sum, 0)) # Виводить 6 
        print([1, 2, 3].reduce(sum, 10)) # Виводить 16 

        # Те саме, що й вище, але з використанням лямбда-функції. 
        print([1, 2, 3].reduce(func(accum, number): return accum + number, 10))  

Якщо :ref:`max()<class_Array_method_max>` є небажаним, цей метод також можна використовувати для реалізації спеціального компаратора: 

::
 
    func _ready(): 
        var arr = [Vector2i(5, 0), Vector2i(3, 4), Vector2i(1, 2)] 

        var longest_vec = arr.reduce(func(max, vec): return vec, if is_length_greater(vec, max) else max) 
        print(longest_vec) # Відбитки (3, 4) 

    func is_length_greater(a, b): 
        return a.length() > b.length()  

Цей метод також можна використовувати для підрахунку кількості елементів у масиві, які задовольняють певну умову, подібно до :ref:`count()<class_Array_method_count>`: 

::
 
    func is_even(number): 
        return number% 2 == 0 

    func _ready(): 
        var arr = [1, 2, 3, 4, 5] 
        # Якщо поточний елемент парний, збільште кількість, інакше залиште кількість незмінною. 
        var even_count = arr.reduce(func(count, next): return count + 1 if is_even(next) else count, 0) 
        print(even_count) # Виводить 2  

Див. також :ref:`map()<class_Array_method_map>`, :ref:`filter()<class_Array_method_filter>`, :ref:`any()<class_Array_method_any>`, and :ref:`all()<class_Array_method_all>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_remove_at:

.. rst-class:: classref-method

|void| **remove_at**\ (\ position\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Array_method_remove_at>`

Removes the element from the array at the given index (``position``). If the index is out of bounds, this method fails. If the index is negative, ``position`` is considered relative to the end of the array.

If you need to return the removed element, use :ref:`pop_at()<class_Array_method_pop_at>`. To remove an element by value, use :ref:`erase()<class_Array_method_erase>` instead.

\ **Note:** This method shifts every element's index after ``position`` back, which may have a noticeable performance cost, especially on larger arrays.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_resize:

.. rst-class:: classref-method

:ref:`int<class_int>` **resize**\ (\ size\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Array_method_resize>`

Встановлює кількість елементів масиву на ``size``. Якщо ``size`` менший за поточний розмір масиву, елементи в кінці масиву видаляються. Якщо ``size`` більший, додаються нові елементи за замовчуванням (зазвичай ``null``), залежно від типу масиву.

Повертає :ref:`@GlobalScope.OK<class_@GlobalScope_constant_OK>` у разі успіху або одну з наступних констант :ref:`Error<enum_@GlobalScope_Error>`, якщо цей метод не спрацює: :ref:`@GlobalScope.ERR_LOCKED<class_@GlobalScope_constant_ERR_LOCKED>`, якщо масив доступний лише для читання, :ref:`@GlobalScope.ERR_INVALID_PARAMETER<class_@GlobalScope_constant_ERR_INVALID_PARAMETER>` якщо розмір від'ємний, або :ref:`@GlobalScope.ERR_OUT_OF_MEMORY<class_@GlobalScope_constant_ERR_OUT_OF_MEMORY>`, якщо розподіл пам'яті не вдався. Використовуйте :ref:`size()<class_Array_method_size>`, щоб знайти фактичний розмір масиву після зміни розміру.

\ **Примітка:** Виклик цього методу один раз і призначення нових значень відбувається швидше, ніж виклик :ref:`append()<class_Array_method_append>` для кожного нового елемента.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_reverse:

.. rst-class:: classref-method

|void| **reverse**\ (\ ) :ref:`🔗<class_Array_method_reverse>`

Змінює порядок усіх елементів у масиві на протилежний.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_rfind:

.. rst-class:: classref-method

:ref:`int<class_int>` **rfind**\ (\ what\: :ref:`Variant<class_Variant>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_Array_method_rfind>`

Повертає індекс **останнього** входження ``what`` у цьому масиві або ``-1``, якщо їх немає. Початок пошуку можна вказати за допомогою ``from``, продовжуючи до початку масиву. Цей метод є зворотним до :ref:`find()<class_Array_method_find>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_rfind_custom:

.. rst-class:: classref-method

:ref:`int<class_int>` **rfind_custom**\ (\ method\: :ref:`Callable<class_Callable>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_Array_method_rfind_custom>`

Повертає індекс **останнього** елемента масиву, який змушує ``method`` повертати ``true`` або ``-1``, якщо їх немає. Початок пошуку можна вказати за допомогою ``from``, продовжуючи до початку масиву. Цей метод є зворотним до :ref:`find_custom()<class_Array_method_find_custom>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_set:

.. rst-class:: classref-method

|void| **set**\ (\ index\: :ref:`int<class_int>`, value\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_Array_method_set>`

Встановлює значення елемента для заданого ``index`` у задане ``value``. Це не змінить розмір масиву, це лише змінить значення за індексом, який уже є в масиві. Це те саме, що використання оператора ``[]`` (``array[index] = valve``).

.. rst-class:: classref-item-separator

----

.. _class_Array_method_shuffle:

.. rst-class:: classref-method

|void| **shuffle**\ (\ ) :ref:`🔗<class_Array_method_shuffle>`

Перемішує всі елементи масиву в довільному порядку.

\ **Примітка:** Як і багато подібних функцій у системі (наприклад, :ref:`@GlobalScope.randi()<class_@GlobalScope_method_randi>` або :ref:`pick_random()<class_Array_method_pick_random>`), цей метод використовує звичайне глобальне випадкове початкове число. Щоб отримати передбачуваний результат від цього методу, перегляньте :ref:`@GlobalScope.seed()<class_@GlobalScope_method_seed>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_size:

.. rst-class:: classref-method

:ref:`int<class_int>` **size**\ (\ ) |const| :ref:`🔗<class_Array_method_size>`

Повертає кількість елементів у масиві. Порожні масиви (``[]``) завжди повертають ``0``. Дивіться також :ref:`is_empty()<class_Array_method_is_empty>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_slice:

.. rst-class:: classref-method

:ref:`Array<class_Array>` **slice**\ (\ begin\: :ref:`int<class_int>`, end\: :ref:`int<class_int>` = 2147483647, step\: :ref:`int<class_int>` = 1, deep\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_Array_method_slice>`

Повертає новий **Array**, що містить елементи цього масиву, від індексу ``begin`` (включно) до ``end`` (виключно), кожен елемент ``step``.

 Якщо ``begin`` або ``end`` від’ємні, їхнє значення є відносно кінця масиву.

 Якщо ``step`` є від’ємним, цей метод повторює масив у зворотному порядку, повертаючи фрагмент, упорядкований у зворотному порядку. Щоб це працювало, ``begin`` має бути більшим за ``end``.

 Якщо ``deep`` має значення ``true``, усі вкладені елементи **Array** і :ref:`Dictionary<class_Dictionary>` у фрагменті дублюються з оригіналу рекурсивно. Дивіться також :ref:`duplicate()<class_Array_method_duplicate>`).

::

    var letters = ["A", "B", "C", "D", "E", "F"]

    print(letters.slice(0, 2)) # Виводить ["A", "B"]
    print(letters.slice(2, -2)) # Виводить ["C", "D"]
    print(letters.slice(-2, 6)) # Виводить ["E", "F"]

    print(letters.slice(0, 6, 2)) # Виводить ["A", "C", "E"]
    print(letters.slice(4, 1, -1)) # Виводить ["E", "D", "C"]

.. rst-class:: classref-item-separator

----

.. _class_Array_method_sort:

.. rst-class:: classref-method

|void| **sort**\ (\ ) :ref:`🔗<class_Array_method_sort>`

Сортує масив у порядку зростання. Остаточний порядок залежить від порівняння елементів оператором "менше" (``<``). 


.. tabs:: 

 .. code-tab:: gdscript
 
    var numbers = [10, 5, 2.5, 8] 
    numbers.sort() 
    print(numbers) # Виводить [2.5, 5, 8, 10]  

 .. code-tab:: csharp
 
    Godot.Collections.Array numbers = [10, 5, 2.5, 8]; 
    numbers.Sort(); 
    GD.Print(числа); // Виводить [2.5, 5, 8, 10]  

 

\ **Примітка:** Використаний алгоритм сортування не є `стабільним <https://en.wikipedia.org/wiki/Sorting_algorithm#Stability>`__. Це означає, що порядок еквівалентних елементів (таких як ``2`` і ``2.0``) може змінитися під час виклику :ref:`sort()<class_Array_method_sort>`.

.. rst-class:: classref-item-separator

----

.. _class_Array_method_sort_custom:

.. rst-class:: classref-method

|void| **sort_custom**\ (\ func\: :ref:`Callable<class_Callable>`\ ) :ref:`🔗<class_Array_method_sort_custom>`

Сортує масив за допомогою спеціального :ref:`Callable<class_Callable>`.

\ ``func`` викликається необхідну кількість разів, отримуючи два елементи масиву як аргументи. Функція має повернути ``true``, якщо перший елемент потрібно перемістити *перед* другим, інакше вона має повернути ``false``.

::

    func sort_ascending(a, b):
         if a[1] < b[1]:
             return true
         return false

    func _ready():
         var my_items = [["Помідор", 5], ["Яблуко", 9], ["Рис", 4]]
         my_items.sort_custom(sort_ascending)
         print(my_items) # Виводить [["Rice", 4], ["Tomato", 5], ["Apple", 9]]

         # Сортувати за спаданням, використовуючи лямбда-функцію.
         my_items.sort_custom(func(a, b): повернути a[1] > b[1])
         print(my_items) # Виводить [["Apple", 9], ["Tomato", 5], ["Rice", 4]]

 Також може знадобитися використовувати цей метод для сортування рядків у природному порядку за допомогою :ref:`String.naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, як у наступному прикладі:

::

    var files = ["новий файл1", "новий файл2", "новий файл10", "новий файл11"]
    files.sort_custom(func(a, b): return a.naturalnocasecmp_to(b) < 0)
    print(files) # Виводить ["новийфайл1", "новийфайл2", "новийфайл10", "новийфайл11"]

\ **Примітка:** у C# цей метод не підтримується.

\ **Примітка.** Використаний алгоритм сортування не є `стабільним <https://en.wikipedia.org/wiki/Sorting_algorithm#Stability>`__. Це означає, що значення, які вважаються рівними, можуть змінити свій порядок під час виклику цього методу.

\ **Примітка:** Ви не повинні рандомізувати значення, що повертається ``func``, оскільки алгоритм heapsort очікує узгодженого результату. Рандомізація поверненого значення призведе до неочікуваної поведінки.

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Описи операторів
--------------------------------

.. _class_Array_operator_neq_Array:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_operator_neq_Array>`

Повертає ``true``, якщо розмір масиву або його елементи відмінні від ``right``.

.. rst-class:: classref-item-separator

----

.. _class_Array_operator_sum_Array:

.. rst-class:: classref-operator

:ref:`Array<class_Array>` **operator +**\ (\ right\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_operator_sum_Array>`

Додає масив ``right`` до лівого операнда, створюючи новий **Array**. Це також відомо як конкатенація масиву.


.. tabs::

 .. code-tab:: gdscript

    var array1 = ["Один", 2]
    var array2 = [3, "Чотири"]
    print(array1 + array2) # Виводить ["Один", 2, 3, "Чотири"]

 .. code-tab:: csharp

     // Зауважте, що конкатенація неможлива з власним типом масиву C#.
    var array1 = new Godot.Collections.Array{"One", 2};
    var array2 = new Godot.Collections.Array{3, "Four"};
    GD.Print(Areay1 + Array2); // Виводить ["One", 2, 3, "Four"]



\ **Примітка.** Для існуючих масивів :ref:`append_array()<class_Array_method_append_array>` набагато ефективніший, ніж конкатенація та присвоєння за допомогою оператора ``+=``.

.. rst-class:: classref-item-separator

----

.. _class_Array_operator_lt_Array:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_operator_lt_Array>`

Порівнює елементи обох масивів по порядку, починаючи з індексу ``0`` і закінчуючи останнім спільним індексом обох масивів. Для кожної пари елементів повертає ``true``, якщо елемент цього масиву менший за ``right``, ``false``, якщо цей елемент більший. В іншому випадку переходить до наступної пари.

 Якщо всі шукані елементи рівні, повертає ``true``, якщо розмір цього масиву менший за ``right``, інакше повертає ``false``.

.. rst-class:: classref-item-separator

----

.. _class_Array_operator_lte_Array:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_operator_lte_Array>`

Порівняти елементи обох масивів для того, щоб, починаючи від індексу ``0`` і закінчуючи останнього індексу в загальному між масивами. Для кожної пари елементів, повертає ``true``, якщо цей елемент масиву менше ``right``, ``false``, якщо цей елемент більший. В іншому випадку продовжується наступна пара.

Якщо всі пошукові елементи рівні, повертає ``true``, якщо цей розмір масиву менше або дорівнює ``парам прямо``, інакше повертає ``false``.

.. rst-class:: classref-item-separator

----

.. _class_Array_operator_eq_Array:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_operator_eq_Array>`

Порівнює лівий **Array** з ``right`` **Array**. Повертає ``true``, якщо розміри та вміст масивів рівні, у протилежному випадку ``false``.

.. rst-class:: classref-item-separator

----

.. _class_Array_operator_gt_Array:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_operator_gt_Array>`

Порівняти елементи обох масивів для того, щоб, починаючи від індексу ``0`` і закінчуючи останнього індексу в загальному між масивами. Для кожної пари елементів, повертає ``true``, якщо цей елемент масиву перевищує ``right``, ``false``, якщо цей елемент менше. В іншому випадку продовжується наступна пара.

Якщо всі пошукові елементи рівні, повертає ``true``, якщо цей розмір масиву перевищує ``right``, інакше повертає ``false``.

.. rst-class:: classref-item-separator

----

.. _class_Array_operator_gte_Array:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`Array<class_Array>`\ ) :ref:`🔗<class_Array_operator_gte_Array>`

Порівняти елементи обох масивів для того, щоб, починаючи від індексу ``0`` і закінчуючи останнього індексу в загальному між масивами. Для кожної пари елементів, повертає ``true``, якщо цей елемент масиву перевищує ``right``, ``false``, якщо цей елемент менше. В іншому випадку продовжується наступна пара.

Якщо всі пошукові елементи рівні, повертає ``true``, якщо цей розмір масиву більше або дорівнює ``парам прямо``, інакше повертає ``false``.

.. rst-class:: classref-item-separator

----

.. _class_Array_operator_idx_int:

.. rst-class:: classref-operator

:ref:`Variant<class_Variant>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_Array_operator_idx_int>`

Повертає елемент :ref:`Variant<class_Variant>` вказаний ``index``. Початок масиву в індексі 0. Якщо ``index`` більший або рівний ``0``, елемент виходить від початку масиву. Якщо ``index`` є негативним значенням, елемент відступається від кінця. Доступ до масиву з-під-під ключів призведе до помилки запуску часу, призупинення виконання проекту, якщо запустити з редактора.

.. |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 (Значення не повертається.)`