introducir
El compuesto combina objetos en una estructura de árbol para representar una jerarquía "parcial". El modo de combinación hace que los usuarios sean consistentes con el uso de objetos individuales y objetos combinados.
Los escenarios comunes incluyen el mecanismo de control en ASP.NET (es decir, el control puede contener el control del niño, que puede operar, agregar y eliminar el control infantil de manera recursiva), y de manera similar, existe un mecanismo DOM. Un nodo DOM puede contener nodos infantiles. Ya sea que se trate de un nodo principal o un nodo infantil, tiene las funciones comunes de agregar, eliminar y atravesar nodos infantiles. Por lo tanto, la clave para el patrón de combinación es tener una clase abstracta, que puede representar tanto elementos infantiles como elementos principales.
texto
Por ejemplo, hay un restaurante que ofrece una variedad de platos. Cada mesa tiene un menú. El menú enumera los platos de los que se trata el restaurante, incluidos pasteles de desayuno, almuerzo, cena, etc. Cada comida tiene una variedad de artículos de menú. Suponiendo que se deben imprimir tanto los elementos del menú como el menú completo, y se pueden agregar subtemas, como se pueden agregar nuevos platos para el almuerzo, y se puede agregar azúcar para elementos del menú como el café.
En este caso, podemos usar la combinación para representar estos contenidos como jerarquías. Desglosemos nuestros pasos de implementación uno por uno.
El primer paso es implementar nuestra función de "clase abstracta" menucomponente:
La copia del código es la siguiente:
var menucoMponent = function () {
};
Menucomponent.prototype.getName = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Menucomponent.prototype.getDescription = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Menucomponent.prototype.getprice = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Menucomponent.prototype.isvegeTarian = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Menucomponent.prototype.print = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Menucomponent.prototype.add = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Menucomponent.prototype.remove = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Menucomponent.prototype.getchild = function () {
arrojar un nuevo error ("Este método debe reescribirse!");
};
Esta función proporciona dos tipos de métodos, uno es obtener información, como precio, nombre, etc., y el otro es un método de operación general, como imprimir, agregar, eliminar y obtener submenú.
El segundo paso es crear platos básicos:
La copia del código es la siguiente:
var menuitem = function (sname, sdescription, bvegetarian, nprice) {
Menucomponente.apply (esto);
this.sname = sname;
this.sdescription = sdescription;
this.bvegetarian = bvegetarian;
this.nprice = nprice;
};
Menuitem.prototype = new Menucomponent ();
Menuitem.prototype.getName = function () {
devolver esto.sname;
};
Menuitem.prototype.getDescription = function () {
devolver esto.sdescription;
};
Menuitem.prototype.getPrice = function () {
devolver esto.nprice;
};
Menuitem.prototype.isvegeTarian = function () {
devolver esto.bvegetarian;
};
Menuitem.prototype.print = function () {
console.log (this.getName () + ":" + this.getDescription () + "," + this.getPrice () + "euros");
};
Como se puede ver en el código, solo volvimos a prototipos de 4 métodos para obtener información e imprimir métodos, y no sobrecargamos los otros 3 métodos operativos, porque los platos básicos no incluyen formas de agregar, eliminar y obtener subcontrataciones.
Paso 3: Crea los platos:
La copia del código es la siguiente:
var menú = function (sname, sdescription) {
Menucomponente.apply (esto);
this.amenucponds = [];
this.sname = sname;
this.sdescription = sdescription;
this.createIterator = function () {
arrojar un nuevo error ("Este método debe sobrescribirse!");
};
};
Menú.prototype = new Menucponnent ();
Menú.prototype.add = function (omeNucponnent) {
// Agregar sustituto
this.amenucomponents.push (omenucponnent);
};
Menú.prototype.remove = function (omeNucponnent) {
// Eliminar sustitutos
var amenuitems = [];
var nmenuitem = 0;
var nlenmenuitems = this.amenucpondents.length;
var oitem = null;
para (; nmenuitem <nlenmenuitems;) {
oitem = this.amenucpondents [nmenuitem];
if (oiTem! == Omenucponent) {
amenuitems.push (oitem);
}
nmenuitem = nmenuitem + 1;
}
this.amenucpondents = amenuitems;
};
Menú.prototype.getchild = function (nindex) {
// Obtener el sustituto especificado
devuelve this.amenucpondents [nindex];
};
Menú.prototype.getName = function () {
devolver esto.sname;
};
Menú.prototype.getDescription = function () {
devolver esto.sdescription;
};
Menú.prototype.print = function () {
// Imprimir platos actuales y todos
console.log (this.getName () + ":" + this.getDescription ());
console.log ("--------------------------------------------");
var nmenucponent = 0;
var nlenMenucponents = this.amenucpondents.length;
var omeComponent = null;
para (; nmenucponent <nlenMenucpondents;) {
omenucponent = this.amenucpondents [nMenucponnent];
Omenucponent.print ();
nmenucponent = nmenucponent + 1;
}
};
Tenga en cuenta que, además de implementar los métodos para agregar, eliminar y obtener, el método de impresión de impresión es imprimir primero la información del plato actual y luego recorrer la impresión de toda la información subdish.
Paso 4: Crea el plato especificado:
Podemos crear varios platos reales, como cena, café, pasteles, etc. Todos usan el menú como su prototipo, y el código es el siguiente:
La copia del código es la siguiente:
var dinnermenu = function () {
Menú.apply (esto);
};
Dinnermenu.prototype = nuevo menú ();
var cafeMenu = function () {
Menú.apply (esto);
};
Cafemenu.prototype = nuevo menú ();
var pancakehouseMenu = function () {
Menú.apply (esto);
};
PancakehouseMenu.prototype = nuevo menú ();
Paso 5: Cree el contenedor de menú superior - Libro del menú:
La copia del código es la siguiente:
colchón var = function (amenus) {
this.amenus = amenus;
};
Colchón.prototype.printmenu = function () {
this.amenus.print ();
};
Esta función toma una matriz de menú como parámetro, y el valor proporciona el método Printmenu para imprimir todos los contenidos del menú.
Paso 6, método de llamada:
La copia del código es la siguiente:
var opancakehouseMenu = nuevo menú ("menú de la casa de panqueques", "desayuno");
var odinnermenu = nuevo menú ("menú de cena", "almuerzo");
var oCoffeEmenu = nuevo menú ("menú de café", "cena");
var oallmenus = nuevo menú ("Todos los menús", "Todos los menús combinados");
oallmenus.add (Opancakehousemenu);
Oallmenus.add (Odinnermenu);
odinnermenu.add (nuevo menuitem ("pasta", "espagueti con salsa marinara y una porción de pan de masa fermentada", verdadero, 3.89));
Odinnermenu.add (Ocoffeemenu);
Ocoffeemenu.add (nuevo menuitem ("express", "café de la máquina", falso, 0.99));
var Omattress = nuevo colchón (oallmenus);
console.log ("---------------------------------------------");
Omattress.printmenu ();
console.log ("---------------------------------------------");
¿Los estudiantes que están familiarizados con el desarrollo de control de ASP.NET parecen familiares?
Resumir
El escenario de uso del modo combinado es muy claro:
Cuando desea representar la parte del objeto, la jerarquía general;
Desea que el usuario ignore la diferencia entre un objeto combinado y un solo objeto, y el usuario usará todos los objetos en la estructura combinada de manera uniforme (métodos)
Además, este patrón se usa a menudo con los decoradores. Por lo general, tienen una clase principal común (es decir, prototipo), por lo que la decoración debe admitir interfaces de componentes con las operaciones ADD, Eliminar y GetChild.