recursal/MDN huggingface dataset:
Array.prototype.reverse()
=========================

La méthode **`reverse()`** transpose les éléments d'un tableau : le premier élément devient le dernier et le dernier devient le premier et ainsi de suite.

Exemple interactif
------------------

Syntaxe
-------


```js
arr.reverse();
```

### Valeur de retour

Le tableau inversé.

Description
-----------

La méthode `reverse()` permet d'inverser l'ordre des éléments du tableau. La méthode modifie le tableau courant et renvoie une référence à ce tableau.

Cette méthode est intentionnellement générique et peut être appelée (via `Function.call()`) ou appliquée (via `Function.apply()`) sur des objets semblables à des tableaux. Les objets qui ne contiennent pas de propriété `length` qui soit cohérente avec leurs propriétés indexées sur des nombres ne seront pas traités par `reverse()`.

Exemples
--------

### Inverser l'ordre des éléments d'un tableau

L'exemple qui suit crée un tableau `monArray`, qui contient trois éléments, puis inverse celui-ci.


```js
var monArray = ["un", "deux", "trois"];
monArray.reverse();

console.log(monArray); // ["trois", "deux", "un"]
```

### Inverser l'ordre des éléments d'un objet semblable à un tableau

Dans l'exemple suivant, on crée un objet semblable à un tableau `a` qui contient trois éléments et une propriété `length`. On appelle ensuite `reverse()` grâce à `call()` sur cet objet pour inverser ses éléments :


```js
const a = { 0: 1, 1: 2, 2: 3, length: 3 };

console.log(a); // {0: 1, 1: 2, 2: 3, length: 3}

Array.prototype.reverse.call(a); // On aurait pu utiliser apply() également

console.log(a); // {0: 3, 1: 2, 2 : 1, length: 3}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.reverse |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.join()`
* `Array.prototype.sort()`
* `TypedArray.prototype.reverse()`
Array.prototype.values()
========================

La méthode **`values()`** renvoie un nouvel objet **`Array Iterator`** qui contient les valeurs pour chaque indice du tableau. Cette méthode est l'implémentation par défaut de `Array.prototype[Symbol.Iterator]`.

Exemple interactif
------------------


```js
var a = ["t", "i", "t", "o", "u"];
var iterateur = a.values();

console.log(iterateur.next().value); // t
console.log(iterateur.next().value); // i
console.log(iterateur.next().value); // t
console.log(iterateur.next().value); // o
console.log(iterateur.next().value); // u
```

Syntaxe
-------


```js
array.values();
```

### Valeur de retour

Un nouvel objet itérateur sur `Array`.

Exemples
--------

### Itérer avec une boucle `for...of`


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr.values();
// votre navigateur doit supporter les boucles for..of
// et les variables définies avec let
for (let lettre of eArr) {
  console.log(lettre);
}
```

### Itérer avec `next()`


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr.values();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.values |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
Array.prototype.length
======================

La propriété **`length`** (longueur) est un entier non-signé de 32 bits qui indique le nombre d'éléments présents dans le tableau. Elle est toujours supérieure au plus grand indice du tableau.

Exemple interactif
------------------

Description
-----------

La valeur de la propriété `length` est un entier de signe positif dont la valeur est inférieure à 2 à la puissance 32 (2^32).


```js
var tableauA = new Array(4294967296); // 2 à la puissance 32 = 4294967296
var tableauC = new Array(-100); // une valeur négative

console.log(tableauA.length); // RangeError: Invalid array length
console.log(tableauC.length); // RangeError: Invalid array length

var tableauB = [];
tableauB.length = Math.pow(2, 32) - 1; // On déclare une longueur inférieure à 2 puissance 32
console.log(tableauB.length); // 4294967295
```


Vous pouvez modifier la propriété `length` d'un tableau à loisir pour le tronquer. Quand vous étendez un tableau en modifiant la valeur de sa propriété `length`, le nombre d'éléments réellement présents dans ce tableau n'augmente pas : par exemple, si vous affectez la valeur 3 à la propriété `length` d'un tableau alors qu'elle vaut 2, le tableau contiendra toujours seulement 2 éléments. La troisième « case » ne sera pas itérable. De ce fait, la propriété `length` d'un tableau ne renseigne en rien sur le nombre de valeurs définies dans le tableau. Voir aussi la relation entre longueur et propriétés numériques.


```js
const arr = [1, 2, 3];
console.table(arr);
// [1, 2]

arr.length = 5; // On définit une longueur à 5
console.table(arr);
// [1, 2, <3 éléments vides>]

arr.forEach((element) => console.log(element));
// 1
// 2
```


| Attributs de `Array.prototype.length` |
| --- |
| Écrivable | Oui |
| Énumérable | Non |
| Configurable | Non |

Exemples
--------

### Renvoyer la longueur d'un tableau


```js
var items = ["chaise", "bureau", "table", "sac"];
items.length; // 4
```

### Parcourir un tableau

Dans l'exemple suivant, on itère sur le tableau `nombres` en utilisant la propriété `length` afin de connaître son nombre d'élément. La valeur de chaque élément est ensuite multipliée par deux :


```js
var nombres = [1, 2, 3, 4, 5];

for (var i = 0; i < nombres.length; i++) {
  nombres[i] \*= 2;
}
// nombres vaut maintenant [2,4,6,8,10];
```

### Tronquer un tableau

L'exemple suivant raccourcit le tableau `etatsUS` à 50 si sa longueur actuelle est supérieure à 50.


```js
if (etatsUS.length > 50) {
  etatsUS.length = 50;
}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-properties-of-array-instances-length |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array`
get Array[@@species]
====================

La propriété d'accesseur **`Array[@@species]`** renvoie le constructeur `Array`.

Syntaxe
-------


```js
Array[Symbol.species];
```

### Valeur de retour

Le constructeur `Array`.

Description
-----------

L'accesseur `species` renvoie le constructeur par défaut pour les objets `Array`. Les constructeurs des sous-classes peuvent le surcharger afin de modifier l'affectation du constructeur.

Exemples
--------

La propriété renvoie le constructeur par défaut, dans le cas des objets `Array`, c'est le constructeur `Array` :


```js
Array[Symbol.species]; // function Array()
```


Pour un objet dérivé, la valeur de `species` pour une classe `MonArray` sera le constructeur de cette classe. Vous pouvez surcharger ce comportement afin de renvoyer le constructeur `Array` :


```js
class MonArray extends Array {
  // On surcharge le symbole species
  // pour renvoyer le constructeur Array parent
  static get [Symbol.species]() {
    return Array;
  }
}
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-array-@@species |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array`
* `Symbol.species`
Array.prototype[@@iterator]()
=============================

La valeur initiale de la propriété **`@@iterator`** correspond à la valeur initiale fournie par l'itérateur `values`.

Syntaxe
-------


```js
arr[Symbol.iterator]();
```

### Valeur de retour

La première valeur fournie par `values()`. Si on utilise `arr[Symbol.iterator]` (sans les parenthèses) le navigateur renverra par défaut la fonction `values()`.

Exemples
--------

### Parcourir un tableau avec une boucle `for...of`


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
// il est nécessaire que l'environnement supporte
// les boucles for..of et les variables
// utilisées avec let ou const ou var
for (let letter of eArr) {
  console.log(letter);
}
```

### Parcourir un tableau avec `next`


```js
var arr = ["w", "y", "k", "o", "p"];
var eArr = arr[Symbol.iterator]();
console.log(eArr.next().value); // w
console.log(eArr.next().value); // y
console.log(eArr.next().value); // k
console.log(eArr.next().value); // o
console.log(eArr.next().value); // p
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype-@@iterator |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.keys()`
* `Array.prototype.entries()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `Array.prototype.values()`
Array.prototype.unshift()
=========================

La méthode **`unshift()`** ajoute un ou plusieurs éléments au début d'un tableau et renvoie la nouvelle longueur du tableau.

Exemple interactif
------------------

Syntaxe
-------


```js
arr.unshift([élém1[, ...[, élémN]]])
```

### Paramètres

`élémN`

Les éléments que l'on souhaite ajouter en début de tableau.

### Valeur de retour

La nouvelle valeur de la propriété `length` du tableau sur lequel a été appelée la méthode.

Description
-----------

La méthode `unshift()` insère les valeurs renseignées au début d'un objet ressemblant à un tableau.

`unshift()` est volontairement générique ; cette méthode peut être appelée ou appliquée sur des objets ressemblant à des tableaux. Les objets qui ne contiennent pas une propriété `length` reflètant la fin d'une série de propriétés indexées numériquement pourront ne pas avoir un comportement cohérent avec cette méthode.

Attention, lorsqu'on utilise `unshift()` avec plusieurs arguments, ceux-ci sont insérés au début du tableau dans l'ordre selon lequel ils sont passés en arguments. Aussi, on n'obtiendra pas le même résultat en appelant `unshift()` *n* fois avec 1 arguments ou en appelant `unshift()` avec *n* arguments.


```js
let arr = [4, 5, 6];

arr.unshift(1, 2, 3);
console.table(arr);
// [1, 2, 3, 4, 5, 6]

let arr2 = [4, 5, 6];

arr2.unshift(1);
arr2.unshift(2);
arr2.unshift(3);

console.table(arr2);
// [3, 2, 1, 4, 5, 6]
```

Exemples
--------


```js
var arr = [1, 2];

arr.unshift(0); // renvoie 3, la nouvelle longueur du tableau
// arr est [0, 1, 2]

arr.unshift(-2, -1); // = 5
// arr est [-2, -1, 0, 1, 2]

arr.unshift([-3]); // 6
// arr est [[-3], -2, -1, 0, 1, 2]

arr.unshift([-7, -6], [-5]); // 8
// arr est [[-7, -6], [-5], [-3], -2, -1, 0, 1, 2]
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.unshift |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.concat()`
Array.prototype.pop()
=====================

La méthode **`pop()`** supprime le **dernier** élément d'un tableau et retourne cet élément. Cette méthode modifie la longueur du tableau.

Exemple interactif
------------------

Syntaxe
-------


```js
arr.pop();
```

### Valeur de retour

L'élément qui a été retiré du tableau. Si le tableau est vide, elle renvoie `undefined`.

Description
-----------

La méthode `pop()` supprime le dernier élément d'un tableau et retourne cette valeur.

`pop()` est volontairement générique ; cette méthode peut être `appelée` ou `appliquée` pour des objets ressemblant à des tableaux. Les objets qui ne contiennent pas une propriété `length` reflétant la fin d'une série de propriétés consécutives numérotées peuvent se comporter bizarrement.

Si vous appelez `pop()` sur un tableau vide, il renverra la valeur `undefined`.

**Note :** La méthode `Array.prototype.shift()` possède un comportement analogue mais retire le *premier* élément du tableau.

Exemples
--------

### Supprimer le dernier élément d'un tableau

Le code suivant crée le tableau `mesPoissons` qui contient quatre éléments puis supprime le dernier élément.


```js
var mesPoissons = ["angel", "clown", "mandarin", "sturgeon"];

var popped = mesPoissons.pop();

console.table(mesPoissons); // angel, clown, madarin
console.log(popped); // sturgeon
```

### Utiliser `apply()` ou `call()` sur les objets semblables aux tableaux

Le code suivant crée un objet `mesPoissons` semblable à un tableau, qui contient 4 propriétés indexées avec des nombres et une propriété `length`. On utilise la méthode `Function.call()` pour invoquer `pop()` sur cet objet :


```js
var mesPoissons = {
  0: "angel",
  1: "clown",
  2: "mandarin",
  3: "sturgeon",
  length: 4,
};

var popped = Array.prototype.pop.call(mesPoissons); // on aurait pu utiliser apply()
console.log(mesPoissons); // {0: 'angel', 1: 'clown', 2: 'mandarin', length: 3}
console.log(popped); // 'sturgeon'
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.pop |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.push()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.splice()`
Array.from()
============

La méthode **`Array.from()`** permet de créer une nouvelle instance d'`Array` (une copie superficielle) à partir d'un objet itérable ou semblable à un tableau.

Exemple interactif
------------------

Syntaxe
-------


```js
Array.from(arrayLike [, fonctionMap[, thisArg]])
```

### Paramètres

`arrayLike`

Un objet semblable à un tableau ou bien un objet itérable dont on souhaite créer un tableau, instance d'`Array`.

`fonctionMap` Facultatif

Argument optionnel, une fonction à appliquer à chacun des éléments du tableau.

`thisArg` Facultatif

Argument optionnel. La valeur à utiliser pour `this` lors de l'exécution de la fonction `fonctionMap`.

### Valeur de retour

Une nouvelle instance de `Array`.

Description
-----------

`Array.from()` permet de créer des instances d'`Array` à partir :

* d'objets semblables à des tableaux (qui disposent d'une propriété `length` et d'éléments indexés) ou
* d'objets itérables (des objets dont on peut avoir les éléments comme `Map` et `Set`).

`Array.from()` possède un paramètre optionnel `fonctionMap`, qui permet d'exécuter une fonction `map` sur chacun des éléments du tableau (ou de l'instance de la classe fille) qui est créé. Autrement dit `Array.from(obj, mapFn, thisArg)` correspond exactement à `Array.from(obj).map(mapFn, thisArg)`, sauf qu'il n'y a pas de tableau intermédiaire de créé. Cet aspect est notamment important pour certaines classes filles, comme les tableaux typés (en effet, un tableau intermédiaire aurait eu ses valeurs tronquées pour qu'elles soient du type approprié).

La propriété `length` de la méthode `from()` est 1.

Avec ES6, la syntaxe de classe permet d'avoir des sous-classes pour les objets natifs comme pour les objets définis par l'utilisateur. Ainsi, les méthodes statiques de classe comme `Array.from()` sont héritées par les sous-classes d'`Array` et créent de nouvelles instances de la sous-classe d'`Array`.

Exemples
--------


```js
// créer une instance d'Array à partir de l'objet arguments qui est semblable à un tableau
function f() {
  return Array.from(arguments);
}

f(1, 2, 3);
// [1, 2, 3]

// Ça fonctionne avec tous les objets itérables...
// Set
const s = new Set(["toto", "truc", "truc", "bidule"]);
Array.from(s);
// ["toto", "truc", "bidule"]

// Map
const m = new Map([
  [1, 2],
  [2, 4],
  [4, 8],
]);
Array.from(m);
// [[1, 2], [2, 4], [4, 8]]

const mapper = new Map([
  ["1", "a"],
  ["2", "b"],
]);
Array.from(mapper.values());
// ["a", "b"]

Array.from(mapper.keys());
// ["1", "2"]

// String
Array.from("toto");
// ["t", "o", "t", "o"]

// En utilisant une fonction fléchée pour remplacer map
// et manipuler des éléments
Array.from([1, 2, 3], (x) => x + x);
// [2, 4, 6]

// Pour générer une séquence de nombres
Array.from({ length: 5 }, (v, k) => k);
// [0, 1, 2, 3, 4]
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.from |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array`
* `Array.prototype.map()`
* `TypedArray.from()`
Array.prototype.shift()
=======================

La méthode **`shift()`** permet de retirer le **premier** élément d'un tableau et de renvoyer cet élément. Cette méthode modifie la longueur du tableau.

Exemple interactif
------------------

Syntaxe
-------


```js
arr.shift();
```

### Valeur de retour

L'élément retiré du tableau ou `undefined` si le tableau est vide.

Description
-----------

La méthode `shift` retire l'élément situé à l'index zéro et décrémente l'index des éléments suivant avant de retourner l'élément supprimé. Si la propriété `length` vaut 0, `undefined` est retourné.

Cette méthode est générique et peut être appelée ou appliquée sur des objets similaires à des tableaux.

Cette méthode n'est pas exploitable pour les objets dont la propriété `length` ne reflète pas la taille du contenu, ou pour lesquels la propriété `length` n'est pas définie.

**Note :** La méthode `Array.prototype.pop()` possède un comportement similaire mais retire le dernier élément du tableau (et non le premier).

Exemples
--------

### Supprimer un élément d'un tableau

Le code suivant affiche le tableau `mesPoissons` avant et après avoir enlevé le premier élément. Il affiche aussi l'élément supprimé :


```js
var mesPoissons = ["ange", "clown", "mandarin", "chirurgien"];

console.log("mesPoissons avant : " + JSON.stringify(mesPoissons));
// mesPoissons avant : ["ange","clown","mandarin","chirurgien"]

var premierÉlément = mesPoissons.shift();

console.log("mesPoissons après :", mesPoissons);
// mesPoissons après : ["clown", "mandarin", "chirurgien"]

console.log("Cet élément a été enlevé :", premierÉlément);
// "Cet élément a été enlevé : ange"
```

### Utiliser `shift()` dans une boucle `while`

La méthode `shift()` peut être utilisée dans une boucle `while`. Dans l'exemple suivant, chaque itération de la boucle retire un élément du tableau et l'affiche dans la console, jusqu'à ce que ce dernier soit vide.


```js
var noms = ["André", "Édouard", "Paul", "Christophe", "Jean"];
while ((i = noms.shift()) !== undefined) {
  console.log(i);
}
// André, Édouard, Paul, Christophe, Jean
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.shift |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.push()`
* `Array.prototype.pop()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`
Array.prototype.flatMap()
=========================

Baseline Widely available
-------------------------

This feature is well established and works across many devices and browser versions. It’s been available across browsers since January 2020.

* Learn more
* See full compatibility
* Report feedback
La méthode **`flatMap()`** permet d'appliquer une fonction à chaque élément du tableau puis d'aplatir le résultat en un tableau. Cela correspond à l'enchaînement de `Array.prototype.map()` suivi de `Array.prototype.flat()` de profondeur 1. `flatMap` est plus efficace que la combinaison de ces deux opérations, souvent réalisées conjointement.

Syntaxe
-------


```js
var new_array = arr.flatMap(function callback(currentValue[, index[, array]]) {
    // return element for new\_array
}[, thisArg])
```

### Paramètres

`callback`

La fonction qui produit un élément du nouveau tableau et qui prend trois arguments :

`currentValue`

La valeur du tableau qui est traitée.

`index`Facultatif

L'indice de l'élément du tableau qui est traitée.

`array`Facultatif

Le tableau sur lequel `flatMap` a été appelée.


`thisArg`Facultatif

La valeur à utiliser comme contexte `this` lors de l'exécution de `callback`.

### Valeur de retour

Un nouveau tableau composé d'éléments résultants de la fonction de rappel (*callback*) et aplati d'un niveau de profondeur.

Description
-----------

Pour la fonction de rappel, voir `Array.prototype.map()`. La méthode `flatMap()` est identique à un appel de `Array.prototype.map()` suivi d'un appel de `Array.prototype.flat()` avec la profondeur 1.

Exemples
--------

### `map()` et `flatMap()`


```js
var arr1 = [1, 2, 3, 4];

arr1.map((x) => [x \* 2]);
// [[2], [4], [6], [8]]

arr1.flatMap((x) => [x \* 2]);
// [2, 4, 6, 8]

// seul un niveau est aplati
arr1.flatMap((x) => [[x \* 2]]);
// [[2], [4], [6], [8]]
```


On peut utiliser un autre exemple où on génère une liste de mots à partir d'une liste de phrases :


```js
let tableau1 = ["Coucou comment", "", "ça va ?"];

tableau1.map((x) => x.split(" "));
// [["Coucou", "comment"], [""], ["ça", "va", "?"]]

tableau1.flatMap((x) => x.split(" "));
// ["Coucou", "comment", "", "ça", "va", "?"]
```


On notera que la longueur de la liste obtenue avec `flatMap` est différente de la longueur de la liste originale.
```

//=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
```

Équivalent
----------

### `reduce()` et `concat()`


```js
var arr = [1, 2, 3, 4];

arr.flatMap((x) => [x, x \* 2]);
// est équivalent à
arr.reduce((acc, x) => acc.concat([x, x \* 2]), []);
// [1, 2, 2, 4, 3, 6, 4, 8]
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.flatmap |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.flat()`
* `Array.prototype.map()`
* `Array.prototype.reduce()`
* `Array.prototype.concat()`
Array.prototype.entries()
=========================

La méthode **`entries()`** renvoie un nouvel objet de type **`Array Iterator`** qui contient le couple clef/valeur pour chaque éléments du tableau.

Exemple interactif
------------------

Syntaxe
-------


```js
arr.entries();
```

### Valeur de retour

Un nouvel objet qui est un itérateur pour `Array`.

Exemples
--------

### Parcourir un tableau avec ses index et éléments


```js
const arr = ["a", "b", "c"];
for (const [index, element] of arr.entries()) {
  console.log(index, element);
}
// 0 "a"
// 1 "b"
// 2 "c"
```

### Boucle `for...of`

On peut avoir le même résultat en utilisant une boucle for...of :


```js
var arr = ["a", "b", "c"];
var eArr = arr.entries();

for (let e of eArr) {
  console.log(e);
}
// [0, 'a']
// [1, 'b']
// [2, 'c']
```

Spécifications
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-array.prototype.entries |

Compatibilité des navigateurs
-----------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Voir aussi
----------

* `Array.prototype.keys()`
* `Array.prototype.values()`
* `Array.prototype.forEach()`
* `Array.prototype.every()`
* `Array.prototype.some()`
* `for...of`
* Les protocoles d'itération