introduzir
A cadeia de responsabilidade é permitir que vários objetos tenham a oportunidade de processar a solicitação, evitando assim a relação de acoplamento entre o remetente e o destinatário da solicitação. Conecte o objeto em uma corrente e passe a solicitação ao longo da corrente até que um objeto o line.
Ou seja, após a solicitação, começando pelo primeiro objeto, o objeto que recebe a solicitação na cadeia o lida pessoalmente ou a encaminha para o próximo candidato na cadeia. O objeto que envia a solicitação não sabe exatamente qual objeto lidará com ele - ou seja, a solicitação possui um receptor implícito. Dependendo do tempo de execução, qualquer candidato pode responder à solicitação correspondente. O número de candidatos é arbitrário. Você pode decidir quais candidatos participam da cadeia no tempo de execução.
texto
Para implementações de JavaScript, podemos usar seus recursos de protótipo para implementar o padrão da cadeia de responsabilidade.
A cópia do código é a seguinte:
var no_topic = -1;
tópico var;
manipulador de funções (s, t) {
this.successor = s || nulo;
this.topic = t || 0;
}
Handler.prototype = {
Handle: function () {
if (this.successor) {
this.successor.Handle ()
}
},
tem: function () {
retornar this.topic! = no_topic;
}
};
O manipulador aceita apenas 2 parâmetros. O primeiro é o sucessor (usado para passar a solicitação de processamento) e o segundo é o nível de aprovação (que pode ser usado para controlar se deve executar uma operação em um determinado nível, ou não). O protótipo manipulador expõe um método de identificação, que é a chave para implementar esse padrão. Vamos primeiro olhar como usar o código acima.
A cópia do código é a seguinte:
var app = novo manipulador ({
Handle: function () {
console.log ('identificador de aplicativo');
}
}, 3);
diálogo var = new Handler (app, 1);
var Button = new Handler (diálogo, 2);
Button.Handle ();
Altere o código através do recurso de protótipo e ligue para o código do botão.Handle ()-> dialog.Handle ()-> App.Handle ()-> Parâmetro Handle (). Os três primeiros são todas as alças que chamam o protótipo. Finalmente, a alça no parâmetro passada é encontrada e, em seguida, o resultado é emitido, o que significa que apenas a última camada é processada.
Então, como posso deixar o objeto de diálogo ser processado ao ligar? De fato, você pode definir o método de manipulação do objeto da instância de diálogo, mas ele precisa ser feito antes do novo botão. O código é o seguinte:
A cópia do código é a seguinte:
var app = novo manipulador ({
Handle: function () {
console.log ('identificador de aplicativo');
}
}, 3);
diálogo var = new Handler (app, 1);
dialog.handle = function () {
console.log ('diálogo antes ...')
// Aqui estão as operações específicas de processamento
console.log ('diálogo depois de ...')
};
var Button = new Handler (diálogo, 2);
Button.Handle ();
O resultado da execução desse código é o resultado do processo na caixa de diálogo.
Então, podemos passar pelo processo do sucessor e depois deixar o sucessor continuar a lidar com isso? A resposta é sim, mas depois de ligar para o identificador, você precisa usar as características do protótipo para chamar o seguinte código:
A cópia do código é a seguinte:
Handler.prototype.handle.call (this);
O significado desta frase é chamar o método de manipulação do protótipo para continuar chamando o método de manipulação de seu sucessor (ou seja, sucessor). O código a seguir é expresso como: As alças definidas pelos três objetos de botão/diálogo/aplicativo serão executadas.
A cópia do código é a seguinte:
var app = novo manipulador ({
Handle: function () {
console.log ('identificador de aplicativo');
}
}, 3);
diálogo var = new Handler (app, 1);
dialog.handle = function () {
console.log ('diálogo antes ...')
// Aqui estão as operações específicas de processamento
Handler.prototype.handle.call (this); // continua a subir
console.log ('diálogo depois de ...')
};
var Button = new Handler (diálogo, 2);
Button.Handle = function () {
Console.log ('Botão antes ...')
// Aqui estão as operações específicas de processamento
Handler.prototype.handle.call (this);
console.log ('Botão depois ...')
};
Button.Handle ();
Através dos resultados em execução do código, podemos ver que, se você deseja processá -lo primeiro e depois chamar o sucessor para processá -lo, execute o manipulador.prototype.handle.call (this); código no final. Se você deseja processar o código do sucessor primeiro, execute o handler.prototype.handle.call (this); código no início.
Resumir
A cadeia de responsabilidades é frequentemente usada com o padrão de combinação, para que o componente pai de um componente possa servir como seu sucessor.
Ao mesmo tempo, o mecanismo de bolha do evento no DOM parece ser um pouco semelhante a isso. Por exemplo, depois de clicar em um botão, se a bolha não for evitada, o evento de cliques sempre borbulhará em direção ao elemento pai. Esse mecanismo também pode ser usado para lidar com muitos problemas relacionados, como o código de exemplo de "Exemplo 1: Gerenciamento de Eventos Centralizados" no padrão de design desta série.