¿tiene jquery un equivalente de dojo.hitch()?

Question

Perdona mi ignorancia ya que no estoy tan familiarizado con jquery. ¿Hay un equivalente a dojo.hitch()? Devuelve una función que se garantiza que se ejecutará en el alcance dado.

- edición - Según lo solicitado, aquí hay un ejemplo. Uso el enganche con mucha frecuencia para asegurar que las devoluciones de llamada se ejecuten dentro del objeto correcto. Por ejemplo, supongamos que tengo un método de utilidad llamado doSomethingAsync y le paso una función de devolución de llamada. Con el enganche, puedo hacer que la función se ejecuta dentro de un ámbito particular, aunque el método de utilidad realiza llamadas ajax y así sucesivamente:

expectedScopeObj = { 
    flag: true, 
    callback: function(){console.debug(this.flag);}, 
    main: function() { 
    // without hitch the callback function would not find flag 
    core.util.doSomethingAsync(dojo.hitch(this, this.callback)); 
    } 
} 

Sin enganche, la función de devolución de llamada, posiblemente, podría ser ejecutado en un ámbito diferente y una se generaría un error con this.flag siendo indefinido. Sin embargo, con el enganche, se garantiza que se ejecutará dentro de execptedScopeObj.

Answer 1

Sé que esto ha sido respondido, pero no correctamente. jQuery.proxy es lo que estás buscando, creo.

ACTUALIZACIÓN

muchos, muchos años más tarde después de un montón de trabajo JavaScript, y después de despojar a mi uso de jQuery ya la compatibilidad del navegador se ha convertido en un problema menor, yo recomendaría usar Function.prototype.bind sobre jQuery.proxy, como @bobince suggested . Si bien esta sigue siendo la respuesta correcta a la pregunta original, me siento obligado a dirigir a las personas a una solución estándar en lugar de confiar en jQuery.

Answer 2

No. No en 1.3.2, al menos, ya que no sé acerca de 1.4. Hay, sin embargo, algunos plugins:

(function($) { 
    $.fn.hitch = function(ev, fn, scope) { 
    return this.bind(ev, function() { 
     return fn.apply(scope || this, Array.prototype.slice.call(arguments)); 
    }); 
    }; 
})(jQuery); 

Answer 3

El function.bind mencionado por bobince es una herramienta muy útil. Se podría utilizar para volver a escribir la función de enganche bastante simple:

// The .bind method from Prototype.js 
if (!Function.prototype.bind) { // check if native implementation available 
    Function.prototype.bind = function(){ 
    var fn = this, args = Array.prototype.slice.call(arguments), 
     object = args.shift(); 
    return function(){ 
     return fn.apply(object, 
     args.concat(Array.prototype.slice.call(arguments))); 
    }; 
    }; 
} 

jQuery.hitch = function(scope, fn) { 
    if (typeof fn == "string") fn = scope[fn]; 
    if (fn && fn.bind) return fn.bind(scope); 
}; 

Al menos basado en la página doc se enlazó, esta es la forma en que vi la función de trabajo ...

Answer 4

[ADMIN EDITAR: Tenga en cuenta la respuesta mucho más popular, a continuación.- danorton]

Iría por function.bind, que será la forma estándar de hacer esto en versiones futuras de JavaScript. Además de la fijación de this, le permite pasar argumentos a las funciones de destino.

Hasta que todos los navegadores lo admitan de forma nativa, puede hack support in yourself.

Answer 5

//why not just: 
(function($){ 
    $.hitch = function(scope, fn){ 
    return function(){ 
     return fn.apply(scope, arguments); 
    } 
    } 
})(JQuery); 
//This works exactly like Dojo's hitch from what I can tell. 

Answer 6

En mi mente, hitch en Dojo es más complejo,

por ejemplo,

function f(a,b,c){return a+b*c} 
var newF = hitch(null,f,1,undefined,3); 
newF(2) /*1+2*3*/ 

Answer 7

/** 
* This is for simulate dojo.hitch. 
* @param $ 
*/ 
(function($) { 
    $.hitch = function(context, func) { 
     var args = Array.prototype.slice.call(arguments, 
       2/*Remove context, and func*/); 

     return function() { 
      return func.apply(context, 
        Array.prototype.concat.call(args, arguments)); 
     }; 
    }; 
})(jQuery);