Comment puis-je passer une référence à une fonction, avec des paramètres? [dupliquer]

Question

  

Possible en double:    Comment puis-je effectuer une pré-set arguments en appel de fonction JavaScript? (Application partielle de fonction)

Je dois pouvoir passer une référence à une fonction avec un ensemble de paramètres .

Voici un exemple de passer une référence sans paramètres :

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

Maintenant, ce que je dois faire est de passer la même fonction de f, mais cette fois je aurais besoin de passer des paramètres à la référence. Maintenant, je peux le faire avec une fonction anonyme et appeler la fonction de f avec des paramètres dans la fonction nouvellement créée, comme par exemple:

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

Mais ma question est, Est-il possible de passer une référence directe à la fonction f Avec paramètres à fr, mais sans l'enfermer dans une fonction anonyme?

Que dois-je attribuer à fr pour le rendre invocable sans paramètres (fr()), de sorte que f (1,2,3) est exécutée lorsque fr est invoquée?

[UPDATE] Je suivais la réponse de Jason Bunting sur les Fonction partielle et la fonction JavaScript il affiche il y a exactement ce que je cherchais. Voici la solution:

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

Ce que vous AFTER est appelé application de fonction partielle .

Ne vous laissez pas berner par ceux qui ne leur sont comprennent pas la différence subtile entre cela et curryfication, différent.

application de fonction partielle peut être utilisée pour mettre en œuvre, mais est pas curryfication. Voici une citation de un billet de blog sur la différence :

  

Lorsque l'application partielle et prend une fonction de celle-ci crée une fonction qui prend moins d'arguments, corroyage construit des fonctions qui prennent plusieurs arguments par composition de fonctions qui prennent chacune un seul argument.

Cela a déjà répondu, voir cette question pour votre réponse: Comment puis-je les arguments pré-établis dans l'appel de fonction JavaScript

Exemple:

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

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

Encore une fois, voir cette question pour les détails.

Answer 2

Vous pouvez également surcharger le prototype de fonction:

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

Ce qui suit est équivalent à votre deuxième bloc de code:

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

var fr = f;

fr(pars);

Si vous voulez passer en fait une référence à une fonction à une autre fonction, vous pouvez faire quelque chose comme ceci:

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

Vous êtes certainement mieux d'utiliser un cadre pour ce genre de chose, cependant.