Function.prototype.caller

Beschreibung

Wenn die Funktion f durch den obersten Code aufgerufen wurde, ist der Wert von f.caller null; andernfalls ist es die Funktion, die f aufgerufen hat. Wenn die Funktion, die f aufgerufen hat, eine Strict-Modus-Funktion ist, ist der Wert von f.caller ebenfalls null.

Es ist zu beachten, dass das einzige Verhalten, das durch die ECMAScript-Spezifikation festgelegt ist, darin besteht, dass Function.prototype einen anfänglichen caller-Accessor hat, der bedingungslos einen TypeError für jede get oder set-Anforderung auslöst (bekannt als ein "Giftpille-Accessor"), und dass Implementierungen nicht erlaubt sind, diese Semantik für irgendeine Funktion zu ändern, außer für nicht-strict normale Funktionen, in welchem Fall sie nicht den Wert einer Strict-Modus-Funktion haben darf. Das tatsächliche Verhalten der caller-Eigenschaft, wenn es etwas anderes als das Auslösen eines Fehlers ist, ist implementationsspezifisch. Zum Beispiel definiert Chrome sie als eine eigene Dateneigenschaft, während Firefox und Safari den anfänglichen Giftpillen-Function.prototype.caller-Accessor erweitern, um this-Werte speziell zu behandeln, die nicht-strict Funktionen sind.

(function f() {
  if (Object.hasOwn(f, "caller")) {
    console.log(
      "caller is an own property with descriptor",
      Object.getOwnPropertyDescriptor(f, "caller"),
    );
  } else {
    console.log(
      "f doesn't have an own property named caller. Trying to get f.[[Prototype]].caller",
    );
    console.log(
      Object.getOwnPropertyDescriptor(
        Object.getPrototypeOf(f),
        "caller",
      ).get.call(f),
    );
  }
})();

// In Chrome:
// caller is an own property with descriptor {value: null, writable: false, enumerable: false, configurable: false}

// In Firefox:
// f doesn't have an own property named caller. Trying to get f.[[Prototype]].caller
// null

Diese Eigenschaft ersetzt die veraltete arguments.caller-Eigenschaft des arguments-Objekts.

Die spezielle Eigenschaft __caller__, die das Aktivierungsobjekt des Callers zurückgab und so die Rekonstruktion des Stacks ermöglichte, wurde aus Sicherheitsgründen entfernt.

Beispiele

Überprüfen des Werts der caller-Eigenschaft einer Funktion

Der folgende Code prüft den Wert der caller-Eigenschaft einer Funktion.

function myFunc() {
  if (myFunc.caller === null) {
    return "The function was called from the top!";
  }
  return `This function's caller was ${myFunc.caller}`;
}

Rekonstruktion des Stacks und Rekursion

Beachten Sie, dass im Falle einer Rekursion der Aufrufstapel mit dieser Eigenschaft nicht rekonstruiert werden kann. Beachten Sie:

function f(n) {
  g(n - 1);
}
function g(n) {
  if (n > 0) {
    f(n);
  } else {
    stop();
  }
}
f(2);

In dem Moment, in dem stop() aufgerufen wird, sieht der Aufrufstapel folgendermaßen aus:

f(2) -> g(1) -> f(1) -> g(0) -> stop()

Folgendes ist wahr:

stop.caller === g && f.caller === g && g.caller === f;

wenn Sie also versuchen würden, den Stack-Trace in der stop()-Funktion auf diese Weise zu ermitteln:

let f = stop;
let stack = "Stack trace:";
while (f) {
  stack += `\n${f.name}`;
  f = f.caller;
}

würde die Schleife niemals enden.

Strict-Modus-Caller

Wenn der Caller eine Strict-Modus-Funktion ist, ist der Wert von caller null.

function callerFunc() {
  calleeFunc();
}

function strictCallerFunc() {
  "use strict";
  calleeFunc();
}

function calleeFunc() {
  console.log(calleeFunc.caller);
}

(function () {
  callerFunc();
})();
// Logs [Function: callerFunc]

(function () {
  strictCallerFunc();
})();
// Logs null

Spezifikationen

Nicht Teil eines Standards.

Browser-Kompatibilität

Siehe auch

• Function.prototype.name
• arguments