Le clonage d'objets avec PHP 5

Un article de ToutProgrammer.com.

PHP évoluant énormément, son utilisation devrait petit à petit s'étendre à des domaines pour lesquels il n'avait pas été étudié à l'origine. C'est le cas par exemple avec PHP-GTK. Dans ce contexte de nouveaux besoins apparaissent comme par exemple la copie d'objets qui était inexistante jusqu'alors avec les autres versions de PHP.

Sommaire

1 A quoi sert le clonage d'objets
2 Pas de clonage avec PHP 4
3 Le clonage dans PHP 5
4 Personnalisation du clonage
5 Un second exemple de personnalisation de __clone
6 Historique de l'article

[modifier] A quoi sert le clonage d'objets

On entend par clonage d'objets l'action qui consiste à dupliquer intelligemment un objet. S'il y a copie, cela signifie que chacune des références des attributs de l'objet original sera elle aussi recopiée ce qui fait que le clone et l'original partageront certains espaces de la mémoire. Le clonage doit permettre de modifier cela afin que chacun des attributs du clone utilise sa propre instance.

[modifier] Pas de clonage avec PHP 4

Le titre de cette section résume tout puisqu'en effet, il n'est pas possible avec PHP version 4 (et les versions antérieures) d'effectuer un clonage d'objet. Une chose possible, simple et rapide, est de faire une référence à un autre objet ce qui est très loin du clonage. Il est également possible de copier un objet mais le processus ne fera que copier les membres de l'objet original sans introduire de personnalisation automatisée.

[modifier] Le clonage dans PHP 5

PHP 5 introduit le nouveau mot clé clone. Celui-ci fonctionne comme le mot clé new mais l'instance retournée est une référence sur une copie. Voici un exemple simple d'utilisation de cloneavec PHP 5:

<?php
// La ligne ci-dessous permet d'afficher tout texte
// comme texte simple et non comme du HTML.
// C'est utile car nous utiliserons la fonction print_r
// (voir la documentation PHP pour plus d'info)
header("Content-type: text/plain");
 
class Personne {
   private $nom;
   private $prenom;
 
   function Personne($nom, $prenom) {
       $this->setNom($nom);
       $this->setPrenom($prenom);
   }
 
   function setNom($nom) {
       $this->nom = $nom;
   }
 
   function setPrenom($prenom) {
       $this->prenom = $prenom;
   }
 
   function getNomPrenom() {
       return($this->nom." ".$this->prenom);
   }
}
 
// Instanciation de l'objet original
$personne = new Personne("MARTIN", "Paul");
 
// Clonage de l'objet
$clonePersonne = clone $personne;
 
// Ces lignes nous démontrent que nous avons bien 2 objets qui contenaient
// les mêmes données mais n'avaient pas les mêmes
// références sur celles-ci
$clonePersonne->setPrenom("Jean");
print_r($personne);
print_r($clonePersonne);
?>

produit:

Personne Object
(
[nom:private] => MARTIN
[prenom:private] => Paul
)
Personne Object
(
[nom:private] => MARTIN
[prenom:private] => Jean
)

Comme nous le voyons avec ces 2 personnes, Jeanest le clone de Paul: elles ont toutes les deux les mêmes caractéristiques (un nom et un prénom) mais ce sont 2 êtres indépendants. Ceci est démontré en modifiant le prénom du clone ce qui ne modifie pas le prénom de l'original.

Comme indiqué plus haut, le clonage est un élément qui peut avoir son importance avec PHP-GTK. Comme indiqué dans le document de référence Zend Engine 2.0, vous pouvez vouloir créer une copie conforme d'une fenêtre avec les mêmes propriétés: le clonage le permet.

On retrouve déjà un fonctionnement similaire dans certaines applications Java qui proposent un menu "Cloner" ou comme dans l'EDI Eclipse un sous menu "Nouvelle fenêtre".

[modifier] Personnalisation du clonage

Avec PHP 5, une nouvelle méthode réservée et nommée __clone est ajoutée à chaque objet. Par défaut celle-ci ne fait que dupliquer les différents attributs de l'objet original dans l'instance de l'objet cloné. Mais un problème se pose dès lors qu'un attribut est une instance d'un objet.

Pour mieux comprendre le problème posé, nous allons étudier un exemple avec cette fois 2 classes:

<?php
// La ligne ci-dessous permet d'afficher tout
// texte comme texte simple et non comme du HTML
// C'est utile car nous utiliserons la fonction
// print_r (voir la documentation PHP pour plus d'info)
header("Content-type: text/plain");
 
// Un object de gestion des chaines de caractères
class Chaine {
   private $valeur;
 
   function Chaine($valeur) {
       $this->setValeur($valeur);
   }
 
   function setValeur($valeur) {
       $this->valeur = $valeur;
   }
 
   function getValeur() {
       return($this->valeur);
   }
}
 
class Personne {
   private    $nom;
   private    $prenom;
 
   function Personne($nom, $prenom) {
       $this->nom = new Chaine($nom);
       $this->prenom = new Chaine($prenom);
   }
 
   function setNom($nom) {
       $this->nom->setValeur($nom);
   }
 
   function setPrenom($prenom) {
       $this->prenom->setValeur($prenom);
   }
 
   function getNomPrenom() {
       return($this->nom." ".$this->prenom);
   }
}
 
// Instanciation de l'objet original
$personne = new Personne("MARTIN", "Paul");
 
// Clonage de l'objet
$clonePersonne = clone $personne;
 
// Ces lignes nous démontrent que nous avons
// bien 2 objets qui avec la méthode de clonage
// par défaut contiennent des références sur les
// mêmes objects
$clonePersonne->setPrenom("Jean");
print_r($personne);
print_r($clonePersonne);
?>

affiche:

Personne Object
(
[nom:private] => Chaine Object
(
[valeur:private] => MARTIN
)

[prenom:private] => Chaine Object
(
[valeur:private] => Jean
)

)
Personne Object
(
[nom:private] => Chaine Object
(
[valeur:private] => MARTIN
)

[prenom:private] => Chaine Object
(
[valeur:private] => Jean
)

)

Comme nous pouvons le voir avec cet exemple, la méthode __clone de base de chacun des objets (méthode gérée en interne par PHP 5 lorsque celle-ci n'est pas implémentée par le développeur) n'a fait que dupliquer les références que sont les attributs $nom et $prenom de la classe Personne. Les objets (clone et original) ne sont plus indépendants puisqu'ils utilisent des références communes alors que nous souhaiterions que ces références soient différentes.

Afin de régler ce problème, il est possible de ré-écrire la méthode __clone afin d'obtenir un fonctionnement plus évolué et répondant mieux aux attentes que l'on peut en avoir.

<?php
// La ligne ci-dessous permet d'afficher tout
// texte comme texte simple et non comme du HTML
// C'est utile car nous utiliserons la fonction
// print_r (voir la documentation PHP pour plus d'info)
header("Content-type: text/plain");
 
// Un object de gestion des chaines de caractères
class Chaine {
   private $valeur;
 
   function Chaine($valeur) {
       $this->setValeur($valeur);
   }
 
   function setValeur($valeur) {
       $this->valeur = $valeur;
   }
 
   function getValeur() {
       return($this->valeur);
   }
}
 
class Personne {
   private    $nom;
   private    $prenom;
 
   function Personne($nom, $prenom) {
       $this->nom = new Chaine($nom);
       $this->prenom = new Chaine($prenom);
   }
 
   function setNom($nom) {
       $this->nom->setValeur($nom);
   }
 
   function setPrenom($prenom) {
       $this->prenom->setValeur($prenom);
   }
 
   function getNomPrenom() {
       return($this->nom." ".$this->prenom);
   }
 
   function __clone() {
       $this->nom = new Chaine($this->nom->getValeur());
       $this->prenom = new Chaine($this->prenom->getValeur());
   }
}
 
// Instanciation de l'objet original
$personne = new Personne("MARTIN", "Paul");
 
// Clonage de l'objet
$clonePersonne = clone $personne;
 
// Ces lignes nous démontrent que nous avons bien 2 objets qui avec
// la méthode de clonage par défaut contient des références sur les
// mêmes objects
$clonePersonne->setPrenom("Jean");
print_r($personne);
print_r($clonePersonne);
?>

produit:

Personne Object
(
[nom:private] => Chaine Object
(
[valeur:private] => MARTIN
)

[prenom:private] => Chaine Object
(
[valeur:private] => Paul
)

)
Personne Object
(
[nom:private] => Chaine Object
(
[valeur:private] => MARTIN
)

[prenom:private] => Chaine Object
(
[valeur:private] => Jean
)

)

Comme nous le voyons, nous avons ajouté une méthode __clone dans l'objet Personne. Nous voyons dans celle-ci que nous réinstancions les 2 attributs $nom et $prenom. Nous faisons ceci afin de dissocier les attributs de l'instance originale des attributs du clone.

Lorsque le mot clé cloneest rencontré lors de l'exécution, le moteur interne PHP 5 duplique l'objet indiqué et appelle la méthode __clone de la copie. Donc, à la première ligne de la méthode __clone, l'ensemble des attributs de notre clone sont initialisés avec les mêmes valeurs ou les mêmes références que l'original. C'est pour cette raison que nous recréons des instances indépendantes pour ces attributs et que nous les initialisons avec leur valeur courante.

Avec ce mécanisme, comme nous créons de nouvelles instances, il n'y a plus de problème: les attributs des 2 instances de Personne sont bel et bien indépendants. Nous pouvons modifier un objet sans impacter l'autre.

[modifier] Un second exemple de personnalisation de __clone

Voici un autre exemple de ré-écriture de la méthode de clonage. En partant d'un exemple vu un peu plus haut, nous ajoutons un attribut: l'heure d'instanciation de l'objet. Comme je l'ai indiqué plus haut, appeler la méthode __clone revient à instancier un objet comme le fait le mot réservé newmais à la différence que le constructeur de l'objet n'est pas appelé. Si la méthode n'est pas personnalisée, la date d'instanciation du clone sera donc la même que l'original, ce que nous ne voulons pas.

Voici donc le code modifié:

<?php
// La ligne ci-dessous permet d'afficher tout texte
// comme texte simple et non comme du HTML.
// C'est utile car nous utiliserons la fonction print_r
// (voir la documentation PHP pour plus d'info)
header("Content-type: text/plain");
ob_implicit_flush(true);
 
class Personne {
   private $nom;
   private $prenom;
   private $dateCreation;
 
   function Personne($nom, $prenom) {
       $this->setNom($nom);
       $this->setPrenom($prenom);
       $this->setDateCreation(date("j/m/Y H:i:s"));
   }
 
   function setDateCreation($dateCreation) {
       $this->dateCreation = $dateCreation;
   }
 
   function getDateCreation() {
       return($this->dateCreation);
   }
 
   function setNom($nom) {
       $this->nom = $nom;
   }
 
   function setPrenom($prenom) {
       $this->prenom = $prenom;
   }
 
   function getNomPrenom() {
       return($this->nom." ".$this->prenom);
   }
 
   function __clone() {
       $this->dateCreation = date("j/m/Y H:i:s");
   }
}
 
// Instanciation de l'objet original
$personne = new Personne("MARTIN", "Paul");
print_r($personne);
 
// Une boucle d'attente de 5 secondes
sleep(5);
print("\n\n");
 
// Clonage de l'objet
$clonePersonne = clone $personne;
 
// Ces lignes nous démontrent que nous avons bien 2
// objets qui contenaient les mêmes données mais
// n'avaient pas les mêmes références sur celles-ci
$clonePersonne->setPrenom("Jean");
print_r($personne);
print_r($clonePersonne);
?>

affichera par exemple:

Personne Object
(
[nom:private] => MARTIN
[prenom:private] => Paul
[dateCreation:private] => 1/08/2004 01:52:43
)


Personne Object
(
[nom:private] => MARTIN
[prenom:private] => Paul
[dateCreation:private] => 1/08/2004 01:52:43
)
Personne Object
(
[nom:private] => MARTIN
[prenom:private] => Jean
[dateCreation:private] => 1/08/2004 01:52:48
)

L'appel à sleep() n'est là que pour démontrer que nous avons des dates/heures de création différentes.

Nous voyons donc que le clonage permet d'automatiser la copie "intelligente" d'un objet.

[modifier] Historique de l'article

Cet article, réalisé par Stéphane VANPOPERYNGHE, a été publié pour la première fois le 1^er août 2004 sur le site ToutProgrammer.com (1^ème version).

Récupérée de « http://www.toutprogrammer.com/wiki/Le_clonage_d%27objets_avec_PHP_5 »

Navigation