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

In PHP gibt es func_num_argsund func_get_argsgibt es etwas Ähnliches für JavaScript?

Verwenden Sie arguments. Sie können wie ein Array darauf zugreifen. Verwenden Sie arguments.lengthfür die Anzahl der Argumente.

Die Argumente sind 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

ES6 ermöglicht ein Konstrukt, bei dem ein Funktionsargument mit der Notation "..." angegeben wird, z

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

Im argumentsObjekt werden die Funktionsargumente gespeichert.

Das Argumentobjekt verhält sich und sieht aus wie ein Array. Es verfügt im Grunde genommen nicht über die Methoden, die Arrays ausführen, 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 argumentsObjekt in ein echtes Array zu konvertieren, ist folgender:

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

Sie können es auch in ein Array konvertieren, wenn Sie dies bevorzugen. Wenn Array-Generika verfügbar sind:

var args = Array.slice(arguments)

Andernfalls:

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

von Mozilla MDN :

Sie sollten nicht auf Argumente verzichten, da dies Optimierungen in JavaScript-Engines (z. B. V8) verhindert.

argumentsEnthält, wie viele andere betonten, alle an eine Funktion übergebenen Argumente.

Wenn Sie eine andere Funktion mit denselben 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")

Ähnliche Antwort zu Gunnar mit vollständigerem 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

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 über das Argumentarray, das zum Zeitpunkt des Funktionsaufrufs übergeben wird, auf alle Variablen zugreifen.

In ES6 können Sie Folgendes tun:

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

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


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

Verwenden Sie in ES6 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"

Verwenden Sie für Nicht-ES6-Code JSON.stringify und 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]

Wenn anstelle einer Stringifizierung eine Aufbewahrung erforderlich ist, verwenden Sie den internen strukturierten Klonierungsalgorithmus .

Wenn DOM-Knoten übergeben werden, verwenden Sie XMLSerializer wie in einer nicht verwandten Frage .

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

Wenn Sie als Lesezeichen ausgeführt werden, müssen Sie möglicherweise jedes Argument für strukturierte Daten in einen Fehlerkonstruktor einschließen, damit JSON.stringifyes ordnungsgemäß funktioniert.

Verweise

• Strukturklon CommonJS-Modul

• JS-Objektklon

• MDN: Array.from ()