PHP POO fr avec exemples

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

objet Représentant de la classe dans l'application, il se nomme instance de classe.

classe Entité contenant toutes les méthodes et attributs.

méthode Nom donné aux fonctions contenu dans la classe.

attribut Nom donné aux variables globales de la classe, définis aux début.

constructeur Nom donné à la méthode lancé lors de l'instanciation de la classe, elle porte le même nom que la classe.

destructeur Nom donné à la méthode lancé lors de la destruction de la 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

class Il sert à définir une classe, utiliser au début, nous reverrons sont utilisation plus loin.

var Défini les attributs de la classe.

function Défini les méthodes de la classe (même utilisation que le mot-clé du même nom dans le code source PHP)

new Il permet d'instancer une classe dans un objet, à utiliser dans 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 "Erreur : 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 "Erreur : Connection à MySQL impossible."; exit; } // Connection à la base de données if (!mysql_select_db($this->SGBD_base, $connect)) { // Affichage du message d'erreur echo "Erreur : 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 "Erreur : 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 "Erreur : Connection à MySQL impossible."; exit; } // Connection à la base de données if(!mysql_select_db($this->SGBD_base, $connect)) {

// Affichage du message d'erreur echo "Erreur : 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 "Erreur : 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 "Erreur : 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 "Erreur : 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 "Erreur : 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 ("Erreur : Impossible d'envoyer l'email."); } else { // Affichage du message d'erreur echo "Erreur : 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 "Erreur : 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 "Erreur : 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 "Erreur : 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 ("Erreur : Impossible d'envoyer l'email."); } else { // Affichage du message d'erreur echo "Erreur : 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 ('[email protected]', '[email protected]'); // Réinitialisation des informations $email->reset ('[email protected]', '[email protected]'); // Réinitialisation du destinataire $email->add ('[email protected]', '1');

// Ajout d'un nouveau destinataire $email->add ('[email protected]'); // 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 message', '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.

function assign() Méthode qui permet de donner une valeur aux variables 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}.  <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.

PHP POO fr avec exemples

Documents

Transcript of PHP POO fr avec exemples