Come posso passare un riferimento a una funzione, con parametri?

Possibile duplicato:
Come posso pre-impostare gli argomenti nella chiamata della funzione JavaScript? (Applicazione funzione parziale)

Devo riuscire a passare un riferimento a una funzione con un determinato set di parametri .

Ecco un esempio di passaggio di un riferimento senza parametri:

var f = function () { //Some logic here... }; var fr = f; //Here I am passing a reference to function 'f', without parameters fr(); //the 'f' function is invoked, without parameters 

Ora quello che devo fare è passare la stessa funzione f , ma questa volta avrei bisogno di passare i parametri al riferimento. Ora, posso farlo con una funzione anonima e invocare la funzione f con parametri all’interno della funzione appena creata, come tale:

 var f = function () { //Some logic here... }; var fr = function (pars) { f(pars); }; //Here I am creating an anonymous function, and invoking f inside it fr({p : 'a parameter'}); //Invoking the fr function, that will later invoke the f function with parameters 

Ma la mia domanda è: esiste un modo per passare un riferimento diretto alla funzione f con parametri a fr , ma senza racchiuderlo in una funzione anonima?

    Cosa devo assegnare a fr per renderlo invocabile senza parametri ( fr() ), in modo che f (1,2,3) venga eseguito quando viene richiamato fr ?

    [AGGIORNAMENTO] Ho seguito la risposta di Jason Bunting a proposito della Funzione parziale e la funzione JavaScript che pubblica è esattamente quello che stavo cercando. Ecco la soluzione:

     function partial(func /*, 0..n args */) { var args = Array.prototype.slice.call(arguments).splice(1); return function() { var allArguments = args.concat(Array.prototype.slice.call(arguments)); return func.apply(this, allArguments); }; } 

    Quello che cercate è chiamato applicazione a funzioni parziali .

    Non farti ingannare da quelli che non capiscono la sottile differenza tra quello e il curry, sono diversi.

    L’applicazione della funzione parziale può essere utilizzata per implementare, ma non sta funzionando . Ecco una citazione da un post sul blog sulla differenza :

    Dove un’applicazione parziale prende una funzione e da essa costruisce una funzione che impiega un numero minore di argomenti, le funzioni di compilazione di curring che prendono più argomenti per composizione di funzioni che ciascuno prende un singolo argomento.

    È già stata fornita una risposta, vedi questa domanda per la tua risposta: Come posso pre-impostare gli argomenti nella chiamata alla funzione JavaScript?

    Esempio:

     var fr = partial(f, 1, 2, 3); // now, when you invoke fr() it will invoke f(1,2,3) fr(); 

    Ancora una volta, vedi questa domanda per i dettagli.

    Puoi anche sovraccaricare il prototipo Function:

     // partially applies the specified arguments to a function, returning a new function Function.prototype.curry = function( ) { var func = this; var slice = Array.prototype.slice; var appliedArgs = slice.call( arguments, 0 ); return function( ) { var leftoverArgs = slice.call( arguments, 0 ); return func.apply( this, appliedArgs.concat( leftoverArgs ) ); }; }; // can do other fancy things: // flips the first two arguments of a function Function.prototype.flip = function( ) { var func = this; return function( ) { var first = arguments[0]; var second = arguments[1]; var rest = Array.prototype.slice.call( arguments, 2 ); var newArgs = [second, first].concat( rest ); return func.apply( this, newArgs ); }; }; /* eg var foo = function( a, b, c, d ) { console.log( a, b, c, d ); } var iAmA = foo.curry( "I", "am", "a" ); iAmA( "Donkey" ); -> I am a Donkey var bah = foo.flip( ); bah( 1, 2, 3, 4 ); -> 2 1 3 4 */ 

    Quanto segue è equivalente al tuo secondo blocco di codice:

     var f = function () { //Some logic here... }; var fr = f; fr(pars); 

    Se vuoi effettivamente passare un riferimento ad una funzione ad un’altra funzione, puoi fare qualcosa del genere:

     function fiz(x, y, z) { return x + y + z; } // elsewhere... function foo(fn, p, q, r) { return function () { return fn(p, q, r); } } // finally... f = foo(fiz, 1, 2, 3); f(); // returns 6 

    È quasi certamente meglio usare un framework per questo genere di cose, comunque.