Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Array

Une structure de données intégrée qui contient une suite d'éléments.

Description

An array data structure that can contain a sequence of elements of any Variant type by default. Values can optionally be constrained to a specific type by creating a typed array. 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.).

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"

# This typed array can only contain integers.
# Attempting to add any other type will result in an error.
var typed_array: Array[int] = [1, 2, 3]

Godot.Collections.Array array = ["First", 2, 3, "Last"];
GD.Print(array[0]); // Prints "First"
GD.Print(array[2]); // Prints 3
GD.Print(array[^1]); // Prints "Last"

array[1] = "Second";
GD.Print(array[1]); // Prints "Second"
GD.Print(array[^3]); // Prints "Second"

// This typed array can only contain integers.
// Attempting to add any other type will result in an error.
Godot.Collections.Array<int> typedArray = [1, 2, 3];

Note: Arrays are always passed by reference. To get a copy of an array that can be modified independently of the original array, use duplicate().

Note: Erasing elements while iterating over arrays is not supported and will result in unpredictable behavior.

Note: In a boolean context, an array will evaluate to false if it's empty ([]). Otherwise, an array will always evaluate to true.

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. 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 map(). Typed arrays are in turn faster to iterate on and modify than untyped arrays.

Note

Il y a des différences notables dans l'utilisation de cette API en C#. Voir Différences de l'API C# par rapport à GDScript pour plus d'informations.

Constructeurs

Array	Array()
Array	Array(base: Array, type: int, class_name: StringName, script: Variant)
Array	Array(from: Array)
Array	Array(from: PackedByteArray)
Array	Array(from: PackedColorArray)
Array	Array(from: PackedFloat32Array)
Array	Array(from: PackedFloat64Array)
Array	Array(from: PackedInt32Array)
Array	Array(from: PackedInt64Array)
Array	Array(from: PackedStringArray)
Array	Array(from: PackedVector2Array)
Array	Array(from: PackedVector3Array)
Array	Array(from: PackedVector4Array)

Méthodes

bool	all(method: Callable) const
bool	any(method: Callable) const
void	append(value: Variant)
void	append_array(array: Array)
void	assign(array: Array)
Variant	back() const
int	bsearch(value: Variant, before: bool = true) const
int	bsearch_custom(value: Variant, func: Callable, before: bool = true) const
void	clear()
int	count(value: Variant) const
Array	duplicate(deep: bool = false) const
Array	duplicate_deep(deep_subresources_mode: int = 1) const
void	erase(value: Variant)
void	fill(value: Variant)
Array	filter(method: Callable) const
int	find(what: Variant, from: int = 0) const
int	find_custom(method: Callable, from: int = 0) const
Variant	front() const
Variant	get(index: int) const
int	get_typed_builtin() const
StringName	get_typed_class_name() const
Variant	get_typed_script() const
bool	has(value: Variant) const
int	hash() const
int	insert(position: int, value: Variant)
bool	is_empty() const
bool	is_read_only() const
bool	is_same_typed(array: Array) const
bool	is_typed() const
void	make_read_only()
Array	map(method: Callable) const
Variant	max() const
Variant	min() const
Variant	pick_random() const
Variant	pop_at(position: int)
Variant	pop_back()
Variant	pop_front()
void	push_back(value: Variant)
void	push_front(value: Variant)
Variant	reduce(method: Callable, accum: Variant = null) const
void	remove_at(position: int)
int	resize(size: int)
void	reverse()
int	rfind(what: Variant, from: int = -1) const
int	rfind_custom(method: Callable, from: int = -1) const
void	set(index: int, value: Variant)
void	shuffle()
int	size() const
Array	slice(begin: int, end: int = 2147483647, step: int = 1, deep: bool = false) const
void	sort()
void	sort_custom(func: Callable)

Opérateurs

bool	operator !=(right: Array)
Array	operator +(right: Array)
bool	operator <(right: Array)
bool	operator <=(right: Array)
bool	operator ==(right: Array)
bool	operator >(right: Array)
bool	operator >=(right: Array)
Variant	operator [](index: int)

Descriptions des constructeurs

Array Array() 🔗

Construit un Array vide.

Array Array(base: Array, type: int, class_name: StringName, script: Variant)

Crée un tableau typé depuis le tableau base. Un tableau typé ne peut contenir que des éléments du type donné, ou qui héritent de la classe donnée, comme décrit par les paramètres du constructeur :

type est le type intégré Variant, en tant qu'une des constantes Variant.Type .
class_name est le nom de la classe intégrée (voir Object.get_class()).
script est le script associé. Il doit être une instance Script ou null.

Si type n'est pas @GlobalScope.TYPE_OBJECT, class_name doit être une chaîne StringName vide et script doit être null.

class_name Epee
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", Epee)       # Array[Epee]
    var d = Array([], TYPE_OBJECT, "RefCounted", Stats) # Array[Stats]

Les éléments du tableau base sont convertis si nécessaire. Si cela n'est pas possible ou que base est déjà typé, ce constructeur échoue et renvoie un Array vide.

En GDScript, ce constructeur n'est généralement pas nécessaire, car il est possible de créer un tableau typé par le typage statique :

var nombres: Array[float] = []
var enfants: Array[Node] = [$Node, $Sprite2D, $RigidBody3D]

var entiers: Array[int] = [0.2, 4.5, -2.0]
print(entiers) # Affiche [0, 4, -2]

Array Array(from: Array)

Renvoie le même tableau que from. Si vous avez besoin d'une copie du tableau, utilisez duplicate().

Array Array(from: PackedByteArray)

Construit un tableau à partir d'un PackedByteArray.

Array Array(from: PackedColorArray)

Construit un tableau à partir d'un PackedColorArray.

Array Array(from: PackedFloat32Array)

Construit un tableau à partir d'un PackedFloat32Array.

Array Array(from: PackedFloat64Array)

Construit un tableau à partir d'un PackedFloat64Array.

Array Array(from: PackedInt32Array)

Construit un tableau à partir d'un PackedInt32Array.

Array Array(from: PackedInt64Array)

Construit un tableau à partir d'un PackedInt64Array.

Array Array(from: PackedStringArray)

Construit un tableau à partir d'un PackedStringArray.

Array Array(from: PackedVector2Array)

Construit un tableau à partir d'un PackedVector2Array.

Array Array(from: PackedVector3Array)

Construit un tableau à partir d'un PackedVector3Array.

Array Array(from: PackedVector4Array)

Construit un tableau à partir d'un PackedVector4Array.

Descriptions des méthodes

bool all(method: Callable) const 🔗

Appelle le Callable donné sur chaque élément du tableau et renvoie true si le Callable renvoie true pour tous les éléments du tableau. Si le Callable renvoie false pour un élément du tableau ou plus, cette méthode renvoie false.

La méthode method devrait prendre un paramètre Variant (l'élément de tableau courant) et renvoyer un booléen bool.

func superieur_a_5(nombre):
    return nombre > 5

func _ready():
    print([6, 10, 6].all(superieur_a_5)) # Affiche true (3/3 éléments sont évalués à true).
    print([4, 10, 4].all(superieur_a_5)) # Affiche false (1/3 éléments sont évalués à true).
    print([4, 4, 4].all(superieur_a_5))  # Affiche false (0/3 éléments sont évalués à true).
    print([].all(superieur_a_5))         # Affiche true (0/0 éléments sont évalués à true).

    # Même chose que la première ligne du dessus, mais avec une fonction lambda.
    print([6, 10, 6].all(func(element): return element > 5)) # Affiche true

private static bool SuperieurA5(int nombre)
{
    return nombre > 5;
}

public override void _Ready()
{
    // Affiche True (3/3 éléments sont évalués à true).
    GD.Print(new Godot.Collections.Array<int> { 6, 10, 6 }.All(SuperieurA5));
    // Affiche False (1/3 éléments sont évalués à true).
    GD.Print(new Godot.Collections.Array<int> { 4, 10, 4 }.All(SuperieurA5));
    // Affiche False (0/3 éléments sont évalués à true).
    GD.Print(new Godot.Collections.Array<int> { 4, 4, 4 }.All(SuperieurA5));
    // Affiche True (0/0 éléments sont évalués à true).
    GD.Print(new Godot.Collections.Array<int> { }.All(SuperieurA5));

    // Même chose que la première ligne du dessus, mais avec une fonction lambda.
    GD.Print(new Godot.Collections.Array<int> { 6, 10, 6 }.All(element => element > 5)); // Affiche True
}

Voir aussi any(), filter(), map() et reduce().

Note : Au lieu de se baser sur la taille du tableau renvoyé par filter(), cette méthode renverra le résultat le plus tôt possible pour améliorer les performances (en particulier avec de grands tableaux).

Note : Pour un tableau vide, cette méthode renvoie toujours true.

bool any(method: Callable) const 🔗

Appelle le Callable donné sur chaque élément du tableau et renvoie true si le Callable renvoie true pour un ou plusieurs éléments dans le tableau. Si le Callable renvoie false pour tous les éléments du tableau, cette méthode renvoie false.

La méthode method devrait prendre un paramètre Variant (l'élément de tableau courant) et renvoyer un bool.

func superieur_a_5(nombre):
    return number > 5

func _ready():
    print([6, 10, 6].any(superieur_a_5)) # Affiche true (3 éléments sont évalués à true).
    print([4, 10, 4].any(superieur_a_5)) # Affiche true (1 élément est évalué à true).
    print([4, 4, 4].any(superieur_a_5))  # Affiche false (0 éléments sont évalués à true).
    print([].any(superieur_a_5))         # Affiche false (0 éléments sont évalués à true).

    # Comme la première ligne au dessus, mais en utilisant une fonction lambda.
    print([6, 10, 6].any(func(nombre): return nombre > 5)) # Affiche true

Voir aussi all(), filter(), map() et reduce().

Note : Au lieu de se baser sur la taille du tableau renvoyé par filter(), cette méthode renverra le résultat le plus tôt possible pour améliorer les performances (en particulier avec de grands tableaux).

Note : Pour un tableau vide, cette méthode renvoie toujours false.

void append(value: Variant) 🔗

Ajoute une valeur value à la fin du tableau (alias de push_back()).

void append_array(array: Array) 🔗

Ajoute un autre tableau array à la fin de ce tableau.

var numbers = [1, 2, 3]
var extra = [4, 5, 6]
numbers.append_array(extra)
print(numbers) # Affiche [1, 2, 3, 4, 5, 6].

void assign(array: Array) 🔗

Attribue des éléments d'un autre tableau array dans le tableau. Redimensionne le tableau pour correspondre à array. Effectue les conversions de type si le tableau est typé.

Variant back() const 🔗

Renvoie le dernier élément du tableau. Si le tableau est vide, affiche une erreur et renvoie null. Voir aussi front().

Note : Différemment de l'opérateur [] (array[-1]), une erreur est générée sans arrêter l'exécution du projet.

int bsearch(value: Variant, before: bool = true) const 🔗

Renvoie l'index de la valeur value dans le tableau trié. Si elle ne peut pas être trouvée, renvoie où value doit être insérée pour garder le tableau trié. L'algorithme utilisé est la recherche dichotomique.

Si before vaut true (comme par défaut), l'index renvoyé arrive avant tous les éléments existants égaux à value dans le tableau.

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

nombres.insert(idx, 7)
print(nombres) # Affiche [2, 4, 7, 8, 10]

var fruits = ["Pomme", "Citron", "Citron", "Orange"]
print(fruits.bsearch("Citron", true) # Affiche 1, pointe vers le premier "Citron".
print(fruits.bsearch("Citron", false) # Affiche 3, pointe vers "Orange".

Note : Appeler bsearch() sur un tableau non trié résultera en un comportement inattendu. Utilisez sort() avant d'appeler cette méthode.

int bsearch_custom(value: Variant, func: Callable, before: bool = true) const 🔗

Renvoie l'index de la valeur value dans le tableau trié. Si elle ne peut pas être trouvée, renvoie où value doit être insérée pour garder le tableau trié (en utilisant func pour les comparaisons). L'algorithme utilisé est la recherche dichotomique.

Semblable à sort_custom(), func est appelé autant de fois que nécessaire, recevant un élément du tableau et value comme arguments. La fonction doit renvoyer true si l'élément du tableau devrait être derrière value, sinon elle devrait renvoyer false.

Si before vaut true (comme par défaut), l'index renvoyé arrive avant tous les éléments existants égaux à value dans le tableau.

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

func _ready():
    var mes_objets = [["Tomate", 2], ["Kiwi", 5], ["Riz", 9]]

    var pomme = ["Pomme", 5]
    # "Pomme" est inséré avant "Kiwi".
    mes_objets.insert(mes_objets .bsearch_custom(pomme , trier_par_quantite, true), pomme)

    var banane = ["Banane", 5]
    # "Banane" est inséré après "Kiwi".
    mes_objets .insert(mes_objets .bsearch_custom(banane, trier_par_quantite, false), banane)

    # Affiche [["Tomate", 2], ["Pomme", 5], ["Kiwi", 5], ["Banane", 5], ["Riz", 9]]
    print(mes_objets )

Note : Appeler bsearch_custom() sur un tableau non trié résultera en un comportement inattendu. Utilisez sort_custom() avec func avant d'appeler cette méthode.

void clear() 🔗

Retire tous les éléments du tableau. C'est équivalent à utiliser resize() avec une taille de 0.

int count(value: Variant) const 🔗

Renvoie le nombre de fois qu'un élément est dans le tableau.

Pour compter combien d'éléments dans un tableau satisfont une condition, voir reduce().

Array duplicate(deep: bool = false) const 🔗

Renvoie une nouvelle copie du tableau.

Par défaut, une copie superficielle est renvoyée : tous les éléments Array, Dictionary et Resource imbriqués sont partagés avec le tableau original. Modifier l'un d'eux dans un tableau les affectera également dans l'autre.

Si deep vaut true, une copie profonde est renvoyée : tous les tableaux et dictionnaires imbriqués sont également dupliqués (récursivement). Cependant, toute Resource est toujours partagée avec le tableau original.

Array duplicate_deep(deep_subresources_mode: int = 1) const 🔗

Duplicates this array, deeply, like duplicate() when passing true, with extra control over how subresources are handled.

deep_subresources_mode must be one of the values from DeepDuplicateMode. By default, only internal resources will be duplicated (recursively).

void erase(value: Variant) 🔗

Trouve et supprime la première occurrence de la valeur value du tableau. Si value n'existe pas dans le tableau, rien ne se passe. Pour supprimer un élément par index, utilisez remove_at() à la place.

Note : Cette méthode déplace l'index de chaque élément après la valeur value supprimée en arrière, ce qui peut avoir un coût de performance notable, en particulier sur les tableaux plus grands.

Note : Effacer des éléments lors de l'itération d'un tableau n'est pas supporté et va résulter en un comportement imprévisible.

void fill(value: Variant) 🔗

Assigne la valeur value à tous les éléments du tableau.

Cette méthode est souvent combinée avec resize() pour créer un tableau d'une taille donnée avec tous ses éléments initialisés :

var array = []
array.resize(5)
array.fill(2)
print(array) # Affiche [2, 2, 2, 2, 2]

Godot.Collections.Array array = [];
array.Resize(5);
array.Fill(2);
GD.Print(array); // Affiche [2, 2, 2, 2, 2]

Note: Si value est un Variant passé par référence (dérivé de Object, Array, Dictionary, etc...), le tableau sera rempli de référence à la même valeur value, qui ne seront pas des dupliqués.

Array filter(method: Callable) const 🔗

Appelle le Callable donné sur chaque élément dans le tableau et renvoie un nouveau tableau Array filtré.

La méthode method reçoit l'un des éléments du tableau comme argument, et devrait renvoyer true pour ajouter l'élément au tableau filtré, ou false pour l'exclure.

func est_pair(nombre):
    return nombre % 2 == 0

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

    # Comme la première ligne au dessus, mais en utilisant une fonction lambda.
    print([1, 4, 5, 8].filter(func(nombre): return nombre % 2 == 0))

Voir aussi any(), all(), map() et reduce().

int find(what: Variant, from: int = 0) const 🔗

Renvoie l'index de la première occurrence de l'objet what dans ce tableau, ou -1 s'il n'y en a pas. Le début de la recherche peut être spécifié avec from, continuant vers la fin du tableau.

Note : Si vous voulez juste savoir si le tableau contient what, utilisez has() (Contains en C#). En GDScript, vous pouvez aussi utiliser l'opérateur in.

Note : Pour des raisons de performance, la recherche est affectée par le type de variant Variant.Type de what. Par exemple, 7 (un entier int) et 7.0 (un flottant float) ne sont pas considérés égaux pour cette méthode.

int find_custom(method: Callable, from: int = 0) const 🔗

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

Note: If you just want to know whether the array contains anything that satisfies method, use any().

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

func _ready():
    print([1, 3, 4, 7].find_custom(is_even.bind())) # Prints 2

# Another example using `bind()` to pass an additional parameter:
func is_specific_number(number, expected):
    return number == expected

func _ready():
    print([1, 3, 4, 7].find_custom(is_specific_number.bind(4))) # Prints 2

Variant front() const 🔗

Renvoie le premier élément du tableau. Si le tableau est vide, échoue et renvoie null. Voir aussi back().

Note : Contrairement à l'opérateur [] (array[0]), une erreur est générée sans arrêter l'exécution du projet.

Variant get(index: int) const 🔗

Renvoie l'élément à l'index index du tableau. Si index est hors des limites ou négatif, cette méthode échoue et renvoie null.

Cette méthode est similaire (mais pas identique) à l'opérateur []. Plus particulièrement, lorsque cette méthode échoue, elle ne met pas en pause l'exécution de projet si elle est exécutée depuis l'éditeur.

int get_typed_builtin() const 🔗

Renvoie le type intégré Variant du tableau typé en tant que constante Variant.Type. Si le tableau n'est pas typé , renvoie @GlobalScope.TYPE_NIL. Voir aussi is_typed().

StringName get_typed_class_name() const 🔗

Renvoie le nom de classe intégré du tableau typé, si le type intégré Variant est @GlobalScope.TYPE_OBJECT. Sinon, renvoie un StringName vide. Voir aussi is_typed() et Object.get_class().

Variant get_typed_script() const 🔗

Renvoie l'instance Script associée à ce tableau typé, ou null si elle n'existe pas. Voir aussi is_typed().

bool has(value: Variant) const 🔗

Renvoie true si le tableau contient la valeur value donnée.

print(["dedans", 7].has("dedans"))  # Affiche true
print(["dedans", 7].has("dehors")) # Affiche false
print(["dedans", 7].has(7))         # Affiche true
print(["dedans", 7].has("7"))       # Affiche false

Godot.Collections.Array tab = ["dedans", 7];
// Par convention C#, cette méthode est renommée en `Contains`.
GD.Print(arr.Contains("dedans"));  // Affiche True
GD.Print(arr.Contains("dehors")); // Affiche False
GD.Print(arr.Contains(7));         // Affiche True
GD.Print(arr.Contains("7"));       // Affiche False

En GDScript, c'est équivalent à l'opérateur in :

if 4 in [2, 4, 6, 8]:
    print("4 est là!") # Sera affiché.

Note : Pour des raisons de performances, la recherche est affectée par le type de variant Variant.Type de value. Par exemple, 7 (un entier int) et 7.0 (un flottant float) ne sont pas considérés comme égaux pour cette méthode.

int hash() const 🔗

Renvoie un entier 32 bits haché représentant le tableau et son contenu.

Note : Les tableaux avec des valeurs de hachage égales ne sont pas garantis d'être les même, à cause des collisions de hachage. Au contraire, les tableaux avec différentes valeurs de hachage sont garantis d'être différents.

int insert(position: int, value: Variant) 🔗

Insère un nouvel élément (value) à un index donné (position) dans le tableau. position devrait être entre 0 et la taille (size()) du tableau. Si négatif, position est considéré comme relatif à la fin du tableau.

Renvoie @GlobalScope.OK lors du succès, ou l'une des autres constantes Error si cette méthode échoue.

Note : L'index de chaque élément après position doit être déplacé vers l'avant, ce qui peut avoir un coût de performance notable, en particulier sur les tableaux plus grands.

bool is_empty() const 🔗

Renvoie true si le tableau est vide ([]. Voir aussi size().

bool is_read_only() const 🔗

Renvoie true si le tableau est en lecture seule. Voir make_read_only().

En GDScript, les tableaux sont automatiquement en lecture seule s'ils sont déclarés avec le mot-clé const.

bool is_same_typed(array: Array) const 🔗

Renvoie true si ce tableau est typé de la même manière que le tableau array donné. Voir aussi is_typed().

bool is_typed() const 🔗

Renvoie true si le tableau est typé. Les tableaux typés peuvent contenir uniquement des éléments d'un type spécifique, tel que défini par le constructeur du tableau typé. Les méthodes d'un tableau typé sont toujours censées renvoyer un Variant générique.

En GDScript, il est possible de définir un tableau typé avec le typage statique :

var nombres: Array[float] = [0.2, 4.2, -2.0]
print(nombres.is_typed()) # Affiche true

void make_read_only() 🔗

Rend le tableau en lecture seule. Les éléments du tableau ne peuvent être remplacés par des valeurs différentes, et leur ordre ne peut pas changer. Ne s'applique pas aux éléments imbriqués, comme les dictionnaires.

En GDScript, les tableaux sont automatiquement en lecture seule s'ils sont déclarés avec le mot-clé const.

Array map(method: Callable) const 🔗

Appelle le Callable donné pour chaque élément dans le tableau et renvoie un nouveau tableau rempli de valeurs renvoyées par la méthode method

La méthode method devrait prendre un paramètre Variant (l'élément de tableau courant) et peut renvoyer n'importe quel Variant.

func doubler(nombre):
    return nombre * 2

func _ready():
    print([1, 2, 3].map(doubler)) # Affiche [2, 4, 6]

    # La même qu'au dessus, mais en utilisant une fonction lambda.
    print([1, 2, 3].map(func(element): return element * 2))

Voir aussi filter(), reduce(), any() et all().

Variant max() const 🔗

Renvoie la valeur maximale contenue dans le tableau, si tous les éléments peuvent être comparés. Sinon, renvoie null. Voir aussi min().

Pour trouver la valeur maximale en utilisant un comparateur personnalisé, vous pouvez utiliser reduce().

Variant min() const 🔗

Renvoie la valeur minimale contenue dans le tableau si tous les éléments peuvent être comparés entre eux. Si les éléments ne peuvent pas être comparés, renvoie null. Voir aussi max().

Variant pick_random() const 🔗

Renvoie un élément aléatoire du tableau. Génère une erreur et renvoie null si le tableau est vide.

# Peut afficher 1, 2, 3.25, ou "Salut".
print([1, 2, 3.25, "Salut"].pick_random())

Godot.Collections.Array tableau = [1, 2, 3.25f, "Salut"];
GD.Print(tableau.PickRandom()); // Peut afficher 1, 2, 3.25, ou "Salut".

Note : Comme beaucoup de fonctions similaires dans le moteur (comme @GlobalScope.randi() ou shuffle()), cette méthode utilise une graine aléatoire commune et globale. Pour obtenir un résultat prévisible de cette méthode, voir @GlobalScope.seed().

Variant pop_at(position: int) 🔗

Retire et renvoie l'élément du tableau à l'index position. Si la position est négative, elle est considérée par rapport à la fin du tableau. Renvoie null si le tableau est vide. Si position est hors des limites, un message d'erreur est également généré.

Note : Cette méthode déplace l'index de chaque élément après position vers l'arrière, ce qui peut avoir un coût de performance notable, en particulier sur les tableaux plus grands.

Variant pop_back() 🔗

Retire et renvoie le dernier élément du tableau. Renvoie null si le tableau est vide, sans affiche de message d'erreur. Voir aussi pop_front().

Variant pop_front() 🔗

Retire et renvoie le premier élément du tableau. Renvoie null si le tableau est vide, sans générer d'erreur. Voir aussi pop_back().

Note : Cette méthode déplace l'index de chaque autre élément en arrière, ce qui peut avoir un coût de performance notable, en particulier sur les tableaux plus grands.

void push_back(value: Variant) 🔗

Ajout un élément à la fin du tableau. Voir aussi push_front().

void push_front(value: Variant) 🔗

Ajoute un élément au début du tableau. Voir aussi push_back().

Note : Cette méthode déplace l'index de chaque autre élément vers l'avant, ce qui peut avoir un coût de performance notable, en particulier sur les tableaux plus grands.

Variant reduce(method: Callable, accum: Variant = null) const 🔗

Appelle l'appelable Callable pour chaque élément du tableau, accumule le résultat dans l'accumulateur accum, puis le renvoie.

La méthode method prend deux arguments : la valeur actuelle de accum et l'élément du tableau actuel. Si accum est null (comme par défaut), l'itération va commencer au second élément, avec le premier élément utilisé comme valeur initiale de accum.

func somme(accum, nombre):
    return accum + nombre

func _ready():
    print([1, 2, 3].reduce(somme, 0))  # Affiche 6
    print([1, 2, 3].reduce(somme, 10)) # Affiche 16

    # Comme au dessus, mais avec une fonction lambda.
    print([1, 2, 3].reduce(func(accum, nombre): return accum + nombre, 10))

Si max() n'est pas désirable, cette méthode peut aussi être utilisé pour implémenter un comparateur personnalisé :

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

    var vecteur_le_plus_long = arr.reduce(func(max, vec): return vec if est_plus_long(vec, max) else max)
    print(vecteur_le_plus_long) # Affiche (3, 4)

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

Cette méthode peut aussi être utilisée pour compter combien d'éléments dans un tableau satisfont une condition donné, comme avec count() :

func est_pair(nombre):
    return nombre % 2 == 0

func _ready():
    var arr = [1, 2, 3, 4, 5]
    # Si l'élément actuel est pair, incrémente le compte, sinon laisse le compte inchangé.
    var compte_pair = arr.reduce(func(compte, prochain): return compte + 1 if est_pair(prochain) else compte, 0)
    print(compte_pair ) # Affiche 2

Voir aussi map(), filter(), any(), et all().

void remove_at(position: int) 🔗

Retire l'élément du tableau à l'index donné (position). Si l'index est hors des limites, cette méthode échoue. Si l'index est négatif, position est considéré comme relatif par rapport à la fin du tableau.

Si vous devez renvoyer l'élément enlevé, utilisez pop_at(). Pour supprimer un élément par valeur, utilisez plutôt erase().

Note : Cette méthode déplace l'index de chaque élément après position en arrière, ce qui peut avoir un coût en performance notable, en particulier sur les grands tableaux.

int resize(size: int) 🔗

Définit le nombre d'éléments du tableau à la taille size. Si size est plus petite que la taille actuelle du tableau, les éléments à la fin sont enlevés. Si size est plus grande, de nouveaux éléments par défaut (généralement null) sont ajoutés, selon le type du tableau.

Renvoie @GlobalScope.OK lors du succès, ou l'une des constantes Error suivantes si cette méthode échoue : @GlobalScope.ERR_LOCKED si le tableau est en lecture seule, @GlobalScope.ERR_INVALID_PARAMETER si la taille est négative, ou @GlobalScope.ERR_OUT_OF_MEMORY si les allocations échouent. Utilisez size() pour trouver la taille réelle du tableau après le redimensionnement.

Note : Appeler cette méthode une fois et attribuer les nouvelles valeurs est plus rapide que d'appeler append() pour chaque nouvel élément.

void reverse() 🔗

Inverse l'ordre des éléments du tableau.

int rfind(what: Variant, from: int = -1) const 🔗

Renvoie l'index de la dernière occurrence de l'objetwhat dans ce tableau, ou -1 s'il n'y en a pas. Le début de la recherche peut être spécifié avec from, continuant vers le début du tableau. Cette méthode est l'inverse de find().

int rfind_custom(method: Callable, from: int = -1) const 🔗

Renvoie l'index du dernier élément du tableau qui provoque method de renvoyer true, ou -1 s'il n'y en a pas. Le début de la recherche peut être spécifié avec from, continuant vers le début du tableau. Cette méthode est l'inverse de find_custom().

void set(index: int, value: Variant) 🔗

Définit la valeur de l'élément à la position index donné à la valeur value donnée. Cela ne changera pas la taille du tableau, ça ne change que la valeur à un index déjà dans le tableau. Cela revient à utiliser l'opérateur [] (``array[index] = value ``).

void shuffle() 🔗

Mélange tous les éléments du tableau dans un ordre aléatoire.

Note : Comme beaucoup de fonctions similaires dans le moteur (comme @GlobalScope.randi() ou pick_random()), cette méthode utilise une graine aléatoire commune et globale. Pour obtenir un résultat prévisible de cette méthode, voir @GlobalScope.seed().

int size() const 🔗

Renvoie le nombre d'éléments dans le tableau. Les tableaux vides ([]) renvoient toujours 0. Voir aussi is_empty().

Array slice(begin: int, end: int = 2147483647, step: int = 1, deep: bool = false) const 🔗

Renvoie un nouveau tableau Array contenant les éléments de ce tableau, de l'index begin (inclusif) à end (exclusif), tous les step éléments.

Si begin ou end sont négatifs, leur valeur est relative par rapport à la fin du tableau.

Si step est négatif, cette méthode itère à travers le tableau en marche arrière, renvoyant une tranche triée en inverse. Pour que cela fonctionne, begin doit être supérieur à end.

Si deep vaut true, tous les éléments Array et Dictionary imbriqués de la tranche sont dupliqués de l'original, récursivement. Voir aussi duplicate().

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

print(letters.slice(0, 2) # Affiche ["A", "B"]
print(letters.slice(2, -2)) # Affiche ["C", "D"]
print(letters.slice(-2, 6)) # Affiche ["E", "F"]

print(letters.slice(0, 6, 2)   # Affiche ["A", "C", "E"]
print(letters.slice(4, 1, -1)) # Affiche ["E", "D", "C"]

void sort() 🔗

Trie le tableau dans l'ordre ascendant. L'ordre final dépend de la comparaison "inférieur à" (<) entre les éléments.

var nombres = [10, 5, 2.5, 8]
nombres .sort()
# Affiche [2.5, 5, 8, 10]

Godot.Collections.Array nombres = [10, 5, 2.5, 8];
nombres.Sort();
GD.Print(nombres); // Affiche [2.5, 5, 8, 10]

Note : L'algorithme de tri utilisé n'est pas stable. Cela signifie que les éléments équivalents (tels que 2 et 2.0) peuvent avoir leur ordre modifié lors de l'appel de sort().

void sort_custom(func: Callable) 🔗

Trie le tableau en utilisant un appelable Callable personnalisé.

func est appelé autant de fois que nécessaire, recevant deux éléments de tableau comme arguments. La fonction devrait renvoyer true si le premier élément doit être déplacé avant le deuxième, sinon elle devrait renvoyer false.

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

func _ready():
    var mes_objets = [["Tomate", 5], ["Pomme", 9], ["Riz", 4]]
    mes_objets.sort_custom(tri_ascendant)
    print(mes_objets) # Affiche [["Riz", 4], ["Tomate", 5], ["Pomme", 9]]

    # Tri descendant, mais avec une fonction lambda.
    mes_objets.sort_custom(func(a, b): return a[1] > b[1])
    print(mes_objets) # Affiche [["Pomme", 9], ["Tomate", 5], ["Riz", 4]]

Il peut être aussi nécessaire d'utiliser cette méthode pour trier des chaînes de caractères dans l'ordre naturel, avec String.naturalnocasecmp_to(), comme dans l’exemple suivant :

var fichiers = ["nouveauficher1", "nouveauficher2", "nouveauficher10", "nouveauficher11"]
fichiers.sort_custom(func(a, b): return a.naturalnocasecmp_to(b) < 0)
print(files) # Affiche ["nouveauficher1", "nouveauficher2", "nouveauficher10", "nouveauficher11"]

Note : En C#, cette méthode n'est pas supportée.

Note : L'algorithme de tri utilisé n'est pas stable. Cela signifie que les valeurs considérées comme égales peuvent avoir changé leur ordre en appelant cette méthode.

Note : Vous ne devriez pas randomiser la valeur de retour de func, car l'algorithme de tri par tas s'attend à un résultat consistant. Randomiser la valeur de retour va résulter en un comportement inattendu.

Descriptions des opérateurs

bool operator !=(right: Array) 🔗

Renvoie true si la taille du tableau ou ses éléments sont différent de ceux du tableau right.

Array operator +(right: Array) 🔗

Ajoute le tableau right à l'opérande de gauche, créant un nouvel Array. Ceci est également connu comme une concaténation de tableau.

var tableau1 = ["Un", 2]
var tableau2 = [3, "Quatre"]
print(tableau1 + tableau2) # Affiche ["Un", 2, 3, "Quatre"]

// Notez que la concaténation n'est pas possible avec le type Array natif de C#.
Godot.Collections.Array tableau1 = ["Un", 2];
Godot.Collections.Array tableau2 = [3, "Quatre"];
GD.Print(tableau1 + tableau2 ); // Affiche ["Un", 2, 3, "Quatre"]

Note: Pour les tableaux existants, append_array() est beaucoup plus efficace que la concaténation et l'affectation avec l'opérateur +=.

bool operator <(right: Array) 🔗

Compare les éléments des deux tableaux dans l'ordre, à partir de l'index 0 et se terminant sur le dernier index en commun entre les deux tableaux. Pour chaque paire d'éléments, renvoie true si l'élément de ce tableau est inférieur à celui de right, false si cet élément est supérieur. Sinon, continue avec la paire suivante.

Si tous les éléments cherchés sont égaux, renvoie true si la taille de ce tableau est inférieure à celle de right, sinon renvoie false.

bool operator <=(right: Array) 🔗

Compare les éléments des deux tableaux dans l'ordre, à partir de l'index 0 et se terminant sur le dernier index en commun entre les deux tableaux. Pour chaque paire d'éléments, renvoie true si l'élément de ce tableau est inférieur à celui de right, false si cet élément est supérieur. Sinon, continue avec la paire suivante.

Si tous les éléments cherchés sont égaux, renvoie true si la taille de ce tableau est inférieure ou égale à celle de right, sinon renvoie false.

bool operator ==(right: Array) 🔗

Compare l'opérande gauche Array contre l'opérande droite Array right. Renvoie true si les dimensions et le contenu des tableaux sont égaux, false sinon.

bool operator >(right: Array) 🔗

Compare les éléments des deux tableaux dans l'ordre, à partir de l'index 0 et se terminant sur le dernier index en commun entre les deux tableaux. Pour chaque paire d'éléments, renvoie true si l'élément de ce tableau est supérieur à celui de right, false si cet élément est inférieur. Sinon, continue avec la paire suivante.

Si tous les éléments cherchés sont égaux, renvoie true si la taille de ce tableau est inférieure à celle de right, sinon renvoie false.

bool operator >=(right: Array) 🔗

Compare les éléments des deux tableaux dans l'ordre, à partir de l'index 0 et se terminant sur le dernier index en commun entre les deux tableaux. Pour chaque paire d'éléments, renvoie true si l'élément de ce tableau est supérieur à celui de right, false si cet élément est inférieur. Sinon, continue avec la paire suivante.

Si tous les éléments cherchés sont égaux, renvoie true si la taille de ce tableau est supérieure ou égale à celle de right, sinon renvoie false.

Variant operator [](index: int) 🔗

Renvoie l'élément Variant à la position index spécifiée. Les tableaux commencent à l'index 0. Si index est supérieur ou égal à 0, l'élément est récupéré à partir du début du tableau. Si index est une valeur négative, l'élément est récupéré à partir de la fin. L'accès à un tableau hors des limites causera une erreur d'exécution, mettant en pose l'exécution du projet s'il est exécuté depuis l'éditeur.