does jquery have an equivalent of dojo.hitch()?

Question

Forgive my ignorance as I am not as familiar with jquery. Is there an equivalent to dojo.hitch()? It returns a function that is guaranteed to be executed in the given scope.

-- edit -- As requested, here is an example. I use hitch very frequently to ensure callbacks are executed within the right object. For example, let's say I have a utility method called aggregateMashupData and I pass it a callback function. With hitch, I can make sure the function is executed within a particular scope even if the utility method performs ajax calls and so forth:

expectedScopeObj = {
   flag: true,
   callback: function(){console.debug(this.flag);},
   main: function() {
     core.util.aggregateMashupData("somecmd", dojo.hitch(this.callback));
   }
}

Without hitch, the callback function could possibly be executed in a different scope and an error would be thrown with this.flag being undefined. However, with hitch it is guaranteed to be executed within execptedScopeObj.

Answer 1

No. Not in 1.3.2, at least, as I don't know about 1.4. There are, however, some 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 2

The function.bind mentioned by bobince is a pretty useful tool. You could use it to rewrite the hitch function pretty simply:

// 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);
};

At least based on the doc page you linked, this is how I saw the function working...

Answer 3

I'd go for function.bind, which will be the standard way of doing this in future versions of JavaScript. As well as fixing this , it allows you to pass arguments through to the target functions.

Until all browsers support it natively, you can hack support in yourself.