it-swarm.com.de

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

Mögliches Duplizieren:
Wie kann ich im JavaScript-Funktionsaufruf Argumente voreinstellen? (Partial Function Application)

Ich muss in der Lage sein, einen Verweis auf eine Funktion mit einem bestimmten Satz von Parametern zu übergeben.

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 dieselbe f -Funktion übergeben, aber dieses Mal müsste ich Parameter an die Referenz übergeben. Jetzt kann ich es mit einer anonymen Funktion machen und die Funktion f mit Parametern innerhalb der neu erstellten Funktion aufrufen, wie zum Beispiel:

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 Funktion f mit Parametern an fr zu übergeben, ohne ihn jedoch in eine anonyme Funktion einzuschließen?

Was muss ich fr zuweisen, damit es ohne Parameter aufgerufen werden kann (fr()), damit f (1,2,3) ausgeführt wird, wenn fr wird aufgerufen?

[UPDATE] Ich bin Jason Bunting s Antwort auf hier über die Teilfunktion und die JavaScript-Funktion gefolgt Er postet dort 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);
  };
}
88
Andreas Grech

Was Sie suchen, heißt Teilfunktionsanwendung .

Lass dich nicht von denen täuschen, die den subtilen Unterschied zwischen dem und dem Curry nicht verstehen, sie sind sind verschieden.

Teilfunktionsanwendung kann verwendet werden, um zu implementieren, aber ist nicht currying. Hier ist ein Zitat aus einem Blogbeitrag über den Unterschied :

Wenn eine Teilanwendung eine Funktion übernimmt und daraus eine Funktion mit weniger Argumenten erstellt, erstellt currying Funktionen, die mehrere Argumente annehmen, indem Funktionen zusammengesetzt werden, die jeweils ein einziges Argument enthalten.

Dies wurde bereits beantwortet, sehen Sie 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.

78
Jason Bunting

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