javascript - retornar - ¿Cómo puedo pasar una referencia a una función, con parámetros?

pasar variables entre funciones javascript

Question

Posible duplicado:
¿Cómo puedo preestablecer argumentos en la llamada a función de JavaScript? (Aplicación de función parcial)

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

Aquí hay un ejemplo de pasar 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 necesitaría pasar parámetros a la referencia. Ahora, puedo hacerlo con una función anónima e invocar la función f con parámetros dentro de la función recién creada, como esta:

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 alguna manera de pasar una referencia directa a la función f Con parámetros a fr , pero sin encerrarlo en una función anónima?

¿Qué debo asignar a fr para hacerlo invokable sin parámetros ( fr() ), de modo que f (1,2,3) se ejecute cuando se invoca fr ?

[ACTUALIZACIÓN] Seguí la respuesta de Jason Bunting here sobre la función parcial y la función de JavaScript que publica allí 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á buscando se llama aplicación de función parcial .

No te dejes engañar por aquellos que no entienden la diferencia sutil entre eso y currying, son diferentes.

La aplicación de función parcial se puede usar para implementar, pero no currying. Aquí hay una cita de una publicación de blog sobre la diferencia :

Donde la aplicación parcial toma una función y a partir de ella construye una función que toma menos argumentos, currying funciones de compilación que toman múltiples argumentos por composición de funciones que cada uno toma un solo argumento.

Esto ya ha sido respondido, vea esta pregunta por su respuesta: here

Ejemplo:

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

Nuevamente, vea esa pregunta para los detalles.

Answer 2

Lo siguiente es equivalente a tu segundo bloque de código:

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

Si realmente desea pasar una referencia a una función a alguna 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

Sin embargo, es casi seguro que es mejor utilizar un marco para este tipo de cosas.

Answer 3

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