Das arguments-Objekt

Probieren Sie es aus

function func1(a, b, c) {
  console.log(arguments[0]);
  // Expected output: 1

  console.log(arguments[1]);
  // Expected output: 2

  console.log(arguments[2]);
  // Expected output: 3
}

func1(1, 2, 3);

Beschreibung

Das arguments-Objekt ist eine lokale Variable, die innerhalb aller nicht-Arrow-Funktionen verfgbar ist. Sie knnen auf die Argumente einer Funktion innerhalb dieser Funktion durch Verwendung des arguments-Objekts zugreifen. Es hat Eintrge fr jedes Argument, mit dem die Funktion aufgerufen wurde, wobei der Index des ersten Eintrags bei 0 beginnt.

Zum Beispiel, wenn eine Funktion mit 3 Argumenten aufgerufen wird, knnen Sie auf diese wie folgt zugreifen:

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

Das arguments-Objekt ist ntzlich fr Funktionen, die mit mehr Argumenten aufgerufen werden, als sie formell zu akzeptieren deklariert sind, genannt variadische Funktionen, wie z.B. Math.min(). Diese Beispiel-Funktion akzeptiert eine beliebige Anzahl von Zeichenfolgen-Argumenten und gibt die lngste zurck:

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 knnen arguments.length verwenden, um zu zhlen, wie viele Argumente die Funktion bergeben wurden. Wenn Sie stattdessen zhlen mchten, wie viele Parameter eine Funktion zu akzeptieren deklariert ist, inspizieren Sie die length-Eigenschaft dieser Funktion.

Zuweisung zu Indizes

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 von Parametern 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 destruierte Parameter bergeben bekommen, synchronisieren keine neuen, im Funktionskrper zugewiesenen Parameterwerte mit dem arguments-Objekt. Stattdessen spiegelt das arguments-Objekt in nicht-strikten Funktionen mit komplexen Parametern immer die Werte wider, die der Funktion bergeben wurden, als die Funktion aufgerufen wurde.

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, unabhngig vom Typ der bergebenen Parameter. Das heit, die Zuweisung neuer Werte zu Parametern im Krper der Funktion beeinflusst nie das arguments-Objekt, genauso wenig wie die Zuweisung neuer Werte zu den Indizes von arguments den Wert von Parametern beeinflusst, selbst wenn die Funktion nur einfache Parameter hat.

arguments ist ein array-hnliches Objekt

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 von Array, wie z.B. forEach() oder map(), verfgt. Es kann jedoch in ein echtes Array umgewandelt werden, indem man eine von slice(), Array.from(), oder Spread-Syntax verwendet.

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

Fr allgemeine Anwendungsflle reicht es aus, 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

Eigenschaften

arguments.callee

Referenz auf die aktuell ausgefhrte Funktion, zu der die Argumente gehren. In strict mode verboten.

arguments.length

Die Anzahl der Argumente, die der Funktion bergeben wurden.

arguments[Symbol.iterator]()

Gibt ein neues Array Iterator-Objekt zurck, das die Werte fr jeden Index in arguments enthlt.

Beispiele

Definition einer Funktion, die mehrere Zeichenfolgen konkateniert

Dieses Beispiel definiert eine Funktion, die mehrere Zeichenfolgen konkateniert. Das einzige formale Argument der Funktion ist eine Zeichenfolge, die die Zeichen enthlt, die die zu konkatenierten Elemente trennen.

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

Sie knnen dieser Funktion beliebig viele Argumente bergeben. Sie gibt eine Zeichenfolgenliste zurck, indem sie 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"

Definition einer Funktion, die HTML-Listen erstellt

Dieses Beispiel definiert eine Funktion, die einen String enthlt, der HTML fr eine Liste erstellt. Das einzige formale Argument fr die Funktion ist eine Zeichenfolge, die "u" ist, wenn die Liste ungeordnet (mit Punkten) 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 knnen dieser Funktion eine beliebige Anzahl von Argumenten bergeben, und sie fgt 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>"

Verwendung von typeof mit arguments

Der typeof-Operator gibt 'object' zurck, wenn er mit arguments verwendet wird.

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

Der Typ der einzelnen Argumente kann durch Indizierung von arguments bestimmt werden:

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

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Leitfaden zu Funktionen
• Funktionen
• Rest-Parameter