introduzir
O Composite combina objetos em uma estrutura de árvore para representar uma hierarquia "total". O modo de combinação torna os usuários consistentes com o uso de objetos individuais e objetos combinados.
Os cenários comuns incluem o mecanismo de controle no ASP.NET (ou seja, o controle pode conter o controle da criança, que pode operar recursivamente, adicionar e excluir controle da criança) e, da mesma forma, existe um mecanismo DOM. Um nó DOM pode conter nós filhos. Seja um nó pai ou um nó filho, ele tem as funções comuns de adicionar, excluir e atravessar nós filhos. Portanto, a chave para o padrão de combinação é ter uma classe abstrata, que pode representar elementos filhos e elementos pais.
texto
Por exemplo, há um restaurante que oferece uma variedade de pratos. Cada tabela tem um menu. O menu lista os pratos dos quais o restaurante é tudo, incluindo bolos de café da manhã, almoço, jantar etc. Cada refeição tem uma variedade de itens de menu. Supondo que os itens do menu e o menu inteiro sejam impressos e os sub-itens possam ser adicionados, como novos pratos podem ser adicionados para o almoço e o açúcar pode ser adicionado para itens de menu, como café.
Nesse caso, podemos usar a combinação para representar esses conteúdos como hierarquias. Vamos dividir nossas etapas de implementação uma a uma.
O primeiro passo é implementar nossa função de "classe abstrata" menucomponente:
A cópia do código é a seguinte:
var menucomponent = function () {
};
Menucomponent.prototype.getName = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Menucomponent.prototype.getDescription = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Menucomponent.prototype.getprice = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Menucomponent.prototype.isvegetarian = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Menucomponent.prototype.print = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Menucomponent.prototype.add = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Menucomponent.prototype.remove = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Menucomponent.prototype.getChild = function () {
lançar um novo erro ("Este método deve ser reescrito!");
};
Esta função fornece dois tipos de métodos, um é obter informações, como preço, nome, etc., e o outro é um método de operação geral, como impressão, adição, exclusão e obtenção de submenu.
O segundo passo é criar pratos básicos:
A cópia do código é a seguinte:
var menuitem = função (snome, sdescription, bvegetarian, nprice) {
Menucomponent.apply (isto);
this.sname = snome;
this.sDescription = sDescription;
this.bveGetarian = bvegetarian;
this.nprice = nprice;
};
Menuitem.prototype = new menucomponent ();
Menuitem.prototype.getName = function () {
devolver este.sname;
};
Menuitem.prototype.getDescription = function () {
retornar esta.Sdescription;
};
Menuitem.prototype.getprice = function () {
retornar este.nprice;
};
Menuitem.prototype.isvegetarian = function () {
devolver this.bveGetarian;
};
Menuitem.prototype.print = function () {
console.log (this.getName () + ":" + this.getDescription () + "," + this.getprice () + "euros");
};
Como pode ser visto no código, apenas re-prototipamos 4 métodos para obter informações e métodos de impressão e não sobrecarregamos os outros três métodos operacionais, porque os pratos básicos não incluem maneiras de adicionar, excluir e obter subdishes.
Etapa 3: Crie os pratos:
A cópia do código é a seguinte:
var menu = function (snome, sdescription) {
Menucomponent.apply (isto);
this.amenucomponents = [];
this.sname = snome;
this.sDescription = sDescription;
this.createIterator = function () {
lançar um novo erro ("Este método deve ser substituído!");
};
};
Menu.prototype = new menucomponent ();
MENU.PROTOTYPE.ADD = função (OMENUCOMPONENT) {
// Adicione substituto
this.amenucomponents.push (omenucomponent);
};
MENU.PROTOTYPE.REMOVE = FUNÇÃO (OMENUCOMPONS) {
// Excluir substitutos
var amenuitems = [];
var nmenuitem = 0;
var nlenmenuitems = this.amenucomponents.length;
var oitem = nulo;
para (; nmenuitem <nlenmenuitems;) {
oitem = this.amenucomponents [nmenuitem];
if (oitem! == omenucomponent) {
amenuitems.push (Oitem);
}
nmenuitem = nmenuitem + 1;
}
this.amenucomponents = amenuitems;
};
MENU.PROTOTYPE.GETCHILD = function (nindex) {
// Obtenha o substituto especificado
devolver this.amenucomponents [nindex];
};
MENU.PROTOTYPE.GETNAME = function () {
devolver este.sname;
};
MENU.Prototype.getDescription = function () {
retornar esta.Sdescription;
};
MENU.PROTOTYPE.print = function () {
// Imprima pratos atuais e todos os subdilos
console.log (this.getName () + ":" + this.getDescription ());
console.log ("----------------------------------------");
var nmenucomponent = 0;
var nlenMenucomponents = this.amenucomponents.length;
var omenucomponent = null;
para (; nmenucomponent <nlenmenucomponents;) {
omenucomponent = this.amenucomponents [nmenucomponent];
omenucomponent.print ();
nmenucomponent = nmenucomponent + 1;
}
};
Observe que, além de implementar os métodos de adição, exclusão e obtenção, o método de impressão de impressão é primeiro imprimir as informações atuais do prato e depois atravessar a impressão de todas as informações dos sub-dish.
Etapa 4: Crie o prato especificado:
Podemos criar vários pratos reais, como jantar, café, bolos, etc. Todos usam o menu como protótipo, e o código é o seguinte:
A cópia do código é a seguinte:
var dinNermenu = function () {
MENU.APPLY (isto);
};
DinNermenu.prototype = new Menu ();
var cafemenu = function () {
MENU.APPLY (isto);
};
Cafemenu.prototype = new Menu ();
var pancakehouseMenu = function () {
MENU.APPLY (isto);
};
PancakehouseMenu.prototype = new Menu ();
Etapa 5: Crie o recipiente de menu superior - Livro de menus:
A cópia do código é a seguinte:
var colchão = função (amenus) {
this.amenus = amenus;
};
Mattress.prototype.printmenu = function () {
this.amenus.print ();
};
Esta função leva uma matriz de menus como um parâmetro e o valor fornece o método PrintMenu para imprimir todos os conteúdos do menu.
Etapa 6, método de chamada:
A cópia do código é a seguinte:
var opancakehouseMenu = novo menu ("Menu da casa de panquecas", "café da manhã");
var odinNermenu = novo menu ("menu do jantar", "almoço");
var ocoffeemenu = novo menu ("menu do café", "jantar");
var oallmenus = novo menu ("todos os menus", "todos os menus combinados");
oallmenus.add (opancakehousemenu);
Oallmenus.add (OdinNermenu);
odinnermenu.add (New Menuitem ("Massas", "espaguete com molho marinara e uma fatia de pão de fermento", verdadeiro, 3,89));
odinNermenu.add (Ocoffeemenu);
ocoffeemenu.add (New Menuitem ("Express", "Coffee From Machine", False, 0,99));
var omattress = novo colchão (Oallmenus);
console.log ("-------------------------------------------");
omattress.printmenu ();
console.log ("-------------------------------------------");
Os alunos que estão familiarizados com o desenvolvimento de controle do ASP.NET parecem familiares?
Resumir
O cenário de uso do modo de combinação é muito claro:
Quando você deseja representar a parte do objeto - a hierarquia geral;
Você deseja que o usuário ignore a diferença entre um objeto combinado e um único objeto, e o usuário usará todos os objetos na estrutura combinada uniformemente (métodos)
Além disso, esse padrão é frequentemente usado com decoradores. Eles geralmente têm uma classe pai comum (ou seja, protótipo), portanto a decoração deve suportar interfaces componentes com operações de add, remover e getchild.