假设我有一个基本的递归函数：
function recur(data) {
data = data+1;
var nothing = function() {
recur(data);
}
nothing();
}
如果我有一个匿名函数，我该怎么做呢？...
(function(data){
data = data+1;
var nothing = function() {
//Something here that calls the function?
}
nothing();
})();
我希望有一种方法可以调用调用当前函数的函数... 我曾经在某个地方看到过脚本（我现在记不起来了）可以告诉您被调用的函数的名称，但我现在无法回想起任何与此相关的信息。
即使您将函数创建为值而不是“函数声明”语句，也可以为函数命名。换句话说：
您可以给函数命名。
(function foo() { foo(); })();
这是一个递归函数，使用了栈溢出的技巧。但一般情况下 你可能不想 不建议使用它，因为在各种JavaScript实现中存在一些奇怪的问题。（注：这是一个相当古老的评论；部分/许多/全部Kangax的博客文章中描述的问题可能已经在更现代化的浏览器中得到解决。）
当你给函数起这样的名称时，名称在函数外部不可见（好吧，它本应该不可见；这是其中的一个奇怪之处）。这就像Lisp中的"letrec"。
至于arguments.callee，它在“严格”模式下被禁止，并且通常被认为是一个糟糕的事情，因为它使某些优化难以实现。它也比人们期望的要慢得多。
编辑 - 如果你想要一个可以调用自身的“匿名”函数的效果，你可以像这样做（假设你正在把函数作为回调传递或类似情况）：
asyncThingWithCallback(params, (function() {
function recursive() {
if (timeToStop())
return whatever();
recursive(moreWork);
}
return recursive;
})());
这样做的作用是定义一个函数，使用良好、安全且在IE中不会出现错误的函数声明语句，创建一个本地函数，其名称不会污染全局命名空间。包装器（真正匿名）函数只返回该本地函数。
(() => { call_recursively_self_here() })() 并递归调用函数自身是不可能的，对吗？我必须给它一个名字。 - Qwertyrecursive)通过名称调用自身，因此实际上它不是匿名递归函数。但是用户633183在这里展示了（https://dev59.com/dG865IYBdhLWcg3wTctY#43195580），这是可能的。 - Kamil Kiełczewski在评论中人们谈论了Y组合器，但没有人将其写成答案。
Y组合器可以用以下javascript代码定义：（感谢steamer25提供的链接）
var Y = function (gen) {
return (function(f) {
return f(f);
}(function(f) {
return gen(function() {
return f(f).apply(null, arguments);
});
}));
}
当您想传递匿名函数时：
(Y(function(recur) {
return function(data) {
data = data+1;
var nothing = function() {
recur(data);
}
nothing();
}
})());
这个解决方案最重要的一点是，你不应该使用它。
U组合器
通过将一个函数作为参数传递给自身，函数可以使用其参数而不是名称来进行递归！ 因此，给定给 U 的函数应至少有一个参数，该参数将绑定到该函数（它本身）。
在下面的示例中，我们没有退出条件，因此我们会无限循环，直到发生堆栈溢出。
const U = f => f (f) // call function f with itself as an argument
U (f => (console.log ('stack overflow imminent!'), U (f)))const log = x => (console.log (x), x)
const U = f => f (f)
// when our function is applied to itself, we get the inner function back
U (f => x => x > 0 ? U (f) (log (x - 1)) : 0)
// returns: (x => x > 0 ? U (f) (log (x - 1)) : 0)
// where f is a reference to our outer function
// watch when we apply an argument to this function, eg 5
U (f => x => x > 0 ? U (f) (log (x - 1)) : 0) (5)
// 4 3 2 1 0这里并不立即显而易见的是，当我们首次使用 U 组合子将函数应用于自身时，它会返回一个等待第一个输入的函数。如果我们给它一个名称，就可以有效地使用 lambda 表达式（匿名函数）构建递归函数。
const log = x => (console.log (x), x)
const U = f => f (f)
const countDown = U (f => x => x > 0 ? U (f) (log (x - 1)) : 0)
countDown (5)
// 4 3 2 1 0
countDown (3)
// 2 1 0只是这不是直接递归——一个使用自己的名字调用自己的函数。我们定义的countDown函数在其主体内没有引用自身，但仍然可以进行递归。
// direct recursion references itself by name
const loop = (params) => {
if (condition)
return someValue
else
// loop references itself to recur...
return <b>loop</b> (adjustedParams)
}
// U combinator does not need a named reference
// no reference to `countDown` inside countDown's definition
const countDown = U (f => x => x > 0 ? U (f) (log (x - 1)) : 0)如何使用U组合子从现有函数中删除自引用
本文将向您展示如何将使用自引用的递归函数更改为使用U组合子替代自引用的函数。
const factorial = x =>
x === 0 ? 1 : x * factorial (x - 1)
console.log (factorial (5)) // 120现在使用U组合子来替换对factorial的内部引用
const U = f => f (f)
const factorial = U (f => x =>
x === 0 ? 1 : x * U (f) (x - 1))
console.log (factorial (5)) // 120// self reference recursion
const foo = x => ... foo (nextX) ...
// remove self reference with U combinator
const foo = U (f => x => ... U (f) (nextX) ...)
Y组合子
相关： 使用镜子类比讲解U和Y组合子
在前一节中，我们了解了如何将自我引用递归转换为不依赖命名函数的递归函数，方法是使用 U 组合子。但有一个小烦恼，就是必须记住总是将函数作为第一个参数传递给它本身。那么，Y 组合子建立在 U 组合子的基础上，并消除了那个繁琐的部分。这是个好事情，因为减少复杂性是我们构建函数的主要原因。
首先，让我们推导出自己的 Y 组合子。
// standard definition
const Y = f => f (Y (f))
// prevent immediate infinite recursion in applicative order language (JS)
const Y = f => f (<b>x =></b> Y (f) <b>(x)</b>)
// remove reference to self using U combinator
const Y = <b>U (h =></b> f => f (x => <b>U (h)</b> (f) (x))<b>)</b>现在我们将看到它的使用与 U-combinator 的比较。请注意，为了进行递归，我们可以简单地调用 f() 而不是 U(f)。
const U = f => f (f)
const Y = U (h => f => f (x => U (h) (f) (x)))
Y (f => (console.log ('stack overflow imminent!'), f ()))现在我将演示使用Y的countDown程序 - 您会发现这两个程序几乎相同，但Y组合子使事情变得更加简洁。
const log = x => (console.log (x), x)
const U = f => f (f)
const Y = U (h => f => f (x => U (h) (f) (x)))
const countDown = Y (f => x => x > 0 ? f (log (x - 1)) : 0)
countDown (5)
// 4 3 2 1 0
countDown (3)
// 2 1 0现在我们将看到 阶乘
const U = f => f (f)
const Y = U (h => f => f (x => U (h) (f) (x)))
const factorial = Y (f => x =>
x === 0 ? 1 : x * f (x - 1))
console.log (factorial (5)) // 120正如您所看到的，f 成为了递归本身的机制。要进行递归，我们像调用普通函数一样调用它。我们可以使用不同的参数多次调用它，结果仍然是正确的。由于它是普通函数参数，因此我们可以随意命名，例如下面的 recur -
const U = f => f (f)
const Y = U (h => f => f (x => U (h) (f) (x)))
const fibonacci = Y (recur => n =>
n < 2 ? n : recur (n - 1) + (n - 2))
console.log (fibonacci (10)) // 55具有多个参数的U和Y组合子
在上面的示例中，我们看到了如何循环并传递参数以跟踪我们计算的“状态”。但是如果我们需要跟踪其他状态怎么办？
我们可以使用类似于数组或其他复合数据类型的东西...
const U = f => f (f)
const Y = U (h => f => f (x => U (h) (f) (x)))
const fibonacci = Y (f => ([a, b, x]) =>
x === 0 ? a : f ([b, a + b, x - 1]))
// starting with 0 and 1, generate the 7th number in the sequence
console.log (fibonacci ([0, 1, 7]))
// 0 1 1 2 3 5 8 13但这样做是不好的，因为它暴露了内部状态（计数器a和b）。如果我们只能调用fibonacci (7)来获得我们想要的答案就好了。
利用我们对柯里化函数（一次只接受一个参数的函数序列）的了解，我们可以轻松实现我们的目标，而无需修改Y的定义，也不需要依赖于复合数据或高级语言特性。
仔细看一下下面的fibonacci的定义。我们立即应用了绑定到a和b上的0和1。现在，fibonacci只是在等待最后一个参数被提供，并将其绑定到x上。当我们进行递归时，我们必须调用f(a)(b)(x)（而不是f(a,b,x)），因为我们的函数处于柯里化形式。
const U = f => f (f)
const Y = U (h => f => f (x => U (h) (f) (x)))
const fibonacci = Y (f => a => b => x =>
x === 0 ? a : f (b) (a + b) (x - 1)) (0) (1)
console.log (fibonacci (7))
// 0 1 1 2 3 5 8 13Y组合器（range和reduce）定义的两个函数和reduce的一个导数map。
const U = f => f (f)
const Y = U (h => f => f (x => U (h) (f) (x)))
const range = Y (f => acc => min => max =>
min > max ? acc : f ([...acc, min]) (min + 1) (max)) ([])
const reduce = Y (f => g => y => ([x,...xs]) =>
x === undefined ? y : f (g) (g (y) (x)) (xs))
const map = f =>
reduce (ys => x => [...ys, f (x)]) ([])
const add = x => y => x + y
const sq = x => x * x
console.log (range (-2) (2))
// [ -2, -1, 0, 1, 2 ]
console.log (reduce (add) (0) ([1,2,3,4]))
// 10
console.log (map (sq) ([1,2,3,4]))
// [ 1, 4, 9, 16 ]一切都是匿名的，哇哦
因为我们在这里使用的是纯函数，所以我们可以用其定义替换任何命名函数。看看当我们将斐波那契数列中的命名函数替换为它们的表达式时会发生什么。
/* const U = f => f (f)
*
* const Y = U (h => f => f (x => U (h) (f) (x)))
*
* const fibonacci = Y (f => a => b => x => x === 0 ? a : f (b) (a + b) (x - 1)) (0) (1)
*
*/
/*
* given fibonacci (7)
*
* replace fibonacci with its definition
* Y (f => a => b => x => x === 0 ? a : f (b) (a + b) (x - 1)) (0) (1) (7)
*
* replace Y with its definition
* U (h => f => f (x => U (h) (f) (x))) (f => a => b => x => x === 0 ? a : f (b) (a + b) (x - 1)) (0) (1) (7)
//
* replace U with its definition
* (f => f (f)) U (h => f => f (x => U (h) (f) (x))) (f => a => b => x => x === 0 ? a : f (b) (a + b) (x - 1)) (0) (1) (7)
*/
let result =
(f => f (f)) (h => f => f (x => h (h) (f) (x))) (f => a => b => x => x === 0 ? a : f (b) (a + b) (x - 1)) (0) (1) (7)
console.log (result) // 13就是这样 - 使用匿名函数递归计算fibonacci(7)
({
do: function() {
console.log("don't run this ...");
this.do();
}
}).do();
您的全局空间完全没有受到污染。这很简单明了。而且您可以轻松地利用对象的非全局状态。
您还可以使用ES6对象方法使语法更加简洁。
({
do() {
console.log("don't run this ...");
this.do();
}
}).do();
Array.map 或 Array.forEach。替代方案：我们不想污染全局范围，使用模块可以轻易实现此目的。如果将代码分成模块，函数就不会污染全局范围。它将保持未导出状态，并且只会“污染”其模块的空间。是的，我们会牺牲可读性，但至少它能够工作。 - Ahmed Shaqanbiarguments.callee。但是这通常被认为是不可取的，在ECMAScript第五版的“严格模式”中被禁止。虽然ECMA 3和非严格模式并没有消失，但在严格模式下工作可以提供更多可能的语言优化。(function foo(data){
data++;
var nothing = function() {
foo(data);
}
nothing();
})();
然而，被命名的内联函数表达式也最好避免，因为IE的JScript会对它们做一些不好的事情。在上面的例子中，foo 在IE中错误地污染了父级作用域，而父级的 foo 是一个单独的实例，与在 foo 中看到的 foo 不同。
把这个代码放在匿名内联函数中有什么目的？如果你只想避免污染父级作用域，当然可以将你的第一个示例隐藏在另一个自调用的匿名函数（命名空间）中。你真的需要在每次递归时创建一个 nothing 的新副本吗？你可能会更好地使用一个包含两个简单相互递归函数的命名空间。
recur_foo这样的名称很难与父作用域中的函数发生冲突（或被误用）。 - gblazex(function(data){
var recursive = arguments.callee;
data = data+1;
var nothing = function() {
recursive(data)
}
nothing();
})();
arguments.callee存在的问题：在严格模式和ES5中，它是被禁止使用的。 - Pointy您可以进行以下操作：
(foo = function() { foo(); })()
(recur = function(data){
data = data+1;
var nothing = function() {
if (data > 100) return; // put recursion limit
recur(data);
}
nothing();
})(/* put data init value here */ 0);
var 语句先声明 recur。不知道这是否违反了问题的规则，但是如果现在没有 var 语句，那么在 ECMAScript 5 严格模式下会出现错误。 - Tim Downvar 关键字，但一旦我测试了这段代码，它就会抛出错误，因为你不能在自调用块内声明变量，而我的方法依赖于未定义变量的自动声明，因此 @Pointy 的解决方案更正确。不过，我仍然投了 Fabrizio Calderan 的答案 ;) - ArtBIT(var recur = function() {...})();不起作用，因为它现在是一个语句而不是赋值表达式（返回分配的值）。我建议改为var recur; (recur = function() {...})();。 - Tim Down在某些情况下，您必须依靠匿名函数。 给出一个递归的map函数：
const map = f => acc => ([head, ...tail]) => head === undefined
? acc
: map (f) ([...acc, f(head)]) (tail);
const sqr = x => x * x;
const xs = [1,2,3,4,5];
console.log(map(sqr) ([0]) (xs)); // [0] modifies the structure of the arraymap不能修改数组的结构。因此累加器acc不需要暴露出来。我们可以将map包装在另一个函数中，例如：const map = f => xs => {
let next = acc => ([head, ...tail]) => head === undefined
? acc
: map ([...acc, f(head)]) (tail);
return next([])(xs);
}
但是这个解决方案相当啰嗦。让我们使用被低估的U组合子：
const U = f => f(f);
const map = f => U(h => acc => ([head, ...tail]) => head === undefined
? acc
: h(h)([...acc, f(head)])(tail))([]);
const sqr = x => x * x;
const xs = [1,2,3,4,5];
console.log(map(sqr) (xs));简洁易懂，不是吗？U非常简单，但有一个缺点就是递归调用有点难懂：sum(...)变成了h(h)(...) - 就是这样。
(function () {
// Pass
}());
这被认为是一个函数表达式，它有一个可选的名称（您可以使用该名称从内部调用它）。但由于它是一个函数表达式（而不是语句），因此它是匿名的（但有一个名称可供调用）。因此，这个函数可以调用自身：
(function foo () {
foo();
}());
foo //-> undefined
foo 没有在当前上下文中声明，但这或多或少是无关紧要的。带有名称的函数仍然是命名函数 - 不是 匿名的。 - Mulan var functionCaller = function(thisCaller, data) {
data = data + 1;
var nothing = function() {
thisCaller(thisCaller, data);
};
nothing();
};
functionCaller(functionCaller, data);
arguments.callee存在，而这个函数并没有做任何有用的事情。我正在查找Y组合子，该东西永远不会变得有用... - Kobi