Das arguments-Objekt — Keyword · JavaScript-Referenz

Signatur

arguments

Beschreibung

arguments ist eine lokale Variable, die in jeder mit function definierten Funktion automatisch zur Verfügung steht. Sie enthält alle tatsächlich übergebenen Argumente, auch solche, für die kein benannter Parameter existiert. Den Zugriff gibt es über den Index (arguments[0]), die Anzahl über arguments.length.

Das Objekt ist array-ähnlich, aber kein echtes Array: Es hat length und numerische Indizes, aber keine Array-Methoden wie map, filter oder forEach. Man kann es mit Array.from(arguments) oder [...arguments] umwandeln. Seit ES2015 ist es iterierbar und funktioniert daher mit for...of und dem Spread-Operator.

In modernem Code ersetzt man arguments meist durch Rest-Parameter (...args). Die liefern ein echtes Array, sind im Funktionskopf sichtbar und funktionieren auch in Pfeilfunktionen. Nützlich bleibt arguments vor allem in älterem Code, beim Weiterreichen aller Argumente in Wrapper-Funktionen ohne Rest-Syntax und wenn man prüfen will, wie viele Argumente wirklich übergeben wurden.

Rückgabewert

Typ

Arguments (array-ähnliches Objekt)

Beschreibung

Ein Objekt mit numerischen Indizes 0…n-1, der Eigenschaft length, Symbol.iterator sowie (nur im Non-Strict-Modus) arguments.callee.

Beispiele

Beliebig viele Argumente summieren

function summe() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

console.log(summe(1, 2, 3));
console.log(summe(10, 20, 30, 40));
console.log(summe());

6 100 0

In ein echtes Array umwandeln

function verbinde(trenner) {
  // erstes Argument ist der Trenner, der Rest sind die Teile
  const teile = Array.from(arguments).slice(1);
  return teile.map((t) => t.toUpperCase()).join(trenner);
}

console.log(verbinde(' | ', 'html', 'css', 'js'));

HTML | CSS | JS

Übergebene Argumente zählen (optionale Parameter erkennen)

function setzeWert(schluessel, wert) {
  if (arguments.length < 2) {
    return `Lese ${schluessel}`;
  }
  // unterscheidet 'nicht übergeben' von explizit undefined
  return `Setze ${schluessel} = ${wert}`;
}

console.log(setzeWert('farbe'));
console.log(setzeWert('farbe', undefined));

Lese farbe Setze farbe = undefined

Moderne Alternative: Rest-Parameter

const log = (level, ...nachrichten) => {
  // in Pfeilfunktionen gibt es kein eigenes arguments
  console.log(`[${level}]`, nachrichten.join(' '));
};

function wrapper() {
  // alle Argumente unverändert weiterreichen
  return log(...arguments);
}

wrapper('INFO', 'Server', 'gestartet');

[INFO] Server gestartet

// Wichtig · Fallstricke

Pfeilfunktionen haben kein eigenes arguments. Sie greifen auf das arguments der umgebenden Funktion zu oder lösen auf oberster Ebene eines Moduls einen ReferenceError aus. Nimm dort Rest-Parameter.
Kein echtes Array: arguments.map(...) löst einen TypeError aus. Wandle es vorher mit Array.from() oder [...arguments] um.
Kopplung an Parameter: Im Non-Strict-Modus und nur bei einfachen Parameterlisten sind arguments[i] und die benannten Parameter miteinander verknüpft. Eine Änderung an einem von beiden ändert auch den anderen. Im Strict-Modus und bei Standardwerten, Rest- oder Destrukturierungs-Parametern gibt es diese Verknüpfung nicht.
arguments.callee ist veraltet und löst im Strict-Modus (also auch in Klassen und ES-Modulen) einen TypeError aus. Nimm stattdessen benannte Funktionsausdrücke.
Im Strict-Modus darf man arguments nicht neu zuweisen und nicht als Bezeichner verwenden.
Performance: Wenn man arguments nach außen weiterreicht (z. B. return arguments), kann das Optimierungen der Engine verhindern. Rest-Parameter sind hier unproblematisch.
arguments.length ist die Zahl der übergebenen Argumente. fn.length dagegen ist die Zahl der deklarierten Parameter.

Siehe auch

Spread-Syntax Array.from() Function.prototype.apply() Function.length Öffentliche Klassenfelder