Das `arguments`-Objekt

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

Beispielsweise, wenn eine Funktion mit 3 Argumenten aufgerufen wird, können Sie auf sie wie folgt 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 haben, sogenannte variadische Funktionen, wie z.B. Math.min(). Diese Beispiel-Funktion akzeptiert eine beliebige Anzahl von String-Argumenten und gibt das längste davon zurück:

function longestString() {
  let longest = "";
  for (let i = 0; i < arguments.length; i++) {
    if (arguments[i].length > longest.length) {
      longest = arguments[i];
    }
  }
  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 hat, untersuchen Sie die length-Eigenschaft dieser Funktion.

Jeder Argumentindex kann auch gesetzt oder neu zugewiesen werden:

arguments[1] = "new value";

Nicht-strikte Funktionen, die nur einfache Parameter haben (d.h. 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-(rest), Standard-(default) oder destrukturierte(destructured) Parameter übergeben bekommen, werden neue zugewiesene Werte der Parameter im Funktionskörper nicht mit dem arguments-Objekt synchronisieren. Stattdessen wird das arguments-Objekt in nicht-strikten Funktionen mit komplexen Parametern immer die Werte reflektieren, die der Funktion beim Aufruf ü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 alle strict-mode Funktionen zeigen, unabhängig davon, welche Art von Parametern sie übergeben bekommen. Das heißt, das Zuweisen neuer Werte zu den Parametern im Körper der Funktion beeinflusst niemals das arguments-Objekt, und das Zuweisen neuer Werte zu den arguments-Indizes beeinflusst auch nicht den Wert der Parameter, selbst wenn die Funktion nur einfache Parameter hat.

arguments ist ein array-ähnliches Objekt, was bedeutet, dass arguments eine length-Eigenschaft und von null indizierte Eigenschaften hat, aber nicht über die eingebauten Methoden des Array wie forEach() oder map() verfügt. Es kann jedoch in ein echtes Array umgewandelt werden, indem einer von 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 allgemeine Anwendungsfälle reicht es aus, arguments als array-ähnliches Objekt zu verwenden, da es sowohl iterierbar ist als auch length und nummerierte 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 derzeit ausgeführte Funktion, zu der die Argumente gehören. In 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 konkateniert. Das einzige formale Argument der Funktion ist ein String, der die Zeichen enthält, die die zu konkatenierenden Elemente 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 enthält, der HTML für eine Liste erstellt. Das einzige formale Argument für die Funktion ist ein Zeichenkette, die "u" ist, wenn die Liste ungeordnet (mit Aufzählungszeichen), oder "o" ist, wenn die Liste geordnet (nummeriert) sein soll. Die Funktion wird folgendermaßen 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 dieser Funktion eine beliebige Anzahl von Argumenten ü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 durch Indizierung von arguments bestimmt werden:

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

• Funktionen Leitfaden
• Funktionen
• Rest-Parameter