Est-il possible d'obtenir tous les arguments d'une fonction en tant qu'objet unique à l'intérieur de cette fonction?

En PHP, il existe func_num_argset func_get_argsexiste-t-il quelque chose de similaire pour JavaScript?

Utilisez arguments. Vous pouvez y accéder comme un tableau. Utilisez arguments.lengthpour le nombre d'arguments.

Les arguments sont un objet de type tableau (pas un tableau réel). Exemple de fonction ...

function testArguments () // <-- notice no arguments specified
{
    console.log(arguments); // outputs the arguments to the console
    var htmlOutput = "";
    for (var i=0; i < arguments.length; i++) {
        htmlOutput += '<li>' + arguments[i] + '</li>';
    }
    document.write('<ul>' + htmlOutput + '</ul>');
}

Essaye le...

testArguments("This", "is", "a", "test");  // outputs ["This","is","a","test"]
testArguments(1,2,3,4,5,6,7,8,9);          // outputs [1,2,3,4,5,6,7,8,9]

Les détails complets: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments

ES6 autorise une construction dans laquelle un argument de fonction est spécifié avec une notation "..." telle que

function testArgs (...args) {
 // Where you can test picking the first element
 console.log(args[0]); 
}

le arguments objet est l'endroit où les arguments des fonctions sont stockés.

L'objet arguments agit et ressemble à un tableau, il l'est fondamentalement, il n'a tout simplement pas les méthodes utilisées par les tableaux, par exemple:

Array.forEach(callback[, thisArg]);

Array.map(callback[, thisArg])

Array.filter(callback[, thisArg]);

Array.slice(begin[, end])

Array.indexOf(searchElement[, fromIndex])

Je pense que la meilleure façon de convertir un argumentsobjet en un vrai tableau est la suivante:

argumentsArray = [].slice.apply(arguments);

Cela en fera un tableau;

réutilisable:

function ArgumentsToArray(args) {
    return [].slice.apply(args);
}

(function() {
   args = ArgumentsToArray(arguments);

   args.forEach(function(value) {
      console.log('value ===', value);
   });

})('name', 1, {}, 'two', 3)

résultat:

> value === name
> value === 1
> value === Object {}
> value === two
>value === 3

Vous pouvez également le convertir en tableau si vous préférez. Si des génériques de tableau sont disponibles:

var args = Array.slice(arguments)

Autrement:

var args = Array.prototype.slice.call(arguments);

de Mozilla MDN :

Vous ne devez pas trancher les arguments car cela empêche les optimisations dans les moteurs JavaScript (V8 par exemple).

Comme beaucoup d'autres l'ont souligné, argumentscontient tous les arguments passés à une fonction.

Si vous souhaitez appeler une autre fonction avec les mêmes arguments, utilisez apply

Exemple:

var is_debug = true;
var debug = function() {
  if (is_debug) {
    console.log.apply(console, arguments);
  }
}

debug("message", "another argument")

Réponse similaire à Gunnar, avec un exemple plus complet: vous pouvez même renvoyer le tout de manière transparente:

function dumpArguments(...args) {
  for (var i = 0; i < args.length; i++)
    console.log(args[i]);
  return args;
}

dumpArguments("foo", "bar", true, 42, ["yes", "no"], { 'banana': true });

Production:

foo
bar
true
42
["yes","no"]
{"banana":true}

https://codepen.io/fnocke/pen/mmoxOr?editors=0010

Oui, si vous n'avez aucune idée du nombre d'arguments possibles au moment de la déclaration de fonction, vous pouvez déclarer la fonction sans paramètres et accéder à toutes les variables par le tableau d'arguments qui est passé au moment de l'appel de la fonction.

Dans ES6, vous pouvez faire quelque chose comme ceci:

function foo(...args) 
{
   let [a,b,...c] = args;

   console.log(a,b,c);
}


foo(1, null,"x",true, undefined);

Dans ES6, utilisez Array.from:

function foo()
  {
  foo.bar = Array.from(arguments);
  foo.baz = foo.bar.join();
  }

foo(1,2,3,4,5,6,7);
foo.bar // Array [1, 2, 3, 4, 5, 6, 7]
foo.baz // "1,2,3,4,5,6,7"

Pour le code non ES6, utilisez JSON.stringify et JSON.parse:

function foo()
  {
  foo.bar = JSON.stringify(arguments); 
  foo.baz = JSON.parse(foo.bar); 
  }

/* Atomic Data */
foo(1,2,3,4,5,6,7);
foo.bar // "{"0":1,"1":2,"2":3,"3":4,"4":5,"5":6,"6":7}"
foo.baz // [object Object]

/* Structured Data */
foo({1:2},[3,4],/5,6/,Date())
foo.bar //"{"0":{"1":2},"1":[3,4],"2":{},"3":"Tue Dec 17 2013 16:25:44 GMT-0800 (Pacific Standard Time)"}"
foo.baz // [object Object]

Si la conservation est nécessaire au lieu de la stringification, utilisez l' algorithme de clonage structuré interne .

Si des nœuds DOM sont passés, utilisez XMLSerializer comme dans une question non liée .

with (new XMLSerializer()) {serializeToString(document.documentElement) }

Si vous exécutez en tant que bookmarklet, vous devrez peut-être encapsuler chaque argument de données structurées dans un constructeur d'erreur pour JSON.stringifyfonctionner correctement.

Références

• Structure Clone CommonJS Module

• Clone d'objet JS

• MDN: Array.from ()