:github_url: hide .. DO NOT EDIT THIS FILE!!! .. Generated automatically from Godot engine sources. .. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py. .. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/Array.xml. .. _class_Array: Array ===== A built-in data structure that holds a sequence of elements. .. rst-class:: classref-introduction-group Description ----------- An array data structure that can contain a sequence of elements of any :ref:`Variant` type. Elements are accessed by a numerical index starting at ``0``. Negative indices are used to count from the back (``-1`` is the last element, ``-2`` is the second to last, etc.). .. tabs:: .. code-tab:: gdscript var array = ["First", 2, 3, "Last"] print(array[0]) # Prints "First" print(array[2]) # Prints 3 print(array[-1]) # Prints "Last" array[1] = "Second" print(array[1]) # Prints "Second" print(array[-3]) # Prints "Second" .. code-tab:: csharp var array = new Godot.Collections.Array{"First", 2, 3, "Last"}; GD.Print(array[0]); // Prints "First" GD.Print(array[2]); // Prints 3 GD.Print(array[array.Count - 1]); // Prints "Last" array[2] = "Second"; GD.Print(array[1]); // Prints "Second" GD.Print(array[array.Count - 3]); // Prints "Second" \ **Note:** Arrays are always passed by **reference**. To get a copy of an array that can be modified independently of the original array, use :ref:`duplicate`. \ **Note:** Erasing elements while iterating over arrays is **not** supported and will result in unpredictable behavior. \ **Differences between packed arrays, typed arrays, and untyped arrays:** Packed arrays are generally faster to iterate on and modify compared to a typed array of the same type (e.g. :ref:`PackedInt64Array` versus ``Array[int]``). Also, packed arrays consume less memory. As a downside, packed arrays are less flexible as they don't offer as many convenience methods such as :ref:`map`. Typed arrays are in turn faster to iterate on and modify than untyped arrays. .. note:: There are notable differences when using this API with C#. See :ref:`doc_c_sharp_differences` for more information. .. rst-class:: classref-reftable-group Constructors ------------ .. table:: :widths: auto +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ base\: :ref:`Array`, type\: :ref:`int`, class_name\: :ref:`StringName`, script\: :ref:`Variant`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedByteArray`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedColorArray`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedFloat32Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedFloat64Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedInt32Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedInt64Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedStringArray`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedVector2Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedVector3Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`Array`\ (\ from\: :ref:`PackedVector4Array`\ ) | +---------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Methods ------- .. table:: :widths: auto +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`all`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`any`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`append`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`append_array`\ (\ array\: :ref:`Array`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`assign`\ (\ array\: :ref:`Array`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`back`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bsearch`\ (\ value\: :ref:`Variant`, before\: :ref:`bool` = true\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bsearch_custom`\ (\ value\: :ref:`Variant`, func\: :ref:`Callable`, before\: :ref:`bool` = true\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`clear`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`count`\ (\ value\: :ref:`Variant`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`duplicate`\ (\ deep\: :ref:`bool` = false\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`erase`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`fill`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`filter`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find`\ (\ what\: :ref:`Variant`, from\: :ref:`int` = 0\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find_custom`\ (\ method\: :ref:`Callable`, from\: :ref:`int` = 0\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`front`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`get`\ (\ index\: :ref:`int`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_typed_builtin`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`StringName` | :ref:`get_typed_class_name`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`get_typed_script`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`has`\ (\ value\: :ref:`Variant`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`hash`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`insert`\ (\ position\: :ref:`int`, value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_empty`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_read_only`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_same_typed`\ (\ array\: :ref:`Array`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_typed`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`make_read_only`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`map`\ (\ method\: :ref:`Callable`\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`max`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`min`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pick_random`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pop_at`\ (\ position\: :ref:`int`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pop_back`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`pop_front`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`push_back`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`push_front`\ (\ value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`reduce`\ (\ method\: :ref:`Callable`, accum\: :ref:`Variant` = null\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`remove_at`\ (\ position\: :ref:`int`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`resize`\ (\ size\: :ref:`int`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`reverse`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind`\ (\ what\: :ref:`Variant`, from\: :ref:`int` = -1\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind_custom`\ (\ method\: :ref:`Callable`, from\: :ref:`int` = -1\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`set`\ (\ index\: :ref:`int`, value\: :ref:`Variant`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`shuffle`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`size`\ (\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`slice`\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647, step\: :ref:`int` = 1, deep\: :ref:`bool` = false\ ) |const| | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`sort`\ (\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | |void| | :ref:`sort_custom`\ (\ func\: :ref:`Callable`\ ) | +-------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Operators --------- .. table:: :widths: auto +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`Array` | :ref:`operator +`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator \<`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator \<=`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator >`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator >=`\ (\ right\: :ref:`Array`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ | :ref:`Variant` | :ref:`operator []`\ (\ index\: :ref:`int`\ ) | +-------------------------------+----------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Constructor Descriptions ------------------------ .. _class_Array_constructor_Array: .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ ) :ref:`🔗` Constructs an empty **Array**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ base\: :ref:`Array`, type\: :ref:`int`, class_name\: :ref:`StringName`, script\: :ref:`Variant`\ ) Creates a typed array from the ``base`` array. A typed array can only contain elements of the given type, or that inherit from the given class, as described by this constructor's parameters: - ``type`` is the built-in :ref:`Variant` type, as one the :ref:`Variant.Type` constants. - ``class_name`` is the built-in class name (see :ref:`Object.get_class`). - ``script`` is the associated script. It must be a :ref:`Script` instance or ``null``. If ``type`` is not :ref:`@GlobalScope.TYPE_OBJECT`, ``class_name`` must be an empty :ref:`StringName` and ``script`` must be ``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] The ``base`` array's elements are converted when necessary. If this is not possible or ``base`` is already typed, this constructor fails and returns an empty **Array**. In GDScript, this constructor is usually not necessary, as it is possible to create a typed array through static typing: :: var numbers: Array[float] = [] var children: Array[Node] = [$Node, $Sprite2D, $RigidBody3D] var integers: Array[int] = [0.2, 4.5, -2.0] print(integers) # Prints [0, 4, -2] .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`Array`\ ) Returns the same array as ``from``. If you need a copy of the array, use :ref:`duplicate`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedByteArray`\ ) Constructs an array from a :ref:`PackedByteArray`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedColorArray`\ ) Constructs an array from a :ref:`PackedColorArray`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedFloat32Array`\ ) Constructs an array from a :ref:`PackedFloat32Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedFloat64Array`\ ) Constructs an array from a :ref:`PackedFloat64Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedInt32Array`\ ) Constructs an array from a :ref:`PackedInt32Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedInt64Array`\ ) Constructs an array from a :ref:`PackedInt64Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedStringArray`\ ) Constructs an array from a :ref:`PackedStringArray`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedVector2Array`\ ) Constructs an array from a :ref:`PackedVector2Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedVector3Array`\ ) Constructs an array from a :ref:`PackedVector3Array`. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`Array` **Array**\ (\ from\: :ref:`PackedVector4Array`\ ) Constructs an array from a :ref:`PackedVector4Array`. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Method Descriptions ------------------- .. _class_Array_method_all: .. rst-class:: classref-method :ref:`bool` **all**\ (\ method\: :ref:`Callable`\ ) |const| :ref:`🔗` Calls the given :ref:`Callable` on each element in the array and returns ``true`` if the :ref:`Callable` returns ``true`` for *all* elements in the array. If the :ref:`Callable` returns ``false`` for one array element or more, this method returns ``false``. The ``method`` should take one :ref:`Variant` parameter (the current array element) and return a :ref:`bool`. .. tabs:: .. code-tab:: gdscript func greater_than_5(number): return number > 5 func _ready(): print([6, 10, 6].all(greater_than_5)) # Prints true (3/3 elements evaluate to true). print([4, 10, 4].all(greater_than_5)) # Prints false (1/3 elements evaluate to true). print([4, 4, 4].all(greater_than_5)) # Prints false (0/3 elements evaluate to true). print([].all(greater_than_5)) # Prints true (0/0 elements evaluate to true). # Same as the first line above, but using a lambda function. print([6, 10, 6].all(func(element): return element > 5)) # Prints true .. code-tab:: csharp private static bool GreaterThan5(int number) { return number > 5; } public override void _Ready() { // Prints true (3/3 elements evaluate to true). GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(GreaterThan5)); // Prints false (1/3 elements evaluate to true). GD.Print(new Godot.Collections.Array>int< { 4, 10, 4 }.All(GreaterThan5)); // Prints false (0/3 elements evaluate to true). GD.Print(new Godot.Collections.Array>int< { 4, 4, 4 }.All(GreaterThan5)); // Prints true (0/0 elements evaluate to true). GD.Print(new Godot.Collections.Array>int< { }.All(GreaterThan5)); // Same as the first line above, but using a lambda function. GD.Print(new Godot.Collections.Array>int< { 6, 10, 6 }.All(element => element > 5)); // Prints true } See also :ref:`any`, :ref:`filter`, :ref:`map` and :ref:`reduce`. \ **Note:** Unlike relying on the size of an array returned by :ref:`filter`, this method will return as early as possible to improve performance (especially with large arrays). \ **Note:** For an empty array, this method `always `__ returns ``true``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_any: .. rst-class:: classref-method :ref:`bool` **any**\ (\ method\: :ref:`Callable`\ ) |const| :ref:`🔗` Calls the given :ref:`Callable` on each element in the array and returns ``true`` if the :ref:`Callable` returns ``true`` for *one or more* elements in the array. If the :ref:`Callable` returns ``false`` for all elements in the array, this method returns ``false``. The ``method`` should take one :ref:`Variant` parameter (the current array element) and return a :ref:`bool`. :: func greater_than_5(number): return number > 5 func _ready(): print([6, 10, 6].any(greater_than_5)) # Prints true (3 elements evaluate to true). print([4, 10, 4].any(greater_than_5)) # Prints true (1 elements evaluate to true). print([4, 4, 4].any(greater_than_5)) # Prints false (0 elements evaluate to true). print([].any(greater_than_5)) # Prints false (0 elements evaluate to true). # Same as the first line above, but using a lambda function. print([6, 10, 6].any(func(number): return number > 5)) # Prints true See also :ref:`all`, :ref:`filter`, :ref:`map` and :ref:`reduce`. \ **Note:** Unlike relying on the size of an array returned by :ref:`filter`, this method will return as early as possible to improve performance (especially with large arrays). \ **Note:** For an empty array, this method always returns ``false``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_append: .. rst-class:: classref-method |void| **append**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` Appends ``value`` at the end of the array (alias of :ref:`push_back`). .. rst-class:: classref-item-separator ---- .. _class_Array_method_append_array: .. rst-class:: classref-method |void| **append_array**\ (\ array\: :ref:`Array`\ ) :ref:`🔗` Appends another ``array`` at the end of this 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`\ ) :ref:`🔗` Assigns elements of another ``array`` into the array. Resizes the array to match ``array``. Performs type conversions if the array is typed. .. rst-class:: classref-item-separator ---- .. _class_Array_method_back: .. rst-class:: classref-method :ref:`Variant` **back**\ (\ ) |const| :ref:`🔗` Returns the last element of the array. If the array is empty, fails and returns ``null``. See also :ref:`front`. \ **Note:** Unlike with the ``[]`` operator (``array[-1]``), an error is generated without stopping project execution. .. rst-class:: classref-item-separator ---- .. _class_Array_method_bsearch: .. rst-class:: classref-method :ref:`int` **bsearch**\ (\ value\: :ref:`Variant`, before\: :ref:`bool` = true\ ) |const| :ref:`🔗` Returns the index of ``value`` in the sorted array. If it cannot be found, returns where ``value`` should be inserted to keep the array sorted. The algorithm used is `binary search `__. If ``before`` is ``true`` (as by default), the returned index comes before all existing elements equal to ``value`` in the array. :: 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)) # Prints 1, points at the first "Lemon". print(fruits.bsearch("Lemon", false)) # Prints 3, points at "Orange". \ **Note:** Calling :ref:`bsearch` on an *unsorted* array will result in unexpected behavior. Use :ref:`sort` before calling this method. .. rst-class:: classref-item-separator ---- .. _class_Array_method_bsearch_custom: .. rst-class:: classref-method :ref:`int` **bsearch_custom**\ (\ value\: :ref:`Variant`, func\: :ref:`Callable`, before\: :ref:`bool` = true\ ) |const| :ref:`🔗` Returns the index of ``value`` in the sorted array. If it cannot be found, returns where ``value`` should be inserted to keep the array sorted (using ``func`` for the comparisons). The algorithm used is `binary search `__. Similar to :ref:`sort_custom`, ``func`` is called as many times as necessary, receiving one array element and ``value`` as arguments. The function should return ``true`` if the array element should be *behind* ``value``, otherwise it should return ``false``. If ``before`` is ``true`` (as by default), the returned index comes before all existing elements equal to ``value`` in the array. :: 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" is inserted before "Kiwi". my_items.insert(my_items.bsearch_custom(apple, sort_by_amount, true), apple) var banana = ["Banana", 5] # "Banana" is inserted after "Kiwi". my_items.insert(my_items.bsearch_custom(banana, sort_by_amount, false), banana) # Prints [["Tomato", 2], ["Apple", 5], ["Kiwi", 5], ["Banana", 5], ["Rice", 9]] print(my_items) \ **Note:** Calling :ref:`bsearch_custom` on an *unsorted* array will result in unexpected behavior. Use :ref:`sort_custom` with ``func`` before calling this method. .. rst-class:: classref-item-separator ---- .. _class_Array_method_clear: .. rst-class:: classref-method |void| **clear**\ (\ ) :ref:`🔗` Removes all elements from the array. This is equivalent to using :ref:`resize` with a size of ``0``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_count: .. rst-class:: classref-method :ref:`int` **count**\ (\ value\: :ref:`Variant`\ ) |const| :ref:`🔗` Returns the number of times an element is in the array. To count how many elements in an array satisfy a condition, see :ref:`reduce`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_duplicate: .. rst-class:: classref-method :ref:`Array` **duplicate**\ (\ deep\: :ref:`bool` = false\ ) |const| :ref:`🔗` Returns a new copy of the array. By default, a **shallow** copy is returned: all nested **Array** and :ref:`Dictionary` elements are shared with the original array. Modifying them in one array will also affect them in the other. If ``deep`` is ``true``, a **deep** copy is returned: all nested arrays and dictionaries are also duplicated (recursively). .. rst-class:: classref-item-separator ---- .. _class_Array_method_erase: .. rst-class:: classref-method |void| **erase**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` Finds and removes the first occurrence of ``value`` from the array. If ``value`` does not exist in the array, nothing happens. To remove an element by index, use :ref:`remove_at` instead. \ **Note:** This method shifts every element's index after the removed ``value`` back, which may have a noticeable performance cost, especially on larger arrays. \ **Note:** Erasing elements while iterating over arrays is **not** supported and will result in unpredictable behavior. .. rst-class:: classref-item-separator ---- .. _class_Array_method_fill: .. rst-class:: classref-method |void| **fill**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` Assigns the given ``value`` to all elements in the array. This method can often be combined with :ref:`resize` to create an array with a given size and initialized elements: .. tabs:: .. code-tab:: gdscript var array = [] array.resize(5) array.fill(2) print(array) # Prints [2, 2, 2, 2, 2] .. code-tab:: csharp var array = new Godot.Collections.Array(); array.Resize(5); array.Fill(2); GD.Print(array); // Prints [2, 2, 2, 2, 2] \ **Note:** If ``value`` is a :ref:`Variant` passed by reference (:ref:`Object`-derived, **Array**, :ref:`Dictionary`, etc.), the array will be filled with references to the same ``value``, which are not duplicates. .. rst-class:: classref-item-separator ---- .. _class_Array_method_filter: .. rst-class:: classref-method :ref:`Array` **filter**\ (\ method\: :ref:`Callable`\ ) |const| :ref:`🔗` Calls the given :ref:`Callable` on each element in the array and returns a new, filtered **Array**. The ``method`` receives one of the array elements as an argument, and should return ``true`` to add the element to the filtered array, or ``false`` to exclude it. :: func is_even(number): return number % 2 == 0 func _ready(): print([1, 4, 5, 8].filter(is_even)) # Prints [4, 8] # Same as above, but using a lambda function. print([1, 4, 5, 8].filter(func(number): return number % 2 == 0)) See also :ref:`any`, :ref:`all`, :ref:`map` and :ref:`reduce`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_find: .. rst-class:: classref-method :ref:`int` **find**\ (\ what\: :ref:`Variant`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` Returns the index of the **first** occurrence of ``what`` in this array, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the end of the array. \ **Note:** If you just want to know whether the array contains ``what``, use :ref:`has` (``Contains`` in C#). In GDScript, you may also use the ``in`` operator. \ **Note:** For performance reasons, the search is affected by ``what``'s :ref:`Variant.Type`. For example, ``7`` (:ref:`int`) and ``7.0`` (:ref:`float`) are not considered equal for this method. .. rst-class:: classref-item-separator ---- .. _class_Array_method_find_custom: .. rst-class:: classref-method :ref:`int` **find_custom**\ (\ method\: :ref:`Callable`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` Returns the index of the **first** element in the array that causes ``method`` to return ``true``, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the end of the array. \ ``method`` is a callable that takes an element of the array, and returns a :ref:`bool`. \ **Note:** If you just want to know whether the array contains *anything* that satisfies ``method``, use :ref:`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` **front**\ (\ ) |const| :ref:`🔗` Returns the first element of the array. If the array is empty, fails and returns ``null``. See also :ref:`back`. \ **Note:** Unlike with the ``[]`` operator (``array[0]``), an error is generated without stopping project execution. .. rst-class:: classref-item-separator ---- .. _class_Array_method_get: .. rst-class:: classref-method :ref:`Variant` **get**\ (\ index\: :ref:`int`\ ) |const| :ref:`🔗` Returns the element at the given ``index`` in the array. This is the same as using the ``[]`` operator (``array[index]``). .. rst-class:: classref-item-separator ---- .. _class_Array_method_get_typed_builtin: .. rst-class:: classref-method :ref:`int` **get_typed_builtin**\ (\ ) |const| :ref:`🔗` Returns the built-in :ref:`Variant` type of the typed array as a :ref:`Variant.Type` constant. If the array is not typed, returns :ref:`@GlobalScope.TYPE_NIL`. See also :ref:`is_typed`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_get_typed_class_name: .. rst-class:: classref-method :ref:`StringName` **get_typed_class_name**\ (\ ) |const| :ref:`🔗` Returns the **built-in** class name of the typed array, if the built-in :ref:`Variant` type :ref:`@GlobalScope.TYPE_OBJECT`. Otherwise, returns an empty :ref:`StringName`. See also :ref:`is_typed` and :ref:`Object.get_class`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_get_typed_script: .. rst-class:: classref-method :ref:`Variant` **get_typed_script**\ (\ ) |const| :ref:`🔗` Returns the :ref:`Script` instance associated with this typed array, or ``null`` if it does not exist. See also :ref:`is_typed`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_has: .. rst-class:: classref-method :ref:`bool` **has**\ (\ value\: :ref:`Variant`\ ) |const| :ref:`🔗` Returns ``true`` if the array contains the given ``value``. .. tabs:: .. code-tab:: gdscript print(["inside", 7].has("inside")) # Prints true print(["inside", 7].has("outside")) # Prints false print(["inside", 7].has(7)) # Prints true print(["inside", 7].has("7")) # Prints false .. code-tab:: csharp var arr = new Godot.Collections.Array { "inside", 7 }; // By C# convention, this method is renamed to `Contains`. GD.Print(arr.Contains("inside")); // Prints true GD.Print(arr.Contains("outside")); // Prints false GD.Print(arr.Contains(7)); // Prints true GD.Print(arr.Contains("7")); // Prints false In GDScript, this is equivalent to the ``in`` operator: :: if 4 in [2, 4, 6, 8]: print("4 is here!") # Will be printed. \ **Note:** For performance reasons, the search is affected by the ``value``'s :ref:`Variant.Type`. For example, ``7`` (:ref:`int`) and ``7.0`` (:ref:`float`) are not considered equal for this method. .. rst-class:: classref-item-separator ---- .. _class_Array_method_hash: .. rst-class:: classref-method :ref:`int` **hash**\ (\ ) |const| :ref:`🔗` 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 countrary, 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` **insert**\ (\ position\: :ref:`int`, value\: :ref:`Variant`\ ) :ref:`🔗` Inserts a new element (``value``) at a given index (``position``) in the array. ``position`` should be between ``0`` and the array's :ref:`size`. Returns :ref:`@GlobalScope.OK` on success, or one of the other :ref:`Error` constants if this method fails. \ **Note:** Every element's index after ``position`` needs to be shifted forward, which may have a noticeable performance cost, especially on larger arrays. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_empty: .. rst-class:: classref-method :ref:`bool` **is_empty**\ (\ ) |const| :ref:`🔗` Returns ``true`` if the array is empty (``[]``). See also :ref:`size`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_read_only: .. rst-class:: classref-method :ref:`bool` **is_read_only**\ (\ ) |const| :ref:`🔗` Returns ``true`` if the array is read-only. See :ref:`make_read_only`. In GDScript, arrays are automatically read-only if declared with the ``const`` keyword. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_same_typed: .. rst-class:: classref-method :ref:`bool` **is_same_typed**\ (\ array\: :ref:`Array`\ ) |const| :ref:`🔗` Returns ``true`` if this array is typed the same as the given ``array``. See also :ref:`is_typed`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_is_typed: .. rst-class:: classref-method :ref:`bool` **is_typed**\ (\ ) |const| :ref:`🔗` Returns ``true`` if the array is typed. Typed arrays can only contain elements of a specific type, as defined by the typed array constructor. The methods of a typed array are still expected to return a generic :ref:`Variant`. In GDScript, it is possible to define a typed array with static typing: :: 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:`🔗` Makes the array read-only. The array's elements cannot be overridden with different values, and their order cannot change. Does not apply to nested elements, such as dictionaries. In GDScript, arrays are automatically read-only if declared with the ``const`` keyword. .. rst-class:: classref-item-separator ---- .. _class_Array_method_map: .. rst-class:: classref-method :ref:`Array` **map**\ (\ method\: :ref:`Callable`\ ) |const| :ref:`🔗` Calls the given :ref:`Callable` for each element in the array and returns a new array filled with values returned by the ``method``. The ``method`` should take one :ref:`Variant` parameter (the current array element) and can return any :ref:`Variant`. :: func double(number): return number * 2 func _ready(): print([1, 2, 3].map(double)) # Prints [2, 4, 6] # Same as above, but using a lambda function. print([1, 2, 3].map(func(element): return element * 2)) See also :ref:`filter`, :ref:`reduce`, :ref:`any` and :ref:`all`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_max: .. rst-class:: classref-method :ref:`Variant` **max**\ (\ ) |const| :ref:`🔗` Returns the maximum value contained in the array, if all elements can be compared. Otherwise, returns ``null``. See also :ref:`min`. To find the maximum value using a custom comparator, you can use :ref:`reduce`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_min: .. rst-class:: classref-method :ref:`Variant` **min**\ (\ ) |const| :ref:`🔗` Returns the minimum value contained in the array, if all elements can be compared. Otherwise, returns ``null``. See also :ref:`max`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_pick_random: .. rst-class:: classref-method :ref:`Variant` **pick_random**\ (\ ) |const| :ref:`🔗` Returns a random element from the array. Generates an error and returns ``null`` if the array is empty. .. tabs:: .. code-tab:: gdscript # May print 1, 2, 3.25, or "Hi". print([1, 2, 3.25, "Hi"].pick_random()) .. code-tab:: csharp var array = new Godot.Collections.Array { 1, 2, 3.25f, "Hi" }; GD.Print(array.PickRandom()); // May print 1, 2, 3.25, or "Hi". \ **Note:** Like many similar functions in the engine (such as :ref:`@GlobalScope.randi` or :ref:`shuffle`), this method uses a common, global random seed. To get a predictable outcome from this method, see :ref:`@GlobalScope.seed`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_pop_at: .. rst-class:: classref-method :ref:`Variant` **pop_at**\ (\ position\: :ref:`int`\ ) :ref:`🔗` Removes and returns the element of the array at index ``position``. If negative, ``position`` is considered relative to the end of the array. Returns ``null`` if the array is empty. If ``position`` is out of bounds, an error message is also generated. \ **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_pop_back: .. rst-class:: classref-method :ref:`Variant` **pop_back**\ (\ ) :ref:`🔗` Removes and returns the last element of the array. Returns ``null`` if the array is empty, without generating an error. See also :ref:`pop_front`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_pop_front: .. rst-class:: classref-method :ref:`Variant` **pop_front**\ (\ ) :ref:`🔗` Removes and returns the first element of the array. Returns ``null`` if the array is empty, without generating an error. See also :ref:`pop_back`. \ **Note:** This method shifts every other element's index back, which may have a noticeable performance cost, especially on larger arrays. .. rst-class:: classref-item-separator ---- .. _class_Array_method_push_back: .. rst-class:: classref-method |void| **push_back**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` Appends an element at the end of the array. See also :ref:`push_front`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_push_front: .. rst-class:: classref-method |void| **push_front**\ (\ value\: :ref:`Variant`\ ) :ref:`🔗` Adds an element at the beginning of the array. See also :ref:`push_back`. \ **Note:** This method shifts every other element's index forward, which may have a noticeable performance cost, especially on larger arrays. .. rst-class:: classref-item-separator ---- .. _class_Array_method_reduce: .. rst-class:: classref-method :ref:`Variant` **reduce**\ (\ method\: :ref:`Callable`, accum\: :ref:`Variant` = null\ ) |const| :ref:`🔗` Calls the given :ref:`Callable` for each element in array, accumulates the result in ``accum``, then returns it. The ``method`` takes two arguments: the current value of ``accum`` and the current array element. If ``accum`` is ``null`` (as by default), the iteration will start from the second element, with the first one used as initial value of ``accum``. :: func sum(accum, number): return accum + number func _ready(): print([1, 2, 3].reduce(sum, 0)) # Prints 6 print([1, 2, 3].reduce(sum, 10)) # Prints 16 # Same as above, but using a lambda function. print([1, 2, 3].reduce(func(accum, number): return accum + number, 10)) If :ref:`max` is not desirable, this method may also be used to implement a custom comparator: :: func _ready(): var arr = [Vector2(5, 0), Vector2(3, 4), Vector2(1, 2)] var longest_vec = arr.reduce(func(max, vec): return vec if is_length_greater(vec, max) else max) print(longest_vec) # Prints Vector2(3, 4). func is_length_greater(a, b): return a.length() > b.length() This method can also be used to count how many elements in an array satisfy a certain condition, similar to :ref:`count`: :: func is_even(number): return number % 2 == 0 func _ready(): var arr = [1, 2, 3, 4, 5] # Increment count if it's even, else leaves count the same. var even_count = arr.reduce(func(count, next): return count + 1 if is_even(next) else count, 0) print(even_count) # Prints 2 See also :ref:`map`, :ref:`filter`, :ref:`any` and :ref:`all`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_remove_at: .. rst-class:: classref-method |void| **remove_at**\ (\ position\: :ref:`int`\ ) :ref:`🔗` Removes the element from the array at the given index (``position``). If the index is out of bounds, this method fails. If you need to return the removed element, use :ref:`pop_at`. To remove an element by value, use :ref:`erase` instead. \ **Note:** This method shifts every element's index after ``position`` back, which may have a noticeable performance cost, especially on larger arrays. \ **Note:** The ``position`` cannot be negative. To remove an element relative to the end of the array, use ``arr.remove_at(arr.size() - (i + 1))``. To remove the last element from the array, use ``arr.resize(arr.size() - 1)``. .. rst-class:: classref-item-separator ---- .. _class_Array_method_resize: .. rst-class:: classref-method :ref:`int` **resize**\ (\ size\: :ref:`int`\ ) :ref:`🔗` Sets the array's number of elements to ``size``. If ``size`` is smaller than the array's current size, the elements at the end are removed. If ``size`` is greater, new default elements (usually ``null``) are added, depending on the array's type. Returns :ref:`@GlobalScope.OK` on success, or one of the other :ref:`Error` constants if this method fails. \ **Note:** Calling this method once and assigning the new values is faster than calling :ref:`append` for every new element. .. rst-class:: classref-item-separator ---- .. _class_Array_method_reverse: .. rst-class:: classref-method |void| **reverse**\ (\ ) :ref:`🔗` Reverses the order of all elements in the array. .. rst-class:: classref-item-separator ---- .. _class_Array_method_rfind: .. rst-class:: classref-method :ref:`int` **rfind**\ (\ what\: :ref:`Variant`, from\: :ref:`int` = -1\ ) |const| :ref:`🔗` Returns the index of the **last** occurrence of ``what`` in this array, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the beginning of the array. This method is the reverse of :ref:`find`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_rfind_custom: .. rst-class:: classref-method :ref:`int` **rfind_custom**\ (\ method\: :ref:`Callable`, from\: :ref:`int` = -1\ ) |const| :ref:`🔗` Returns the index of the **last** element of the array that causes ``method`` to return ``true``, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the beginning of the array. This method is the reverse of :ref:`find_custom`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_set: .. rst-class:: classref-method |void| **set**\ (\ index\: :ref:`int`, value\: :ref:`Variant`\ ) :ref:`🔗` Sets the value of the element at the given ``index`` to the given ``value``. This will not change the size of the array, it only changes the value at an index already in the array. This is the same as using the ``[]`` operator (``array[index] = value``). .. rst-class:: classref-item-separator ---- .. _class_Array_method_shuffle: .. rst-class:: classref-method |void| **shuffle**\ (\ ) :ref:`🔗` Shuffles all elements of the array in a random order. \ **Note:** Like many similar functions in the engine (such as :ref:`@GlobalScope.randi` or :ref:`pick_random`), this method uses a common, global random seed. To get a predictable outcome from this method, see :ref:`@GlobalScope.seed`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_size: .. rst-class:: classref-method :ref:`int` **size**\ (\ ) |const| :ref:`🔗` Returns the number of elements in the array. Empty arrays (``[]``) always return ``0``. See also :ref:`is_empty`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_slice: .. rst-class:: classref-method :ref:`Array` **slice**\ (\ begin\: :ref:`int`, end\: :ref:`int` = 2147483647, step\: :ref:`int` = 1, deep\: :ref:`bool` = false\ ) |const| :ref:`🔗` Returns a new **Array** containing this array's elements, from index ``begin`` (inclusive) to ``end`` (exclusive), every ``step`` elements. If either ``begin`` or ``end`` are negative, their value is relative to the end of the array. If ``step`` is negative, this method iterates through the array in reverse, returning a slice ordered backwards. For this to work, ``begin`` must be greater than ``end``. If ``deep`` is ``true``, all nested **Array** and :ref:`Dictionary` elements in the slice are duplicated from the original, recursively. See also :ref:`duplicate`). :: var letters = ["A", "B", "C", "D", "E", "F"] print(letters.slice(0, 2)) # Prints ["A", "B"] print(letters.slice(2, -2)) # Prints ["C", "D"] print(letters.slice(-2, 6)) # Prints ["E", "F"] print(letters.slice(0, 6, 2)) # Prints ["A", "C", "E"] print(letters.slice(4, 1, -1)) # Prints ["E", "D", "C"] .. rst-class:: classref-item-separator ---- .. _class_Array_method_sort: .. rst-class:: classref-method |void| **sort**\ (\ ) :ref:`🔗` Sorts the array in ascending order. The final order is dependent on the "less than" (``<``) comparison between elements. .. tabs:: .. code-tab:: gdscript var numbers = [10, 5, 2.5, 8] numbers.sort() print(numbers) # Prints [2.5, 5, 8, 10] .. code-tab:: csharp var numbers = new Godot.Collections.Array { 10, 5, 2.5, 8 }; numbers.Sort(); GD.Print(numbers); // Prints [2.5, 5, 8, 10] \ **Note:** The sorting algorithm used is not `stable `__. This means that equivalent elements (such as ``2`` and ``2.0``) may have their order changed when calling :ref:`sort`. .. rst-class:: classref-item-separator ---- .. _class_Array_method_sort_custom: .. rst-class:: classref-method |void| **sort_custom**\ (\ func\: :ref:`Callable`\ ) :ref:`🔗` Sorts the array using a custom :ref:`Callable`. \ ``func`` is called as many times as necessary, receiving two array elements as arguments. The function should return ``true`` if the first element should be moved *before* the second one, otherwise it should return ``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]] # Sort descending, using a lambda function. my_items.sort_custom(func(a, b): return a[1] > b[1]) print(my_items) # Prints [["Apple", 9], ["Tomato", 5], ["Rice", 4]] It may also be necessary to use this method to sort strings by natural order, with :ref:`String.naturalnocasecmp_to`, as in the following example: :: 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"] \ **Note:** In C#, this method is not supported. \ **Note:** The sorting algorithm used is not `stable `__. This means that values considered equal may have their order changed when calling this method. \ **Note:** You should not randomize the return value of ``func``, as the heapsort algorithm expects a consistent result. Randomizing the return value will result in unexpected behavior. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Operator Descriptions --------------------- .. _class_Array_operator_neq_Array: .. rst-class:: classref-operator :ref:`bool` **operator !=**\ (\ right\: :ref:`Array`\ ) :ref:`🔗` Returns ``true`` if the array's size or its elements are different than ``right``'s. .. rst-class:: classref-item-separator ---- .. _class_Array_operator_sum_Array: .. rst-class:: classref-operator :ref:`Array` **operator +**\ (\ right\: :ref:`Array`\ ) :ref:`🔗` Appends the ``right`` array to the left operand, creating a new **Array**. This is also known as an array concatenation. .. tabs:: .. code-tab:: gdscript var array1 = ["One", 2] var array2 = [3, "Four"] print(array1 + array2) # Prints ["One", 2, 3, "Four"] .. code-tab:: csharp // Note that concatenation is not possible with C#'s native Array type. var array1 = new Godot.Collections.Array{"One", 2}; var array2 = new Godot.Collections.Array{3, "Four"}; GD.Print(array1 + array2); // Prints ["One", 2, 3, "Four"] \ **Note:** For existing arrays, :ref:`append_array` is much more efficient than concatenation and assignment with the ``+=`` operator. .. rst-class:: classref-item-separator ---- .. _class_Array_operator_lt_Array: .. rst-class:: classref-operator :ref:`bool` **operator <**\ (\ right\: :ref:`Array`\ ) :ref:`🔗` Compares the elements of both arrays in order, starting from index ``0`` and ending on the last index in common between both arrays. For each pair of elements, returns ``true`` if this array's element is less than ``right``'s, ``false`` if this element is greater. Otherwise, continues to the next pair. If all searched elements are equal, returns ``true`` if this array's size is less than ``right``'s, otherwise returns ``false``. .. rst-class:: classref-item-separator ---- .. _class_Array_operator_lte_Array: .. rst-class:: classref-operator :ref:`bool` **operator <=**\ (\ right\: :ref:`Array`\ ) :ref:`🔗` Compares the elements of both arrays in order, starting from index ``0`` and ending on the last index in common between both arrays. For each pair of elements, returns ``true`` if this array's element is less than ``right``'s, ``false`` if this element is greater. Otherwise, continues to the next pair. If all searched elements are equal, returns ``true`` if this array's size is less or equal to ``right``'s, otherwise returns ``false``. .. rst-class:: classref-item-separator ---- .. _class_Array_operator_eq_Array: .. rst-class:: classref-operator :ref:`bool` **operator ==**\ (\ right\: :ref:`Array`\ ) :ref:`🔗` Compares the left operand **Array** against the ``right`` **Array**. Returns ``true`` if the sizes and contents of the arrays are equal, ``false`` otherwise. .. rst-class:: classref-item-separator ---- .. _class_Array_operator_gt_Array: .. rst-class:: classref-operator :ref:`bool` **operator >**\ (\ right\: :ref:`Array`\ ) :ref:`🔗` Compares the elements of both arrays in order, starting from index ``0`` and ending on the last index in common between both arrays. For each pair of elements, returns ``true`` if this array's element is greater than ``right``'s, ``false`` if this element is less. Otherwise, continues to the next pair. If all searched elements are equal, returns ``true`` if this array's size is greater than ``right``'s, otherwise returns ``false``. .. rst-class:: classref-item-separator ---- .. _class_Array_operator_gte_Array: .. rst-class:: classref-operator :ref:`bool` **operator >=**\ (\ right\: :ref:`Array`\ ) :ref:`🔗` Compares the elements of both arrays in order, starting from index ``0`` and ending on the last index in common between both arrays. For each pair of elements, returns ``true`` if this array's element is greater than ``right``'s, ``false`` if this element is less. Otherwise, continues to the next pair. If all searched elements are equal, returns ``true`` if this array's size is greater or equal to ``right``'s, otherwise returns ``false``. .. rst-class:: classref-item-separator ---- .. _class_Array_operator_idx_int: .. rst-class:: classref-operator :ref:`Variant` **operator []**\ (\ index\: :ref:`int`\ ) :ref:`🔗` Returns the :ref:`Variant` element at the specified ``index``. Arrays start at index 0. If ``index`` is greater or equal to ``0``, the element is fetched starting from the beginning of the array. If ``index`` is a negative value, the element is fetched starting from the end. Accessing an array out-of-bounds will cause a run-time error, pausing the project execution if run from the editor. .. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)` .. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)` .. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)` .. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)` .. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)` .. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)` .. |bitfield| replace:: :abbr:`BitField (This value is an integer composed as a bitmask of the following flags.)` .. |void| replace:: :abbr:`void (No return value.)`