Méthylbro Développeur Web PHP - Tag - objet

PHP : Les références

Méthylbro — Tue, 15 Sep 2009 08:00:00 +0200

Lors d'un de mes derniers billets sur la comparaison d'objets avec PHP, j'ai évoqué un concept qui avec du recul m'a semblé nécessaire d'approfondir : les références.

Comme il s'avère que je suis bien partit dans une petite série de billets dédié à des concepts simple ; je pense qu'il est opportun de s'attarder sur le sujet.

Définition d'une référence

En PHP une référence est une autre façon d'accéder à une valeur stockée en mémoire. Ainsi, au lieu d'avoir une variable x qui contient une valeur y, nous avons une variable x qui contient une référence vers la valeur y.

La documentation officielle de PHP compare les références avec les liens symboliques que l'on trouve sur les systèmes UNIX, l'analogie est intéressante.

Ainsi donc, si $A est une référence de la valeur $B alors $A et $B sont des variables qui pointent vers le même contenu.

En PHP lorsque l'on souhaite passer des arguments par référence, nous utiliserons le caractère &. Soit pour dire « A est une référence vers la valeur de B » :

$A =& $B;

Attention, si vous provenez du monde du C, ne confondez pas les références en PHP et les pointeurs que vous pourrez trouver en C. Il s'agit juste ici de pouvoir appeler une valeur identique avec des noms différents.

Une référence s'utilise ensuite comme n'importe quelle variable. Vous pouvez par exemple utilisez la fonction unset($ref) pour détruire votre référence.

Néanmoins, même s'il est très facile de détruire une référence, il deviendra plus complexe de supprimer la valeur stockée en mémoire. C'est pourquoi, la manipulation des références est un des points critique concernant la consommation en ressources mémoire d'un script.

Si l'on reprend notre exemple et que l'on supprime la variable originale $B. La valeur stockée derrière celle-ci sera toujours conservée en mémoire car il restera encore la référence $A liée.

Si vous ne prenez pas garde à faire un minimum le ménage dans vos scripts vous pouvez alors rapidement vous retrouver avec beaucoup de valeurs inutiles stockées en mémoire.

Le problème de la gestion de la mémoire est traité plus largement par ce que l'on appelle le Garbage Collector (le ramasse-miettes en français). Il sera intéressant de revenir sur le GC de PHP plus tard dans un autre article.

Passage de paramètres par référence

Malgré les ennuis que nous venons de voir, les références apportent de tout même plus de solutions que de problèmes. L'un des usages les plus courant et les plus agréable de ce concept est le passage d'arguments par référence.

En effet, il est très fréquent lors de développement d'application de vouloir modifier la valeur même d'un argument au sein d'une fonction. Un peu comme si ce paramètre était défini comme une variable globale.

Pour être plus clair, prenons par exemple les fonctions PHP de tri sur les tableaux comme usort, uksort ou autre. Le tableau que vous passez en paramètre est directement modifié et la fonction ne retourne qu'un booléen.

Prenons par exemple une fonction qui ajoute un retour de chariot à la fin d'une chaîne de caractères, avec la chaîne de caractères étant un paramètre par référence :

function addCRLF(&$string) {

$string."\r\n";

}



$machaine = 'Hello World !';

addCRLF($machaine);

echo $machaine;

Retourner des références

Dans un deuxième cas, il peut être intéressant de récupérer une référence plutôt qu'une valeur après l'exécution d'une fonction. Il ne faudra alors pas oublier de spécifier lors de la définition de la fonction que celle-ci retournera une référence.

Voyons un exemple dans un style un peu plus « Orienté Objet » :

class stdObject {

public $attribute = 1;

function & method() {

return $this->attribute;

}

}



$object = new stdObject;

$myRef = &$object->method();

$myRef = 'Hello World';

echo $object->attribute;

Dans cet exemple, $myRef devient un référence vers la même valeur que $object->attribute.

PHP : Appels de méthode à la chaîne

Méthylbro — Sun, 13 Sep 2009 08:00:00 +0200

Il y a plein de bonne pratique que je vois trop souvent être ignorées par d'autres développeurs qui m'entourent (collègues, stagiaires etc). Pour certaines d'entre elles, il s'agit de pratique que j'ai ignoré pendant trop longtemps par méconnaissance d'un l'intérêt qu'elles peuvent apporter.

J'imagine qu'il m'en reste encore énormément à découvrir d'ailleurs. L'idée ici est de factoriser un ensemble d'appels de méthode sur un objet en une seule instruction. Pouvoir faire des appels de méthodes à la chaîne.

Il est fréquent de tomber sur des cas semblables à l'exemple suivant :

class Object {

function methodA() {}

function methodB() {}

function methodC() {}

}



$instance = new Object();

$instance->methodA();

$instance->methodB();

$instance->methodC();

En considérant que les méthodes A, B et C soit de type void. C'est-à-dire qu'elle ne retournent rien et qu'elle n'auront pas à l'avenir pour vocation de retourner une information. Il serait intéressant alors de factoriser les trois instructions utilisées pour l'appel a ces trois méthodes.

Pour ce faire, il suffit lors de la déclaration des méthodes, de ajouter l'information suivante :

class Object {

function methodA() {

return $this;

}

function methodB() {

return $this;

}

function methodC() {

return $this;

}

}

L'intérêt est de pouvoir utiliser plus simplement cette classe et de faire appel aux méthodes A, B et C en une seule instruction :

$instance = new Object();

$instance->methodA()->methodB()->methodC();

Plus intéressant n'est-ce pas ?

PHP : La comparaison d'objets

Méthylbro — Mon, 07 Sep 2009 08:00:00 +0200

En PHP ; la comparaison d'objet est très simple, mais elle suppose une légère nuance entre le moteur objet de PHP4 et celui de PHP5.

C'est cet aspect de PHP que nous allons voir aujourd'hui.

Comme PHP n'intègre pas (encore) de méthode pour effectuer une surcharge d'opérateur comme cela peut être le cas dans d'autres langages. Nous allons nous concentrer uniquement sur la comparaison d'objets via les opérateurs d'égalité et d'identité (==, ===, !=, !==).

Pour nos exemples, nous utiliserons la petite classe suivante :

class stdObject  {

protected $x,$y;

public function __construct($x, $y)  {

$this->x = $x;

$this->y = $y;

}

}

Comparaison d'objets en PHP4

Pour commencer, en PHP4 la comparaison d'objet est simpliste. Deux objets sont considérés comme égaux s'ils sont tous deux l'instance d'une même classe avec des valeurs égales pour chaque propriétés.

Soit par l'exemple suivant (en PHP4) :

$A = new stdObject(1,1.5);

$B = new stdObject(1,1.5);



$A == $B : TRUE

$A != $B : FALSE

$A === $B : TRUE

$A !== $B : FALSE



$C = new stdObject(1,1.5);

$D = new stdObject(1,1);



$C == $D : FALSE

$C != $D : TRUE

$C === $D : FALSE

$C !== $D : TRUE

Comparaison d'objets en PHP5

Cependant, dans notre premier exemple les objets $A et $B, même s'ils sont égaux ne sont pas identiques. PHP5 va donc se compliquer un peu plus la comparaison d'objets en dissociant l'opérateur d'égalité (==) avec celui d'identité (===).

En PHP5, deux objets pourront être alors égaux mais pas forcément identiques. C'est-à-dire que deux objets peuvent être deux instances d'une même classe avec des valeurs égales pour chacune de leurs propriétés sans toutefois faire référence à une instance identique.

Soit l'exemple suivant (en PHP5) :

$C = new stdObject(1,1.5);

$D = new stdObject(1,1.5);



$C == $D : TRUE

$C != $D : FALSE

$C === $D : FALSE

$C !== $D : TRUE



$E = $D;



$E == $D : TRUE

$E != $D : FALSE

$E === $D : TRUE

$E!== $D : FALSE

Conclusion

Nous venons donc de voir la différence subtile entre PHP4 et PHP5 lors de la comparaison d'objets. En POO, et particulièrement en PHP, comprendre les mécanismes liés au stockage en mémoire de vos objets (références, garbage collector etc) est indispensable.

Conception et programmation orienté objet

Méthylbro — Thu, 03 Sep 2009 08:00:00 +0200

Voici un livre impressionnant sous tous les rapports. D'abord par sa taille, il s'agit d'un pavé énorme, près de 1500 pages. Ensuite par son exhaustivité car il aborde tour à tour tous les concepts inhérents au paradigme objet (modularité, généricité, typage, assertions et exceptions etc …).

Le tout illustré par des exemples éloquents et compréhensibles par tous les développeurs. Qu'ils proviennent du monde du C, du Java ou dans mon cas du PHP (qui est loin d'être un modèle de langage à suivre pour l'application de certains concepts naturels de la Programmation Orienté Objet.

Ce livre est une bonne étape non seulement pour ceux qui veulent apprendre et/ou comprendre la POO mais également pour ceux qui - comme moi - souhaite approfondir le sujet pour pallier à certaines lacunes. Je suis même sur que les développeurs orienté objet les plus chevronné d'entre nous y trouverons tout de même foule d'enseignements.

Ce fut mon livre de chevet pendant ces dernières semaines. Je vous le conseille allègrement malgré son prix un peu élevé (60 € sur le site de l'éditeur). Cela reste néanmoins un bon investissement.

Conception et programmation orienté objet de Bertrand Meyer

Introduction à la POO avec PHP - Partie 2

Méthylbro — Tue, 15 Apr 2008 06:30:00 +0200

La programmation orientée objet (POO) ou programmation par objet, est un paradigme de programmation informatique qui consiste en la définition et l'assemblage de briques logicielles appelées objet ; un objet représente un concept, une idée ou toute entité du monde physique, comme une voiture, une personne ou encore une page d'un livre.

http://fr.wikipedia.org/wiki/Programmation_orientée_objet

Ou bien d'un simple stylo !
Comme promis (Introduction à la POO avec PHP - Partie 1) ; voici la deuxième partie de cette série de billets dédiés à la Programmation Orienté Objet avec PHP.

Les concepts généraux de la POO

Classe et instance de classe

Comme vous pouvez l’imaginer ; avant de pouvoir utiliser un objet ; nous allons devoir définir le type de cet objet.

C’est à ce niveau que la compréhension risque d’être la moins évidente et la plus difficile. Il va falloir distinguer le type d’un objet (entier, réel, booléen etc) de l’objet lui-même (33, 3.14, true etc).

Lorsque nous définirons le type d’un objet ; nous parlerons de classes. Lorsque nous utiliserons ses classes pour créer et manipuler des objets nous parlerons d’instances de classes.

Pour illustrer ; je vais reprendre mon exemple des stylos. La classe sera le schéma pour un stylo. Comme un de plan de fabrication, ou d’utilisation. Tandis que l’instance de cette classe sera techniquement le stylo. Donc ; pour le même schéma ; pour la même classe ; vous pouvez avoir plusieurs stylos ; plusieurs objets ou instances de classe.

En php définir une classe est aussi simple que de définir une fonction :


class Stylo {
  // définition des propriétés
  // définition des méthodes
}

Une fois la classe définie ; vous pouvez très bien créer un nouvel objet ; une nouvelle instance de votre classe. Pour ce faire ; en php on utilise l’opérateur new.

// $myClassInstance est un nouvel objet de type Stylo $myClassInstance = new Stylo() ;

Les propriétés

Les propriétés sont des variables associés aux instances de vos classes (ceci est une généralité. Nous verrons plus loin que des cas spécifiques sont possibles ; notamment avec le mot clé static).

Par exemple ; si nous considérons une entité de type Personne. Chaque personnes possède un nom ; un prénom et une date de naissance. Et bien ces informations seront des propriétés de la classe Personne. Chaque instance de Personne possédera donc un nom ; un prénom et une date de naissance.

Si je reprends mon exemple du stylo ; chaque stylo aura comme propriété un niveau d’encre ; une couleur ; et un statut pour savoir si ma mine est sortie ou capuchée. La définition de ma classe Stylo prendra donc la forme suivante :


class Stylo {
  var $niveau_encre ;
  var $couleur ;
  var $statut ;
  // définition des méthodes
}

Le mot clés var n’est plus utilisé depuis php5. Cependant il a été conservé pour une compatibilité avec php4. Il est utilisé ici ; juste pour que vous sachiez qu’il existe et pour que vous ne soyez pas surpris si un jour vous le rencontrez.

Les méthodes

Les méthodes sont des procédures et/ou des fonctions associées aux instances de vos classes. De la même façon que les propriétés ; nous verrons plus loin que cette affirmation est une généralité assujettie à des exceptions.

Au sein de vos méthodes ; vous pouvez faire appel aux autres éléments (méthodes et ou propriétés) de votre instance de classe à l’aide de l’objet $this. Qui est en fait une référence vers l’instance de classe concernée.

Par exemple ; nous allons créer une méthode qui renvoie vrai si le niveau d’encre est suffisant pour écrire ; et faux le cas contraire. Vous allez voir que ; a part la possibilité d’accéder aux propriétés de l’objet en cours ; rien ne change comparativement aux fonctions que vous connaissez.

class Stylo { $niveau_encre ; $couleur ; $statut ; function peutEcrire() { if ($this->niveau_encre<=0) { $result = false; } else { $result = true ; } return $result ; } }

Introduction à la POO avec PHP

Méthylbro — Mon, 14 Apr 2008 06:00:00 +0200

Depuis sa version 4 ; PHP intègre les concepts de Programmation Orienté Objet. Très à la mode ; cette façon de programmer vous sera très utile. Néanmoins ; elle introduit foule de nouveaux concepts à nos méthodes de développement plus classique.

Il existe beaucoup d’articles et de tutoriel concernant la POO. Mais dans la plupart des cas ; ces articles sont écrits avec des exemples en C++ ou en Java.
Et encore trop peu avec des illustrations en PHP.

Cette semaine ; à l’occasion de la sortie de la version 5 de TitaXium ; je vous propose une série de 6 articles introduisant la Programmation Orienté Objet avec des exemples en PHP.

Ainsi ; en 6 jours ; j’espère faire découvrir à ce qui ne le connaissent pas encore ; le monde des classes ; des méthodes et des objets. Et d’ici à ce week-end ; vous serez sans doutes à même d’écrire vous-même vos propres classes !

Introduction

Prés requis

Avant d’entrer dans le vif du sujet ; je déconseille cet article à toutes les personnes ayant un niveau de débutant en développement.

Cet article s’adresse à des développeurs PHP confirmés ; qui ont de l’expérience. Pour comprendre cet article ; il vous faudra être à l’aise avec tous les outils utilisés dans les langages procéduraux ; et plus particulièrement en PHP.

De plus ; cet article n’est qu’une introduction. Une première étape dans la compréhension de la POO.

Nous ne traiterons donc pas de concepts avancés comme par exemple l’héritage ou les design pattern.

Comparaison avec un développement procédural

En développement classique ; vous connaissez déjà les types de variable les plus courant. Entiers, réels, Tableaux, Chaines de caractères, booléen … Tout ca n’a plus de secrets pour vous.

Vous avez aussi l’habitude de réunir vos traitements récurrents au sein de procédures ou de fonctions. C’est ce que nous faisons tous avec nos db_connect() ou encore les afficher_machin($truc).

Pourtant ; la POO (Programmation Orienté Objet) est un terme qui vous parait obscur et barbare. Vous en entendez parler depuis des années sans trop savoir ce qui se cache derrière.

Imaginez un instant ; qu’en plus des types courant que nous avons cité ci-dessus ; vous puissiez vous même définir vos propres types de valeurs. Avec des comportements et des structures qui leur sont propre. Imaginez vos variables comme des entités ; des individus contenant des informations et pouvant effectuer des traitements divers sur celles-ci.

Vous ne voyez toujours pas ou je veux en venir ?

Si on prend une variable simple ; un entier par exemple ; cette variable peut contenir une valeur. Et sur cette valeur je peux effectuer des traitements (l’additionner ; la comparer ; la diviser etc). En théorie objet ; toutes ces entités que nous utilisons ; nous appelons cela des objets (ou des instances de classe). Et ces traitements ce sont des méthodes. Mon entier sera donc un objet ; sur lequel je pourrais appliquer les méthodes d’addition ; de comparaison ; de division etc.

En plus des objets simple que nous connaissons en développement procédural classique ; nous pouvons donc définir de nouveaux objets. Avec de nouvelles méthodes.

Vous verrez que ce concept d’objets et plus naturel qu’il n’y parait de prime abord. Car tout ce qui nous entoure n’est qu’objets ! Le clavier et la souris que vous avez sous votre nez sont des objets.
Qui contiennent des valeurs et sur lequel vous appliquez des méthodes.

Par exemple ; votre souris est un objet. Qui contient les valeurs x et y (pour connaitre sa position) et sur lequel vous pouvez appliquer les méthodes deplacer(), click_droit(), click_gauche() …

Exemple employé

Pour illustrer mon propos ; je vais utiliser un exemple très simple. Et très commun.

Prenez un stylo. Un de ces stylos à bille commerciaux que l’on trouve n’importe où. Il s’agit bien d’un objet. Un objet que vous pouvez facilement synthétiser le fonctionnement en POO.

Que peut-on faire avec un stylo ou, quelles seront les méthodes de notre objet ? Exactement ce que vous faites avec un stylo traditionnel. Ecrire, cliquer sur ses fesses pour faire apparaitre ou disparaitre la mine ; ou encore observer le niveau de sa réserve d’encre. Et bien ce sera très exactement les méthodes que nous allons retrouver dans notre objet.

Quelles sont les propriétés que possèdes un stylo ? Quels sont les attributs qui font de lui qu’il est différent d’un autre stylo ? Quelles valeurs vont être contenues notre stylo ? Ici nous nous posons la question des valeurs qui seront attachés à chacun de nos stylos.