Wie kann ich einen Verweis auf eine Funktion mit Parametern übergeben? [duplicate]

Mögliches Duplikat:

Wie kann ich Argumente im JavaScript-Funktionsaufruf voreinstellen? (Teilfunktionsanwendung)

Ich muss können Übergeben Sie einen Verweis auf eine Funktion mit einem bestimmten Satz von Parametern.

Hier ist ein Beispiel für die Übergabe einer Referenz ohne Parameter:

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

Jetzt muss ich das gleiche passieren f Funktion, aber dieses Mal müsste ich Parameter an die Referenz übergeben. Jetzt kann ich es mit einer anonymen Funktion machen und die aufrufen f Funktion mit Parametern innerhalb der neu erstellten Funktion, wie folgt:

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

Aber meine Frage ist, Gibt es eine Möglichkeit, einen direkten Verweis auf die zu übergeben f Funktion Mit Parametern bis fraber ohne es in eine anonyme Funktion einzuschließen?

Was muss ich zuweisen fr um es ohne Parameter aufrufbar zu machen (fr()), sodass f(1,2,3) ausgeführt wird, wenn fr wird aufgerufen?

[UPDATE]

Ich bin Jason Buntings Antwort hierher gefolgt Teilfunktion und die JavaScript-Funktion, die er dort postet, ist genau das, wonach ich gesucht habe. Hier ist die Lösung:

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

Was Sie suchen, heißt Teilfunktion Anwendung.

Lassen Sie sich nicht von denen täuschen, die den feinen Unterschied zwischen dem und Curry nicht verstehen, sie sind anders.

Teilfunktionsanwendung kann zur Implementierung verwendet werden, aber ist nicht Curry. Hier ein Zitat von ein Blogbeitrag über den Unterschied:

Während die partielle Anwendung eine Funktion übernimmt und daraus eine Funktion erstellt, die weniger Argumente benötigt, erstellt Currying Funktionen, die mehrere Argumente benötigen, indem Funktionen zusammengesetzt werden, die jeweils ein einzelnes Argument verwenden.

Dies wurde bereits beantwortet, siehe diese Frage für Ihre Antwort: Wie kann ich Argumente im JavaScript-Funktionsaufruf voreinstellen?

Beispiel:

var fr = partial(f, 1, 2, 3);

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

Siehe auch diese Frage für die Details.

Sie können den Funktionsprototyp auch überladen:

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

/*
e.g.

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

Folgendes entspricht Ihrem zweiten Codeblock:

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

var fr = f;

fr(pars);

Wenn Sie tatsächlich einen Verweis auf eine Funktion an eine andere Funktion übergeben möchten, können Sie Folgendes tun:

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

Sie sind jedoch mit ziemlicher Sicherheit besser dran, ein Framework für diese Art von Dingen zu verwenden.