Académique Documents
Professionnel Documents
Culture Documents
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.
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
2.2 Classe
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).
Voyons maintenant ce qui se passe du côté de votre script PHP qui va utiliser votre classe
nouvellement créer :
<?php
?>
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
2. Dans la Classe
2.1 Mots-Clé
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 */
}
?>
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');
?>
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');
?>
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.
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");
/* 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");
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");
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*/
}
?>
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();
/* 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) */
?>
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
}
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.
// 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;
}
// 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;
}
// 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.
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");
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.
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;
}
}
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;
}
}
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");
// Réinitialisation du destinataire
$email->add ('webmaster@moteurprog.com', '1');
// Ajout d'un nouveau destinataire
$email->add ('article@moteurprog.com');
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);
}
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 */
// 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.
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.