Une gestion plus logique des objets en PHP

Un article de ToutProgrammer.com.

Avec PHP 5, le langage PHP entre véritablement dans le monde objet grace à une gestion bien plus évoluée des références que celle que l'on peut avoir avec PHP 4. En effet, PHP 4 offre une gestion "étrange" des références qui à tendance à alourdir l'utilisation des objets ce qui est bien dommage pour un langage qui possède tant d'atouts.

[modifier] L'objet dans PHP 4

Le moteur de PHP 4, le Zend Engine 1.0, permettait pour la première fois dans le monde PHP d'utiliser la programmation orienté objet (POO). Mais malheureusement l'objet dans PHP n'a pas réussi à s'implanter sur les serveurs ce qui n'a fait que retarder l'entrée de PHP comme langage professionnel au même titre que Java (avec ses JSP) ou les ASP.

Une des caractéristiques de PHP 4 est la possibilité de travailler avec des références sur les objets. Mais leur utilisation est plus qu'aléatoire puisque le langage n'utilise pas de lui même ces références et c'est donc au développeur de faire une très grosse partie du travail avec des risques non négligeables de bogues particulièrement difficiles à localiser (surtout lorsque le PHP objet est inhabituel pour le développeur).

Cette version de PHP manipule uniquement les valeurs des variables. En clair, cela signifie que le programme travaille toujours avec des copies d'objets et il n'est pas très difficile de démontrer les problèmes engendrés par ce mode de fonctionnement.

<?php
class maClasse
{
  var    $attribut;
 
  function setAttribut($valeur)
  {
      $this->attribut = $valeur;
  }
 
  function getAttribut()
  {
      return($this->attribut);
  }
}
 
// Instanciation de l'objet
$objetA = new maClasse();
$objetB = $objetA;
 
// Appelle du setter
$objetA->setAttribut("AZERTY");
echo "Valeur de l'attribut de objetA: ".$objetA->getAttribut()."<br>\n";
 
// Affichage du contenu avec le getter de $objetB
echo "Valeur de l'attribut de objetB: ".$objetB->getAttribut()."<br>\n";
?>

Nous voyons que le résultat n'est pas celui auquel on aurait pu s'attendre, mais cela démontre bien que l'objet objetB est une copie de l'objet objetA avant l'appel de $objetA->setAttribut().

Alors on peut se demander s'il est possible de ne pas travailler sur une copie de l'objet en PHP 4. La réponse est OUI bien entendu mais c'est un peu plus lourd. Voici ce qu'il faut faire lors de l'instanciation et la copie d'objets:

<?php
// Instanciation de l'objet
$objetA =& new maClasse();
$objetB =& $objetA;
?>

L'esperluette (signe &) permet d'indiquer à PHP que l'on travaille avec des références sur les objets et plus avec des copies. Dès lors, si vous relancer le programme, vous devriez voir que les attributs des objets objetA et objetB sont bien les mêmes et pour aller plus loin, que les deux objets sont les mêmes: ils utilisent le même espace mémoire.

Il semble simple finalement d'utiliser les références en PHP allez-vous dire! En fait, l'exemple que nous venons de voir est un petit exemple. Partons du principe que vous vouliez utiliser deux classes: la classe Utilisateur et la classe Adresse. Voici ce que nous devons écrire en PHP 4 pour utiliser les références:

<?php
class Adresse
{
   var $adresse;
   var $codepostal;
   var $ville;
 
   function Adresse($adresse, $codePostal, $ville) {
       $this->setAdresse($adresse);
       $this->setCodePostal($codePostal);
       $this->setVille($ville);
   }
   function setAdresse($adresse) {
       $this->adresse = $adresse;
   }
   function setCodePostal($codepostal) {
       $this->codepostal = $codepostal;
   }
   function setVille($ville) {
       $this->ville = $ville;
   }
   function getAdresse() {
       return($this->adresse);
   }
   function getCodePostal() {
       return($this->codepostal);
   }
   function getVille() {
       return($this->ville);
   }
}
 
class Utilisateur
{
   var $nom;
   var $prenom;
   var $email;
   var $adresse;
 
   function Utilisateur($nom, $prenom, $email, &$adresse) {
       $this->setNom($nom);
       $this->setPrenom($prenom);
       $this->setEmail($email);
       $this->setAdresse(&$adresse);
   }
   function setNom($nom) {
       $this->nom = $nom;
   }
   function setPrenom($prenom) {
       $this->prenom = $prenom;
   }
   function setEmail($email) {
       $this->email = $email;
   }
   function setAdresse(&$adresse) {
       $this->adresse =& $adresse;
   }
   function getNom() {
       return($this->nom);
   }
   function getPrenom() {
       return($this->prenom);
   }
   function getEmail() {
       return($this->email);
   }
   function &getAdresse() {
       return($this->adresse);
   }
}
 
$adresse =& new Adresse("1, bd de la Paix", "75000", "PARIS");
$utilisateur =& new Utilisateur("MARTIN", "Jean", "jmartin@adressemailbidon.zz", $adresse);
 
// Affichage des données de l'utilisateur
echo("<pre>");
print_r($utilisateur);
echo("</pre><br>\n");
 
// Modification de l'adresse via la classe Utilisateur (obligé de décomposer les modifications)
$adr =& $utilisateur->getAdresse();
$adr->setCodePostal("44000"); // on peut aussi écrire cela avec $utilisateur->adresse->setCodePostal("44000");
$adr->setVille("NANTES"); // on peut aussi écrire cela avec $utilisateur->adresse->setVille("NANTES");
echo("Après modification de l'adresse:<pre>");
print_r($utilisateur);
echo("</pre><br>\n");
?>

Pour les développeurs qui connaissent le C++ ou Java, ce n'est pas inhabituel. Mais avec PHP 4, il n'est pas possible d'enchaîner les appels comme ceci:

$utilisateur->getAdresse()->setCodePostal("44000");
$utilisateur->getAdresse()->setVille("NANTES");

Il faut impérativement passer par plusieurs étapes en récupérant d'abord l'instance de l'adresse puis en appelant les méthodes de cette adresse. En plus, nous retrouvons des esperluettes un peu "partout" ce qui augmente le risque d'erreurs.

[modifier] Ce que propose PHP 5

PHP 5 propose une approche différentes des objets puisque qu'on ne travaille qu'avec des références (comme en Java par exemple).

Si le développeur déclare une instance de classe, voici ce qu'il a à faire:

<?php
$obj = new MaClasse();
?>

Et c'est bel et bien une référence sur l'objet que le développeur va manipuler. On n'utilise plus d'esperluette , ce n'est plus nécessaire! Grâce à cela, il y a moins de risques d'erreurs.

Si nous réécrivons le code que nous avions vu dans la partie concernant PHP 4 (avec Utilisateur et Adresse), voici ce que nous aurions en PHP 5:

<?php
class Adresse
{
   private $adresse;
   private $codepostal;
   private $ville;
 
   public function setAdresse($adresse) {
       $this->adresse = $adresse;
   }
   public function setCodePostal($codepostal) {
       $this->codepostal = $codepostal;
   }
   public function setVille($ville) {
       $this->ville = $ville;
   }
   public function getAdresse() {
       return($this->adresse);
   }
   public function getCodePostal() {
       return($this->codepostal);
   }
   public function getVille() {
       return($this->ville);
   }
}
 
class Utilisateur
{
   private $nom;
   private $prenom;
   private $email;
   private $adresse;
 
   public function setNom($nom) {
       $this->nom = $nom;
   }
   public function setPrenom($prenom) {
       $this->prenom = $prenom;
   }
   public function setEmail($email) {
       $this->email = $email;
   }
   public function setAdresse($adresse) {
       $this->adresse = $adresse;
   }
   public function getNom() {
       return($this->nom);
   }
   public function getPrenom()    {
       return($this->prenom);
   }
   public function getEmail() {
       return($this->email);
   }
   public function getAdresse() {
       return($this->adresse);
   }
}
 
// On définit une adresse que l'on rattache à un utilisateur
$adresse = new Adresse();
$utilisateur = new Utilisateur();
$utilisateur->setAdresse($adresse);
 
// On définit les paramètres de l'utilisateur
$utilisateur->setNom("MARTIN");
$utilisateur->setPrenom("Paul");
$utilisateur->setEmail("paul.martin@adresse-email-bidon.fr");
 
// On définit les paramètres de son adresse
$adresse->setAdresse("1, rue Sésame");
$adresse->setCodePostal(75001);
$adresse->setVille("PARIS");
 
// On affiche le résultat cequi montre bien que l'objet Utilisateur stocke
// la référence sur l'adresse et non la valeur
print_r($utilisateur); echo("<br>\n");
 
// Ceci démondre que comme dans les langages objets évolués, il est
// possible de "chaîner" les appels de méthodes puisque getAdresse retourne
// la référence de l'objet Adresse
$utilisateur->getAdresse()->setCodePostal(75002);
print_r($utilisateur); echo("<br>\n");
?>

Donc, toutes les esperluettes ont disparu et nous pouvons maintenant enchaîner les appels de méthodes comme nous pourrions le faire en Java. Mais tout ceci n'est pas totalement "innocent" puisque PHP doit se rapprocher petit à petit de Java pour permettre d'utiliser directement les objets Java comme des objets PHP.