arguments.callee

Свойство данных arguments.callee содержит текущую выполняемую функцию, к которой относятся аргументы.

Значение

Ссылка на текущую выполняемую функцию.

Описание

callee — это свойство объекта arguments. Оно может использоваться для ссылки на текущую выполняемую функцию внутри тела этой функции. Это полезно, когда имя функции неизвестно, например, внутри функционального выражения без имени (также называемого "анонимными функциями").

(Нижеследующий текст в значительной степени адаптирован из ответа на Stack Overflow от olliej)

Ранние версии JavaScript не разрешали именованные функциональные выражения, и по этой причине вы не могли создать рекурсивное функциональное выражение.

Например, этот синтаксис работал:

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

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

но:

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

не работал. Для обхода этой проблемы был добавлен arguments.callee, чтобы вы могли делать

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

Однако дизайн arguments.callee имеет несколько проблем. Первая проблема заключается в том, что рекурсивный вызов будет иметь другое значение this. Например:

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]

Кроме того, ссылки на arguments.callee делают невозможным встраивание и хвостовую рекурсию в общем случае. (Вы можете добиться этого в отдельных случаях с помощью трассировки и т. д., но даже лучший код будет субоптимальным из-за проверок, которые иначе не потребовались бы.)

ECMAScript 3 решил эти проблемы, разрешив именованные функциональные выражения. Например:

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

Это имеет множество преимуществ:

• функция может вызываться как любая другая из вашего кода
• она не создает переменную во внешней области видимости (кроме IE 8 и ниже)
• она имеет лучшую производительность, чем доступ к объекту arguments

Строгий режим запретил другие свойства, утекающие информацию о стеке, такие как свойство caller функций. Это связано с тем, что просмотр стека вызовов имеет один основной эффект: он делает большое количество оптимизаций невозможным или гораздо более трудным. Например, если вы не можете гарантировать, что функция f не вызовет неизвестную функцию, невозможно встроить f.

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

Если интерпретатор JavaScript не может гарантировать, что все предоставленные аргументы являются числами в момент вызова, ему необходимо либо вставить проверки для всех аргументов перед встраиваемым кодом, либо он не может встроить функцию. Это означает, что любой вызываемый сайт, который мог быть тривиально встроен, накапливает большое количество защитных механизмов. Теперь в этом конкретном случае умный интерпретатор должен уметь перестраивать проверки, чтобы они были более оптимальными и не проверяли значения, которые не будут использоваться. Однако во многих случаях это просто невозможно, и поэтому становится невозможным встраивание.

Примеры

Использование arguments.callee в анонимной рекурсивной функции

Рекурсивная функция должна уметь ссылаться сама на себя. Обычно функция ссылается на себя по своему имени. Однако анонимная функция (которую можно создать с помощью функционального выражения или конструктора Function) не имеет имени. Поэтому, если нет доступной переменной, ссылающейся на нее, единственный способ, которым функция может ссылаться сама на себя, — это через arguments.callee.

Следующий пример определяет функцию, которая, в свою очередь, определяет и возвращает факториальную функцию. Этот пример не очень практичен, и почти нет случаев, когда тот же результат нельзя было бы достичь с помощью именованных функциональных выражений.

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)

Рекурсия анонимных функций с Y-комбинатором

Хотя функциональные выражения теперь могут быть именованы, стрелочные функции всегда остаются анонимными, что означает, что они не могут ссылаться на себя, не будучи предварительно присвоенными переменной. К счастью, в лямбда-исчислении есть очень хорошее решение, позволяющее функции быть как анонимной, так и самореферентной. Эта техника называется Y-комбинатором. Здесь мы не будем объяснять, *как* это работает, только *то*, что это работает.

// 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 ]

Спецификации

Совместимость с браузерами

См. также

• Руководство по функциям
• Функции
• arguments
• Function.prototype.caller