侦听要调用 JavaScript 的函数

Question

I have the following functions that is called every 2 seconds to load some data. It registers the function [ do ] to do the stuff with the response. (the example is simplified).

function doRequest (){
    $.ajax({ url: 'www.google.com.pe', success: function (response) {do(response)} });
}

function do (text){
    var i = setInterval(doRequest, 2000);
}

I wonder if there is any way that I can create a function that is called every time the [ do ] function is called with out needing to add a call to the listener inside the do function. If there is any better way to do it with jQuery, like a plugin I'd appreciate the help.

[Edit] The idea is not whether it works or not. My question was about if I can add a custom listener to the "do" function which was already implemented. Something like addActionListener("do", "after", doSomeThingElse) ,sSo I could do some thing else just after the do function has finished.

Answer 1

First, your simplified version won't work, because you'd need to pass the do function instead of calling it.

function doRequest (){
    $.ajax({ url: 'www.google.com.pe', success: _do });
}

---

But it sounds like you're asking how to run some other code every time do is invoked.

If do is only invoked inside the doRequest() function, then just add your other code to an anonymous function that invokes do at the right time.

function doRequest (){
    $.ajax({ url: 'www.google.com.pe', success: function(response) {
          // Run your other code
          //   or invoke another function.
          _do(response);
    } });
}

If you want it to be more generalized, you can create a function decorator that returns a function which invokes do after some other code.

function doFactory(fn) {
    return function() {
        fn.apply(this, arguments);
        _do.apply(this, arguments);
    }
}

then make functions like this:

var doFoo = doFactory(function() {
    console.log("foo");
});

---

If your requirement is more specific of a pre-processing of response , you could rework it like this:

function doFactory(fn) {
    return function(response) {
        _do.call(this, fn.call(this, response));
    }
}

Then have the fn manipulate and return response .

var doFoo = doFactory(function(response) {
    return response + "foo";
});

Answer 2

If you want to keep existing code as it is, you could wrap do() in another function which in turn calls do() and your new function (say do_this_as_well() ).

See the example below (I renamed do() to do_this() to avoid confusion around the reserved keyword do ). This works because global functions are nothing but variables with function objects in them. These variables can be overwritten, in this case with a new function that calls the old one:

function do_this(response) { ... }

(function()
{
    var previous=do_this;
    do_this=function(response) { previous(response); do_this_as_well(); }
})();

Answer 3

Replace

success: do(response)

with

success: function(response) { do(response); do_this_as_well(); }