introducir
La cadena de responsabilidad es permitir que múltiples objetos tengan la oportunidad de procesar la solicitud, evitando así la relación de acoplamiento entre el remitente y el receptor de la solicitud. Conecte el objeto en una cadena y pase la solicitud a lo largo de la cadena hasta que un objeto lo maneje.
Es decir, después de la solicitud, a partir del primer objeto, el objeto que recibe la solicitud en la cadena la maneja personalmente o la reenvía al siguiente candidato en la cadena. El objeto que envía la solicitud no sabe exactamente qué objeto lo manejará; es decir, la solicitud tiene un receptor implícito. Dependiendo del tiempo de ejecución, cualquier candidato puede responder a la solicitud correspondiente. El número de candidatos es arbitrario. Puede decidir qué candidatos participan en la cadena en el tiempo de ejecución.
texto
Para las implementaciones de JavaScript, podemos usar sus características prototipo para implementar el patrón de cadena de responsabilidad.
La copia del código es la siguiente:
var no_topic = -1;
tema var;
manejador de funciones (s, t) {
this.successor = s || nulo;
this.topic = t || 0;
}
Handler.prototype = {
Handle: function () {
if (this.successor) {
this.successor.handle ()
}
},
ha: function () {
devuelve this.topic! = no_topic;
}
};
El controlador solo acepta 2 parámetros. El primero es el sucesor (utilizado para pasar la solicitud de procesamiento), y el segundo es el nivel de aprobación (que puede usarse para controlar si realizar una operación en un cierto nivel, o no). El prototipo del controlador expone un método de manejo, que es la clave para implementar este patrón. Primero veamos cómo usar el código anterior.
La copia del código es la siguiente:
Var App = New Handler ({
Handle: function () {
console.log ('App Handle');
}
}, 3);
diálogo var = nuevo manejador (aplicación, 1);
botón var = nuevo manejador (diálogo, 2);
botón.handle ();
Cambie el código a través de la función Prototipo y llame al código desde el botón.handle ()-> dialog.handle ()-> app.handle ()-> parámetro de parámetro (). Los primeros tres son todos los mangos que llaman al prototipo. Finalmente, se encuentra el mango en el parámetro aprobado, y luego el resultado es salida, lo que significa que solo se procesa la última capa.
Entonces, ¿cómo puedo dejar que el objeto de diálogo se procese al llamar? De hecho, puede definir el método de identificación del objeto de instancia de diálogo, pero debe hacerse antes del botón Nuevo. El código es el siguiente:
La copia del código es la siguiente:
Var App = New Handler ({
Handle: function () {
console.log ('App Handle');
}
}, 3);
diálogo var = nuevo manejador (aplicación, 1);
dialog.handle = function () {
console.log ('diálogo antes ...')
// Aquí están las operaciones de procesamiento específicas
console.log ('diálogo después de ...')
};
botón var = nuevo manejador (diálogo, 2);
botón.handle ();
El resultado de la ejecución de este código es el resultado del proceso en el diálogo.handle, y ya no es la operación de ejecución del identificador definido en los parámetros pasados a la aplicación.
Entonces, ¿podemos superar el proceso del sucesor y luego dejar que el sucesor continúe manejándolo? La respuesta es sí, pero después de llamar al mango, debe usar las características del prototipo para llamar al siguiente código:
La copia del código es la siguiente:
Handler.prototype.handle.call (this);
El significado de esta oración es llamar al método de manejo del prototipo para continuar llamando al método de identificación de su sucesor (es decir, sucesor). El siguiente código se expresa como: se ejecutarán los manijas definidas por los tres objetos de botón/diálogo/aplicación.
La copia del código es la siguiente:
Var App = New Handler ({
Handle: function () {
console.log ('App Handle');
}
}, 3);
diálogo var = nuevo manejador (aplicación, 1);
dialog.handle = function () {
console.log ('diálogo antes ...')
// Aquí están las operaciones de procesamiento específicas
Handler.prototype.handle.call (this); // Continúa subiendo
console.log ('diálogo después de ...')
};
botón var = nuevo manejador (diálogo, 2);
botón.handle = function () {
console.log ('Botón antes ...')
// Aquí están las operaciones de procesamiento específicas
Handler.prototype.handle.call (this);
console.log ('botón después ...')
};
botón.handle ();
A través de los resultados en ejecución del código, podemos ver que si desea procesarlo usted mismo primero y luego llamar al sucesor para procesarlo, ejecute el handler.prototype.handle.call (esto); código al final. Si desea procesar primero el código del sucesor, ejecute el handler.prototype.handle.call (esto); código al principio.
Resumir
La cadena de responsabilidades a menudo se usa con el patrón de combinación, de modo que el componente principal de un componente puede servir como su sucesor.
Al mismo tiempo, el mecanismo de burbujas de eventos en el DOM parece ser un poco similar al de esto. Por ejemplo, después de hacer clic en un botón, si no se evita la burbuja, el evento de clic siempre burbujea hacia el elemento principal. Este mecanismo también se puede utilizar para tratar muchos problemas relacionados, como el código de ejemplo de "Ejemplo 1: gestión de eventos centralizados" en el patrón de diseño de esta serie.