Prototype est un design pattern de création: son but est de répliquer des instances dites « prototypes » via un mécanisme de clonage.
Il est prescrit lorsqu’il convient d’éviter de trop nombreuses instanciations d’une classe, notamment lorsque celle-ci possède une logique assez complexe dans son constructeur, ce qui idéalement ne devrait jamais arriver.
Il est important d’économiser les ressources car le coût d’un clonage d’objet reste bien inférieur à celui d’une instanciation. Evidemment, vous ne verrez pas la différence si vous travaillez avec une dizaine d’objets mais ce ne sera sans doute pas le cas si votre application doit gérer 100 000 objets simultanément le jour d’une facturation par exemple.
Protype attendant un clonage incognito
Les composants de Protoype
- une abstraction (classe abstraite ou interface) qui force la présence d’une méthode dédiée au clonage dans les classes concrètes
- une ou plusieurs classes concrètes dériveront l’abstraction, implémentant de fait la méthode de clonage. Les instanciations seront faites sur ces classes
- des clones de ces classes seront effectués par le code client, qui participe à ce pattern
Voici notre abstraction; elle force l’implémentation d’une méthode __clone() et par chance, PHP en fourni une « out of the box » comme on dit (oui, on peut aussi dire « nativement ») ! Le reste est très basique: un constructeur sans aucune logique métier, qui prend ce qu’on lui donne et le range consciencieusement, un setter et deux getters.
L’abstraction
abstract class HumainAbstract
{
protected $prenom;
protected $sexe;
public function __construct(string $prenom)
{
$this->prenom = $prenom;
}
public function donnerSexe(): string
{
return $this->sexe;
}
public function changerPrenom(string $prenom)
{
$this->prenom = $prenom;
}
public function donnerPrenom(): string
{
return $this->prenom;
}
abstract public function __clone();
}
Les classes concrètes
Les classes concrètes – les prototypes – vont dériver cette classe abstraite et, pour rester simples, ne feront absolument rien dans leur méthode __clone() ! Elles ont une variable d’instance qu’il est juste possible de lire mais pas de modifier. Seul le prénom est modifiable (regardez dans la classe abstraite !).
class Male extends HumainAbstract
{
protected $sexe = 'M';
public function __clone()
{
}
}
class Femelle extends HumainAbstract
{
protected $sexe = 'F';
public function __clone()
{
}
}
Le code client
Le client est un acteur à part entière du design pattern prototype, c’est lui qui va cloner les prototypes.
Ici nous décidons que, les premiers humains ayant sans doute communiqué entre eux par un langage très primitif, notre prototype de mâle s’appellera « Rrrnnngrrwggl », tandis que la femelle portera le doux sobriquet de « Nyyyynyaaa ».
Tous les êtres humains descendant de ces respectables parents à la pilosité prononcée ne seront que des clones dont nous changerons uniquement le prénom. Vous noterez que nous utilisons l’affectation dynamique, c’est à dire que chaque clone sera rangé dans une variable dont le nom sera incrémenté à chaque itération de notre boucle.
$prenoms = [
'René', 'Eric', 'Jean', 'Robert', 'Marius',
'Kevin', 'Léo', 'Jacques', 'Loïc', 'John',
'Alexis', 'Kenneth', 'Nathanaël', 'Christophe'
];
$male1 = new Male('Rrrnnngrrwggl');
$numeroClone = 0;
$clones = [];
foreach ($prenoms as $prenom) {
++$numeroClone;
$nomClone = 'clone'.$numeroClone;
$$nomClone = clone $male1;
$$nomClone->changerPrenom($prenom);
$clones[] = $$nomClone;
}
$prenoms = [
'Lise', 'Marie', 'Ninon', 'Rachida', 'Ana',
'Martine', 'Svetlana', 'Eve', 'Carole',
'Sylvie', 'Laurie', 'Zhang', 'Fatoumata'
];
$femelle1 = new Femelle('Nyyyynyaaa');
foreach ($prenoms as $prenom) {
++$numeroClone;
$nomClone = 'clone'.$numeroClone;
$$nomClone = clone $femelle1;
$$nomClone->changerPrenom($prenom);
$clones[] = $$nomClone;
}
foreach ($clones as $clone) {
echo $clone->donnerSexe().'/'.$clone->donnerPrenom().PHP_EOL;
}
A retenir
- N’implémentez pas Prototype si vous devez gérer un petit nombre de copies, ce serait tuer une mouche au lance-roquettes
- Lors d’un appel à __clone(), le constructeur n’est pas appelé (c’est le but)
- Si votre objet à cloner a des objets en compositions, pensez à les cloner eux aussi pour éviter de pointer vers une référence qui n’est pas la bonne…
- Prenez garde aux références circulaires (A dépend de B qui dépend de C qui dépend de A…) entre les objets
