Événements dans une collection/un tableau

Question

Dans mon application web jQuery, j'utilise essentiellement des événements.
Mon composant pour faire des requêtes client ajax (le nom est "comm") au serveur a une file d'attente.
Cette file d'attente est similaire à une collection Backbone.js.

Ainsi, à chaque fois que je place un nouvel objet requête dans la collection de "comm", l'objet comm reçoit un événement "add" et la méthode "worker" de "comm" regarde s'il y a actuellement une requête en cours. S'il n'y en a pas, la méthode "worker" traite la demande et finalement, lorsque tout fonctionne bien, déclenche un événement "complete" sur l'objet de demande.

Dans ce composant comm, une seule demande à la fois est possible. Si j'ajoute un objet de requête à "comm" et que l'événement "add" est déclenché et que la méthode worker voit qu'il y a déjà une requête, alors rien ne se passe.

Ma question est la suivante : dans cette situation, quelle est la meilleure approche pour traiter cet objet de demande non traité au regard d'une "INFRASTRUCTURE D'ÉVÉNEMENT" ?

Jusqu'à présent, j'avais deux approches différentes :

1) Je pourrais faire ce qui suit : Si ma demande en cours est terminée, la méthode worker peut vérifier s'il y a un objet de demande non traité dans la collection et le traiter. C'est simple, aucun événement n'est impliqué.

2) Ou quelque chose de différent : Si la méthode worker démarre à cause d'un événement "add" et voit qu'il y a déjà une demande en cours, je pourrais implémenter quelque chose comme : "Je ne peux pas répondre adéquatement à cet événement d'ajout, je vous replace. Veuillez vous déclencher à nouveau dans 200 millisecondes, j'aurai peut-être le temps à ce moment-là."

Peut-être que quelqu'un a déjà eu un problème similaire et a trouvé une très bonne solution ?

Answer 1

Je pense qu'une bonne approche de ce problème serait d'implémenter un événement "next" qui serait déclenché sur la file d'attente. Chaque fois qu'un événement "complete" est déclenché, il devrait déclencher l'événement suivant sur la file d'attente, qui vérifierait alors s'il y a des demandes non traitées et, si c'est le cas, en choisirait une selon votre logique (je suppose FIFO).

Answer 2

Si je comprends bien, vous voulez enchaîner des requêtes ou d'autres événements asynchrones ? Alors le promesses Le modèle est une solution élégante.

JQuery l'implémente déjà avec la fonction Objet différé .

Avec JQuery 1.8+, le chaînage des requêtes peut être aussi simple que.. :

$.ajax(...).then(
    function() {
        return $.ajax(...);
    }
).then(
    function() {
        return $.ajax(...);
    }
);

Mais vous pouvez aussi construire une architecture plus dynamique et plus complexe autour d'elle. Par exemple, vous pouvez implémenter votre file d'attente de manière à ce qu'elle stocke toujours la dernière promesse non résolue afin de pouvoir y attacher de nouveaux gestionnaires alors qu'elle est déjà active.

Exemple générique :

var Queue = function() {
    // start with resolved promise
    var promise = $.Deferred().resolve();

    this.add = function(handler) {
        // chain and replace latest with next promise
        promise = promise.then(function() {
            var deferred = $.Deferred();
            handler(deferred);
            return deferred;
        }).promise();
    }
};

var q = new Queue();
q.add(function(deferred) {
    setTimeout(function() { alert('handler 1'); deferred.resolve(); }, 1000);
});
q.add(function(deferred) {
    setTimeout(function() { alert('handler 2'); deferred.resolve(); }, 1000);
});

Démonstration de JSFiddle

Dans ce cas, les gestionnaires reçoivent un objet différé comme paramètre et sont responsables de sa résolution (ou de son rejet) lorsqu'ils ont terminé. Une autre possibilité, plus flexible, serait que les gestionnaires créent eux-mêmes l'objet différé et renvoient sa promesse. De cette façon, vous pouvez également utiliser d'autres promesses comme celles qui sont renvoyées par $.ajax.