Design patterns
Prototype patroon
Zoeken…
Invoering
Het prototype-patroon is een creatiepatroon dat nieuwe objecten maakt door een bestaand prototype-object te klonen. Het prototypepatroon versnelt het instantiëren van klassen wanneer het kopiëren van objecten sneller gaat.
Opmerkingen
Het prototypepatroon is een creatief ontwerppatroon. Het wordt gebruikt wanneer het type objecten dat moet worden gemaakt, wordt bepaald door een prototypische instantie, die wordt "gekloond" om nieuwe objecten te produceren.
Dit patroon wordt gebruikt wanneer een klasse een "polymorfe (kopie) constructor" nodig heeft .
Prototype patroon (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; }
};
Dat maakt het mogelijk om de afgeleide klasse te construeren uit een basisklasse-aanwijzer:
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();
Prototype patroon (C #)
Het prototypepatroon kan worden geïmplementeerd met behulp van de ICloneable- interface in .NET.
class Spoon {
}
class DessertSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
class SoupSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
Prototype patroon (JavaScript)
In de klassieke talen zoals Java, C # of C ++ beginnen we met het maken van een klasse en vervolgens kunnen we nieuwe objecten van de klasse maken of we kunnen de klasse uitbreiden.
In JavaScript maken we eerst een object, daarna kunnen we het object vergroten of er nieuwe objecten van maken. Dus ik denk dat JavaScript een ander prototype toont dan de klassieke taal.
Voorbeeld:
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";
}
};
Hier maken we een object met de naam Customer , en vervolgens zonder een nieuw object te maken, hebben we het bestaande Customer object uitgebreid met het prototype- trefwoord. Deze techniek staat bekend als Prototype Pattern .
