introduire
La chaîne de responsabilité est de permettre à plusieurs objets d'avoir la possibilité de traiter la demande, évitant ainsi la relation de couplage entre l'expéditeur et le récepteur de la demande. Connectez l'objet dans une chaîne et passez la demande le long de la chaîne jusqu'à ce qu'un objet le gère.
Autrement dit, après la demande, à partir du premier objet, l'objet recevant la demande dans la chaîne le gère personnellement ou le transmet au candidat suivant de la chaîne. L'objet soumettant la demande ne sait pas exactement quel objet le gérera - c'est-à-dire que la demande a un récepteur implicite. Selon le temps d'exécution, tout candidat peut répondre à la demande correspondante. Le nombre de candidats est arbitraire. Vous pouvez décider quels candidats participent à la chaîne au moment de l'exécution.
texte
Pour les implémentations JavaScript, nous pouvons utiliser ses fonctionnalités de prototype pour implémenter le modèle de chaîne de responsabilité.
La copie de code est la suivante:
var no_topic = -1;
SUJET VAR;
Handler de fonction (s, t) {
this.successor = s || nul;
this.topic = t || 0;
}
Handler.prototype = {
Handle: function () {
if (this.successor) {
this.successor.handle ()
}
},
a: function () {
retourne this.topic! = no_topic;
}
};
Le gestionnaire accepte simplement 2 paramètres. Le premier est le successeur (utilisé pour transmettre la demande de traitement), et le second est le niveau de passage (qui peut être utilisé pour contrôler s'il faut effectuer une opération à un certain niveau, ou non). Le prototype du gestionnaire expose une méthode de poignée, qui est la clé pour implémenter ce modèle. Voyons d'abord comment utiliser le code ci-dessus.
La copie de code est la suivante:
var app = nouveau gestionnaire ({
Handle: function () {
Console.log («Application Manque»);
}
}, 3);
var dialog = new Handler (app, 1);
Var Button = nouveau gestionnaire (boîte de dialogue, 2);
Button.Handle ();
Modifiez le code via la fonctionnalité Prototype et appelez le code à partir de Button.Handle () -> Dialog.Handle () -> App.Handle () -> PARAMETER HANDE (). Les trois premiers sont toutes les poignées qui appellent le prototype. Enfin, la poignée dans le paramètre passé est trouvée, puis le résultat est la sortie, ce qui signifie que seule la dernière couche est traitée.
Alors, comment puis-je laisser l'objet de dialogue être traité lors de l'appel? En fait, vous pouvez définir la méthode de manche de l'objet d'instance de dialogue, mais cela doit être fait avant le nouveau bouton. Le code est le suivant:
La copie de code est la suivante:
var app = nouveau gestionnaire ({
Handle: function () {
Console.log («Application Manque»);
}
}, 3);
var dialog = new Handler (app, 1);
Dialog.Handle = function () {
console.log ('Dialogue avant ...')
// Voici les opérations de traitement spécifiques
console.log ('Dialogue après ...')
};
Var Button = nouveau gestionnaire (boîte de dialogue, 2);
Button.Handle ();
Le résultat de l'exécution de ce code est le résultat du processus dans la boîte de dialogue, et n'est plus l'opération d'exécution de la poignée définie dans les paramètres transmis à l'application.
Pouvons-nous donc passer à travers le processus du successeur, puis laisser le successeur continuer à le gérer? La réponse est oui, mais après avoir appelé la poignée, vous devez utiliser les caractéristiques du prototype pour appeler le code suivant:
La copie de code est la suivante:
Handler.prototype.handle.call (this);
La signification de cette phrase est d'appeler la méthode de la poignée du prototype pour continuer à appeler la méthode de poignée de son successeur (c'est-à-dire le successeur). Le code suivant est exprimé comme: Les poignées définies par les trois objets de bouton / dialogue / application seront exécutées.
La copie de code est la suivante:
var app = nouveau gestionnaire ({
Handle: function () {
Console.log («Application Manque»);
}
}, 3);
var dialog = new Handler (app, 1);
Dialog.Handle = function () {
console.log ('Dialogue avant ...')
// Voici les opérations de traitement spécifiques
Handler.prototype.handle.call (this); // continue de monter
console.log ('Dialogue après ...')
};
Var Button = nouveau gestionnaire (boîte de dialogue, 2);
bouton.handle = function () {
console.log ('bouton avant ...')
// Voici les opérations de traitement spécifiques
Handler.prototype.handle.call (this);
console.log ('bouton après ...')
};
Button.Handle ();
Grâce aux résultats en cours d'exécution du code, nous pouvons voir que si vous souhaitez le traiter vous-même d'abord, puis appelez le successeur pour le traiter, exécutez le gestionnaire.prototype.handle.call (this); code à la fin. Si vous souhaitez d'abord traiter le code du successeur, exécutez le Handler.prototype.Handle.Call (this); code au début.
Résumer
La chaîne de responsabilités est souvent utilisée avec le modèle de combinaison, de sorte que le composant parent d'un composant peut servir de successeur.
Dans le même temps, le mécanisme de bulle d'événements dans le DOM semble être un peu similaire à cela. Par exemple, après avoir cliqué sur un bouton, si la bulle n'est pas empêchée, l'événement Click bouillonnera toujours vers l'élément parent. Ce mécanisme peut également être utilisé pour traiter de nombreux problèmes connexes, tels que l'exemple de code de "Exemple 1: gestion centralisée d'événements" dans le modèle de conception de cette série.