Vous êtes sur la page 1sur 25

Programmation Orientée Objets en PHP

www.moteurprog.com
Partie 1 : Introduction

1. Introduction
1.1 Implémentation en PHP

La notion d'objet dans le langage du PHP à un aspect très limité contrairement au langages de
référence tel que le C++, dans cet article, je vais essayé de vous expliquer son implémentation
dans le PHP, et comment l'utiliser.

1.2 Concept Objet

Le concept objet doit être pris dans le sens de "module", sous ce nom, se cache un ensemble
de commandes visant à exécuter des actions, un objet est une entité, un peu comme si l'on
voulait diviser notre programme en sous-tâches.

1.3 Avantages

Beaucoup d'avantages donnent raisons à l'utilisation des classes, réutilisation du code plus
facile, traitement des informations à part, cela réduit aussi considérablement le temps de
travail, car vous incluez votre classe dans tous les programmes qui vont l'utiliser au lieu de la
réécrire.

1.4 Acquis

Dans cet article, je considérerais que vous avez de bonnes bases en PHP, ce tutorial s'adresse
néanmoins surtout aux débutants.

2. Théorie
2.1 Thermes

La programmation objet utilise un vocabulaire particulier :


Vocabulaire du concept Objet en PHP
Représentant de la classe dans l'application, il se nomme
objet
instance de classe.
classe Entité contenant toutes les méthodes et attributs.
méthode Nom donné aux fonctions contenu dans la classe.
Nom donné aux variables globales de la classe, définis aux
attribut
début.
Nom donné à la méthode lancé lors de l'instanciation de la
constructeur
classe, elle porte le même nom que la classe.
Nom donné à la méthode lancé lors de la destruction de la
destructeur classe, cet notion, n'existe pas vraiment dans
l'implémentation du concept objet en PHP.

2.2 Classe

Pour introduire une classe dans un programme vous devez utiliser :


class nom_classe
{
//...
}
La spécification des attributs se fait au début :
class nom_classe
{
// Variable sans valeur
var $variable1;
// Variable avec valeur
var $variable2 = "Variable 2";
// Tableau
var $tableau = array();
//...
}

Comme vous pouvez le voir, on utilise le mot clé var pour introduire un attribut, vous pouvez
laissez cette variable indéfinie, ou lui donner une valeur.
Introduction du constructeur (facultatif) :

class nom_classe
{
// Variable sans valeur
var $variable1;
// Variable avec valeur
var $variable2 = "Variable 2";
// Tableau
var $tableau = array();

// Le constructeur de la classe
function nom_classe ($var, $autre_var)
{
//...
}
}

Le constructeur est une méthode lancé lors de l'encapsulation (instanciation) de la classe, cette
méthode est facultative.
Inclusion d'autres méthodes :

class nom_classe
{
// Variable sans valeur
var $variable1;
// Variable avec valeur
var $variable2 = "Variable 2";
// Tableau
var $tableau = array();

// Le constructeur de la classe
function nom_classe ($var, $autre_var)
{
//...
}

// Fonction1
function Fonction1 ()
{
//...
}
// fonction2
function fonction2 ($var)
{
//...
}
}

La définition de méthodes dans une classe se fait de la même manière que les fonctions dans
le code source PHP, j'en profite pour rappeler que PHP est sensible à la casse
(majuscule/minuscule).

2.2 Code source

Voyons maintenant ce qui se passe du côté de votre script PHP qui va utiliser votre classe
nouvellement créer :

<?php

// Création d'une instance de la classe nom_classe et lancement de la


// fonction de construction (le constructeur)
$objet = new nom_classe ("valeur, valeur2");
// Vous l'avez remarqué, $objet est l'objet !

// Définition de la variable $variable1


$objet->variable1 = "Variable 1";

// Lancement de la fonction fonction2()


$objet->fonction2 ("valeur");

?>

On commence tout d'abord par créer une nouvelle instance de la classe nom_classe à l'aide du
mot-clé new, par la même occasion, la fonction du même nom que la classe (le constructeur)
est lancé, le constructeur sert en général à définir les attributs selon les arguments passés en
paramètres.
Ensuite, nous définissons la variable de la classe, $variable1, pour cela on utilise l'objet suivi
d'un tiret - puis d'un signe supérieur > et on ajoute le nom de la variable (qui est à l'intérieur
de la classe) sans le signe dollar $.
L'utilisation des fonctions (méthodes) de la classe se fait de la même manière que les
variables (attributs) comme nous le voyons pour la méthode fonction2().
Partie 2 : Pratique

1. De la Théorie à la Pratique
1.1 POO en PHP : Partie 2

Bienvenu(e) dans la deuxième partie de ce tutorial réservé à l'étude et l'apprentissage de la


POO (Programmation Orientée Objets) dans le langage PHP. Nous allons étudier plus en
profondeur le fonctionnement des classes.

1.2 Pour la Pratique

Je considèrerais comme acquis le premier article du même sujet (Partie 1 : Introduction)

2. Dans la Classe
2.1 Mots-Clé

Voici un résumé des mots-clés à utiliser dans vos classes :


Mots-clé des classes
Il sert à définir une classe, utiliser au début, nous reverrons
class
sont utilisation plus loin.
var Défini les attributs de la classe.
Défini les méthodes de la classe (même utilisation que le
function
mot-clé du même nom dans le code source PHP)
Il permet d'instancer une classe dans un objet, à utiliser dans
new
le code source de votre page PHP.

2.2 Création d'une classe

Nous allons utiliser le mot clé class pour commencer une nouvelle classe. Le mieux, est de
placer la source de la classe dans un fichier à part de la page PHP, afin de pouvoir réutiliser la
classe dans d'autres pages ou applications. Vous n'avez plus qu'ensuite à faire un include du
fichier contenant la classe dans toutes vos pages PHP devant l'utiliser.
Moi, j'utilise, pour nommer les fichiers de mes classes l'extension : ".class.php", bien sur vous
pouvez choisir ce qu'il vous plait. Certains utilise ".class" comme extension, c'est une faute
grave car n'importe qui sachant où se trouve le fichier pourra voir le code source de la classe.
Dans la mesure du possible donner à vos fichiers une extension fini par ".php"

<?php
/* Fichier classe1.class.php */
// Création d'une nouvelle classe :
class classe1 // classe1 est le nom de la classe
{
/* Le code de la classe est contenu entre les accolades */
}
?>

2.3 Définition d'attributs

Les attributs sont des variables qui sont utilisés dans tous le code de la classe (uniquement),
chaque fonction de la classe peut utiliser un attribut, pour cela, elle utilise une variable
spéciale qui fait référence à l'objet : $this, ainsi pour qu'une méthode puisse profiter d'un
attributs de la classe (p. ex. $variable1) elle utilise $this->variable (p. ex. $this->variable1).
Notez bien que vous devez omettre le signe dollar $ devant le nom de l'attribut de la même
façon que dans le code source de la page PHP (cf. Partie 1). Pour voir comment une fonction
utilise les attributs, référez-vous au 2.4.
Pour définir un attribut dans une classe, vous devez utiliser var, suivi du nom de la variable
(attribut) puis d'un point-virgule ; (p. ex. var $variable1; ) Vous pouvez introduire un nombre
infini d'attributs à n'importe quel endroit de la classe.
Vous pouvez au moment de définir un attribut lui donner une valeur par défaut, pour cela,
taper var, suivi du nom de la variable (p. ex. $variable2), suivi d'un égal =, puis de la valeur
entre parenthèses (p. ex. "Valeur 2"), pour finir ajouter l'habituel point-virgule ; (ce qui donne
p. ex. var $variable2 = "Valeur2";).
Vous avez aussi la possibilité de définir un tableau, de la même façon que ci-dessous, sauf
que la valeur est remplacée par array ('valeur1', 'valeur2', 'valeur3') (p. ex. var $variable3 =
array ('Valeur1', 'Valeur2', 'Valeur3');). Voir ci-dessous pour un exemple de tous ce qui à été
vu précédemment.

<?php/
* Fichier classe2.class.php */
// Création d'une nouvelle classe :
class classe2 // classe2 est le nom de la classe
{
// Attribut sans valeur
var $variable1;
// Attribut avec valeur par défaut
var $variable2 = "Variable 2";
// Tableau de valeur
var $variable3 = array('Valeur1''Valeur2', 'Valeur3');

?>

2.4 Définition de méthodes

Les méthodes sont des fonctions utilisées dans la classe, elles ont les mêmes spécifications
que les fonctions utilisées dans le code source de la page. Ainsi je ne m'étendrais pas
beaucoup dessus, référez-vous à un cours sur les fonctions utilisateurs, plus complet.
Utilisez le mot-clé function pour introduire une nouvelle fonction au sein de la classe.
Pour savoir comment utiliser les attributs de la classe dans une fonction, voyez l'exemple ci-
dessous. Pour l'utilisation d'autres méthodes de la classe, on procède de la même façon que
pour les attributs, vous devez utiliser le mot-clé $this faisant référence à l'objet, suivi de -> et
enfin la fonction, (p. ex. $this->fonction1()). Voyez ci-dessous pour un exemple.
<?php
/* Fichier classe3.class.php */
// Création d'une nouvelle classe :
class classe3 // classe3 est le nom de la classe
{
// Attribut sans valeur
var $variable1;
// Attribut avec valeur par défaut
var $variable2 = "Variable 2";
// Tableau de valeur
var $variable3 = array('Valeur1','Valeur2', 'Valeur3');

/* Méthode appelant un attribut de la classe */


function fonction1 ($var)
{
/* Donne une valeur à l'attribut $variable1 */:
$this->variable1 = "$var";
}

/* Méthode appelant une autre méthode de la classe */


function fonction2 ()
{
// Appelle la méthode fonction1()
$this->fonction1 ('Variable1');
}
}

?>

2.5 Définition du constructeur

Le constructeur est une méthode particulière, elle est lancée au moment de l'instanciation de
la classe, elle porte exactement le même nom que la classe elle-même.
Le constructeur a généralement la fonction de donner des valeurs à certains attributs selon ce
que le programmeur à spécifié lors de la création (l'instanciation, l'encapsulation) de l'objet (p.
ex. pour une classe gérant la date (on peut tout imaginer ;-)) le programmeur va à la création
de l'objet dire qu'il veut la date en français, le constructeur va par exemple modifier l'attribut
$lang, qui était par défaut en EN, il va lui donner la valeur FR.). Voir ci-dessous pour son
utilisation.

3. Dans le code source PHP


3.1 Création d'un nouvel objet

L'objet est l'utilisateur de la classe, c'est lui qui va profiter des méthodes et attributs de la
classe. Lors de la création d'un objet (nommé instanciation de la classe) se produit
l'encapsulation, qui cache toute la partie privée de la classe (fonctionnement des méthodes...)
ce qui permet vraiment d'avoir un sentiments de programme à part, l'objet est, pour résumer,
le client de la classe, il lui demande des informations et la classe lui fournit.
Un objet est en fait une variable qui fait référence à la classe. Comme toute variable, on doit
placer le signe dollar $ devant.
Pour créer un objet (instancer la classe) on utilise le nom de l'objet (p. ex. $mydate, suivi du
mot-clé new, puis de la classe (p. ex. date()). Pour un exemple voyez plus bas.
Attention : Veillez à inclure le fichier contenant votre classe avant de créer l'objet.
Post Scriptum : Vous pouvez créer plusieurs objets de la même classe dans le même script.

<?php
/* Fichier date.php */
// Inclusion de la classe
include ("date.class.php");

/* Création d'un objet sans lancement du constructeur */


$mydate = new date();

/* Création d'un objet avec lancement du constructeur */


$mydate2 = new date ("FR");

/* Une classe peut aussi être instancer dans une ligne d'un tableau */
$myarray[3] = new date ("FR");
?>
3.2 Appel d'attribut

Une classe ne servirait à rien si vous ne pouviez accéder aux informations qu'elle contient (via
les attributs). Donc je vais vous expliquer comment y accéder et les utiliser.
Pour utiliser un attribut d'une classe, vous devez utiliser l'objet, suivi de -> et du nom de la
variable sans le signe dollar $, cela ne vous rappelle rien ? Mais si ! La variable $this que l'on
utilise pour faire référence à l'objet à l'intérieur de la classe. Et bien en dehors de la classe,
cela se comporte de la même façon. (p. ex. $mydate->lang, fait référence à l'attribut $lang de
la classe date vu ci-dessus)

<?php
/* Fichier date.php */
// Inclusion de la classe
include ("date.class.php");

/* Création d'un objet avec lancement du constructeur */


$mydate = new date ("FR");

// Redéfinition de la valeur de l'attribut $lang


$mydate->lang = "EN";

// Affichage de l'attribut $lang


echo "$mydate->lang";
?>

3.3 Appel de méthodes

Pour utiliser les méthodes d'une classe on utilise la même technique que pour les attributs (cf.
ci-dessus). En effet, l'on procède de cette façon : $class->fonction1 ("valeur1", "valeur2");
<?php
/* Fichier classe3.php */
// Inclusion de la classe
include ("classe3.class.php");

/* Création d'un objet : Instance de la classe3 (vu dans 2.4)*/


$class = new classe3 ();

// Appel de la méthode fonction1()


$class->fonction1 ("Variable 1");
?>

4. Pour aller plus loin


4.1 L'héritage de classe

C'est dans ce domaine que nous apercevons que la POO en PHP n'est qu'une "copie" de la
vraie Programmation Orientée Objets. En effet, il ne gère que l'héritage de classe simple.
L'héritage de classe est la technique qui permet de créer des extensions de classes, une classe
qui est "fille" d'une autre classe, "hérite" des attributs et méthodes de la classe "mère". C'est là
l'aspect le plus compliqué des objets.
Pour déclarer une extension d'une classe (classe fille), on utilise le mot-clé class, suivi de le
classe fille puis du nouveau mot-clé extends, terminé par la classe mère (p. ex. class
classe_fille extends classe_mere).
<?php
/* Fichier extends.class.php */
// Création d'une classe fille
/* classe_fille est le nom de la classe qui hérite des attributs et
méthodes de classe_mere */
class classe_fille extends classe_mere
{
/* Définition des attributs et méthodes de la classe classe_fille.
L'utilisation des attributs et des méthodes de la classe classe_mere se
fait comme-ci ils étaient inclus dans classe_fille*/
}
?>

4.2 Durée de vie des Objets

Un des énormes avantages des objets, peu connu par les débutants, est le passage d'un objet
d'une page à l'autre. Comment-est-ce possible ? En appelant une fonction qui va linéariser
notre objet, de tel façon que l'on puisse le passer en paramètre à un URL, dans une variable de
session ou encore par un champs caché dans la page (input hidden).
Cette fonction magique est serialize(), il vous suffit de stocker dans une variable l'objet traité
par serialize(), puis de le "regonfler" grâce à une autre fonctions connexe, unserialize() (cf. ci-
dessous).

<?php
/* Fichier linear.php */
// Création d'un nouvel objet (celui à linéariser)
$objet = new classe();

// Variable qui contient l'objet linéariser


$objet_linear = serialize($objet);

/* Nous supposons que la variable à été passé à une autre page, nous allons
maintenant la délinéariser */

/* On créer la variable "hôte" de l'objet (du même nom que l'objet original
par exemple) */
$objet = unserialize($objet_linear);
/* Et voilà ! $objet dispose des même caractéristique qu'au départ,
(n'oubliez pas d'inclure sur la nouvelle page la classe qui à été instancé
par $objet) */
?>

4.3 "Endormir" l'Objet

Lors de la linéarisation de l'objet par la fonction serialize() (cf. ci-dessus), les connections aux
bases de données, fichiers ouverts, sockets...etc. ne sont pas refermés, ce qui peut causer de
graves ennuis. C'est pourquoi la fonction __sleep() à été définie. Vous devez, si votre objet est
destiné à être linéariser, créer une nouvelle méthode dans votre classe portant le nom :
__sleep(), elle aura pour fonction de fermer toutes les connections. Au moment de l'appel de
la fonction serialize(), la méthode __sleep() sera automatiquement lancée.
Par opposition, la méthode __wakeup(), sera automatiquement lancée, si elle existe, lors de
l'appel à la fonction unserialize(). Elle servira à relancer les diverses connections closent après
l'appel de la méthode __sleep().
<?php
/* Fichier sleep.class.php */
// Création d'une nouvelle classe
class endormir
{
// Définition de la méthode __sleep()
function __sleep()
{
// Fermeture des connections
}

// Définition de la méthode __wakeup()


function __wakeup()
{
// Réouverture des connections
}
}
?>
Partie 3 : Exemples

1 Introduction

Dans l'article précédent nous avons vu la création et l'utilisation des classes en PHP, dans le
présent article, nous allons étudier des exemples concrets et commentés afin de mieux
comprendre le fonctionnement des objets et classes, ainsi nous écarterons les éventuelles
lacunes ou questions que vous vous posiez.

2. Classe 1 : SGBD
2.1 Connexion à une base de données

Sur cet exemple, nous allons à partir d'une première classe (la classe mère) obtenir des
informations, telles que le login, password, hôte et nom de la base de données. Ensuite, nous
allons utiliser une classe différente qui sera une expansion de la classe mère (une classe fille),
elle aura pour utilité d'effectuer des requêtes, de se connecter/déconnecter à la base de
données. Elle sera spécifique à une base de données (MySQL) mais puisqu'elle est une
expansion de la classe mère, nous pourrons créer d’autres classes filles pour des SGBD
(Serveur de Gestion de Base de Données) différents.

Tableau des différentes classes, attributs et méthodes


class SGBD Nom de la classe mère
class MySQL Nom de la classe fille, destinée pour le SGBD MySQL.
var $SGBD_login Attribut contenant le login de la base de donnée
var $SGBD_password Attribut contenant le password de la base de donnée
var $SGBD_host Attribut contenant l'hôte de la base de donnée
var $SGBD_base Attribut contenant le nom de la base de donnée
function connect() Méthode de connection au SGBD
function requete() Méthode d'envoi de requête au SGBD
function deconnect() Méthode de déconnection au SGBD
var $connect Attribut contenant la connection au SGBD

Nous pouvons maintenant construire notre classe mère (SGBD) !


<?php
/* Fichier : SGBD.class.php */
// Création de la classe mère
class SGBD
{
// Attribut du login du SGBD
var $SGBD_login;
// Attribut du password du SGBD
var $SGBD_password;
// Attribut de l'hôte du SGBD
var $SGBD_host;
// Attribut du nom de la base de données
var $SGBD_base;
// Attribut de connection
var $connect;
// Attribut de requête
var $requete;

// Définition du constructeur
function SGBD ($login, $password, $host, $base)
{
// Vérification des variables
if (empty ($login) || empty ($host) || empty ($base))
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Une ou plusieurs variable(s) n'ont pas
été renseigné.";
exit;
}
else
{
// Initialisation des attributs
$this->SGBD_login = $login;
$this->SGBD_password = $password;
$this->SGBD_host = $host;
$this->SGBD_base = $base;
}
}
}
?>

Voyons maintenant la création d'une méthode pour se connecter, avec les informations vu ci-
dessus, à une base de données MySQL
function connect()
{
// Connection à MySQL
$connect = mysql_pconnect($this->SGBD_host, $this->SGBD_login, $this-
>SGBD_password);

// Vérification de la connection
if(!$connect)
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Connection à MySQL impossible.";
exit;
}

// Connection à la base de données


if (!mysql_select_db($this->SGBD_base, $connect))
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Connection à la base de données impossible.";
exit;
}

// Initialisation de l'attribut de connection


$this->connect = $connect;
}
Après la connection, il faut envoyer des requêtes au SGBD, pour cela, nous allons
programmer une petite méthode : requete().
Remarque : Cet article est consacré à l'apprentissage de la Programmation Objets en PHP. En
conséquence je ne ferais pas de rappel sur l'utilisation du langage SQL.
function requete ($requete)
{
// Exécution de la requête
$result = mysql_query($requete, $this->connect);

// Vérification de la requête
if (!$result)
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Impossible d'effectuer la requête au
serveur.";
exit;
}
else
{
// Initialisation de l'attribut de requête
$this->requete = $result;
}
}

Ultime et dernière méthode : deconnect(). Comme vous l'avez sûrement deviné, cette fonction
sert à se déconnecter de la base de données.
function deconnect()
{
// Déconnection de la base de données
mysql_close($this->connect);
}

Voilà ! Nous avons finis de programmer toutes les méthodes de l'expansion de classe
MySQL. Il reste une dernière chose à faire, très importante. La création de la classe fille
MySQL.
<?php
/* Fichier : MySQL.SGBD.class.php */
// Création de la classe fille
class MySQL extends SGBD
{
// Méthode connect()
function connect()
{
// Connection à MySQL
$connect = mysql_pconnect ($this->SGBD_host, $this->SGBD_login,
$this->SGBD_password);

// Vérification de la connection
if(!$connect)
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Connection à MySQL impossible.";
exit;
}

// Connection à la base de données


if(!mysql_select_db($this->SGBD_base, $connect))
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Connection à la base de données
impossible.";
exit;
}

// Initialisation de l'attribut de connection


$this->connect = $connect;
}

// Méthode requete()
function requete ($requete)
{
// Exécution de la requête
$result = mysql_query($requete, $this->connect);

// Vérification de la requête
if(!$result)
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Impossible d'effectuer la requête au
serveur.";
exit;
}
else
{
// Initialisation de l'attribut de requête
$this->requete = $result;
}
}

// Méthode deconnect()
function deconnect()
{
// Déconnection de la base de données
mysql_close($this->connect);
}
}
?>

Nous avons maintenant terminer notre classe, dans le paragraphe suivant, nous allons voir
comment l'utiliser.

2.2 Utilisation de la Classe

Résumons la situation, nous avons une classe (mère) : SGBD, qui obtient les informations
pour se connecter à un SGBD. Ensuite, nous avons une deuxième classe (fille) : MySQL, qui
permet de se connecter, d'effectuer des requêtes et de se déconnecter à la base de donnée
MySQL, cette classe peut être dupliquer et "traduite" pour d'autres SGBD.
Dans le fichier ci-dessous, nous allons mettre à l'oeuvre nos deux classes parentes (Aucun
rappel sur le SQL ne sera fait).
<?php
/* Fichier : SGBD.php */
// Inclusion de la classe mère
include ("SGBD.class.php");

/* Initialisation de la variable du SGBD correspondant */


$SQL = "MySQL";
// Inclusion de la classe fille du SGBD correspondant
include ($SQL.".SGBD.class.php");

/* Création d'un nouvel objet de la classe fille + lancement du


constructeur */
/* Les informations sont adaptés à mon serveur, à vous de les modifier pour
quelles correspondent avec votre SGBD */
$database = new $SQL('root', '', 'localhost', 'test');

// Connection à la base de données


$database->connect();

/* Exécution d'une requête (création d'une nouvelle base de données).


Attention, pour créer une nouvelle base de données, il faut que votre
utilisateur ai touts les droits. Ceci n'est qu'un exemple parmi tant
d'autres, vous pouvez effectuer n'importe quel requête MySQL avec cette
méthode */
$database->requete("CREATE DATABASE newBase");

// Déconnection de la base de données


$database->deconnect();
?>

2.3 Synthèse

Au cours de la réalisation de cette classe, je me suis rendu compte qu'il était beaucoup plus
facile de créer une base de données via ce script , que en utilisant PHPMyAdmin ou encore
eSKUel. Notre classe est maintenant finis, je vous invite à l'améliorer (c'est facile), vous
pouvez par exemple postez dans les commentaires des classes filles de votre création
s'adaptant à d'autre SGBD. Vous pouvez aussi améliorer la méthode requete(), tout est
possible !

3. Classe 2 : email
3.1 Envois d'emails

Dans cet exemple, nous allons réaliser une classe d'envois d'emails. Cela existe déjà ? Oui, la
fonction mail() permet en effet de procéder à l'envois d'emails; mais elle ne gère pas les
erreurs, et l'utilisation du HMTL est laborieux pour un débutant. Nous allons en réaliser une
plus simple mais plus puissante (seulement en fonctionnalité, car au sein de notre classe, nous
utiliserons la fonction mail()).
Attention : Votre hébergeur doit accepter la fonction mail().
Notre classe va tout d'abord, lors de son instanciation, récupérer les informations concernant
l'expéditeur et le destinataire, il sera possible de réinitialiser le destinataire en cours
d'utilisation ou d'en définir plusieurs.

Tableau des différents attributs, méthodes et la classe


class email Nom de la classe.
function email Constructeur, il défini le destinataire
function add() Méthode d'ajout de destinataire
function send() Méthode d'envoi de l'email
function reset() Méthode de réinitialisation des attributs
var $dest Attribut contenant le(s) destinataire(s)
var $from Attribut contenant l'expéditeur
Passons à la programmation du constructeur de la classe. Portant le même nom que la classe
bien sûr.
function email ($from, $dest)
{
// Vérification des variables
if (!empty ($dest) && !empty ($from))
{
// Initialisation des attributs
$this->dest = $dest;
$this->from = $from;
}

else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Le destinataire ou/et l'expéditeur n'ont pas
été définis.";
exit;
}
}

Maintenant, nous allons réaliser la méthode la plus simple, reset(). Elle va tout simplement
remettre à zéro les attributs et les redéfinir, en fait, elle est exactement identique au
constructeur.
function reset ($from, $dest)
{
// Vérification des variables
if (!empty ($dest) && !empty ($from))
{
// Initialisation des attributs
$this->dest = $dest;
$this->from = $from;
}
else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Le destinataire ou/et l'expéditeur n'ont pas
été définis.";
exit;
}
}

Prochaine méthode : add(), elle permet d'ajouter un nouveau destinataire, ou de réinitialiser


l'attribut $dest.
function add ($dest, $reset = '0')
{
// Vérification de la variable $dest
if (!empty ($dest))
{
// Vérification de la variable $reset
if (!$reset)
{
// Initialisation du destinataire
$this->dest = $dest;
}
else
{
// Ajout d'un nouveau destinataire
$this->dest .= "; $dest";
}
}
else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Aucun nouveau destinataire défini.";
}
}

Ensuite, nous allons coder la méthode la plus importante : send(), c'est elle qui va envoyer
l'email, plusieurs paramètres vont être à saisir, notamment $HTML qui va spécifier si l'envoi
devra se faire au format HTML.
function send ($sujet, $message, $HTML = '0')
{
// Vérification des variables
if (!empty($sujet) && !empty($message))
{
// Vérification de la variable $HTML
if (!$HTML)
{
// Initialisation de la variable $from
$from = "From: ".$this->from."\r\n";
}
else
{
// Initialisation de la variable $from
$from = "From: ".$this->from."\r\n";
$from .= "Content-Type: text/html; charset=us-ascii\r\n";
}
// Envoie de l'email
@mail ($this->dest, $sujet, $message, $from) or die ("<b>Erreur
:</b> Impossible d'envoyer l'email.");
}
else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Le sujet ou/et le message n'ont pas été
définis.";
exit;
}
}

Assemblons maintenant toutes nos méthodes au sein de la classe email.


<?php
/* Fichier : email.class.php */
// Création d'une nouvelle classe
class email
{
// Attribut $dest
var $dest;
// Attribut $from
var $from;
// Constructeur de la classe : email()
function email ($from, $dest)
{
// Vérification des variables
if (!empty ($dest) && !empty ($from))
{
// Initialisation des attributs
$this->dest = $dest;
$this->from = $from;
}
else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Le destinataire ou/et l'expéditeur n'ont
pas été définis.";
exit;
}
}

// Méthode de réinitialisation : reset()


function reset ($from, $dest)
{
// Vérification des variables
if (!empty ($dest) && !empty ($from))
{
// Initialisation des attributs
$this->dest = $dest;
$this->from = $from;
}
else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Le destinataire ou/et l'expéditeur n'ont
pas été définis.";
exit;
}
}

// Méthode j'ajout de destinataire : add()


function add ($dest, $reset = '0')
{
// Vérification de la variable $dest
if (!empty ($dest))
{
// Vérification de la variable $reset
if ($reset)
{
// Initialisation du destinataire
$this->dest = $dest;
}
else
{
// Ajout d'un nouveau destinataire
$this->dest .= ",$dest";
}
}
else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Aucun nouveau destinataire défini.";
}
}

// Méthode d'envoie d'email

function send ($sujet, $message, $HTML = '0')


{
// Vérification des variables
if (!empty ($sujet) && !empty ($message))
{
// Vérification de la variable $HTML
if (!$HTML)
{
// Initialisation de la variable $from
$from = "From: ".$this->from."\r\n";
}
else
{
// Initialisation de la variable $from
$from = "From: ".$this->from."\r\n";
$from .= "Content-Type: text/html; charset=us-ascii\r\n";
}
// Envoie de l'email
@mail ($this->dest, $sujet, $message, $from) or die ("<b>Erreur
:</b> Impossible d'envoyer l'email.");
}
else
{
// Affichage du message d'erreur
echo "<b>Erreur :</b> Le sujet ou/et le message n'ont pas été
définis.";
exit;
}
}
}
?>

Voilà, vous disposez maintenant d'une classe facilitant l'envoie de mail HTML et texte.
Voyons maintenant son utilisation.
3.2 Utilisation de la classe
Résumons le fonctionnement de cette classe, lors de l'instanciation, le constructeur défini un
expéditeur et un destinataire, la méthode reset(), équivalente, peut être utiliser à n'importe
quel endroit du script. La méthode add() permet de réinitialiser le destinataire ou d'en ajouter
de nouveaux. Quant à la méthode send(), elle envoie un email avec les informations données,
elle prend en paramètre la possibilité d'utilisation du HTML.
<?php
/* Fichier : email.php */
// Inclusion de la classe email
include ("email.class.php");

/* Création d'un nouvel objet de la classe email + lancement du


constructeur */
$email = new email ('expeditaire@mail.org', 'destinataire@mail.org');

// Réinitialisation des informations


$email->reset ('bloodshed@xosc.org', 'article@moteurprog.com');

// Réinitialisation du destinataire
$email->add ('webmaster@moteurprog.com', '1');
// Ajout d'un nouveau destinataire
$email->add ('article@moteurprog.com');

// Envoie de l'email au format texte


$email->send ('sujet', 'Voici le message');

// Envoie de l'email au format HTML


$email->send ('sujet', 'Voici le <b>message</b>', '1');
?>

3.3 Synthèse

A vous maintenant d'améliorer cette classe ! Vous pouvez par exemple la modifier pour qu'il
corresponde à un script de newsletter.
Partie 4 : Librairie

1. Librairie
1.1 Librairie ou bibliothèque ?

L'appellation de librairie vient d'un import abusif du mot "library" en anglais. C'est un
synonyme de bibliothèque. Une librairie est un ensemble de méthodes, d'attributs et de classes
réunis dans un fichier directement utilisable à l'intérieur d'une application. Il y a différents
types de librairies, le PHP utilise les bibliothèques statiques, qui sont systématiquement
recopiées au sein du code source.

1.2 Au projet ?

Dans cet article nous allons développer une petite bibliothèque de moteur de modèle
(templates). Pourquoi ? Parce que je n'ai remarqué aucun article francophone permettant
d'expliquer la création d'une classe de génération de gabarit HTML et aussi car pendant les
vacances (février 2004), j'en ai réalisé une pour comprendre le principe et pour l'utiliser dans
mes propres programmes. Ainsi, voici le premier article français consacré à la réalisation d'un
mini moteur de template en PHP (le 20/02/2004), et si vous n'êtes pas d'accord, veuillez me le
signaler.
Les templates, un nouveau phénomène actuel dans la programmation en PHP. Je ne ferais
aucune explication quant au fonctionnement des templates et à leur but, je vous conseillerais
avant de lire ce tutorial un très bon article sur les modèles (template en anglais) : Les systèmes
de templates de Bobe.

2. Conception
2.1 Elaboration du plan

Il faut avant tout définir un "plan" de tous les membres de notre classe.
Tableau des membres de la classe
class template Nom de la classe.
var $fields Tableau des variables du template.
var $content Contenu du template .
function template() Constructeur, charge le template.
Méthode qui permet de donner une valeur aux variables
function assign()
du template.
function parse() Remplace les variables par leur valeur.
function display() Envoie le résultat au navigateur.

La génération de gabarit (template) en PHP est plutôt réservé aux niveaux intermédiaires, et
puisque nous sommes dans un article réservés aux débutants qui cherchent à apprendre la
POO (Programmation Orientée Objets) en PHP, j'ai voulu simplifier au maximum la classe.
En effet celle-ci ne gèrera pas les blocs, ni les boucles et ni la gestion de plusieurs templates.
Cependant, pour ceux qui auraient envies de continuer cette mini-classe, je les invite à me
contacter pour récupérer conseils ou algorithmes permettant de rendre cette classe aussi
efficaces sur des petits projets qu'un vrai moteur de modèles.

3. Conception
3.1 La classe !

Commençons par définir les attributs de la classe. Le premier : $fields, va contenir un tableau
avec comme clé le nom de la variable du template et comme valeur, la valeur (logique?) de la
variable. Le suivant et dernier (je vous avez dit qu'elle était simple !) attribut : $content, va,
comme son nom l'indique garder en mémoire le contenu du template.
Voici la source qui définit nos deux attributs :
// Attribut des variables du template
var $fields = array();
// Attribut du contenu du template
var $content;
Après nos attributs, nous allons nous attaquer au constructeur : template(), son but va être de
récolté le chemin d'accès au modèle et de récupérer son contenu dans l'attribut $content.
// Initialisation du constructeur template()
function template ($chemin)
{
// Ouverture du modèle
$modele = @fopen ($chemin, 'r');
// Définition de l'attribut $content
$this->content = @fread ($modele, @filesize ($chemin));
// Fermeture du modèle
@fclose ($modele);
}
Après avoir défini un modèle, il faut attribuer des valeurs à ses variables; ce sera le rôle de la
méthode assign().
// Initialisation de la méthode assign()
function assign ($field, $value)
{
// Ajout d'une ligne dans le tableau $fields
$this->fields[$field] = $value;
}
Troisième méthode : parse(), elle sera chargé de remplacer les variables du template par leur
valeur via le tableau $fields.
// Initialisation de la méthode parse()
function parse()
{
// Parcours du tableau $fields
foreach ($this->fields as $key => $value)
{
// Remplacement des valeurs dans le modèle
$result = ereg_replace ("{".$key."}", $value, $this->content);
// Initialisation du contenu du template
$this->content = $result;
}
}
Dernière méthode, la plus importante, celle qui va afficher le résultat de notre fusion à l'écran
: display(). Sa fonction est très simple, elle prend le contenu de l'attribut contenant le template
($content) puis l'affiche.
// Initialisation de la méthode display()
function display()
{
// Affichage du template
echo $this->content;
}
<?php
/* Fichier : template.class.php */
// Création de la classe
class template
{
// Initialisation du constructeur template()
function template ($chemin)
{
// Ouverture du modèle
$modele = @fopen ($chemin, 'r');
// Définition de l'attribut $content
$this->content = @fread ($modele, @filesize ($chemin));
// Fermeture du modèle
@fclose ($modele);
}

// Initialisation de la méthode assign()


function assign ($field, $value)
{
// Ajout d'une ligne dans le tableau $fields
$this->fields[$field] = $value;
}

// Initialisation de la méthode parse()


function parse()
{
// Parcours du tableau $fields
foreach ($this->fields as $key => $value)
{
// Remplacement des valeurs dans le modèle
$result = ereg_replace ("{".$key."}", $value, $this->content);
// Initialisation du contenu du template
$this->content = $result;
}
}

// Initialisation de la méthode display()


function display()
{
// Affichage du template
echo $this->content;
}
} ?>

4. Utilisation
4.1 Template

Pour utiliser notre classe, il nous faut plusieurs fichiers, un gabarit HTML (template.html), un
utilisateur de la classe (template.php) et la classe elle-même (template.class.php).
Un gabarit HTML ou modèle (template) est tout simplement un fichier HTML normal sauf
que les endroits ou le contenu est généré dynamiquement, il y a une variable de template, elle
ressemble à ceci dans notre cas {VARIABLE}.
<!-- Fichier : template.html -->
<html>
<head>
<title>{TITRE}</title>
</head>

<body>
{TEXTE}
</body>
</html>
Ceci est un exemple très simple, seulement pour montrer le fonctionnement de la classe.
L'utilisateur de la classe, il va définir les valeurs des variables du gabarit, puis les afficher.
<?php
/* Fichier : template.php */

// Inclusion de la classe de template


require ("template.class.php");

// Création d'une nouvelle instance de la classe et définition d'un gabarit


$tpl = new template ("template.html");

// Initialisation des variables du gabarit


$tpl->assign ("TITRE", "Test de notre classe.");
$tpl->assign ("TEXTE", "Voici un test mettant à l'épreuve notre classe de
template");

// Analyse du template
$tpl->parse();

// Affichage du résultat
$tpl->display();
?>

5. Conclusion
5.1 Notre classe

Vous pouvez améliorer cette classe en implémentant la gestion des blocs ou encore de
plusieurs gabarits en même temps, n'oubliez pas non plus la possibilité de "parser" plusieurs
fois les blocs. Pour les plus débutants d'entre vous, vous pouvez programmez la gestion des
erreurs.

5.2 Systèmes alternatifs

Beaucoup de solutions de template existe à l'heure actuelle (Smarty, Templeet, Modelixe...)


mais la plupart son beaucoup trop lourde (malgré un système de cache) pour des petit projet
(un livre d'or...) dans ce cas, la création de son propre système de template est une bonne
solution pour rivaliser de performances.
Partie 5 : Annexe

1. Finis ?

Bienvenu(e) dans le dernier petit article sur la Programmation Orientée Objets en PHP; celui-
ci sera un annexe vous permettant de continuer votre apprentissage de la POO. Vous
trouverez des liens vers d'autres articles, tutoriaux, références et scripts.

2. Liens
2.1 Articles

http://www.phpteam.net/affiche.php?quoi=php5new4
Explications alléchantes des changements dans la POO pour PHP 5.
http://www.phpinfo.net/articles/article_classes.html
Article très complet et intéressant sur la Programmation Orientée Objets en PHP.
http://www.phpdebutant.org/article44.php
Tout sur la sérialisation d'objets en PHP.
http://www.phpdebutant.org/article43.php
Héritage de classe dans ses moindres recoins.
http://www.phpdebutant.org/article42.php
Approche pour les débutant à la Programmation Orientée Objets en PHP.
2.2 Tutoriaux
http://hachesse.developpez.com/objetphp/
Un tutorial des plus complets !
http://www.puread.net/technologie_la_programmation_orientee_objet_poo_article7.html
Approche plutôt complète de la POO en PHP.
2.3 Scripts
http://php-directory.org/directory/data,Scripts,Librairie.html
Beaucoup de librairies intéressantes.
http://www.nexen.net/scripts/
Collection impressionnante de scripts et librairies intéressantes et peu courantes.

3. Finis !
3.1 A suivre

Après avoir finis cet article. J'ai construit un petit fichier compressé contenant les cinq articles
et les sources des trois classes vu à travers notre apprentissage de la POO en PHP. Ce fichier
est téléchargeable dans la rubrique tutorial PHP de MoteurProg.com.
Cette petite liste de liens est loin d'être exhaustive. En effet j'avoue ne pas posséder un
bookmark très complet sur la POO en PHP. Ainsi je fais appelle à vous pour la compléter
dans les commentaires !
3.2 L'auteur
Je suis loin d'être un professionnel en la matière mais j'essaie de vous apporter le (peu?) de
connaissances que je possède, merci de votre compréhension (surtout que c'est mon premier
article), pour les fautes, erreurs ou suggestion contactez-moi. Je m'efforce de relire et faire
relire mes articles, excusez-moi à la rencontre d'une erreur.