Wie Schreibe ich einen Pfeil Funktion im ES6 rekursiv?

Claus Reinke gegeben hat, eine Antwort auf Ihre Frage in eine Diskussion über die esdiscuss.org website.

In ES6 Sie haben zu definieren, was er fordert eine Rekursion combinator.

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

Wenn Sie möchten, rufen Sie eine rekursive Pfeil-Funktion, müssen Sie zum Aufruf der Rekursion combinator mit den Pfeil-Funktion als parameter, der erste parameter der Pfeil-Funktion ist eine rekursive Funktion, und der rest sind die Parameter. Der name des rekursiven Funktion hat keine Bedeutung, als wäre es nicht verwendet werden, außerhalb der rekursiven combinator. Sie können dann aufrufen, die anonyme Pfeil-Funktion. Hier berechnen wir die Fakultät von 6.

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

Wenn Sie wollen, um es zu testen in Firefox müssen Sie mit den ES5 übersetzung der Rekursion combinator:

function rec(f){ 
    return function(){
        return f.apply(this,[
                               function(){
                                  return rec(f).apply(this,arguments);
                                }
                            ].concat(Array.prototype.slice.call(arguments))
                      );
    }
}

Verwenden Sie eine variable, die Sie zuweisen die Funktion, z.B.

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

Wenn Sie es wirklich brauchen anonyme, verwenden Sie die Y combinator, wie diese:

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) …

(ist das nicht häßlich?)

Seit arguments.callee ist eine schlechte option, aufgrund der Missbilligung/funktioniert nicht im strict-Modus, und etwas zu tun, wie var func = () => {} auch schlecht ist, ist dies ein hack wie beschrieben, in dieser Antwort ist wahrscheinlich Ihre einzige option:

javascript: rekursive anonyme Funktion?

Zuzuordnen, können Sie Ihre Funktion um eine variable in einem iife

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

countdown(3)

//3
//2
//1
//0

Ich fand die Lösungen sehr kompliziert, und ehrlich gesagt konnte nicht verstehen, alle von Ihnen, so dachte ich, sich eine einfachere Lösung ist mir (ich bin sicher, es ist schon bekannt, aber hier geht meiner Denkweise):

So, du machst eine faktorielle Funktion

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

den (???) ist, wo die Funktion soll sich selbst aufrufen, aber da kann man es nicht benennen, ist die offensichtliche Lösung ist, um übergeben Sie Sie als argument an sich

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

Dies wird nicht funktionieren wenn. denn wenn wir rufen f(x-1) wir nennen diese Funktion selbst, und wir gerade definiert es die Argumente wie 1) f: die Funktion selbst wieder und 2) x den Wert. Auch wir haben die Funktion selbst f erinnern? so einfach geben Sie zunächst:

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

... Und das ist es. Wir haben eine Funktion, sich selbst als das erste argument, die Herstellung der Factorial-Funktion! Nur wörtlich weitergeben zu sich selbst:

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

Anstelle des Schreibens es zweimal, können Sie eine weitere Funktion, die vergeht, es ist argument, um zu sich selbst:

y => y(y)

und pass deine factorial-Funktion machen es:

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

Boom. Hier eine kleine Formel:

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

Für eine basic-Funktion fügt hinzu, dass die zahlen von 0 bis x, endCondition ist, wenn Sie benötigen, um immer wiederkehrende, also x => x == 0. default ist der Letzte Wert, den Sie geben einmal endCondition erfüllt ist, so x => x. operation ist einfach der Vorgang, den Sie tun auf jeden Rekursion, wie die Multiplikation in der Fakultät oder hinzufügen, die in Fibonacci: x1 => x2 => x1 + x2. und schließlich nextStep ist der nächste Wert der Funktion übergibt, die in der Regel den aktuellen Wert minus eins: x => x - 1. Anwendung:

(y => y(y))(f => x => x == 0 ? x : x + f(f)(x - 1))(5)
>15