¿Cómo puedo pasar una referencia a una función, con los parámetros? [duplicar]

Question

  

Duplicar posible:
   ¿Cómo puedo preestablecido argumentos de llamada a la función de JavaScript? (Solicitud de función parcial)

Necesito capaz de pasar una referencia a una función con un conjunto dado de parámetros .

Aquí es un ejemplo de que pasa una referencia sin parámetros :

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

Ahora lo que tengo que hacer es pasar la misma función f, pero esta vez yo tendría que pasar parámetros a la referencia. Ahora, puedo hacerlo con una función anónima e invocar la función f con los parámetros dentro de la función de nueva creación, como por ejemplo:

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

Pero mi pregunta es, ¿Hay una manera de pasar una referencia directa a la función f Con los parámetros a fr, pero sin formar parte de una función anónima?

¿Qué necesito para asignar a fr para que sea invocable sin parámetros (fr()), por lo que se ejecuta f (1,2,3) cuando se invoca fr?

[ACTUALIZACIÓN] Seguí respuesta Jason Bunting 's de aquí sobre los Función parcial y la función de JavaScript él mensajes no es exactamente lo que estaba buscando. Aquí está la solución:

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

Lo que está después de que se llama aplicación de función parcial .

No se deje engañar por aquellos que no entienden la sutil diferencia entre eso y currificación, que son diferente.

aplicación de función parcial se puede utilizar para poner en práctica, pero no es currificación. Aquí es una cita de una entrada de blog en la diferencia :

  

Cuando la aplicación parcial toma una función y de ella construye una función que toma menos argumentos, currificación construye funciones que tienen múltiples argumentos por la composición de funciones que cada toma un solo argumento.

Esto ya ha sido respondida, consulte esta pregunta para su respuesta: ¿Cómo puedo argumentos pre-establecidos en llamada a la función JavaScript

Ejemplo:

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

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

Una vez más, ver a esa pregunta para los detalles.

Answer 2

También puede sobrecargar el prototipo de función:

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

El siguiente es equivalente a su segundo bloque de código:

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

var fr = f;

fr(pars);

Si desea pasar en realidad una referencia a una función a otra función, puede hacer algo como esto:

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

Usted es casi seguro que mejor usar un marco para este tipo de cosas, sin embargo.