Ist es möglich, alle Argumente einer Funktion als einzelnes Objekt innerhalb dieser Funktion abzurufen?

Das Argument arguments ist ein Array-ähnliches Objekt (kein tatsächliches Array). Beispielfunktion ...

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>');
}

Versuch es...

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]

Die vollständigen Details: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments

Im Objekt arguments werden die Funktionsargumente gespeichert.

Das Argumentobjekt wirkt und sieht aus wie ein Array. Im Grunde gibt es einfach nicht die Methoden, die Arrays verwenden, zum Beispiel:

Array.forEach(callback[, thisArg]);

Array.map(callback[, thisArg])

Array.filter(callback[, thisArg]);

Array.slice(begin[, end])

Array.indexOf(searchElement[, fromIndex])

Ich denke, der beste Weg, ein arguments-Objekt in ein real -Array zu konvertieren, ist wie folgt:

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

Das macht es zu einem Array;

wiederverwendbar:

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

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

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

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

ergebnis: 

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

ES6 erlaubt ein Konstrukt, bei dem ein Funktionsargument mit einer "..." - Notation angegeben wird, z 

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

Sie können es auch in ein Array konvertieren, wenn Sie möchten. Wenn Array-Generics verfügbar sind:

var args = Array.slice(arguments)

Andernfalls:

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

von Mozilla MDN :

Argumente sollten nicht in Scheiben geschnitten werden, da Optimierungen in .__ verhindert werden. JavaScript-Engines (beispielsweise V8).

Wie viele andere bereits erwähnt, enthält arguments alle an eine Funktion übergebenen Argumente.

Wenn Sie eine andere Funktion mit den gleichen Argumenten aufrufen möchten, verwenden Sie apply.

Beispiel:

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

debug("message", "another argument")

Ja, wenn Sie keine Ahnung haben, wie viele Argumente zum Zeitpunkt der Funktionsdeklaration möglich sind, können Sie die Funktion ohne Parameter deklarieren und auf alle Variablen durch das Argument-Array zugreifen, das zum Zeitpunkt des Funktionsaufrufs übergeben wird.

Eine ähnliche Antwort auf Gunnar mit einem vollständigeren Beispiel: Sie können das Ganze sogar transparent zurückgeben:

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 });

Ausgabe:

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

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

In ES6 können Sie so etwas tun:

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

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


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