introduzir
Os decoradores oferecem alternativas mais flexíveis do que a herança. Os decoradores usam objetos usados para embrulhar a mesma interface, que não apenas permite adicionar comportamento aos métodos, mas também definir os métodos para chamadas de objeto originais (como o construtor do decorador).
Os decoradores são usados para adicionar novas funções através da forma de métodos sobrecarregados. Esse modo pode adicionar seu próprio comportamento antes ou depois do decorador para obter um objetivo específico.
texto
Então, quais são os benefícios do modo decorador? Como mencionado anteriormente, o decorador é uma alternativa para alcançar a herança. Quando o script está em execução, adicionar comportamento à subclasse afeta todas as instâncias da classe original, mas o decorador não. Em vez disso, pode adicionar um novo comportamento a diferentes objetos. O código a seguir se parece:
A cópia do código é a seguinte:
// classe (função) que precisa de decoração (função)
function MacBook () {
this.Cost = function () {
retornar 1000;
};
}
Memória da função (MacBook) {
this.Cost = function () {
retornar MacBook.Cost () + 75;
};
}
Função BlurayDrive (MacBook) {
this.Cost = function () {
retornar MacBook.Cost () + 300;
};
}
Seguro de função (MacBook) {
this.Cost = function () {
retornar MacBook.Cost () + 250;
};
}
// Uso
var myMacBook = novo seguro (novo BlurayDrive (nova memória (new MacBook ())));
console.log (mymacbook.cost ());
Abaixo está outro exemplo. Quando chamamos o PerformTask no objeto Decorator, ele não apenas possui algum comportamento do decorador, mas também chama a função de desempenho do desempenho do objeto inferior.
A cópia do código é a seguinte:
função concreteclass () {
this.performTask = function () {
this.pretask ();
console.log ('fazendo algo');
this.postTask ();
};
}
Função AbstractDecorator (decorada) {
this.performTask = function () {
decorado.PerformTask ();
};
}
função concretedecoratorclass (decorada) {
this.base = abstractDecorator;
this.base (decorado);
Decorated.pretask = function () {
console.log ('pré-chamada ..');
};
Decorated.PostTask = function () {
console.log ('pós-chamada ..');
};
}
var concreto = novo concreteclass ();
var decorator1 = novo concretedecoratorclass (concreto);
var decorator2 = novo concretedecoratorclass (decorator1);
decorator2.PerformTask ();
Vamos dar outro exemplo completo:
A cópia do código é a seguinte:
var árvore = {};
árvore.Decorate = function () {
console.log ('Certifique -se de que a árvore ganhou/' T outono ');
};
árvore.getDecorator = function (deco) {
árvore [deco] .prototype = this;
devolver nova árvore [deco];
};
Tree.redballs = function () {
this.Decorate = function () {
this.redballs.prototype.Decorate (); // Etapa 7: Primeiro execute o método do protótipo (este é anjo)
console.log ('Coloque algumas bolas vermelhas'); // Etapa 8 Saída vermelha
// Use essas 2 etapas como o método decorado de Redballs
}
};
Tree.Blueballs = function () {
this.Decorate = function () {
this.blueballs.prototype.Decorate (); // Etapa 1: primeiro execute o método decorado do protótipo, ou seja, árvore.Decorate ()
console.log ('Add Blue Balls'); // Etapa 2 Saída azul
// Use essas 2 etapas, pois as bolas de azul decoram o método
}
};
árvore.Angel = function () {
this.Decorate = function () {
this.Angel.prototype.Decorate (); // Etapa 4: primeiro execute o protótipo (este é o método de decorar blueballs)
console.log ('um anjo no topo'); // Etapa 5 Saída Anjo
// Use essas 2 etapas como método de decorar anjo
}
};
árvore = árvore.getDecorator ('Blueballs'); // Etapa 3: Atribuir o objeto Blueballs à árvore e o getDecorator no protótipo pai ainda está disponível
árvore = árvore.getDecorator ('anjo'); // Etapa 6: atribua o objeto de anjo à árvore. Neste momento, o getDecorator no protótipo pai do protótipo pai ainda está disponível
árvore = árvore.getDecorator ('Redballs'); // Etapa 9: Atribua o objeto Redballs à árvore
árvore.Decorate (); // Etapa 10: Execute o método decorado do objeto Redballs
Resumir
O padrão do decorador é uma maneira de adicionar dinamicamente mais funções às funções existentes. Cada função a ser decorada é colocada em uma função separada e, em seguida, use essa função para envolver o objeto de função existente a ser decorado. Portanto, quando o comportamento especial precisa ser executado, o código de chamada pode usar seletiva e sequencialmente a função de decoração para envolver o objeto conforme necessário. A vantagem é que ele distingue as responsabilidades centrais da classe (função) da função decorativa.