:github_url: hide

.. _class_Array:

Array
=====

一种内置数据结构，包含一系列元素。

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

描述
----

数组数据类型，默认可以包含任意 :ref:`Variant<class_Variant>` 类型元素的序列。创建\ *类型化数组*\ 可以将其中的值限制为特定的类型。可以使用从 ``0`` 开始的索引号来访问元素。可以使用负的索引号从结尾开始计数（\ ``-1`` 表示倒数第一个元素、\ ``-2`` 表示倒数第二个元素，以此类推）。


.. tabs::

 .. code-tab:: gdscript

    var array = ["第一", 2, 3, "最后"]
    print(array[0])  # 输出“第一”
    print(array[2])  # 输出 3
    print(array[-1]) # 输出“最后”

    array[1] = "第二"
    print(array[1])  # 输出“第二”
    print(array[-3]) # 输出“第二”

    # 这个类型化数组中只能包含整数。
    # 尝试向其中添加其他类型会报错。
    var typed_array: Array[int] = [1, 2, 3]

 .. code-tab:: csharp

    Godot.Collections.Array array = ["第一", 2, 3, "最后"];
    GD.Print(array[0]); // 输出“开头”
    GD.Print(array[2]); // 输出 3
    GD.Print(array[^1]); // 输出“最后”

    array[2] = "第二";
    GD.Print(array[1]); // 输出“第二”
    GD.Print(array[^3]); // 输出“第二”

    // 这个类型化数组中只能包含整数。
    // 尝试向其中添加其他类型会报错。
    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::

	通过 C# 使用该 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>`\ ，如果 :ref:`Callable<class_Callable>` 为数组中的 *所有* 元素返回 ``true``\ ，则返回 ``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 元素被评估为真）。
        print([4, 10, 4].all(greater_than_5)) # 输出 false （1/3 元素被评估为真）。
        print([4, 4, 4].all(greater_than_5))  # 输出 false （0/3 元素被评估为真）。
        print([].all(greater_than_5))         # 输出 true （0/0 元素被评估为真）。

        # 与上面的第一行相同，但使用 lambda 函数。
        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 元素被评估为真）。
        GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(GreaterThan5));
        // 输出 False （1/3 元素被评估为真）。
        GD.Print(new Godot.Collections.Array>int< { 4, 10, 4 }.All(GreaterThan5));
        // 输出 False （0/3 元素被评估为真）。
        GD.Print(new Godot.Collections.Array>int< { 4, 4, 4 }.All(GreaterThan5));
        // 输出 True （0/0 元素被评估为真）。
        GD.Print(new Godot.Collections.Array>int< { }.All(GreaterThan5));

        // 与上面的第一行相同，但使用 lambda 函数。
        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>`\ ，如果 :ref:`Callable<class_Callable>` 为数组中的\ * 一个或多个*\ 元素返回 ``true``\ ，则返回 ``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 个元素被评估为真）。
        print([4, 10, 4].any(greater_than_5)) #输出 true （1 个元素被评估为真）。
        print([4, 4, 4].any(greater_than_5))  # 输出 false （0 个元素被评估为真）。
        print([].any(greater_than_5))         # 输出 false （0 个元素被评估为真）。

        # 与上面的第一行相同，但使用 lambda 函数。
        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://zh.wikipedia.org/wiki/%E4%BA%8C%E5%88%86%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95>`__\ 。

如果 ``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 = ["Apple", "Lemon", "Lemon", "Orange"]
    print(fruits.bsearch("Lemon", true))  # 输出 1，位于第一个 "Lemon"。
    print(fruits.bsearch("Lemon", false)) # 输出 3，位于 "Orange"。

\ **注意：**\ 对\ *未排序的*\ 数组调用 :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://zh.wikipedia.org/wiki/%E4%BA%8C%E5%88%86%E6%90%9C%E5%B0%8B%E6%BC%94%E7%AE%97%E6%B3%95>`__\ 。

与 :ref:`sort_custom()<class_Array_method_sort_custom>` 类似，\ ``func`` 会根据需要多次调用，接收一个数组元素和 ``value`` 作为参数。如果数组元素应该在 ``value`` *后面*\ ，则函数应该返回 ``true``\ ，否则应该返回 ``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>`

深度复制该数组，类似 :ref:`duplicate()<class_Array_method_duplicate>`\ ``(true)``\ ，但能够额外控制子资源的处理方式。

\ ``deep_subresources_mode`` 必须是 :ref:`DeepDuplicateMode<enum_Resource_DeepDuplicateMode>` 中的一个值。默认只会（递归）复制内部资源。

.. 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(array); // 输出 [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]

        # 与上面相同，但使用 lambda 函数。
        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>`

返回 ``what`` 在该数组中\ **第一次**\ 出现时的索引，不存在时返回 ``-1``\ 。搜索的起点可以使用 ``from`` 指定，终点为数组末尾。

\ **注意：**\ 如果你只想知道数组中是否包含 ``what``\ ，请使用 :ref:`has()<class_Array_method_has>`\ （C# 则为 ``Contains``\ ）。在 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(number):
        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>`

返回数组中索引为 ``index`` 的元素。如果 ``index`` 越界或为负数，则该方法失败并返回 ``null``\ 。

该方法类似于 ``[]`` 运算符（但不等价）。最显著的区别就是从编辑器中运行时，该方法失败不会暂停项目运行。

.. 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>`

如果该数组包含给定的 ``value``\ ，则返回 ``true``\ 。


.. 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>`

返回代表该数组及其内容的散列 32 位整数值。

\ **注意：**\ 由于哈希碰撞的缘故，哈希相同的数组\ *不*\ 保证相同。而相对的是，哈希不同的数组保证不同。

.. 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>`

在数组中给定索引（\ ``position``\ ）处插入新元素（\ ``value``\ ）。\ ``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>`

如果该数组的类型与给定的 ``array`` 相同，则返回 ``true``\ 。另见 :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()) # 输出 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]

        # 与上面相同，但使用 lambda 函数。
        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、或 "Hi"。
    print([1, 2, 3.25, "Hi"].pick_random())

 .. code-tab:: csharp

    Godot.Collections.Array array = [1, 2, 3.25f, "Hi"];
    GD.Print(array.PickRandom()); // 可能输出 1、2、3.25、或 "Hi"。



\ **注意：**\ 与引擎中的许多类似函数（例如 :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

        # 与上面相同，但是使用 lambda 函数。
        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>`\ 、\ :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>`

从数组中移除指定索引（\ ``position``\ ）处的元素。如果索引超出范围，则该方法失败。如果为负数，则认为 ``position`` 为相对于数组结尾的索引。

如果需要返回被移除的元素，请使用 :ref:`pop_at()<class_Array_method_pop_at>`\ 。要按值移除元素，请改用 :ref:`erase()<class_Array_method_erase>`\ 。

\ **注意：**\ 该方法将 ``position`` 之后每个元素的索引向前移动，这可能会产生明显的性能成本，尤其是在较大的数组上。

\ **注意：**\ ``position`` 不能为负数。要移除相对于数组末尾的元素，请使用 ``arr.remove_at(arr.size() - (i + 1))``\ 。要从数组中移除最后一个元素，请使用 ``arr.resize(arr.size() - 1)``\ 。

.. 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) # 输出 [2.5, 5, 8, 10]

 .. code-tab:: csharp

    Godot.Collections.Array numbers = [10, 5, 2.5, 8];
    numbers.Sort();
    GD.Print(numbers); // 输出 [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) # 输出 [["Rice", 4], ["Tomato", 5], ["Apple", 9]]

        # 使用 lambda 函数按降序排序。
        my_items.sort_custom(func(a, b): return a[0] > b[0])
        print(my_items) # 输出 [["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) # 输出 ["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>`

如果该数组的大小或其元素与 ``right`` 不同，则返回 ``true``\ 。

.. 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) # 输出 ["One", 2, 3, "Four"]

 .. code-tab:: csharp

    // 请注意，C# 的原生数组类型无法进行拼接。
    Godot.Collections.Array array1 = ["One", 2];
    Godot.Collections.Array array2 = [3, "Four"];
    GD.Print(array1 + 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`` 开始，到两个数组共同的最后一个索引结束。对于每对元素，如果该数组的元素小于 ``right`` 的元素，则返回 ``true``\ ；如果该元素大于 ``right`` 的元素，则返回 ``false``\ 。否则，继续下一对。

当所有搜索到的元素都相等时，如果该数组的大小小于 ``right`` 的大小，则返回 ``true``\ ，否则返回 ``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`` 开始，到两个数组共同的最后一个索引结束。对于每对元素，如果该数组的元素小于 ``right`` 的元素，则返回 ``true``\ ；如果该元素较大则返回 ``false``\ 。否则，继续下一对。

当所有搜索到的元素都相等时，如果该数组的大小小于或等于 ``right`` 的大小，则返回 ``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`` 开始，到两个数组共同的最后一个索引结束。对于每对元素，如果该数组的元素大于 ``right`` 的元素，则返回 ``true``\ ；如果该元素较小则返回 ``false``\ 。否则，继续下一对。

当所有搜索到的元素都相等时，如果该数组的大小大于 ``right`` 的大小，则返回 ``true``\ ，否则返回 ``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`` 开始，到两个数组共同的最后一个索引结束。对于每对元素，如果该数组的元素大于 ``right`` 的元素，则返回 ``true``\ ，如果该元素较小则返回 ``false``\ 。否则，继续下一对。

当所有搜索到的元素都相等时，如果该数组的大小大于或等于 ``right`` 的大小，则返回 ``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>`

返回指定 ``index`` 处的 :ref:`Variant<class_Variant>` 元素。数组从索引 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 (无返回值。)`