Array.prototype.push()
======================

La méthode **`push()`** ajoute un ou plusieurs éléments à la fin d'un tableau et retourne la nouvelle taille du tableau.

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

Syntaxe
-------


```js
arr.push(élément1, ..., élémentN)
```

### Paramètres

`élément1, ..., élémentN`

Les éléments à ajouter à la fin du tableau.

### Valeur de retour

La nouvelle valeur de la propriété `length` de l'objet sur lequel la méthode a été appelée.

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

La méthode `push` permet d'ajouter des valeurs à un tableau.

`push` est une méthode générique. Cette méthode peut ainsi être utilisée avec les méthodes `Function.call()` ou `Function.apply()` sur des objets similaires aux tableaux.

La méthode `push` se base sur la propriété `length` pour déterminer à partir de quel index les valeurs données doivent être insérées. Si la propriété `length` ne peut pas être convertie en nombre, l'index utilisé est 0. Si la propriété `length` n'est pas définie, elle est alors créée.

Bien que `push` soit une méthode générique, elle ne peut pas être utilisée sur les chaînes de caractères ou sur l'objet `arguments` car ils sont immuables.

Exemples
--------

### Ajouter des éléments à un tableau

Le code suivant crée un tableau `sports` contenant à sa création deux éléments, auxquels sont ajoutés deux nouveaux éléments. La variable `total` contient la nouvelle taille du tableau.


```js
var sports = ["plongée", "baseball"];
var total = sports.push("football", "tennis");

console.log(sports); // ["plongée", "baseball", "football", "tennis"]
console.log(total); // 4
```

### Fusionner deux tableaux

Dans l'exemple qui suit, on utilise la méthode `Function.apply()` pour ajouter les différents éléments d'un second tableau


```js
var legumes = ["navet", "pomme de terre"];
var autresLegumes = ["céleri", "radis"];

// On fusionne les deux tableaux
// Équivalent à legumes.push('céleri', 'radis');
Array.prototype.push.apply(legumes, autresLegumes);

console.log(legumes); // ['navet', 'pomme de terre', 'céleri', 'radis']
```


**Note :** Attention à ne pas utiliser cette méthode lorsque les tableaux sont très grands car une fonction n'accepte qu'un nombre limité d'arguments. Voir `apply()` pour plus d'informations sur ces limites.

L'exemple qui suit utilise la syntaxe de décomposition pour ajouter les éléments d'un second tableau à la fin du premier tableau.


```js
const legumes = ["navet", "pomme de terre"];
const autresLegumes = ["céleri", "radis"];

// On fusionne les deux tableaux
// Équivalent à legumes.push('céleri', 'radis');
legumes.push(...autresLegumes);

console.log(legumes); // ['navet', 'pomme de terre', 'céleri', 'radis']
```

### Utiliser un objet comme on utiliserait un tableau

Comme nous l'avons vu auparavant, `push` est une méthode générique et nous pouvons donc utiliser `Array.prototype.push` sur les objets. On notera qu'il n'est pas nécessaire de stocker un ensemble d'objets. En fait, on enregistre l'ensemble dans l'objet et on utilise `call` sur `Array.prototype.push` :


```js
var obj = {
  length: 0,

  ajoutElem: function ajoutElem(elem) {
    // obj.length est automatiquement incrémenté
    // quand on ajoute un élément
    [].push.call(this, elem);
  },
};

// Ajoutons quelques objets vides pour illustrer
// l'exemple.
obj.ajoutElem({});
obj.ajoutElem({});
console.log(obj.length);
// → 2
```

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

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

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

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

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

* `Array.prototype.pop()`
* `Array.prototype.shift()`
* `Array.prototype.unshift()`
* `Array.prototype.concat()`