Université Moulay Ismail Année universitaire : 2019/2020

Faculté des Sciences et Techniques Filière Génie Logiciel : I616

Département d’Informatique Prof Y.FARHAOUI
Errachidia

Programmation Web
Langage PHP (III-POO)

1
Prof Yousef FARHAOUI Filière GI (S6) : Module I616
 Introduction
Qu'est ce qu'un objet?
La programmation orientée objet est plus naturelle donc plus intuitive. Si c'est le cas, c'est
parce qu’elle utilise des entités appelés objets. Un objet possède sa propre structure interne
qui définit ses propriétés et son comportement. Si on compare avec le monde réel, les objets
sont partout autour de nous. Une personne est un objet, une voiture en est un autre, une
maison, une école une télé, un ballon... tous sont des objets.

Prenons l'objet "voiture". Bien qu'il en existe plusieurs modèles, le fait d'évoquer le mot
"voiture" fait penser à des points comme:
couleur, options, puissance du moteur, vitesse, nombre de rapports de vitesse, ...

Ces points représentent les caractéristiques (ou propriétés) de l'objet voiture. Dans le jargon
de la POO on les appelles des attributs.

Cependant, une voiture peut aussi entamer des actions, par exemple:
Accélérer, Ralentir, Tourner à droite, Tourner à gauche, Reculer, ...
Vous avez sans doute remarqué que j'ai utilisé des verbes pour spécifier les actions que peut
entreprendre une voiture. L'ensemble de ces actions constitue le comportement de celle-ci. En
POO on les appelles des méthodes.

2
 Introduction

Une classe c'est quoi?

Une classe est une structure cohérente de propriétés (attributs) et de comportements

(méthodes). C'est elle qui contient la définition des objets qui vont être créés après. En
général on considère une classe comme un moule à objets. Avec un seul moule on peut créer
autant d'objets que l'on souhaite.

Techniquement parlant, une classe est une structure qui contient des attributs (appelés aussi
variables membres) et des méthodes (connus également par fonctions membres). Les
méthodes agissent sur les attributs de cette structure. Par exemple, le fait d’accélérer
augmente la vitesse de la voiture.

L'instanciation
L'instanciation est le fait de créer une instance. Pour être précis, on parle d'une instance de
classe. La classe étant le moule qui sert à fabriquer les objets, alors chaque objet créé
correspond à une instance de la classe qui lui a donné vie.

3
 Déclaration de la classe
<?php
class Voiture{
// Déclaration des membres
}
?>

Déclaration des attributs - Principe d'encapsulation

Les attributs sont les variables membres de la classe. Ils constituent les propriétés ou les
caractéristiques de l'objet (l'instance de classe) qui en sera né.

Principe d'encapsulation:
La visibilité d'un attribut indique à partir d'où on peut en avoir accès. Il existe trois types de
visibilité:

public: l'attribut est accessible de partout (de l'intérieur de la classe dont il est membre
comme de l'extérieur).

private: l'attribut est accessible seulement de l'intérieur de la classe dont il est membre.

protected: dans ce cas, l'attribut est accessible seulement de l'intérieur de la classe dont
il est membre ainsi que de l'intérieur des classes fille qui héritent de cette classe.
4
 Déclaration de la classe
les attributs de la classe "Voiture":

<?php <?php
class Voiture{ class Voiture{
private $couleur="Rouge"; private $couleur;
private $puissance=130; private $puissance;
private $vitesse=0; private $vitesse;
} }
?> ?>

5
 Déclaration des méthodes

Les méthodes sont des fonctions membres. Ce sont elles qui se chargent de manipuler les
attributs et dotent ainsi la classe de son comportement.

<?php
class Voiture{
private $couleur;
private $puissance;
private $vitesse;

public function accelerer(){

// Corps de la méthode accelerer()
}
public function ralentir(){
// Corps de la méthode ralentir()
}
}
?>

6
 Instanciation de classes et manipulation d'objets
Instancier une classe
La classe est le moule qui sert à fabriquer les objets. Le nombre d'objet que l'on peut créer à
l'aide d'une classe est illimité. On appelle l'opération qui consiste à créer un objet
instanciation et l'objet ainsi créé peut aussi être appelé instance de classe.

<?php
class Voiture{
private $couleur="Rouge"; <?php
private $puissance; $objvoiture = new Voiture();
private $vitesse; ?>
public function accelerer(){
echo "Appel de la méthode accelerer()"; l'objet $objvoiture dispose de ses
} propres attributs $couleur, $puissance,
public function ralentir(){ et $vitesse et les méthodes accelerer()
echo "Appel de la méthode ralentir()"; et relentir().
}
}
?>

7
 Appel d'attributs et méthodes
Après avoir créé l'objet, on peut désormais accéder à ses membres (attributs et méthodes)
par l'opérateur ->.

<?php
class Voiture{
private $couleur="Rouge";
private $puissance;
private $vitesse; Ce qui donne:
public function accelerer(){ Appel de la méthode accelerer()
echo "Appel de la méthode accelerer()"; Fatal error: Cannot access private
} property Voiture::$couleur in index.php
public function ralentir(){ on line 17
echo "Appel de la méthode ralentir()";
}
}
$objvoiture = new Voiture();

$objvoiture -> accelerer();

echo $objvoiture -> couleur;
?>
8
 Constructeur et destructeur
Le constructeur d'une classe
Est une méthode publique. Elle est appelée automatiquement au moment de l'instanciation.
Elle sert généralement à initialiser les attributs et fournir à l'objet créé tout ce dont il a besoin
pour fonctionner.

Le constructeur est une méthode qui a le même nom que la classe. Cependant, en PHP on
préfère l'identifier par le mot clé __construct() (avec deux sous-tirets au début).

<?php
class Voiture{
le mot clé $this. Il s'agit d'une pseudo-variable
private $couleur;
qui représente l'objet en cours. Autrement dit, au
private $puissance;
sein de l'objet $objvoiture la pseudo-variable
private $vitesse;
$this vaut $objvoiture, par conséquent:
public function __construct(){
$this->couleur="Rouge";
$this->couleur="Rouge";
revient à dire:
$this->puissance=130;
$objvoiture ->couleur="Rouge";
$this->vitesse=0;
}
public function accelerer(){ echo "Appel de la méthode accelerer()"; }
public function ralentir(){ echo "Appel de la méthode ralentir()"; }
}
$objvoiture = new Voiture();
9
?>
 Constructeur et destructeur

<?php
class Voiture{
private $couleur;
private $puissance;
private $vitesse;
public function __construct($couleur,$puissance){
$this->couleur=$couleur;
$this->puissance=$puissance;
$this->vitesse=0;
}
public function accelerer(){
echo "Appel de la méthode accelerer()";
}
public function ralentir(){
echo "Appel de la méthode ralentir()";
}
}

$objvoiture = new Voiture("Rouge",130);

?>
10
 Constructeur et destructeur
Le destructeur et une méthode publique identifiée par le nom __destruct(). Il est appelé
automatiquement par le compilateur lorsqu'il n'y a plus aucune référence à l'objet en cours.
Autrement dit, le destructeur est appelé quand il n'y a plus aucun appel d'un membre
quelconque de l'objet.
<?php
class Voiture{
private $couleur;
private $puissance;
private $vitesse;
public function __construct(){
Ce qui donne:
$this->couleur="Rouge";
$this->puissance=130;
Couleur de la voiture: Rouge
$this->vitesse=0;
}
public function __destruct(){
echo "Couleur de la voiture: ".$this->couleur;
}
public function accelerer(){ echo "Appel de la méthode accelerer()"; }
public function ralentir(){ echo "Appel de la méthode ralentir()"; }
}
$objvoiture = new Voiture();
?> 11
 Accès statique aux membres de la classe
Constantes de classe
Une constante de classe est un élément statique par défaut. Son rôle est le même que celui
d'une constante classique déclarée à l'aide de la fonction define(). Sa valeur est inchangée et
elle appartient à la classe dans laquelle est elle évoquée et non à l'objet qui constitue l'instance
de classe.

<?php La constante de classe peut être appelée de l'intérieur

class Voiture{ comme de l'extérieur de la classe grâce à l'opérateur
const ROUES=4; de résolution de portée ::.
private $couleur="Rouge";
private $puissance; <?php
private $vitesse; echo "Nombre de roues: ".Voiture::ROUES;
public function accelerer(){ ?>
echo "Appel de la méthode accelerer()";
} on obtient:
public function ralentir(){ Nombre de roues: 4
echo "Appel de la méthode ralentir()";
}
}
?>

12
 Accès statique aux membres de la classe
Attributs et méthodes statiques
Les attributs et méthodes statiques appartiennent à la classe et non à l'objet. Par
conséquent on ne peut pas y accéder par l'opérateur -> mais plutôt par l'opérateur de
résolution de portée :: précédé par le nom de la classe dans laquelle ils sont définis.

<?php <?php
class Voiture{ class Voiture{
private static $roues=4; private static $roues=4;
public static function message(){ public static function message(){
echo "Il s'agit d'une voiture.<br />"; echo "Il s'agit d'une voiture.<br />";
echo "Elle a ".Voiture::$roues." roues."; echo "Elle a ".self::$roues." roues.";
} }
} }
Voiture::message(); Voiture::message();
?> ?>
Généralement, si on veut faire un appel statique (d'une
Donne: constante, attribut ou méthode) à l'intérieur de la classe, il
Il s'agit d'une voiture. est préférable de mettre le mot clé self au lieu du nom de
Elle a 4 roues. la classe elle même. Par contre, à l'extérieur de la classe il
faut mettre le nom de celle ci avant l'opérateur de
résolution de portée. 13
 Méthodes magiques

Les méthodes magiques en PHP

Les méthodes magiques sont des méthodes prédéfinies et toutes préfixées par double sous-
tirets (__) dans une classe PHP. Elle sont appelées automatiquement suite à un événement
spécial qui peut survenir lors de l’exécution.

En fait, PHP dispose de plusieurs méthodes magiques. Dans ce qui suit, nous allons essayer
de voir les plus fréquentes.

14
 Méthodes magiques
Méthode __get()
Connue par le nom de getter, __get($att) est une méthode qui s’exécute automatiquement
quand on appelle un attribut inexistant ou inaccessible.
Exemple: <?php
<?php
class Maclasse{ class Maclasse{
private $attribut="Bonjour"; private $attribut="Bonjour";
public function __get($att){ public function __get($att){
return "L'attribut <b>$att</b> est inaccessible."; return $this->$att;
} }
} }
$objet=new Maclasse(); $objet=new Maclasse();
echo $objet->attribut; echo $objet->attribut;
?> ?>

Ce qui donne: Donne:

L'attribut attribut est inaccessible. Bonjour

Remarque: En général le getter est utilisé pour réellement accéder aux attributs privés depuis
l'extérieur de la classe.
15
 Méthodes magiques
Méthode __set()
La méthode __set($att,$val) connue sous le nom de setter est appelée automatiquement
quand on essaie de modifier un attribut inexistant ou inaccessible. Dans ce cas, l'argument
$att reçoit le nom de l'attribut et $val la valeur qu'on tente de lui affecter.

<?php
class Maclasse{
private $attribut="Bonjour";
public function __get($att){
return $this->$att;
} Ce qui donne:
public function __set($att,$val){ Bonsoir
$this->$att=$val;
}
}
$objet=new Maclasse();
$objet->attribut="Bonsoir";
echo $objet->attribut;
?>

16
 Méthodes magiques
Méthode __isset()
La méthode magique __isset($att) est appelé automatiquement quand on exécute la fonction
isset() en lui passant en paramètre un attribut inexistant ou inaccessible. Dans la pratique, on
fait en sorte que cette méthode retourne le résultat escompté par la fonction isset(), à savoir
true si l'attribut existe et false si l'attribut n'existe pas.

<?php

class Maclasse{
private $attribut="Bonjour";
public function __isset($att){
return isset($this->$att); Ce qui donne:
} L'attribut existe
}
$objet=new Maclasse();
if(isset($objet->attribut))
echo "L'attribut existe";
else
echo "L'attribut n'existe pas";
?>

17
 Méthodes magiques

Méthode __unset()
La méthode magique __unset($att) est appelé automatiquement quand on essaie de
supprimer un attribut inexistant ou inaccessible à l'aide de la fonction unset(). Dans la
pratique, on fait en sorte que cette méthode supprime l'attribut souhaité suite à l’invocation
de la fonction unset() en lui passant comme paramètre l'attribut en question.

<?php
class Maclasse{
private $attribut="Bonjour";
public function __unset($att){ Ce code supprime l'attribut privé $attribut.
unset($this->$att);
}
}
$objet=new Maclasse();
unset($objet->attribut);
?>

18
 Méthodes magiques
Méthode __toString()
La méthode magique __toString() est appelé automatiquement quand on tente de traiter un
objet en tant que chaîne de caractères (à l'aide de la structure echo par exemple). Dans ce
cas, cette méthode retourne la chaîne de caractères de notre choix.

<?php
class Maclasse{
private $str;
public function __construct($param){
$this->str=$param;
}
public function __toString(){ Ce code donne:
return $this->str; Bonjour
}
}
$objet=new Maclasse("Bonjour");
echo $objet;

19
 Exercice d’application
L'objectif de cet exercice est de créer une classe PHP au nom de String qui contient les
méthodes du même nom que celles de Javascript et qui font les mêmes tâches.

length: Cet attribut retourne le nombre de caractères contenus dans la chaîne.

charAt(): La méthode charAt(x) (avec A majuscule) permet de retourner le caractères qui se
trouve à la position x passé en paramètre. Le paramètre est un entier qui commence de 0. La
valeur 0 indexe le premier caractère de la chaîne.
indexOf(): La méthode indexOf(car) (avec O en majuscule) permet de retourner la position
du caractères car passé en paramètre. Si le caractère existe dans la chaîne, alors sa position
(comprise entre 0 et la longueur de la chaîne - 1) est retournée, sinon (le caractère ne figure
pas dans la chaîne) alors la valeur -1 est retournée. La méthode indexOf() peut accueillir un
deuxième paramètre qui est un entier qui indique à partir de quel position de la chaîne on
commencera la recherche du caractère passé en premier paramètre.
substring(): La méthode substring(début,fin) permet d'extraire une partie de la chaîne de
caractères commençant de la position débutet finissant à la position fin-1.
split(): La méthode split(occurence) permet de retourner un tableau à partir des fractions de
la chaîne de caractères obtenues en divisant celle-ci au niveau de l'occurence.
toLowerCase(): La méthode toLowerCase() permet de retourner la chaîne de caractère
entièrement en minuscules.
toUpperCase(): La méthode toUpperCase() permet de retourner la chaîne de caractère
entièrement en majuscules.
20
 Solution
<?php public function indexOf($car,$pos=0){
class String{ $existe="non";
private $str; for($i=0;$i<$this->length;$i++){
private $length; if(substr($this->str,$i,1)==$car &&
public function __construct($chaine){ $i>=$pos){
$this->str=$chaine; $existe="oui";
$this->length=strlen($this->str); } return $i;
public function __toString(){ }
return $this->str; } }
public function __get($param){ if($existe=="non")
return $this->$param; } return -1;
public function charAt($pos){ }
return substr($this->str,$pos,1); } }
public function substring($deb,$fin){ ?>
return substr($this->str,$deb,$fin- <?php
$deb); } $str=new String("Bonjour");
public function split($occ){ echo $str->length; // Retourne 7
echo $str->charAt(0); // Retourne B
$tab=explode("$occ",$this->str);
echo $str->indexOf("B"); // Retourne 0
return $tab; } echo $str->indexOf("x"); // Retourne -1
public function toUpperCase(){ echo $str->indexOf("o",2); // Retourne 4;
return strtoupper($this->str); echo $str->substring(0,3); // Retourne Bon
} print_r($str->split("o")); // Retourne
public function toLowerCase(){ Array([0]=>B[1]=>nj[2]=>ur)
return strtolower($this->str); } echo $str->toUpperCase(); // Retourne BONJOUR
echo $str->toLowerCase(); // Retourne bonjour 21
?>
 Héritage
L'héritage est un concept fondamental de la POO. C'est d'ailleurs l'un des plus importants
puisqu'il permet de réutiliser le code d'une classe autant de fois que l'on souhaite tout en
ayant la liberté d'en modifier certaines parties.

<?php Exemple:
class Mere{ <?php
} class Mere{
class Fille extends Mere{ public $attribut="Bonjour.";
} public function methode1(){
?> $str=$this->attribut;
$str.=" Je suis la classe Mère.";
Dans ce cas, la classe Fille hérite de la classe return $str; }
Mère. class Fille extends Mere{
public function methode2(){
$str=$this->attribut;
$str.=" Je suis la classe Fille.";
return $str;
} }
$objet=new Fille();
On obtient alors: echo $objet->methode1();
Bonjour. Je suis la classe Mère. echo "<br />";
Bonjour. Je suis la classe Fille. echo $objet->methode2();
22
?>
 Héritage
Visibilité protected
Afin de respecter le principe d'encapsulation, il faut que tous les attributs soient privés.
Mais si on veut hériter d'une classe, alors les attributs privés ne sont plus réutilisables
puisqu'ils sont reconnus uniquement au sein de la classe où ils sont déclarés.

La visibilité protected a été intégrée pour résoudre ce problème. En fait, elle se comporte à
peu près comme private. Les attributs ne sont donc pas accessible de n'importe où comme
c'est le cas pour public, mais seulement à l'intérieur de la classe dans laquelle ils sont
déclarés et dans les classes qui héritent de cette classe là.

Le code précédent sera donc mieux comme ça:

<?php class Fille extends Mere{

class Mere{ public function methode2(){
protected $attribut="Bonjour."; $str=$this->attribut;
public function methode1(){ $str.=" Je suis la classe Fille.";
$str=$this->attribut; return $str;
$str.=" Je suis la classe Mère."; }}
return $str; $objet=new Fille();
} echo $objet->methode1();
} echo "<br />";
echo $objet->methode2();
?> 23
 Surcharge d'une méthode
Dans l'exemple précédent où la classe Fille hérite de la classe Mere, il est possible de
définir une méthode du nom de methode1() dans la classe Fille. Bien entendu, cette
méthode figure déjà dans la classe Mere et elle est supposée être héritée elle aussi car elle
est publique. Le fait de déclarer une méthode du même nom dans la classe Fille s'appelle
redéfinition de méthode ou surcharge de méthode.

Reprenons l'exemple précédent en surchargeant la méthode methode1():

<?php class Fille extends Mere{
class Mere{ public function methode1(){
protected $attribut="Bonjour."; $str=$this->attribut;
public function methode1(){ $str.=" Je suis la classe Fille.<br />";
$str=$this->attribut; return $str;
$str.=" Je suis la classe Mère.<br />"; }
return $str; }
} $objet=new Fille();
} echo $objet->methode1();
?>

Ce qui donne:
Je suis la classe Fille.
24
 Surcharge d'une méthode
<?php <?php
class Mere{ class Mere{
protected $attribut="Bonjour."; protected $attribut="Bonjour.";
public function methode1(){ public function methode1(){
$str=$this->attribut; $str=$this->attribut;
$str.=" Je suis la classe Mère.<br />"; $str.=" Je suis la classe Mère.<br />";
return $str; return $str;
} }
} }
class Fille extends Mere{ class Fille extends Mere{
public function methode1(){ public function methode1(){
$str=Mere::methode1(); $str=parent::methode1();
$str.=$this->attribut; $str.=$this->attribut;
$str.=" Je suis la classe Fille.<br />"; $str.=" Je suis la classe Fille.<br />";
return $str; return $str;
} }
} }
$objet=new Fille(); $objet=new Fille();
echo $objet->methode1(); echo $objet->methode1();
?> ?>
25
 Classes et méthodes abstraites (Mot clé abstract)
Une classe abstraite et une classe dont on doit impérativement hériter. Autrement dit, on ne
peut pas l'instancier directement. Pour ce faire, on définit la classe abstraite à l'aide du mot clé
abstract.
Exemple:
<?php Une méthode abstraite est une méthode qui
abstract class A{ doit être redéfinie (ou surchargée) dans les
public function methode(){ classes filles.
echo "Bonjour";
} Exemple:
} <?php
class B extends A{ abstract class A{
} abstract public function methode();
$objet=new B(); }
$objet->methode(); class B extends A{
?> public function methode(){
echo "Bonjour";
Ce qui donne: }
Ce qui donne:
Bonjour }
Bonjour
$objet=new B();
$objet->methode();
?>
26
 Classes et méthodes finales (Mot clé final)
Une classe finale est une classe dont on ne peut pas hériter. Il faut donc l'instancier
directement.

Exemple:
<?php
final class A{
public function methode(){
echo "Bonjour";
}
}
class B extends A{
}
$objet=new B();
$objet->methode();
?>

Ce qui donne:
Fatal error: Class B may not inherit from final class (A) in index.php on line 8

27
 Classes et méthodes finales (Mot clé final)
Une méthode finale est une méthode que l'on peut pas redéfinir dans les classes filles. La
déclaration de la méthode finale se fait normalement mais on précède sa visibilité par le
mot clé final.

Exemple:
<?php
class A{
final public function methode(){
echo "Bonjour";
} Remarque: Dans ce cas, on ne doit jamais
} surcharger methode() dans les classes filles.
class B extends A{
}
$objet=new B();
$objet->methode();
?>

Ce qui donne:
Bonjour

28
 Interfaces et traits
Interfaces PHP
Pour mieux comprendre le principe, supposons que nous avons une classe abstraite du nom
de Vehicule. Les classes Filles qui peuvent en hériter sont par exemple Voiture, Camion et
Fourgon. Ces classes sont en réalité des véhicules plus ou moins différents, donc ils
constituent un sous ensemble de la classe Vehicule. Par contre les classes Vehicule et
Maison ne sont pas de la même famille. Néanmoins chacune d'entre elles peut accueillir
une méthode du nom de peindre(). C'est là où une interface qui renferme la méthode
peindre() peut être utile.
<?php Implémenter une interface
interface Entretien{ <?php
public function peindre($c); class Vehicule implements Entretien{
public function nettoyer(); private $couleur;
} private $propre;
?> public function peindre($c){
$this->couleur=$c;
}
public function nettoyer(){
$this->propre=true;
} }
?>
Dans la classe Vehicule on doit obligatoirement
redéfinir les méthodes peindre() et nettoyer(). 29
 Interfaces et traits
Implémenter plusieurs interfaces
A l'inverse de l'héritage en PHP, on peut implémenter plusieurs interface simultanément:
<?php
interface Int1{
public function f1();
}
Interface Int2{
public function f2();
}
class Classe implements Int1, Int2{
public function f1(){
}
public function f2(){
}
}
?>

Dans ce cas, dans la classe Classe on doit redéfinir les méthodes f1() et f2() dont le
prototype est défini respectivement dans les interfaces Int1 et Int2.

30
 Interfaces et traits
Héritage des interfaces
Comme pour les classes, une interface peut hériter d'une autre. Dans ce cas, la réécriture
d'une méthode dans la classe fille n'est pas autorisée. Bien entendu, il faut réécrire les
méthodes de l'interfaces mère et l'interface fille dans la classe qui implémente cette
dernière:

<?php
interface Int1{
public function f1();
}
Interface Int2 extends Int1{
public function f2();
}
class Classe implements Int2{
public function f1(){
}
public function f2(){
}
}
?>

31
 Interfaces et traits

Constante d'interface
Comme pour les classes, une constante d'interface appartient à cette dernière. Elle peut donc
être appelée statiquement à partir de l'interface dans laquelle elle est déclarée ou de la classe
qui implémente l'interface.

Exemple:
<?php
interface Inter{
const CTE="Bonjour";
}
class Classe implements Inter{

}
echo Inter::CTE; // Affiche Bonjour
echo Classe::CTE; // Affiche Bonjour
?>

32
 Interfaces et traits
Principe des traits
Les traits ont été intégrés au PHP à partir de sa version 5.4. Ils permettent de minimiser le
code en réutilisant des méthodes déjà déclarées sans être obligé d'hériter d'une classe
entière.
Un trait ne peut être ni instancié comme une classe ni implémenté comme une interface. Il
s'agit d'un bloc de code qui sera réutilisé par une classe.

Création et utilisation des traits

Pour se servir du trait Notification dans une
classe on procède comme ceci:
<?php
<?php
trait Notification{
class Operation{
public function afficher(){
use Notification;
echo "Alerte signalée!";
}
}
$op=new Operation();
}
$op->afficher(); // Affiche "Alerte Signalée!"
?>
?>

Vous avez compris que le code du trait

Notification a été réutilisé comme si'il était
déclaré directement dans la classe Operation.
33
 Gestion des exceptions
Une autre manière de gérer les erreurs
Les erreurs en PHP sont gérés à travers le système Error Reporting que l'on peut
configurer grâce à la directive correspondante dans le fichier php.ini.

Ce système affiche les messages d'erreur sur l'écran avec leurs différents niveaux de gravité
comme les notices, les alertes ou les erreurs fatales:

Les notices: sont des erreurs non critiques. Ils n'arrêtent pas l’exécution du programme
(comme la tentative d'affichage d'une variable non initialisée).
Les alertes: sont des erreurs dues à une mauvaise exécution d'une instruction (comme
l'inclusion d'un fichier inexistant). Pourtant, le programme poursuit son exécution.
Les erreurs fatales: sont des erreurs critiques qui interrompent l’exécution du programme
(suite à une erreur de syntaxe par exemple).

Cependant, il existe une autre manière de gérer les erreurs. C'est via le système des
exceptions.

La gestion des exceptions est apparue en PHP dans sa version 5. C'est un concept très
utilisé dans d'autres langages de programmation (orientés objet) comme Java, Python ...

34
 Gestion des exceptions
Bloc try catch
On place le code qui peut générer une erreur éventuelle dans le bloc try et on prévoie un
traitement alternatif dans le bloc catch. Si le bloc try ne génère aucune erreur, alors le bloc
catch sera ignoré, sinon il sera exécuté pour rattraper l'erreur du bloc try.

Une exception peut être lancée grâce au mot clé throw de n'importe où dans le programme.
Une exception lancée représente une instance de la classe Exception prédéfinie en PHP5 et
plus. Il ne faut pas oublier de renseigner, au moins, le message d'erreur ou le code de celui-ci
au constructeur.
<?php
$a=10;
$b=0;
try{
if($b==0)
throw new Exception("Le dénominateur ne doit pas être nul.");
$c=$a/$b;
echo $c;
}
catch(Exception $e){
echo $e->getMessage();
}
?> 35
 Gestion des exceptions
Méthodes de la classe Exception
La classe Exception contient 6 méthodes dont les plus importants sont:
getMessage(): retourne le message d'erreur passé au constructeur lors du lancement de
l'exception.
getCode(): retourne le code d'erreur passé aussi au constructeur.
getLine(): retourne le numéro de la ligne où l'exception a été lancée.
getFile(): retourne le nom du document où les choses se passent.
L'exemple précédent peut donc être amélioré comme ceci: Ce qui donne:
<?php Document: index.php
$a=10;
Line: 6
$b=0;
try{
Code d'erreur: 553
if($b==0) Message d'erreur: Le
throw new Exception("Le dénominateur ne doit pas être nul.","553"); dénominateur ne doit
$c=$a/$b; pas être nul.
echo $c; }
catch(Exception $e){
$erreur="Document: <b>".$e->getFile()."</b><br />";
$erreur.="Line: <b>".$e->getLine()."</b><br />";
$erreur.="Code d'erreur: <b>".$e->getCode()."</b><br />";
$erreur.="Message d'erreur: <b>".$e->getMessage()."</b><br />";
echo $erreur;
}
36
?>
 Cas pratique: classe PDOException
Pour gérer les erreurs éventuelles qui peuvent survenir lors d la manipulation de l'objet PDO
(comme le renseignement d'un mauvais login ou mot de passe, ou encore une mauvaise base
de données...) on fait appel à la classe PDOException.

PDOException hérite indirectement de la classe Exception et peut être utilisée ainsi:

<?php
try{
$pdo=new PDO("Paramètres invalides");
// Suite du traitement
}
catch(PDOException $e){
echo $e->getMessage();
}
?>

Dans ce cas, les paramètres passés au constructeur de la classe PDO sont faux et on obtient
alors:
Invalid data source name

Remarque: la simplicité que procure la classe PDOException surtout que l'exception est
lancée automatiquement (sans avoir besoin de le faire à l'aidre de throw).
37
 Objet PDO pour la connexion à une base de données
Les Sites Web dynamiques reposent généralement sur des bases de données qui sont
interrogées par les scripts CGI utilisés pour leur développement (comme PHP). Le contenu
ainsi visible sur la page provient partiellement de la base de données.

Le SGBD le plus connu pour accompagner le langage PHP est MySQL. Cependant, PHP peut
aussi dialoguer avec plusieurs autres SGBD comme PostgreSQL, Oracle, SQL Server...

Jusqu'à la version 5 de PHP, la connexion à une base de données (en particulier MySQL) se
faisait d'une manière transparente grâce à des fonctions du genre mysql_connect(),
mysql_select_db(), mysql_query()... Ces fonctions marchent encore sur les dernières versions
PHP5.x (y compris PHP5.6), mais elles sont rendues obsolètes à partir de PHP5.5. A la sortie
de PHP7 elles ont été supprimées.

Bien que ces fonctions marchaient très bien, leurs limites n'ont pas mis beaucoup de temps
pour se manifester, en particulier quand on souhaite migrer vers un SBGD autre que MySQL.
En effet, toutes ces fonctions préfixées par mysql_ n'auraient pas marché. Il faut par
conséquent repasser en vue une grande partie du code déjà développé.

Heureusement l'objet PDO a été développé et intégré sous forme d'extension au langage PHP.

38
 Objet PDO pour la connexion à une base de données
PDO signifie PHP Data Object. Il s'agit d'une interface qui permet au scripts PHP d’interroger
une base de données via des requêtes SQL.

PDO est une extension qui s'ajoute au PHP pour que ses différentes fonctionnalités soient
disponibles dans le langage. Il constitue une interface d'abstraction de la base de données, c'est
à dire qu'on peut utiliser l'ensemble de ses fonctions pour executer des requêtes SQL quelque
soit le SGBD.

Le bon fonctionnement de PDO repose sur la disponibilité du pilote de la base de données. Il

faut que celui-ci soit pris en charge pour pouvoir interroger le SGBD souhaité.

Pour déclarer le pilote du SBGD MySQL par exemple, il faut aller dans le fichier php.ini et
ajouter la ligne suivante (si elle n'est pas déjà déclarée):
extension = php_pdo_mysql.dll

Notez que la ligne suivante doit aussi figurer:

extension = php_pdo.dll

Cette étape est nécessaire pour les version PHP inférieures à 5.3.

39