javascript: funzione anonima ricorsiva?

Diciamo che ho una funzione ricorsiva di base:

function recur(data) {
    data = data+1;
    var nothing = function() {
        recur(data);
    }
    nothing();
}

Come potrei farlo se ho una funzione anonima come ...

(function(data){
    data = data+1;
    var nothing = function() {
        //Something here that calls the function?
    }
    nothing();
})();

Mi piacerebbe un modo per chiamare la funzione che ha chiamato questa funzione ... Ho visto script da qualche parte (non ricordo dove) che possono dirti il ​​nome di una funzione chiamata, ma non riesco a ricordare nessuno di quell'informazione adesso.

È possibile assegnare un nome alla funzione, anche quando si crea la funzione come valore e non come istruzione di "dichiarazione di funzione". In altre parole:

(function foo() { foo(); })();

è una funzione ricorsiva di stacking. Detto questo, probabilmente non vorrai farlo in generale perché ci sono alcuni strani problemi con varie implementazioni di Javascript. ( nota : questo è un commento abbastanza vecchio; alcuni / molti / tutti i problemi descritti nel post del blog di Kangax potrebbero essere risolti nei browser più moderni.)

Quando dai un nome del genere, il nome non è visibile al di fuori della funzione (beh, non dovrebbe esserlo; questa è una delle stranezze). È come "letrec" in Lisp.

Quanto a arguments.callee , ciò non è consentito in modalità "rigorosa" e generalmente è considerato una cosa negativa, perché rende difficili alcune ottimizzazioni. È anche molto più lento di quanto ci si potrebbe aspettare.

modifica - Se vuoi avere l'effetto di una funzione "anonima" che può chiamare se stessa, puoi fare qualcosa del genere (supponendo che tu stia passando la funzione come callback o qualcosa del genere):

asyncThingWithCallback(params, (function() {
  function recursive() {
    if (timeToStop())
      return whatever();
    recursive(moreWork);
  }
  return recursive;
})());

Ciò che fa è definire una funzione con un'istruzione di dichiarazione di funzione piacevole, sicura, non danneggiata in IE , creando una funzione locale il cui nome non inquinerà lo spazio dei nomi globale. La funzione wrapper (veramente anonima) restituisce solo quella funzione locale.

Le persone hanno parlato del combinatore Y nei commenti, ma nessuno lo ha scritto come risposta.

Il combinatore Y può essere definito in javascript come segue: (grazie a steamer25 per il link)

var Y = function (gen) {
  return (function(f) {
    return f(f);
  }(function(f) {
    return gen(function() {
      return f(f).apply(null, arguments);
    });
  }));
}

E quando vuoi passare la tua funzione anonima:

(Y(function(recur) {
  return function(data) {
    data = data+1;
    var nothing = function() {
      recur(data);
    }
    nothing();
  }
})());

La cosa più importante da notare su questa soluzione è che non dovresti usarla.

Combinatore U.

Passando una funzione a se stessa come argomento, una funzione può ricorrere utilizzando il suo parametro invece del suo nome! Quindi la funzione assegnata a Udovrebbe avere almeno un parametro che si legherà alla funzione (stessa).

Nell'esempio seguente, non abbiamo condizioni di uscita, quindi eseguiremo un ciclo indefinito fino a quando non si verificherà un overflow dello stack

const U = f => f (f) // call function f with itself as an argument

U (f => (console.log ('stack overflow imminent!'), U (f)))

Possiamo fermare la ricorsione infinita usando una varietà di tecniche. Qui scriverò la nostra funzione anonima per restituire un'altra funzione anonima che attende un input; in questo caso, un certo numero. Quando viene fornito un numero, se è maggiore di 0, continueremo a ricorrere, altrimenti restituiremo 0.

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

Ciò che non è immediatamente evidente qui è che la nostra funzione, quando applicata per la prima volta a se stessa utilizzando il Ucombinatore, restituisce una funzione in attesa del primo input. Se diamo un nome a questo, possiamo costruire efficacemente funzioni ricorsive usando lambda (funzioni anonime)

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

Solo che questa non è ricorsione diretta , una funzione che chiama se stessa usando il proprio nome. La nostra definizione di countDownnon si riferisce a se stessa all'interno del suo corpo ed è comunque possibile la ricorsione

// direct recursion references itself by name
const loop = (params) => {
  if (condition)
    return someValue
  else
    // loop references itself to recur...
    return loop (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)

Come rimuovere l'autoriferimento da una funzione esistente utilizzando il combinatore U.

Qui ti mostrerò come prendere una funzione ricorsiva che usa un riferimento a se stessa e cambiarla in una funzione che impiega il combinatore U al posto dell'autore riferimento

const factorial = x =>
  x === 0 ? 1 : x * factorial (x - 1)
  
console.log (factorial (5)) // 120

Ora usando il combinatore U per sostituire il riferimento interno a factorial

const U = f => f (f)

const factorial = U (f => x =>
  x === 0 ? 1 : x * U (f) (x - 1))

console.log (factorial (5)) // 120

Il modello di sostituzione di base è questo. Prendi nota mentalmente, useremo una strategia simile nella prossima sezione

// self reference recursion
const foo =         x => ...   foo (nextX) ...

// remove self reference with U combinator
const foo = U (f => x => ... U (f) (nextX) ...)

Combinatore Y.

correlati: i combinatori U e Y spiegati usando un'analogia speculare

Nella sezione precedente abbiamo visto come trasformare la ricorsione autoreferenziale in una funzione ricorsiva che non si basa su una funzione denominata utilizzando il combinatore U. C'è un po 'di fastidio anche se doversi ricordare di passare sempre la funzione a se stessa come primo argomento. Bene, il combinatore Y si basa sul combinatore U e rimuove quel pezzo noioso. Questa è una buona cosa perché rimuovere / ridurre la complessità è il motivo principale per cui creiamo funzioni

Innanzitutto, deriviamo il nostro combinatore Y molto personale

// standard definition
const Y = f => f (Y (f))

// prevent immediate infinite recursion in applicative order language (JS)
const Y = f => f (x => Y (f) (x))

// remove reference to self using U combinator
const Y = U (h => f => f (x => U (h) (f) (x)))

Ora vedremo come il suo utilizzo si confronta con il combinatore a U. Nota, per ricorrere, invece di U (f)possiamo semplicemente chiamaref ()

const U = f => f (f)

const Y = U (h => f => f (x => U (h) (f) (x)))

Y (f => (console.log ('stack overflow imminent!'),  f ()))

Ora mostrerò il countDownprogramma che usa Y: vedrai che i programmi sono quasi identici ma il combinatore Y mantiene le cose un po 'più pulite

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

E ora vedremo factorialanche noi

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

Come puoi vedere, fdiventa il meccanismo stesso della ricorsione. Per ricorrere, lo chiamiamo come una funzione ordinaria. Possiamo chiamarlo più volte con argomenti diversi e il risultato sarà comunque corretto. E poiché è un normale parametro di funzione, possiamo nominarlo come preferiamo, come di recurseguito -

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

Combinatore U e Y con più di 1 parametro

Negli esempi precedenti, abbiamo visto come possiamo ripetere e passare un argomento per tenere traccia dello "stato" del nostro calcolo. Ma cosa succede se dobbiamo tenere traccia dello stato aggiuntivo?

Abbiamo potuto utilizzare i dati composto come un array o qualcosa del genere ...

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

Ma questo è negativo perché espone lo stato interno (contatori ae b). Sarebbe bello se potessimo semplicemente chiamare fibonacci (7)per ottenere la risposta che vogliamo.

Usando ciò che sappiamo sulle funzioni curry (sequenze di funzioni unarie (1 parametro)), possiamo raggiungere facilmente il nostro obiettivo senza dover modificare la nostra definizione di Y o fare affidamento su dati composti o funzionalità linguistiche avanzate.

Guarda la definizione di fibonaccisotto. Ci stiamo candidando immediatamente 0e 1che sono vincolati a ae brispettivamente. Ora fibonacci sta semplicemente aspettando che venga fornito l'ultimo argomento a cui sarà legato x. Quando ricorriamo, dobbiamo chiamare f (a) (b) (x)(non f (a,b,x)) perché la nostra funzione è in forma curata.

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 13

Questo tipo di pattern può essere utile per definire tutti i tipi di funzioni. Di seguito vedremo altre due funzioni definite utilizzando il Ycombinatore ( rangee reduce) e un derivato di 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 ]

È TUTTO ANONIMO OMG

Poiché qui stiamo lavorando con funzioni pure, possiamo sostituire qualsiasi funzione denominata per la sua definizione. Guarda cosa succede quando prendiamo Fibonacci e sostituiamo le funzioni con nome con le loro espressioni

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

Ed ecco fatto: fibonacci (7)calcolato in modo ricorsivo utilizzando nient'altro che funzioni anonime

Potrebbe essere più semplice utilizzare un "oggetto anonimo" invece:

({
  do: function() {
    console.log("don't run this ...");
    this.do();
  }
}).do();

Il tuo spazio globale è completamente incontaminato. È abbastanza semplice. E puoi facilmente sfruttare lo stato non globale dell'oggetto.

È inoltre possibile utilizzare i metodi degli oggetti ES6 per rendere la sintassi più concisa.

({
  do() {
    console.log("don't run this ...");
    this.do();
  }
}).do();

Non lo farei come funzione inline. Sta spingendo contro i confini del buon gusto e non ti dà davvero nulla.

Se proprio devi, c'è arguments.calleecome nella risposta di Fabrizio. Tuttavia, questo è generalmente considerato sconsigliabile e non è consentito nella "modalità rigorosa" di ECMAScript Fifth Edition. Sebbene ECMA 3 e la modalità non rigorosa non verranno eliminati, lavorare in modalità rigorosa promette più ottimizzazioni linguistiche possibili.

Si può anche usare una funzione inline denominata:

(function foo(data){
    data++;
    var nothing = function() {
        foo(data);
    }
    nothing();
})();

Tuttavia, è meglio evitare anche le espressioni di funzione inline denominate, poiché JScript di IE fa loro alcune cose cattive. Nell'esempio precedente fooinquina erroneamente l'ambito padre in IE e il genitore fooè un'istanza separata da quella foovista all'internofoo .

Qual è lo scopo di metterlo in una funzione anonima inline? Se vuoi solo evitare di inquinare l'ambito genitore, puoi ovviamente nascondere il tuo primo esempio all'interno di un'altra funzione auto-chiamata anonima (spazio dei nomi). Hai davvero bisogno di creare una nuova copia di nothingogni volta intorno alla ricorsione? Potresti stare meglio con uno spazio dei nomi contenente due semplici funzioni reciprocamente ricorsive.

(function(data){
    var recursive = arguments.callee;
    data = data+1;
    var nothing = function() {
        recursive(data)
    }
    nothing();
})();

Potresti fare qualcosa come:

(foo = function() { foo(); })()

o nel tuo caso:

(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);

Quando dichiari una funzione anonima come questa:

(function () {
    // Pass
}());

È considerata un'espressione di funzione e ha un nome opzionale (che puoi usare per chiamarla dall'interno di se stessa. Ma poiché è un'espressione di funzione (e non un'istruzione) rimane anonima (ma ha un nome che puoi chiamare). questa funzione può chiamare se stessa:

(function foo () {
    foo();
}());
foo //-> undefined

Perché non passare la funzione alla funzione stessa?

    var functionCaller = function(thisCaller, data) {
        data = data + 1;
        var nothing = function() {
            thisCaller(thisCaller, data);
        };
        nothing();
    };
    functionCaller(functionCaller, data);

In alcune situazioni devi fare affidamento su funzioni anonime. Dato è una mapfunzione ricorsiva :

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 array

Notare che mapnon deve modificare la struttura dell'array. Quindi l'accumulatore accnon deve essere esposto. Possiamo avvolgere mapin un'altra funzione, ad esempio:

const map = f => xs => {
  let next = acc => ([head, ...tail]) => head === undefined
   ? acc
   : map ([...acc, f(head)]) (tail);

  return next([])(xs);
}

Ma questa soluzione è piuttosto prolissa. Usiamo il Ucombinatore sottovalutato :

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

Conciso, non è vero? Uè semplicissimo ma ha lo svantaggio che la chiamata ricorsiva viene un po 'offuscata: sum(...)diventa h(h)(...)- tutto qui.

Non sono sicuro che la risposta sia ancora richiesta, ma questo può essere fatto anche utilizzando delegati creati utilizzando function.bind:

    var x = ((function () {
        return this.bind(this, arguments[0])();
    }).bind(function (n) {
        if (n != 1) {
            return n * this.bind(this, (n - 1))();
        }
        else {
            return 1;
        }
    }))(5);

    console.log(x);

Questo non coinvolge funzioni o argomenti con nome.

Come ha scritto Bobince, semplicemente dai un nome alla tua funzione.

Ma immagino che tu voglia anche passare un valore iniziale e alla fine interrompere la tua funzione!

var initialValue = ...

(function recurse(data){
    data++;
    var nothing = function() {
        recurse(data);
    }
    if ( ... stop condition ... )
        { ... display result, etc. ... }
    else
        nothing();
}(initialValue));

esempio jsFiddle funzionante (usa dati + = dati per divertimento)

avevo bisogno (o meglio, volevo) una funzione anonima di una riga per camminare su un oggetto costruendo una stringa, e gestita in questo modo:

var cmTitle = 'Root' + (function cmCatRecurse(cmCat){return (cmCat == root) ? '' : cmCatRecurse(cmCat.parent) + ' : ' + cmCat.getDisplayName();})(cmCurrentCat);

che produce una stringa come "Root: foo: bar: baz: ..."

Con ES2015 possiamo giocare un po 'con la sintassi e abusare di parametri e thunk predefiniti. Queste ultime sono solo funzioni senza argomenti:

const applyT = thunk => thunk();

const fib = n => applyT(
  (f = (x, y, n) => n === 0 ? x : f(y, x + y, n - 1)) => f(0, 1, n)
);

console.log(fib(10)); // 55

// Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...

Si noti che fè un parametro con la funzione anonima (x, y, n) => n === 0 ? x : f(y, x + y, n - 1)come valore predefinito. Quando fviene richiamato da applyTquesta chiamata deve avvenire senza argomenti, in modo che venga utilizzato il valore predefinito. Il valore predefinito è una funzione e quindi fè una funzione denominata, che può chiamare se stessa in modo ricorsivo.

Un'altra risposta che non coinvolge la funzione denominata o arguments.callee

var sum = (function(foo,n){
  return n + foo(foo,n-1);
})(function(foo,n){
     if(n>1){
         return n + foo(foo,n-1)
     }else{
         return n;
     }
},5); //function takes two argument one is function and another is 5

console.log(sum) //output : 15

Questa è una rielaborazione della risposta jforjs con nomi diversi e una voce leggermente modificata.

// function takes two argument: first is recursive function and second is input
var sum = (function(capturedRecurser,n){
  return capturedRecurser(capturedRecurser, n);
})(function(thisFunction,n){
     if(n>1){
         return n + thisFunction(thisFunction,n-1)
     }else{
         return n;
     }
},5); 

console.log(sum) //output : 15

Non era necessario srotolare la prima ricorsione. La funzione che si riceve come riferimento richiama la melma primordiale dell'OOP.

Questa è una versione della risposta di @ zem con le funzioni delle frecce.

Puoi usare Uo ilY combinatore. Combinatore Y è il più semplice da usare.

U combinatore, con questo devi continuare a passare la funzione: const U = f => f(f) U(selfFn => arg => selfFn(selfFn)('to infinity and beyond'))

Y combinatore, con questo non devi continuare a passare la funzione: const Y = gen => U(f => gen((...args) => f(f)(...args))) Y(selfFn => arg => selfFn('to infinity and beyond'))

Ancora un'altra soluzione Y-combinator, utilizzando il collegamento codice rosetta (penso che qualcuno abbia precedentemente menzionato il collegamento da qualche parte su stackOverflow.

Le frecce sono per funzioni anonime più leggibili per me:

var Y = f => (x => x(x))(y => f(x => y(y)(x)));

Potrebbe non funzionare ovunque, ma puoi usarlo arguments.calleeper fare riferimento alla funzione corrente.

Quindi, fattoriale potrebbe essere fatto così:

var fac = function(x) { 
    if (x == 1) return x;
    else return x * arguments.callee(x-1);
}