If the functionf was invoked by the top-level code, the value off.caller isnull; otherwise it's the function that calledf. If the function that calledf is a strict mode function, the value off.caller is alsonull.

Note that the only behavior specified by the ECMAScript specification is thatFunction.prototype has an initialcaller accessor that unconditionally throws aTypeError for anyget orset request (known as a "poison pill accessor"), and that implementations are not allowed to change this semantic for any function except non-strict plain functions, in which case it must not have the value of a strict mode function. The actual behavior of thecaller property, if it's anything other than throwing an error, is implementation-defined. For example, Chrome defines it as an own data property, while Firefox and Safari extend the initial poison-pillFunction.prototype.caller accessor to specially handlethis values that are non-strict functions.

(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

This property replaces the obsoletearguments.caller property of thearguments object.

The special property__caller__, which returned the activation object of the caller thus allowing to reconstruct the stack, was removed for security reasons.

The following code checks the value a function'scaller property.

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

Note that in case of recursion, you can't reconstruct the call stack using this property. Consider:

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

At the momentstop() is called the call stack will be:

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

The following is true:

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

so if you tried to get the stack trace in thestop() function like this:

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

the loop would never stop.

If the caller is a strict mode function, the value ofcaller isnull.

function callerFunc() {  calleeFunc();}function strictCallerFunc() {  "use strict";  calleeFunc();}function calleeFunc() {  console.log(calleeFunc.caller);}(function () {  callerFunc();})();// Logs [Function: callerFunc](function () {  strictCallerFunc();})();// Logs null

Not part of any standard.

• Function.prototype.name
• arguments