Écouter une fonction à appeler JavaScript

Question

J'ai les fonctions suivantes qui sont appelées toutes les 2 secondes pour charger des données. Elle enregistre la fonction [do] pour faire le travail avec la réponse. (l'exemple est simplifié).

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

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

Je me demande s'il existe un moyen de créer une fonction qui est appelée chaque fois que la fonction [do] est appelée sans avoir besoin d'ajouter un appel à l'écouteur dans la fonction do. Merci d'avance. S'il existe un meilleur moyen de le faire avec Jquery, comme un plugin, j'apprécierais votre aide.

[L'idée n'est pas de savoir si cela fonctionne ou non. Ma question était de savoir si je pouvais ajouter un écouteur personnalisé à la fonction "do" qui était déjà implémentée. Quelque chose comme addActionListener("do", "after", doSomeThingElse) Ainsi je pourrais faire quelque chose d'autre juste après que la fonction "do" soit terminée.

Answer 1

Tout d'abord, votre version simplifiée ne fonctionnera pas, car vous devrez passer le paramètre do au lieu de l'appeler.

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

---

Mais on dirait que vous demandez comment exécuter un autre code à chaque fois do est invoquée.

Si do n'est invoquée qu'à l'intérieur de la doRequest() puis ajoutez simplement votre autre code à une fonction anonyme qui appelle do au bon moment.

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

Si vous souhaitez qu'il soit plus généralisé, vous pouvez créer un décorateur de fonction qui renvoie une fonction qui invoque do après un autre code.

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

alors faites des fonctions comme celle-ci :

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

---

Si votre exigence est plus spécifique d'un pré-traitement de response vous pourriez le retravailler comme ceci :

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

Ensuite, ayez le fn manipuler et restituer response .

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

Answer 2

Si vous voulez garder le code existant tel quel, vous pourriez envelopper do() dans une autre fonction qui, à son tour, appelle do() et votre nouvelle fonction (disons do_this_as_well() ).

Voir l'exemple ci-dessous (j'ai renommé do() a do_this() pour éviter toute confusion avec le mot-clé réservé do ). Cela fonctionne parce que les fonctions globales ne sont rien d'autre que des variables contenant des objets fonctionnels. Ces variables peuvent être écrasées, dans ce cas avec une nouvelle fonction qui appelle l'ancienne :

function do_this(response) { ... }

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

Answer 3

Remplacer

success: do(response)

avec

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