Design patterns
Patrón prototipo
Buscar..
Introducción
El patrón de prototipo es un patrón de creación que crea nuevos objetos mediante la clonación de un objeto prototipo existente. El patrón prototipo acelera la creación de instancias de clases cuando la copia de objetos es más rápida.
Observaciones
El patrón prototipo es un patrón de diseño creativo. Se utiliza cuando el tipo de objetos a crear está determinado por una instancia prototípica, que se "clona" para producir nuevos objetos.
Este patrón se usa cuando una clase necesita un "constructor polimórfico (copia)" .
Patrón de prototipo (C ++)
class IPrototype {
public:
virtual ~IPrototype() = default;
auto Clone() const { return std::unique_ptr<IPrototype>{DoClone()}; }
auto Create() const { return std::unique_ptr<IPrototype>{DoCreate()}; }
private:
virtual IPrototype* DoClone() const = 0;
virtual IPrototype* DoCreate() const = 0;
};
class A : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<A>{DoClone()}; }
auto Create() const { return std::unique_ptr<A>{DoCreate()}; }
private:
// Use covariant return type :)
A* DoClone() const override { return new A(*this); }
A* DoCreate() const override { return new A; }
};
class B : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<B>{DoClone()}; }
auto Create() const { return std::unique_ptr<B>{DoCreate()}; }
private:
// Use covariant return type :)
B* DoClone() const override { return new B(*this); }
B* DoCreate() const override { return new B; }
};
class ChildA : public A {
public:
auto Clone() const { return std::unique_ptr<ChildA>{DoClone()}; }
auto Create() const { return std::unique_ptr<ChildA>{DoCreate()}; }
private:
// Use covariant return type :)
ChildA* DoClone() const override { return new ChildA(*this); }
ChildA* DoCreate() const override { return new ChildA; }
};
Eso permite construir la clase derivada desde un puntero de clase base:
ChildA childA;
A& a = childA;
IPrototype& prototype = a;
// Each of the following will create a copy of `ChildA`:
std::unique_ptr<ChildA> clone1 = childA.Clone();
std::unique_ptr<A> clone2 = a.Clone();
std::unique_ptr<IPrototype> clone3 = prototype.Clone();
// Each of the following will create a new default instance `ChildA`:
std::unique_ptr<ChildA> instance1 = childA.Create();
std::unique_ptr<A> instance2 = a.Create();
std::unique_ptr<IPrototype> instance3 = prototype.Create();
Patrón de prototipo (C #)
El patrón prototipo se puede implementar utilizando la interfaz ICloneable en .NET.
class Spoon {
}
class DessertSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
class SoupSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
Patrón de prototipo (JavaScript)
En los lenguajes clásicos como Java, C # o C ++ comenzamos creando una clase y luego podemos crear nuevos objetos de la clase o podemos extender la clase.
En JavaScript primero creamos un objeto, luego podemos aumentar el objeto o crear nuevos objetos a partir de él. Así que creo, JavaScript demuestra prototipo real que el lenguaje clásico.
Ejemplo:
var myApp = myApp || {};
myApp.Customer = function (){
this.create = function () {
return "customer added";
}
};
myApp.Customer.prototype = {
read: function (id) {
return "this is the customer with id = " + id;
},
update: function () {
return "customer updated";
},
remove: function () {
return "customer removed";
}
};
Aquí, creamos un objeto llamado Customer , y luego, sin crear un nuevo objeto , extendimos el Customer object existente mediante la palabra clave prototipo . Esta técnica es conocida como patrón prototipo .