Paramètres du reste

Cette syntaxe permet de représenter un nombre indéfini d'arguments sous forme d'un tableau.

Syntaxe

function f(a, b, ...lesArguments) {
  // ...
}

Description

Si le dernier argument fourni à la fonction est préfixé de ... (trois points), il devient un tableau dont les éléments entre 0 (inclus) et lesArguments.length (exclus) sont fournis comme arguments passés à la fonction.

Dans l'exemple ci-avant, lesArguments regrouperait le troisème argument (les deux premiers étant respectivement a et b) ainsi que les suivants.

Les différences entre ces paramètres « du reste » et l'objet arguments

Il y a trois principales différences entre ces paramètres du reste et l'objet arguments :

• les paramètres du reste ne possèdent pas de noms séparés, l'objet arguments contient chaque argument passé à la fonction
• l'objet arguments n'est pas, à strictement parler, un tableau. Le paramètre représentant les arguments restant est une instance d'Array à laquelle on peut appliquer directement des méthodes comme sort, map, forEach ou pop
• l'objet arguments possède des fonctionnalités spécifiques (comme, par exemple, la propriété callee)

Passer des arguments à un tableau

Ces paramètres ont été introduits afin de réduire le code passe-partout souvent induit par les arguments.

// Avant les paramètres du reste, on observait souvent ce style de code :
function f(a, b){
  var args = Array.prototype.slice.call(arguments, f.length);

  // …
}

// ce qui est l'équivalent de

function f(a, b, ...args) {
  
}

La décomposition sur les paramètres du reste

On peut également décomposer les paramètres du reste en variables distinctes :

function f(...[a, b, c]) {
  return a + b + c;
}

f(1);          // NaN (b et c valent undefined)
f(1, 2, 3);    // 6
f(1, 2, 3, 4); // 6, le dernier paramètre n'est pas décomposé

Exemples

lesArguments est un tableau et dispose donc d'une propriété length permettant de compter ses éléments :

function fun1(...lesArguments) {
  console.log(lesArguments.length);
}

fun1();  // 0
fun1(5); // 1
fun1(5, 6, 7); // 3

Dans l'exemple qui suit, on utilise le paramètre du reste pour collecter les arguments après le premier pour les multiplier par le premier :

function multiplier(facteur, ...lesArguments) {
  return lesArguments.map(function (element) {
    return facteur * element;
  });
}

var arr = multiplier(2, 1, 2, 3); 
console.log(arr); // [2, 4, 6]

L'exemple qui suit illustre comment on peut utiliser des méthodes de Array sur le paramètre du reste mais pas sur l'objet arguments :

function trierParamReste(...lesArguments) {
  var argumentsTriés = lesArguments.sort();
  return argumentsTriés;
}

console.log(trierParamReste(5,3,7,1)); // shows 1,3,5,7

function trierArguments() {
  var argumentsTriés = arguments.sort(); 
  return argumentsTriés; // cela ne sera jamais appelé
}

// renvoie une exception TypeError: arguments.sort n'est pas une function
console.log(trierArguments(5,3,7,1)); 

Pour utiliser les méthodes propres aux instances d'Array sur l'objet arguments, il est nécessaire de le convertir.

Spécifications

Compatibilité des navigateurs

Voir aussi

• L'objet arguments
• Array
• Les fonctions et leurs portées
• L'opérateur de décomposition
• Proposition originale sur ecmascript.org (en anglais)
• JavaScript arguments object and beyond (article en anglais)