48

ES6 中的箭头函数没有arguments属性，因此arguments.callee即使只使用匿名函数，也不会在严格模式下工作。

箭头函数不能命名，因此不能使用命名函数表达式技巧。

那么......如何编写递归箭头函数？那是一个箭头函数，它根据某些条件递归调用自己，当然等等？

4

13 回答 13

39

编写一个没有命名的递归函数是一个与计算机科学本身一样古老的问题（实际上甚至更早，因为 λ-演算早于计算机科学），因为在 λ-演算中，所有函数都是匿名的，但您仍然需要递归。

解决方案是使用定点组合器，通常是 Y 组合器。这看起来像这样：

(y => 
  y(
    givenFact => 
      n => 
        n < 2 ? 1 : n * givenFact(n-1)
  )(5)
)(le => 
  (f => 
    f(f)
  )(f => 
    le(x => (f(f))(x))
  )
);

这将5递归地计算阶乘。

注意：代码很大程度上基于：The Y Combinator Explained with JavaScript。所有功劳应归原作者所有。我大多只是“协调”（这就是你所说的用 ES/Harmony 的新功能重构旧代码吗？）。

于 2014-08-10T22:52:46.163 回答
20

看起来您可以将箭头函数分配给变量并使用它来递归调用该函数。

var complex = (a, b) => {
    if (a > b) {
        return a;
    } else {
        complex(a, b);
    }
};
于 2014-08-10T12:17:23.170 回答
16

Claus Reinke 在esdiscuss.org 网站的讨论中回答了您的问题。

在 ES6 中，您必须定义他所谓的递归组合器。

 let rec = (f)=> (..args)=> f( (..args)=>rec(f)(..args), ..args )

如果要调用递归箭头函数，则必须以箭头函数为参数调用递归组合器，箭头函数的第一个参数为递归函数，其余为参数。递归函数的名称并不重要，因为它不会在递归组合器之外使用。然后，您可以调用匿名箭头函数。这里我们计算 6 的阶乘。

 rec( (f,n) => (n>1 ? n*f(n-1) : n) )(6)

如果你想在 Firefox 中测试它，你需要使用递归组合器的 ES5 翻译：

function rec(f){ 
    return function(){
        return f.apply(this,[
                               function(){
                                  return rec(f).apply(this,arguments);
                                }
                            ].concat(Array.prototype.slice.call(arguments))
                      );
    }
}
于 2014-08-10T21:50:06.773 回答
10

使用分配函数的变量，例如

const fac = (n) => n>0 ? n*fac(n-1) : 1;

如果您真的需要匿名，请使用Y 组合器，如下所示：

const Y = (f) => ((x)=>f((v)=>x(x)(v)))((x)=>f((v)=>x(x)(v)))
… Y((fac)=>(n)=> n>0 ? n*fac(n-1) : 1) …

（丑陋，不是吗？）

于 2014-08-10T21:59:22.500 回答
7

TL;博士：

const rec = f => f((...xs) => rec(f)(...xs));

这里有很多关于正确 Y的变化的答案——但这有点多余......问题是 Y 的通常解释方式是“如果没有递归怎么办”，所以 Y 本身不能引用自己。但是由于这里的目标是一个实用的组合器，所以没有理由这样做。有这个答案定义了rec使用本身，但它很复杂而且有点难看，因为它添加了一个参数而不是柯里化。

简单的递归定义的 Y 是

const rec = f => f(rec(f));

但由于 JS 并不懒惰，因此上面添加了必要的包装。

于 2020-02-20T15:12:32.427 回答
4

用于任意数量参数的递归函数定义的通用组合器（不使用自身内部的变量）将是：

const rec = (le => ((f => f(f))(f => (le((...x) => f(f)(...x))))));

例如，这可以用于定义阶乘：

const factorial = rec( fact => (n => n < 2 ? 1 : n * fact(n - 1)) );
//factorial(5): 120

或字符串反转：

const reverse = rec(
  rev => (
    (w, start) => typeof(start) === "string" 
                ? (!w ? start : rev(w.substring(1), w[0] + start)) 
                : rev(w, '')
  )
);
//reverse("olleh"): "hello"

或有序树遍历：

const inorder = rec(go => ((node, visit) => !!(node && [go(node.left, visit), visit(node), go(node.right, visit)])));

//inorder({left:{value:3},value:4,right:{value:5}}, function(n) {console.log(n.value)})
// calls console.log(3)
// calls console.log(4)
// calls console.log(5)
// returns true
于 2016-11-11T23:38:16.737 回答
3

由于arguments.callee弃用/在严格模式下不起作用，这是一个不好的选择，并且做类似var func = () => {}的事情也很糟糕，所以这个答案中描述的黑客可能是你唯一的选择：

javascript：递归匿名函数？

于 2014-08-10T12:11:46.073 回答
3 
var rec = () => {rec()};
rec();

那会是一个选择吗？

于 2014-08-10T12:20:53.280 回答
3

我发现提供的解决方案非常复杂，而且老实说无法理解其中的任何一个，所以我自己想出了一个更简单的解决方案（我确信它已经知道，但这是我的思考过程）：

所以你正在制作一个阶乘函数

x => x < 2 ? x : x * (???)

(???) 是函数应该调用自身的地方，但是由于您无法命名它，因此显而易见的解决方案是将其作为参数传递给自身

f => x => x < 2 ? x : x * f(x-1)

不过这行不通。因为当我们调用时，我们调用f(x-1)的是这个函数本身，我们只是将它的参数定义为 1) f：函数本身，再次和 2)x值。好吧，我们确实有函数本身，f记得吗？所以先通过它：

f => x => x < 2 ? x : x * f(f)(x-1)
                            ^ the new bit

就是这样。我们刚刚创建了一个将自身作为第一个参数的函数，生成了 Factorial 函数！只需将其传递给自己：

(f => x => x < 2 ? x : x * f(f)(x-1))(f => x => x < 2 ? x : x * f(f)(x-1))(5)
>120

您可以创建另一个将其参数传递给自身的函数，而不是编写两次：

y => y(y)

并将您的阶乘生成函数传递给它：

(y => y(y))(f => x => x < 2 ? x : x * f(f)(x-1))(5)
>120

繁荣。这是一个小公式：

(y => y(y))(f => x => endCondition(x) ? default(x) : operation(x)(f(f)(nextStep(x))))

对于将数字从 0 添加到 的基本功能x，endCondition是当您需要停止重复时，所以x => x == 0. default是你给出的最后一个值endCondition，所以x => x. operation只是您在每次递归中所做的操作，例如在 Factorial 中相乘或在 Fibonacci 中添加：x1 => x2 => x1 + x2. 最后nextStep是传递给函数的下一个值，通常是当前值减一x => x - 1：申请：

(y => y(y))(f => x => x == 0 ? x : x + f(f)(x - 1))(5)
>15
于 2017-11-17T11:45:38.093 回答
2

这是这个答案的一个版本，https://stackoverflow.com/a/3903334/689223，带有箭头功能。

您可以使用U或Y组合符。Y 组合器是最简单易用的。

U组合器，有了这个你必须继续传递函数： const U = f => f(f) U(selfFn => arg => selfFn(selfFn)('to infinity and beyond'))

Y组合器，有了这个你不必继续传递函数： const Y = gen => U(f => gen((...args) => f(f)(...args))) Y(selfFn => arg => selfFn('to infinity and beyond'))

于 2016-12-20T20:15:03.567 回答
0

这里是递归函数js es6的例子。

 let filterGroups = [
     {name: 'Filter Group 1'}
 ];


 const generateGroupName = (nextNumber) => {
    let gN = `Filter Group ${nextNumber}`;
    let exists = filterGroups.find((g) => g.name === gN);
    return exists === undefined ? gN : generateGroupName(++nextNumber); // Important
 };


 let fg = generateGroupName(filterGroups.length);
 filterGroups.push({name: fg});
于 2020-12-29T06:55:44.037 回答
0

我认为最简单的解决方案是查看您唯一没有的东西，即对函数本身的引用。因为如果你有，那么回避是微不足道的。

令人惊讶的是，这可以通过高阶函数实现。

let generateTheNeededValue = (f, ...args) => f(f, ...args);

顾名思义，这个函数将生成我们需要的引用。现在我们只需要将它应用到我们的函数中

(generateTheNeededValue)(ourFunction, ourFunctionArgs)

但是使用这个东西的问题是我们的函数定义需要一个非常特殊的第一个参数

let ourFunction = (me, ...ourArgs) => {...}

我喜欢把这个特殊的价值称为“我”。现在每次我们需要递归时，我们都会这样做

me(me, ...argsOnRecursion);

所有这一切。我们现在可以创建一个简单的阶乘函数。

((f, ...args) => f(f, ...args))((me, x) => {
  if(x < 2) {
    return 1;
  } else {
    return x * me(me, x - 1);
  }
}, 4)

-> 24

我也喜欢看这个的一个班轮

((f, ...args) => f(f, ...args))((me, x) => (x < 2) ? 1 : (x * me(me, x - 1)), 4)
于 2019-05-24T23:06:58.333 回答
0

您可以将函数分配给 iife 中的变量

var countdown = f=>(f=a=>{
  console.log(a)
  if(a>0) f(--a)
})()

countdown(3)

//3
//2
//1
//0
于 2016-08-24T18:17:52.050 回答