Class Lists

Insère un élément à une position ; les éléments à partir de cette position se décalent d'une place.

Exemple : [10, 20, 30, 40] avec 99 à l'index 2 -> [10, 20, 99, 30, 40]

Insère le même élément à plusieurs positions de la liste d'origine.

Exemple : [10, 20, 30] avec 99 aux index [0, 2] -> [99, 10, 20, 99, 30]

Insère plusieurs éléments, le premier au premier index, le second au second, et ainsi de suite, tous comptés sur la liste d'origine.

Les index doivent être par ordre croissant et il doit y en avoir un par élément, sinon une erreur est levée. Exemple : [10, 20, 30] avec les éléments [88, 99] aux index [1, 2] -> [10, 88, 20, 99, 30]

Ajoute un élément à la fin de la liste.

Exemple : [10, 20, 30] en ajoutant 40 -> [10, 20, 30, 40]

Ajoute un élément au début de la liste.

Exemple : [10, 20, 30] en ajoutant 5 au début -> [5, 10, 20, 30]

Ajoute un élément au début ou à la fin de la liste, au choix.

Exemple : [10, 20, 30] en ajoutant 5 au début -> [5, 10, 20, 30] ; à la fin -> [10, 20, 30, 5]

Joint plusieurs listes en une seule, bout à bout.

Exemple : [[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]

Crée une nouvelle liste sans rien dedans.

Exemple : -> []

Crée une liste qui contient le même élément un certain nombre de fois.

Exemple : 5 trois fois -> [5, 5, 5]

Répète un motif d'éléments encore et encore jusqu'à ce que la liste atteigne une longueur donnée.

Exemple : [1, 2, 3] jusqu'à la longueur 7 -> [1, 2, 3, 1, 2, 3, 1]

Inverse l'ordre des éléments.

Exemple : [1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]

Met les éléments dans un ordre aléatoire, différent à chaque appel.

Exemple : [1, 2, 3, 4, 5] -> peut-être [3, 1, 5, 2, 4]

Bascule une liste de listes sur le côté : les lignes deviennent des colonnes et les colonnes des lignes.

Toutes les listes intérieures doivent avoir la même longueur. Exemple : [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]

Répartit la liste en groupes de n éléments.

Les éléments restants à la fin sont ignorés sauf si keepRemainder est actif, qui les ajoute comme un dernier groupe plus court. Exemple : [0, 1, 2, 3, 4, 5, 6, 7, 8] en groupes de 3 -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

Lit l'élément à une position de la liste, en comptant à partir de 0.

Un index hors de la liste lève une erreur. Exemple : [10, 20, 30, 40] à l'index 2 -> 30

Lit le premier élément de la liste.

Exemple : [10, 20, 30, 40] -> 10

Lit le dernier élément de la liste.

Exemple : [10, 20, 30, 40] -> 40

Garde chaque élément de la liste avec une probabilité donnée et supprime les autres, le résultat diffère donc à chaque appel.

Exemple : [1, 2, 3, 4, 5] avec le seuil 0.5 -> peut-être [1, 3, 5]

Découpe les éléments d'un index de début jusqu'à un index de fin, non compris.

Exemple : [10, 20, 30, 40, 50] de 1 à 4 -> [20, 30, 40]

Garde chaque n-ième élément, à partir d'un décalage.

Exemple : [0, 1, 2, 3, 4, 5, 6, 7, 8] avec nth 3 et décalage 0 -> [0, 3, 6] ; avec nth 2 et décalage 1 -> [1, 3, 5, 7]

Garde les éléments là où un motif vrai/faux répété dit vrai et supprime les autres.

Le motif recommence quand il est épuisé. Exemple : [0, 1, 2, 3, 4, 5] avec le motif [true, true, false] -> [0, 1, 3, 4]

Regroupe des listes imbriquées par position : les premiers éléments de chaque liste vont ensemble, puis les deuxièmes éléments, et ainsi de suite.

level dit combien de niveaux d'imbrication aplatir d'abord dans chaque liste ; 0 les regroupe telles quelles. Exemple : [[0, 1, 2], [3, 4, 5]] au niveau 0 -> [[0, 3], [1, 4], [2, 5]]

Mesure la liste la plus longue parmi plusieurs.

Exemple : [[1, 2], [3, 4, 5, 6], [7]] -> 4

Indique si un élément est dans la liste.

Les éléments sont comparés par identité, un objet n'est donc trouvé que si exactement le même objet est dans la liste. Exemple : [10, 20, 30, 40] contient 30 -> true, contient 50 -> false

Trouve la position de la première occurrence d'un élément, ou -1 quand il n'est pas dans la liste.

Exemple : [10, 20, 30, 20, 40] en cherchant 20 -> 1, en cherchant 50 -> -1

Mesure la profondeur d'imbrication des listes dans la liste.

Exemple : [1, 2, 3] -> 1, [[1, 2], [3, 4]] -> 2, [[[1]]] -> 3

Compte les éléments de la liste.

Exemple : [10, 20, 30, 40, 50] -> 5, [] -> 0

Supprime l'élément à une position.

Exemple : [10, 20, 30, 40, 50] en supprimant l'index 2 -> [10, 20, 40, 50]

Supprime le premier élément.

Exemple : [10, 20, 30, 40] -> [20, 30, 40]

Supprime le dernier élément.

Exemple : [10, 20, 30, 40] -> [10, 20, 30]

Supprime un élément compté depuis la fin : l'index 0 est le dernier élément, 1 celui d'avant.

Exemple : [10, 20, 30, 40, 50] en supprimant l'index 1 depuis la fin -> [10, 20, 30, 50]

Supprime les éléments à plusieurs positions, toutes comptées sur la liste d'origine.

Exemple : [10, 20, 30, 40, 50] en supprimant les index [1, 3] -> [10, 30, 50]

Vide la liste qui lui est donnée, sur place : le même tableau revient sans aucun élément.

Exemple : [10, 20, 30, 40] -> []

Supprime chaque n-ième élément, à partir d'un décalage.

Exemple : [0, 1, 2, 3, 4, 5, 6, 7, 8] avec nth 3 et décalage 0 -> [1, 2, 4, 5, 7, 8]

Supprime chaque élément de la liste avec une probabilité donnée et garde les autres, le résultat diffère donc à chaque appel.

Exemple : [1, 2, 3, 4, 5] avec le seuil 0.5 -> peut-être [2, 4]

Supprime les nombres répétés, en gardant la première occurrence de chacun.

Exemple : [1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]

Supprime les nombres qui sont à une tolérance près d'un nombre déjà gardé, de sorte que des valeurs qui ne diffèrent que par du bruit en virgule flottante comptent comme identiques.

Exemple : [1.0, 1.001, 2.0, 2.002, 3.0] avec la tolérance 0.01 -> [1.0, 2.0, 3.0]

Supprime les éléments répétés de toute nature, en gardant la première occurrence de chacun.

Les éléments sont comparés par identité, deux objets d'apparence égale restent donc tous les deux. Exemple : ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']

Trie des nombres du plus petit au plus grand, ou du plus grand au plus petit.

Exemple : [5, 2, 8, 1, 9] croissant -> [1, 2, 5, 8, 9] ; décroissant -> [9, 8, 5, 2, 1]

Trie des textes par ordre alphabétique, de A à Z ou de Z à A.

Exemple : ['dog', 'apple', 'cat'] croissant -> ['apple', 'cat', 'dog']

Trie des objets selon le nombre contenu dans l'une de leurs propriétés.

Exemple : [{age: 30}, {age: 20}, {age: 25}] par 'age' croissant -> [{age: 20}, {age: 25}, {age: 30}]

Entrelace plusieurs listes en une seule en prenant le premier élément de chacune à tour de rôle, puis le second de chacune, et ainsi de suite.

Une liste plus courte sort simplement du jeu une fois épuisée. Une liste de listes vide lève une erreur. Exemple : [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]