Das `arguments` Objekt

Das arguments Objekt ist eine lokale Variable, die in allen nicht-arrow Funktionen verfügbar ist. Sie können auf die Argumente einer Funktion innerhalb dieser Funktion zugreifen, indem Sie das arguments Objekt verwenden. Es enthält Einträge für jedes Argument, mit dem die Funktion aufgerufen wurde, wobei der Index des ersten Eintrags bei 0 liegt.

Zum Beispiel, wenn eine Funktion mit 3 Argumenten aufgerufen wird, können Sie wie folgt auf sie zugreifen:

arguments[0]; // first argument
arguments[1]; // second argument
arguments[2]; // third argument

Das arguments Objekt ist nützlich für Funktionen, die mit mehr Argumenten aufgerufen werden, als sie formal deklariert sind, sogenannte variadische Funktionen, wie z.B. Math.min(). Diese Beispiel-Funktion akzeptiert eine beliebige Anzahl von String-Argumenten und gibt das längste zurück:

function longestString() {
  let longest = "";
  if (arguments.length === 0) {
    throw new TypeError("At least one string is required");
  }
  for (const arg of arguments) {
    if (arg.length > longest.length) {
      longest = arg;
    }
  }
  return longest;
}

Sie können arguments.length verwenden, um zu zählen, mit wie vielen Argumenten die Funktion aufgerufen wurde. Wenn Sie stattdessen zählen möchten, wie viele Parameter eine Funktion deklariert akzeptiert, überprüfen Sie die length Eigenschaft dieser Funktion.

Jeder Argument-Index kann auch gesetzt oder neu zugewiesen werden:

arguments[1] = "new value";

Nicht-strikte Funktionen, die nur einfache Parameter haben (das heißt, keine Rest-, Standard- oder destrukturierten Parameter), synchronisieren den neuen Wert der Parameter mit dem arguments Objekt und umgekehrt:

function func(a) {
  arguments[0] = 99; // updating arguments[0] also updates a
  console.log(a);
}
func(10); // 99

function func2(a) {
  a = 99; // updating a also updates arguments[0]
  console.log(arguments[0]);
}
func2(10); // 99

Nicht-strikte Funktionen, die Rest, Standard oder destrukturierte Parameter übergeben bekommen, synchronisieren keine neuen Werte, die im Funktionskörper den Parametern zugewiesen werden, mit dem arguments Objekt. Stattdessen spiegelt das arguments Objekt in nicht-strikten Funktionen mit komplexen Parametern immer die Werte wider, die bei Aufruf der Funktion übergeben wurden.

function funcWithDefault(a = 55) {
  arguments[0] = 99; // updating arguments[0] does not also update a
  console.log(a);
}
funcWithDefault(10); // 10

function funcWithDefault2(a = 55) {
  a = 99; // updating a does not also update arguments[0]
  console.log(arguments[0]);
}
funcWithDefault2(10); // 10

// An untracked default parameter
function funcWithDefault3(a = 55) {
  console.log(arguments[0]);
  console.log(arguments.length);
}
funcWithDefault3(); // undefined; 0

Dies ist das gleiche Verhalten, das von allen Strict-Mode-Funktionen gezeigt wird, unabhängig von der Art der übergebenen Parameter. Das heißt, das Zuweisen neuer Werte zu Parametern im Körper der Funktion beeinflusst niemals das arguments Objekt, noch beeinflusst das Zuweisen neuer Werte zu den Indizes von arguments den Wert von Parametern, selbst wenn die Funktion nur einfache Parameter hat.

arguments ist ein array-ähnliches Objekt, was bedeutet, dass arguments eine length Eigenschaft und Eigenschaften indiziert ab null hat, aber nicht über die eingebauten Methoden von Array wie forEach() oder map() verfügt. Es kann jedoch in ein echtes Array konvertiert werden, indem einer der slice(), Array.from(), oder Spread-Syntax verwendet wird.

const args = Array.prototype.slice.call(arguments);
// or
const args = Array.from(arguments);
// or
const args = [...arguments];

Für häufige Anwendungsfälle ist es ausreichend, es als array-ähnliches Objekt zu verwenden, da es sowohl iterierbar ist als auch length und numerische Indizes hat. Zum Beispiel akzeptiert Function.prototype.apply() array-ähnliche Objekte.

function midpoint() {
  return (
    (Math.min.apply(null, arguments) + Math.max.apply(null, arguments)) / 2
  );
}

console.log(midpoint(3, 1, 4, 1, 5)); // 3

arguments.callee Veraltet

Referenz auf die aktuell ausgeführte Funktion, zu der die Argumente gehören. Im Strict-Mode verboten.

arguments.length

Die Anzahl der Argumente, die an die Funktion übergeben wurden.

arguments[Symbol.iterator]()

Gibt ein neues Array-Iterator Objekt zurück, das die Werte für jeden Index in arguments enthält.

Dieses Beispiel definiert eine Funktion, die mehrere Strings zusammenfügt. Das einzige formale Argument der Funktion ist ein String, der die Zeichen enthält, die die Elemente zum Zusammenfügen trennen.

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

Sie können beliebig viele Argumente an diese Funktion übergeben. Sie gibt eine String-Liste zurück, die jedes Argument in der Liste verwendet:

myConcat(", ", "red", "orange", "blue");
// "red, orange, blue"

myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
// "elephant; giraffe; lion; cheetah"

myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
// "sage. basil. oregano. pepper. parsley"

Dieses Beispiel definiert eine Funktion, die einen String erstellt, der HTML für eine Liste enthält. Das einzige formale Argument der Funktion ist ein String, der "u" ist, wenn die Liste ungeordnet (bulleted) sein soll, oder "o", wenn die Liste geordnet (nummeriert) sein soll. Die Funktion ist wie folgt definiert:

function list(type) {
  let html = `<${type}l><li>`;
  const args = Array.prototype.slice.call(arguments, 1);
  html += args.join("</li><li>");
  html += `</li></${type}l>`; // end list
  return html;
}

Sie können beliebig viele Argumente an diese Funktion übergeben, und sie fügt jedes Argument als Listenelement zu einer Liste des angegebenen Typs hinzu. Zum Beispiel:

list("u", "One", "Two", "Three");
// "<ul><li>One</li><li>Two</li><li>Three</li></ul>"

Der typeof Operator gibt 'object' zurück, wenn er mit arguments verwendet wird.

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

Der Typ einzelner Argumente kann ermittelt werden, indem arguments indiziert wird:

console.log(typeof arguments[0]); // returns the type of the first argument

• Leitfaden zu Funktionen
• Funktionen
• Rest-Parameter