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 doSomethingAsync 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() {
     // without hitch the callback function would not find flag  
     core.util.doSomethingAsync(dojo.hitch(this, 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.

What exactly are you trying to accomplish? A sample code would be helpful — Ariel, Jan 09 '10 at 22:41
Shouldn't the example have been dojo.hitch(this, this,callback)? — Murali, Oct 25 '10 at 01:19
This [Hitch](https://github.com/phiggins42/bloody-jquery-plugins/blob/master/hitch.js) jQuery plugin is adapted from Dojo — PHearst, Jul 01 '13 at 22:26

LordZardeck · Accepted Answer · 2017-07-14T19:06:57.820

I know this has been answered, but not correctly. jQuery.proxy is what you are looking for I believe.

UPDATE

Many, many years later after lots of JavaScript work, and after stripping out my usage of jQuery since browser compatibility has become less of an issue, I would recommend using Function.prototype.bind over jQuery.proxy, as @bobince suggested. While this is still the correct answer to the original question, I feel obligated to direct people to a vanilla solution rather than relying on jQuery.

score 6 · Answer 2 · edited May 23 '17 at 12:10

6

[ADMIN EDIT: Note the much more popular answer, below.—danorton]

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.

edited May 23 '17 at 12:10

Community

1
1

answered Jan 09 '10 at 23:46

bobince

528,062
107
651
834

although bind is similar and certainly very useful, it doesn't quite accomplish the task – Lightbeard Jan 13 '10 at 05:53
Erm... it accomplishes the task of calling back a function with `this` set appropriately. What else do you expect `hitch` to do? Your example code above doesn't work at all. – bobince Jan 13 '10 at 12:46
You're right. I misunderstood and thought you were referring to jquery's bind function. Thanks – Lightbeard Jan 13 '10 at 13:35

score 2 · Answer 3 · answered Jan 09 '10 at 22:43

2

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

answered Jan 09 '10 at 22:43

Victor Nicollet

24,361
4
58
89

We try if at all possible to avoid using plugins only because we prefer to go with the support of a base library. It looks like right now our best bet is to use a combined dojo base and jquery build so we get the best of both worlds :) – Lightbeard Jan 13 '10 at 05:55
This is necromancer territory, but for anyone else who hasn't already solved this, you may wat to look at @phiggins' hitch plugin: https://github.com/phiggins42/bloody-jquery-plugins/blob/master/hitch.js – Oskar Austegard Oct 04 '11 at 21:37
Even more zombie-like, I just reposted that link above – PHearst Jul 01 '13 at 22:28

gnarf · Answer 4 · 2010-01-10T00:56:20.890

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

score 1 · Answer 5 · answered Jun 10 '11 at 17:24

1

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

answered Jun 10 '11 at 17:24

Leland

11
1

score 0 · Answer 6 · edited Mar 22 '16 at 15:37

0

In my mind, hitch in Dojo is more complex,

e.g.,

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

edited Mar 22 '16 at 15:37

Abhijeet Kasurde

3,937
1
24
33

answered Sep 13 '13 at 08:01

user2582131

11
1

score 0 · Answer 7 · edited Nov 03 '14 at 12:34

0

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

edited Nov 03 '14 at 12:34

Community

1
1

answered Aug 19 '14 at 09:15

olojiang

21
5

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

7 Answers7

Linked