arguments.callee

Wert

Ein Verweis auf die aktuell ausgefhrte Funktion.

Beschreibung

callee ist eine Eigenschaft des arguments-Objekts. Sie kann innerhalb des Funktionskrpers verwendet werden, um auf die aktuell ausgefhrte Funktion zu verweisen. Dies ist ntzlich, wenn der Name der Funktion unbekannt ist, wie bei einem Funktionsausdruck ohne Namen (auch als "anonyme Funktionen" bezeichnet).

(Der folgende Text ist weitgehend aus einer Stack Overflow-Antwort von olliej bernommen)

Frhe Versionen von JavaScript erlaubten keine benannten Funktionsausdrcke, und aus diesem Grund konnten Sie keinen rekursiven Funktionsausdruck erstellen.

Zum Beispiel funktionierte diese Syntax:

function factorial(n) {
  return n <= 1 ? 1 : factorial(n - 1) * n;
}

[1, 2, 3, 4, 5].map(factorial);

aber:

[1, 2, 3, 4, 5].map(function (n) {
  return n <= 1 ? 1 : /* what goes here? */ (n - 1) * n;
});

nicht. Um dies zu umgehen, wurde arguments.callee hinzugefgt, sodass Sie Folgendes tun konnten:

[1, 2, 3, 4, 5].map(function (n) {
  return n <= 1 ? 1 : arguments.callee(n - 1) * n;
});

Das Design von arguments.callee weist jedoch mehrere Probleme auf. Das erste Problem ist, dass der rekursive Aufruf einen anderen this-Wert erhlt. Zum Beispiel:

function sillyFunction(recursed) {
  if (this !== globalThis) {
    console.log("This is:", this);
  } else {
    console.log("This is the global");
  }

  if (!recursed) {
    return arguments.callee(true);
  }
}

sillyFunction();
// This is the global
// This is: [object Arguments]

Darber hinaus machen Verweise auf arguments.callee das Inlining und die Endrekursion im Allgemeinen unmglich. (In bestimmten Fllen knnen Sie dies durch Nachverfolgung usw. erreichen, aber selbst der beste Code ist aufgrund von berprfungen, die sonst nicht notwendig wren, suboptimal.)

ECMAScript 3 hat diese Probleme gelst, indem benannte Funktionsausdrcke erlaubt wurden. Zum Beispiel:

[1, 2, 3, 4, 5].map(function factorial(n) {
  return n <= 1 ? 1 : factorial(n - 1) * n;
});

Dies hat zahlreiche Vorteile:

• die Funktion kann wie jede andere innerhalb Ihres Codes aufgerufen werden
• sie erstellt keine Variable im ueren Bereich (auer bei IE 8 und darunter)
• sie hat eine bessere Performance als der Zugriff auf das arguments-Objekt

Der strict mode hat andere Eigenschaften verboten, die Stapelinformationen durchsickern, wie die caller-Eigenschaft von Funktionen. Dies liegt daran, dass das Betrachten des Aufrufstapels einen einzigen groen Effekt hat: Es macht eine groe Anzahl von Optimierungen unmglich oder viel schwieriger. Zum Beispiel, wenn Sie nicht garantieren knnen, dass eine Funktion f keine unbekannte Funktion aufruft, ist es nicht mglich, f zu inlineen.

function f(a, b, c, d, e) {
  return a ? b * c : d * e;
}

Wenn der JavaScript-Interpreter nicht garantieren kann, dass alle bergebenen Argumente zum Zeitpunkt des Aufrufs Zahlen sind, muss er entweder berprfungen fr alle Argumente vor dem inlangenen Code einfgen, oder er kann die Funktion nicht inlinen. Dies bedeutet, dass jede Aufrufstelle, die trivial inlinebar gewesen sein knnte, eine groe Anzahl an Wachen ansammelt. In diesem speziellen Fall sollte ein intelligenter Interpreter in der Lage sein, die berprfungen optimaler umzuordnen und keine Werte zu berprfen, die nicht verwendet wrden. In vielen Fllen ist dies jedoch einfach nicht mglich, und es wird unmglich, die Funktion zu inlinen.

Beispiele

Verwendung von arguments.callee in einer anonymen rekursiven Funktion

Eine rekursive Funktion muss in der Lage sein, sich selbst zu referenzieren. Normalerweise referenziert eine Funktion sich selbst ber ihren Namen. Eine anonyme Funktion (die durch einen Funktionsausdruck oder den Function-Konstruktor erstellt werden kann) hat jedoch keinen Namen. Wenn es daher keine zugngliche Variable gibt, die auf sie verweist, ist arguments.callee der einzige Weg, ber den die Funktion auf sich selbst verweisen kann.

Das folgende Beispiel definiert eine Funktion, die wiederum eine Fakulttsfunktion definiert und zurckgibt. Dieses Beispiel ist nicht sehr praktisch, und es gibt nahezu keine Flle, in denen dasselbe Ergebnis nicht mit benannten Funktionsausdrcken erreicht werden kann.

function create() {
  return function (n) {
    if (n <= 1) {
      return 1;
    }
    return n * arguments.callee(n - 1);
  };
}

const result = create()(5); // returns 120 (5 * 4 * 3 * 2 * 1)

Rekursion von anonymen Funktionen mit einem Y-Kombinator

Obwohl Funktionsausdrcke jetzt benannt werden knnen, bleiben Pfeilfunktionen immer anonym, was bedeutet, dass sie nicht auf sich selbst referenzieren knnen, ohne zuerst einer Variablen zugewiesen zu werden. Glcklicherweise gibt es im Lambda-Kalkl eine sehr gute Lsung, die es einer Funktion ermglicht, sowohl anonym als auch selbstreferenziell zu sein. Die Technik wird als Y-Kombinator bezeichnet. Hier wird nicht erklrt, wie es funktioniert, sondern nur, dass es funktioniert.

// The Y-combinator: a utility function!
const Y = (hof) => ((x) => x(x))((x) => hof((y) => x(x)(y)));

console.log(
  [1, 2, 3, 4, 5].map(
    // Wrap the higher-order function in the Y-combinator
    // "factorial" is not a function's name: it's introduced as a parameter
    Y((factorial) => (n) => (n <= 1 ? 1 : factorial(n - 1) * n)),
  ),
);
// [ 1, 2, 6, 24, 120 ]

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Funktionen Leitfaden
• Funktionen
• arguments
• Function.prototype.caller