L'objetarguments est un objet,semblable à un tableau, correspondant aux arguments passés à une fonction.

Exemple interactif

function func1(a, b, c) {  console.log(arguments[0]);  // Expected output: 1  console.log(arguments[1]);  // Expected output: 2  console.log(arguments[2]);  // Expected output: 3}func1(1, 2, 3);

Syntaxe

arguments;

Description

L'objetarguments est une variable locale (intrinsèque et inhérente aux fonctions) disponible dans toutes les fonctions (qui ne sont pasdes fonctions fléchées).

Vous pouvez accéder aux arguments d'une fonction à l'intérieur de celle-ci en utilisant l'objetarguments. Cet objet contient une entrée pour chaque argument passé à la fonction, l'indice de la première entrée commençant à 0. Par exemple, si une fonction est appelée avec trois arguments, on accède à ceux-ci comme suit :

arguments[0];arguments[1];arguments[2];

Les arguments peuvent aussi être modifiés :

arguments[1] = "nouvelle valeur";

Type de l'objetarguments et liens avecArray

L'objetarguments n'est pas unArray. Il est similaire à unArray, mais il n'a pas les propriétés d'unArray, exceptée la propriétélength. Par exemple, il n'a pas la méthodepop(). Néanmoins, il peut être converti en un vrai objet de typeArray :

console.log(typeof arguments); // 'object'var args = Array.prototype.slice.call(arguments);// Avec ECMAScript 2015 / ES6var args = Array.from(arguments);

Utilisation de la décomposition avec les arguments

On peut utiliser la méthodeArray.from() ou encorel'opérateur de décomposition afin de convertir cet objet en unvraiArray :

var args = Array.from(arguments);var args = [...arguments];

var args =  arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);

L'objetarguments est disponible uniquement dans le corps d'une fonction. Tenter d'accéder à l'objetarguments en dehors de la déclaration d'une fonction renvoie une erreur.

Vous pouvez utiliser l'objetarguments si vous appelez une fonction avec plus de paramètres que ceux déclarés dans sa signature. Cette technique est utile pour les fonctions qui acceptent un nombre variable d'arguments. Vous pouvez utiliserarguments.length pour déterminer le nombre de paramètres passés à la fonction, puis utiliser chaque argument en utilisant l'objetarguments. (Pour déterminer le nombre d'arguments déclarés à la définition de la fonction, il faut utiliser la propriétélength.)

Utilisertypeof surarguments

L'opérateurtypeof renvoie"object" lorsqu'on l'utilise surarguments

console.log(typeof arguments); // "object"

On peut tout à fait utilisertypeof sur chacun des arguments afin de connaître leur type respectif

console.log(typeof arguments[0]); // renvoie le type du premier argument

Propriétés

arguments.calleeObsolète

Référence à la fonction en cours d'exécution.

arguments.callerObsolète

Référence à la fonction appelante.

arguments.length

Référence au nombre d'arguments passés à la fonction.

arguments[@@iterator]

Renvoie un nouvelitérateur qui contient les valeurs pour chaque indice d'arguments.

Exemples

Définir une fonction de concaténation d'un nombre variable de chaînes

Cet exemple définit une fonction qui concatène un nombre variable de chaînes. Le seul argument formel de la fonction est une chaîne spécifiant un séparateur inséré entre les chaînes concaténées. La fonction est définie comme suit :

function myConcat(separateur) {  var args = Array.prototype.slice.call(arguments, 1);  return args.join(separateur);}

Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste en utilisant chaque argument comme un élément de la liste.

// renvoie "rouge, orange, bleu"myConcat(", ", "rouge", "orange", "bleu");// renvoie "éléphant ; giraffe ; lion ; guépard"myConcat(" ; ", "elephant", "giraffe", "lion", "guépard");

Définir une fonction de création de listes HTML

Cet exemple définit une fonction qui crée des chaînes définissant des listes HTML. Le seul argument formel de la fonction est une chaîne pouvant valoir "u" (unordered), si la liste doit être sans numérotation (avec des puces), ou "o" (ordered), si la liste doit être numérotée. La fonction est définie comme suit :

function liste(type) {  var resultat = "<" + type + "l><li>";  var args = Array.prototype.slice.call(arguments, 1);  resultat += args.join("</li><li>");  resultat += "</li></" + type + "l>"; // end list  return resultat;}

Vous pouvez passer n'importe quel nombre d'arguments à cette fonction ; elle créera une liste du type indiqué en ajoutant chaque argument comme élément dans la liste. Exemple :

var listeHTML = liste("u", "Un", "Deux", "Trois");/* listeHTML vaut &nbsp;:"<ul><li>Un</li><li>Deux</li><li>Trois</li></ul>"*/

Paramètres du reste, paramètres par défaut et décomposition

L'objetarguments peut être utilisé en combinaison avecles paramètres du reste,les paramètres par défaut oules paramètres décomposés.

function toto(...args) {  return args;}toto(1, 2, 3); // [1, 2, 3]

Toutefois, pour les fonctions utilisées en mode non-strict, unobjetarguments n'est fourni à l'intérieur de la fonction uniquement si celle-ci n'utilise pas deparamètres du reste, pas deparamètres par défaut ou deparamètre décomposé. Par exemple, dans la fonction suivante, qui utilise un paramètre par défaut, ce sera 10 qui sera renvoyé (et non 100) :

function truc(a = 1) {  arguments[0] = 100;  return a;}truc(10); // 10

Si l'objetarguments est modifié dans la fonction, cela modifiera la valeur du paramètre passé. Dans cet exemple où il n'y a niparamètres du reste, niparamètres par défaut, nidécomposition, le résultat sera 100 :

fonction truc(a) {  arguments[0] = 100;  return a;}truc(10); // 100

En fait, lorsqu'il n'y a aucun paramètre du reste, paramètre par défaut ou aucune décomposition, les arguments formels feront références aux valeurs de l'objetarguments. Lorsqu'on aura besoin d'accéder à ces valeurs, on accèdera aux valeurs contenues dansarguments et à l'inverse, lorsqu'on modifiera ces valeurs, cela modifiera le contenu d'arguments. Par exemple

function func(a, b) {  arguments[0] = 99;  arguments[1] = 99;  console.log(a + " " + b);}func(1, 2); // 99 99

ou encore :

function func(a, b) {  a = 9;  b = 99;  console.log(arguments[0] + " " + arguments[1]);}func(3, 4); // 9 99

En revanche, dès qu'on utilise des paramètres du reste, des paramètres par défaut ou la décomposition, c'est le comportement normal qui sera appliqué :

function func(a, b, c = 9) {  arguments[0] = 99;  arguments[1] = 98;  console.log(a + " " + b);}func(3, 4); // 3 4

Spécifications

Compatibilité des navigateurs

Voir aussi

• Function
• Les paramètres du reste
• Contraintes d'optimisations sous V8 en relation avecarguments