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

Question

  

Mögliche Duplizieren:
   Wie kann ich voreinstellen Argumente in JavaScript-Funktionsaufruf? (Partial Funktion Anwendung)

ich in der Lage muß einen Verweis auf eine Funktion mit einem bestimmten Satz von Parametern übergeben .

Hier ist ein Beispiel eine Referenz vorbei 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

Nun, was ich tun muß, ist die gleiche f Funktion übergeben, aber dieses Mal würde ich braucht Parameter an die Referenz zu übergeben. Jetzt kann ich es mit einer anonymen Funktion tun und die f Funktion mit Parametern innerhalb der neu geschaffenen Funktion aufrufen, wie so:

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 Bezug auf die f Funktion Mit Parametern übergeben fr, ohne sie jedoch in einer anonymen Funktion umschließt?

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

[UPDATE] Ich folgte Jason Bunting 's Antwort auf hier über die Teilfunktion und die JavaScript-Funktion er Beiträge gibt es genau das, was ich suchte. 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);
  };
}

Answer 1

Was sind Sie nach heißt Teilfunktion Anwendung .

Lass dich nicht von denen, täuschen, die nicht den feinen Unterschied zwischen diesem und currying verstehen, sie sind anders.

Teilfunktion Anwendung kann zu implementieren verwendet werden, aber nicht currying. Hier ist ein Zitat von eine Blog-Post auf der Differenz :

  

Wo Teil Anwendung nimmt eine Funktion und daraus eine Funktion baut die weniger Argumente übernimmt, currying baut Funktionen, die durch die Zusammensetzung von Funktionen mehrere Argumente, die jeweils ein einziges Argument nehmen.

Dies wurde bereits beantwortet wurde, sehen diese Frage für Ihre Antwort: Wie kann ich voreingestellte Argumente in JavaScript-Funktionsaufruf

Beispiel:

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

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

Auch hier sieht diese Frage für die Details.

Answer 2

Sie können auch den Funktionsprototyp Überlastung:

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

Answer 3

Das folgende ist äquivalent zu Ihrem zweiten Codeblock:

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

var fr = f;

fr(pars);

Wenn Sie möchten, um tatsächlich einen Verweis auf eine Funktion an eine andere Funktion übergeben, können Sie etwas 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 fast sicher besser dran, einen Rahmen für diese Art der Sache mit, though.