introducir
Los decoradores ofrecen alternativas más flexibles que la herencia. Los decoradores usan objetos utilizados para envolver la misma interfaz, lo que no solo le permite agregar comportamiento a los métodos, sino que también establece los métodos en llamadas de objetos originales (como el constructor del decorador).
Los decoradores se utilizan para agregar nuevas funciones a través de la forma de métodos sobrecargados. Este modo puede agregar su propio comportamiento antes o después del decorador para lograr un propósito específico.
texto
Entonces, ¿cuáles son los beneficios del modo decorador? Como se mencionó anteriormente, el decorador es una alternativa para lograr la herencia. Cuando el script se está ejecutando, agregar comportamiento a la subclase afecta todas las instancias de la clase original, pero el decorador no. En su lugar, puede agregar un nuevo comportamiento a diferentes objetos. El siguiente código parece:
La copia del código es la siguiente:
// clase (función) que necesita decoración (función)
función macbook () {
this.cost = function () {
regresar 1000;
};
}
Memoria de funciones (MacBook) {
this.cost = function () {
return MacBook.cost () + 75;
};
}
función bluraydrive (MacBook) {
this.cost = function () {
return MacBook.cost () + 300;
};
}
Function Insurance (MacBook) {
this.cost = function () {
return MacBook.cost () + 250;
};
}
// Uso
var mymacbook = nuevo seguro (new BlurayDrive (nueva memoria (nueva MacBook ()))));
console.log (mymacbook.cost ());
A continuación se muestra otro ejemplo. Cuando llamamos a Performask en el objeto Decorator, no solo tiene algún comportamiento del decorador, sino que también llama a la función PerformTask del objeto inferior.
La copia del código es la siguiente:
función concreteClass () {
this.performTask = function () {
this.Pretask ();
console.log ('hacer algo');
this.postTask ();
};
}
función abstractDecorator (decorada) {
this.performTask = function () {
decorado.performTask ();
};
}
función ConcretedecoratorClass (decorada) {
this.base = AbstractDecorator;
this.base (decorado);
decorated.pretask = function () {
console.log ('Pre-llame ..');
};
decorado.posttask = function () {
console.log ('postaling ..');
};
}
var concrete = new ConcreteClass ();
VAR Decorator1 = nuevo ConcretedecoratorClass (concreto);
VAR Decorator2 = nuevo ConcretedecoratorClass (decorador1);
decorador2.performTask ();
Tomemos otro ejemplo completo:
La copia del código es la siguiente:
var árbol = {};
tree.decory = function () {
console.log ('Asegúrese de que el árbol gane/' t cae ');
};
árbol.getDecorator = function (deco) {
árbol [deco] .prototype = this;
devolver nuevo árbol [deco];
};
Tree.Redballs = function () {
this.Decorate = function () {
this.redballs.prototype.decorat (); // Paso 7: Primero ejecute el método de decorar prototipo (este es ángel)
console.log ('Ponte algunas bolas rojas'); // Paso 8 Salida Roja
// Use estos 2 pasos como el método Decorar de las bolas rojas
}
};
árbol.blueballs = function () {
this.Decorate = function () {
this.blueballs.prototype.decorat (); // Paso 1: Primero ejecute el método Decory del prototipo, es decir, tree.decorat ()
console.log ('Agregar bolas azules'); // Paso 2 Salida Azul
// Use estos 2 pasos como el método de decoración de Blueballs
}
};
árbol.angel = function () {
this.Decorate = function () {
this.angel.prototype.decorat (); // Paso 4: Primero ejecute el método de decorar el prototipo (este es Blueballs)
console.log ('un ángel en la parte superior'); // Paso 5 Angel de salida
// usa estos 2 pasos como método de decoración de ángel
}
};
árbol = árbol.getDecorator ('Blueballs'); // Paso 3: Asigne el objeto Blueballs al árbol, y el GetDecorator en el prototipo principal todavía está disponible
árbol = árbol.getDecorator ('Angel'); // Paso 6: Asigne el objeto Ángel al árbol. En este momento, el getDecorator en el prototipo principal del prototipo principal todavía está disponible
árbol = árbol.getDecorator ('Redballs'); // Paso 9: Asigne el objeto de bolas Redballas al árbol
árbol.decor (); // Paso 10: ejecute el método Decorar del objeto Redballs
Resumir
El patrón del decorador es una forma de agregar dinámicamente más funciones a las funciones existentes. Cada función que se decorará se coloca en una función separada, y luego usa esta función para envolver el objeto de función existente para decorar. Por lo tanto, cuando se necesita realizar un comportamiento especial, el código de llamada puede usar de forma selectiva y secuencial la función de decoración para envolver el objeto según sea necesario. La ventaja es que distingue las responsabilidades centrales de la clase (función) de la función decorativa.