Function.prototype.arguments — Eigenschaft · JavaScript-Referenz

Signatur

get Function.prototype.arguments

Beschreibung

funktion.arguments ist ein Überbleibsel aus den Anfängen von JavaScript. Die Eigenschaft liefert ein array-ähnliches Objekt mit den Argumenten, die der Funktion beim jüngsten noch laufenden Aufruf übergeben wurden. Läuft die Funktion gerade nicht, ist der Wert null. Bei rekursiven Aufrufen bezieht sich der Wert immer auf den innersten, noch aktiven Aufruf.

Die Eigenschaft steht in keinem Standard. Die ECMAScript-Spezifikation definiert auf Function.prototype nur einen Accessor, der beim Lesen und Schreiben einen TypeError wirft. Die Engines geben nicht-strikten, „normalen“ Funktionen (klassische function-Deklarationen und -Ausdrücke) trotzdem noch das Verhalten von früher mit. Bei Funktionen im Strict Mode, Pfeilfunktionen, Klassen- und Objektmethoden, async-Funktionen und Generatoren wirft der Zugriff dagegen einen TypeError.

In neuem Code solltest du die Eigenschaft nicht verwenden. Nimm stattdessen Rest-Parameter (...args) oder, in nicht-strikten Funktionen, das lokale arguments-Objekt innerhalb des Funktionskörpers. Nützlich ist Function.prototype.arguments heute höchstens, um Altcode zu verstehen oder beim Migrieren nach Stellen zu suchen, die den Strict Mode verhindern.

Rückgabewert

Typ

Arguments | null

Beschreibung

Ein array-ähnliches arguments-Objekt des innersten laufenden Aufrufs der Funktion, oder null, wenn die Funktion gerade nicht läuft. Bei strikten Funktionen, Pfeilfunktionen, Methoden, Klassen, async-Funktionen und Generatoren gibt es keinen Rückgabewert, weil ein TypeError geworfen wird.

Beispiele

Wert bei rekursiven Aufrufen und nach dem Ende der Funktion

// Nicht-strikter Code (klassisches Skript, kein ES-Modul)
function f(n) {
  g(n - 1);
}

function g(n) {
  console.log(`vorher: ${g.arguments[0]}`);
  if (n > 0) f(n);
  console.log(`nachher: ${g.arguments[0]}`);
}

f(2);
console.log(`nach Rückkehr: ${g.arguments}`);

vorher: 1 vorher: 0 nachher: 0 nachher: 1 nach Rückkehr: null

TypeError im Strict Mode und bei Pfeilfunktionen

function strikt() {
  'use strict';
  return strikt.arguments;
}

const pfeil = () => pfeil.arguments;

for (const fn of [strikt, pfeil]) {
  try {
    fn(1, 2);
  } catch (err) {
    console.log(`${fn.name}: ${err.constructor.name}`);
  }
}

strikt: TypeError pfeil: TypeError

Moderner Ersatz: Rest-Parameter

// Alt (veraltet, nur nicht-strikt):
// function summe() { return [...summe.arguments].reduce((a, b) => a + b, 0); }

// Neu: funktioniert überall, auch in Modulen und Pfeilfunktionen
const summe = (...zahlen) => zahlen.reduce((a, b) => a + b, 0);

console.log(summe(1, 2, 3, 4));
console.log(summe());

10 0

// Wichtig · Fallstricke

Veraltet und nicht standardisiert: Die Browser haben die Eigenschaft nur behalten, damit alte Webseiten weiter funktionieren. Verlass dich nicht darauf, dass sie sich überall gleich verhält.
Strict Mode: ES-Module und class-Körper laufen automatisch im Strict Mode. Dort wirft jeder Zugriff auf fn.arguments einen TypeError. Das gilt auch für Pfeilfunktionen, Methoden, async-Funktionen und Generatoren.
Nicht dasselbe wie das lokale arguments: Das zurückgegebene Objekt ist nicht unbedingt mit dem lokalen arguments im Funktionskörper identisch und spiegelt dessen Änderungen nicht zuverlässig wider. Bei Rekursion zeigt es immer auf den innersten Aufruf.
Performance und Sicherheit: Über die Eigenschaft kann fremder Code die Argumente einer laufenden Funktion auslesen. Außerdem erschwert sie Optimierungen der Engine. Genau deshalb wurde sie im Strict Mode gesperrt.
Die ebenfalls veraltete Schwester-Eigenschaft Function.prototype.caller unterliegt denselben Einschränkungen.

Siehe auch

Function.prototype.caller Function GeneratorFunction.prototype.prototype Function: prototype DataView.prototype.byteLength