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/ru/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

1567 lines
102 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]); // Выводит "First"
GD.Print(array[2]); // Выводит 3
GD.Print(array[^1]); // Выводит "Last"
array[1] = "Second";
GD.Print(array[1]); // Выводит "Second"
GD.Print(array[^3]); // Выводит "Second"
// Этот типизированный массив может содержать только целые числа.
// Попытка добавить любой другой тип приведет к ошибке.
Godot.Collections.Array<int> typedArray = [1, 2, 3];
\ **Примечание:** Массивы всегда передаются по **ссылке**. Чтобы получить копию массива, которую можно изменять независимо от исходного, используйте :ref:`duplicate()<class_Array_method_duplicate>`.
\ **Примечание:** Удаление элементов при итерации по массивам **не** поддерживается и приведёт к непредсказуемому поведению.
\ **Различия между упакованными, типизированными и нетипизированными массивами:** Упакованные массивы, как правило, быстрее итерируются и изменяются по сравнению с типизированными массивами того же типа (например, :ref:`PackedInt64Array<class_PackedInt64Array>` против ``Array[int]``). Кроме того, упакованные массивы потребляют меньше памяти. Недостатком упакованных массивов является их меньшая гибкость, поскольку они не предлагают столько удобных методов, как :ref:`map()<class_Array_method_map>`. Типизированные массивы, в свою очередь, быстрее итерируются и изменяются, чем нетипизированные массивы.
.. note::
Существуют заметные различия при использовании данного API с C#. Подробнее см. :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>`\ )
Создает массив из ``Packed Float32Array``.
.. 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 greater_than_5(number):
return number > 5
func _ready():
print([6, 10, 6].any(greater_than_5)) # Выводит true (3 элементы оцениваются как true).
print([4, 10, 4].any(greater_than_5)) # Выводит true (1 элементы оцениваются как true).
print([4, 4, 4].any(greater_than_5)) # Выводит false (0 элементы оцениваются как true).
print([].any(greater_than_5)) # Выводит false (0 элементы оцениваются как 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) # Prints [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://en.wikipedia.org/wiki/Binary_search_algorithm>`__.
Если ``before`` равен ``true`` (как по умолчанию), возвращаемый индекс предшествует всем существующим элементам, равным ``value`` в массиве.
::
var numbers = [2, 4, 8, 10]
var idx = numbers.bsearch(7)
numbers.insert(idx, 7)
print(numbers) # Prints [2, 4, 7, 8, 10]
var fruits = ["Apple", "Lemon", "Lemon", "Orange"]
print(fruits.bsearch("Lemon", true)) # Печатает 1, указывает на первый "Lemon".
print(fruits.bsearch("Lemon", false)) # Печатает 3, указывают на "Lemon".
\ **Примечание:** Вызов :ref:`bsearch()<class_Array_method_bsearch>` для *unsorted (несортированного)* массива приведет к неожиданному поведению. Используйте :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``, если элемент массива должен быть *behind (позади)* ``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 = [["Tomato", 2], ["Kiwi", 5], ["Rice", 9]]
var apple = ["Apple", 5]
# "Apple" вставляется перед "Kiwi".
my_items.insert(my_items.bsearch_custom(apple, sort_by_amount, true), apple)
var banana = ["Banana", 5]
# "Banana" вставляется после "Kiwi".
my_items.insert(my_items.bsearch_custom(banana, sort_by_amount, false), banana)
# Выводит [["Tomato", 2], ["Apple", 5], ["Kiwi", 5], ["Banana", 5], ["Rice", 9]]
print(my_items)
\ **Примечание:** Вызов :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``, возвращается **глубокая** копия: все вложенные массивы и словари также дублируются (рекурсивно). Однако любой :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) # Prints [2, 2, 2, 2, 2]
.. code-tab:: csharp
Godot.Collections.Array array = [];
array.Resize(5);
array.Fill(2);
GD.Print(array); // Prints [2, 2, 2, 2, 2]
\ **Примечание:** Если ``value`` является :ref:`Variant<class_Variant>`, переданным по ссылке (производным от :ref:`Object<class_Object>`, **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)) # Выводит [4, 8]
# То же, что и выше, но с использованием лямбда-функции.
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>` и :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>`
Возвращает индекс **first (первого)** вхождения ``what`` в этом массиве или ``-1``, если их нет. Начало поиска можно указать с помощью ``from``, продолжая до конца массива.
\ **Примечание:** Если вы просто хотите узнать, содержит ли массив ``what``, используйте :ref:`has()<class_Array_method_has>` (``Contains`` в C#). В GDScript вы также можете использовать оператор ``in``.
\ **Примечание:** Из соображений производительности на поиск влияет :ref:`Variant.Type<enum_@GlobalScope_Variant.Type>` ``what``. Например, ``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(number):
return number % 2 == 0
func _ready():
print([1, 3, 4, 7].find_custom(is_even.bind())) # Prints 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``.
.. tabs::
.. code-tab:: gdscript
print(["inside", 7].has("inside")) # Выводит true
print(["inside", 7].has("outside")) # Выводит false
print(["inside", 7].has(7)) # Выводит true
print(["inside", 7].has("7")) # Выводит false
.. code-tab:: csharp
Godot.Collections.Array arr = ["inside", 7];
// По соглашению C# этот метод переименован в `Contains`.
GD.Print(arr.Contains("inside")); // Выводит True
GD.Print(arr.Contains("outside")); // Выводит False
GD.Print(arr.Contains(7)); // Выводит True
GD.Print(arr.Contains("7")); // Выводит False
В GDScript это эквивалентно оператору ``in``:
::
if 4 in [2, 4, 6, 8]:
print("4 уже здесь!") # Будет напечатано.
\ **Примечание:** Из соображений производительности на поиск влияет ``value`` :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_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``) в массиве. ``position`` должен быть между ``0`` и :ref:`size()<class_Array_method_size>` массива. Если отрицательно, ``position`` считается относительно конца массива.
Возвращает :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 numbers: Array[float] = [0.2, 4.2, -2.0]
print(numbers.is_typed()) # Prints 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)) # Prints [2, 4, 6]
# То же, что и выше, но с использованием лямбда-функции.
print([1, 2, 3].map(func(element): return element * 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``, если массив пуст.
.. tabs::
.. code-tab:: gdscript
# Может печатать 1, 2, 3.25 или "Привет".
print([1, 2, 3.25, "Привет"].pick_random())
.. code-tab:: csharp
Godot.Collections.Array array = [1, 2, 3.25f, "Привет"];
GD.Print(array.PickRandom()); // Может печатать 1, 2, 3.25 или "Привет".
\ **Примечание:** Как и многие подобные функции в движке (например, :ref:`@GlobalScope.randi()<class_@GlobalScope_method_randi>` или :ref:`shuffle()<class_Array_method_shuffle>`), этот метод использует общее глобальное случайное начальное число. Чтобы получить предсказуемый результат от этого метода, см. :ref:`@GlobalScope.seed()<class_@GlobalScope_method_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(accum, number):
return accum + 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]
# Если текущий элемент четный, увеличиваем count, в противном случае оставляем count прежним.
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>` и :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] = value``).
.. 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) # Prints [2.5, 5, 8, 10]
.. code-tab:: csharp
Godot.Collections.Array numbers = [10, 5, 2.5, 8];
numbers.Sort();
GD.Print(numbers); // Prints [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 = [["Tomato", 5], ["Apple", 9], ["Rice", 4]]
my_items.sort_custom(sort_ascending)
print(my_items) # Prints [["Rice", 4], ["Tomato", 5], ["Apple", 9]]
#Сортировка по убыванию с использованием лямбда-функции.
my_items.sort_custom(func(a, b): return a[1] > b[1])
print(my_items) # Prints [["Apple", 9], ["Tomato", 5], ["Rice", 4]]
Также может потребоваться использовать этот метод для сортировки строк в естественном порядке с помощью :ref:`String.naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, как в следующем примере:
::
var files = ["newfile1", "newfile2", "newfile10", "newfile11"]
files.sort_custom(func(a, b): return a.naturalnocasecmp_to(b) < 0)
print(files) # Prints ["newfile1", "newfile2", "newfile10", "newfile11"]
\ **Примечание:** В C# этот метод не поддерживается.
\ **Примечание:** Используемый алгоритм сортировки не является `стабильным <https://en.wikipedia.org/wiki/Sorting_algorithm#Stability>`__. Это означает, что значения, считающиеся равными, могут иметь измененный порядок при вызове этого метода.
\ **Примечание:** Не следует рандомизировать возвращаемое значение ``func``, так как алгоритм пирамидальной сортировки ожидает согласованного результата. Рандомизация возвращаемого значения приведет к неожиданному поведению.
.. 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 = ["One", 2]
var array2 = [3, "Four"]
print(array1 + array2) # Prints ["One", 2, 3, "Four"]
.. code-tab:: csharp
// Обратите внимание, что конкатенация невозможна с собственным типом массива C#.
Godot.Collections.Array array1 = ["One", 2];
Godot.Collections.Array array2 = [3, "Four"];
GD.Print(array1 + array2); // Prints ["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``, если размер этого массива меньше или равен ``right``, в противном случае возвращает ``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``, если размер этого массива больше или равен ``right``, в противном случае возвращает ``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