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

1557 lines
101 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

: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 (Значення не повертається.)`
Reference in New Issue View Git Blame Copy Permalink