einführen
Verantwortungskette besteht darin, mehrere Objekte zu ermöglichen, die Möglichkeit zu haben, die Anfrage zu bearbeiten, und so die Kopplungsbeziehung zwischen dem Absender und dem Empfänger der Anfrage vermeiden. Schließen Sie das Objekt mit einer Kette an und geben Sie die Anforderung entlang der Kette über, bis ein Objekt es umgeht.
Das heißt, nach der Anfrage startet das erste Objekt, das das Objekt, das die Anforderung in der Kette empfängt, entweder persönlich behandelt oder an den nächsten Kandidaten in der Kette weitergeleitet. Das Objekt, das die Anfrage übermittelt, weiß nicht genau, welches Objekt sie behandelt - dh die Anfrage hat einen impliziten Empfänger. Abhängig von der Laufzeit kann jeder Kandidat auf die entsprechende Anfrage antworten. Die Anzahl der Kandidaten ist willkürlich. Sie können entscheiden, welche Kandidaten zur Laufzeit an der Kette teilnehmen.
Text
Für JavaScript -Implementierungen können wir seine Prototyp -Funktionen verwenden, um das Verantwortungskettenmuster zu implementieren.
Die Codekopie lautet wie folgt:
var no_topic = -1;
var Thema;
Funktionshandler (s, t) {
this.successor = s || Null;
this.topic = t || 0;
}
Handler.Prototype = {
Handle: function () {
if (this.successor) {
this.successor.handle ()
}
},
hat: function () {
retopic zurückgeben.topic! = no_topic;
}
};
Der Handler akzeptiert nur 2 Parameter. Der erste ist der Nachfolger (der zur Abgabestelle der Verarbeitungsanforderung verwendet wird), und das zweite ist das Übergangsniveau (mit dem man steuern kann, ob eine Operation auf einer bestimmten Ebene durchgeführt wird oder nicht). Der Handler -Prototyp enthält eine Handlungsmethode, die der Schlüssel zur Implementierung dieses Musters ist. Schauen wir uns zunächst an, wie Sie den obigen Code verwenden.
Die Codekopie lautet wie folgt:
var app = neuer Handler ({{{{
Handle: function () {
console.log ('App -Handle');
}
}, 3);
var dialog = neuer Handler (App, 1);
var button = neuer Handler (Dialog, 2);
button.handle ();
Ändern Sie den Code über die Prototyp-Funktion und rufen Sie den Code von der Schaltfläche auf. Handle ()-> Dialog.handle ()-> app.handle ()-> Parameter handle (). Die ersten drei sind alle Griffe, die den Prototyp nennen. Schließlich wird der Griff im übergebenen Parameter gefunden, und dann wird das Ergebnis ausgegeben, was bedeutet, dass nur die letzte Schicht verarbeitet wird.
Wie kann ich also nur das Dialogobjekt beim Aufrufen verarbeitet lassen? Tatsächlich können Sie die Handlungsmethode des Dialoginstanzobjekts definieren, sie muss jedoch vor der neuen Taste erfolgen. Der Code ist wie folgt:
Die Codekopie lautet wie folgt:
var app = neuer Handler ({{{{
Handle: function () {
console.log ('App -Handle');
}
}, 3);
var dialog = neuer Handler (App, 1);
dialog.handle = function () {
console.log ('Dialog vor ...')
// Hier sind die spezifischen Verarbeitungsvorgänge
console.log ('Dialog nach ...')
};
var button = neuer Handler (Dialog, 2);
button.handle ();
Das Ausführungsergebnis dieses Codes ist der Prozess, der in den Dialogfeld führt.
Können wir es also durch den Prozess des Nachfolgers schaffen und den Nachfolger dann weiterhin damit umgehen lassen? Die Antwort lautet Ja, aber nachdem Sie den Griff aufgerufen haben, müssen Sie die Eigenschaften des Prototyps verwenden, um den folgenden Code aufzurufen:
Die Codekopie lautet wie folgt:
Handler.Prototype.Handle.call (this);
Die Bedeutung dieses Satzes besteht darin, die Prototypen -Handelsmethode aufzurufen, um die Handlungsmethode seines Nachfolgers (dh Nachfolger) weiterhin aufzurufen. Der folgende Code wird ausgedrückt als: Die durch die drei Objekte des Dialogfelds/App/App definierten Handles werden ausgeführt.
Die Codekopie lautet wie folgt:
var app = neuer Handler ({{{{
Handle: function () {
console.log ('App -Handle');
}
}, 3);
var dialog = neuer Handler (App, 1);
dialog.handle = function () {
console.log ('Dialog vor ...')
// Hier sind die spezifischen Verarbeitungsvorgänge
Handler.Prototype.Handle.call (this); // weiter hochgehen
console.log ('Dialog nach ...')
};
var button = neuer Handler (Dialog, 2);
Taste.Handle = function () {
console.log ('Schaltfläche vor ...')
// Hier sind die spezifischen Verarbeitungsvorgänge
Handler.Prototype.Handle.call (this);
console.log ('Taste nach ...')
};
button.handle ();
Durch die laufenden Ergebnisse des Code können wir sehen, dass, wenn Sie ihn zuerst selbst verarbeiten und den Nachfolger anrufen möchten, um ihn zu verarbeiten, den Handler.Prototype.Handle.call (dies) ausführen; Code am Ende. Wenn Sie zuerst den Code des Nachfolgers verarbeiten möchten, führen Sie den Handler.Prototype.handle.call (this) aus. Code am Anfang.
Zusammenfassen
Die Verantwortungskette wird häufig mit dem Kombinationsmuster verwendet, so dass die übergeordnete Komponente einer Komponente als Nachfolger dienen kann.
Gleichzeitig scheint der Ereignisblasenmechanismus im DOM ein bisschen ähnlich zu sein. Wenn Sie beispielsweise auf eine Schaltfläche geklickt haben, sprudelt das Klickereignis, wenn die Blase nicht verhindert wird, immer in Richtung des übergeordneten Elements. Dieser Mechanismus kann auch verwendet werden, um mit vielen verwandten Problemen umzugehen, z.