Développement Web

Complément PHP
Classes et objets
♦ Classe :
▪ Une classe est un type de données défini par le programmeur. C’est une sorte de
moule à partir duquel sont engendrés les objets réels qui s’appellent des instances
de la classe considérée.
▪ Une classe PHP (créée à l’aide du mot clé « class » suivi du nom de la classe)
regroupe :
* des variables d’instance (appelées attributs ou propriétés), représentés par des
variables PHP. Syntaxe :
[public|protected|private] [static] [typeAttribut] nomAttribut;
* des méthodes manipulant ces variables, définies par des fonctions PHP.
class MaClasse {
// Définition des propriétés et des méthodes
}
▪ Le nom de la classe peut être quelconque à condition que ce ne soit pas un mot
réservé en PHP. Il doit commencer par une lettre ou un underscore, suivi de
n'importe quel nombre de chiffres, ou de lettres, ou d'underscores.
20/01/2023 Prof. Hafida ZROURI 2
Classes et objets
♦ Objet :
▪ Une classe permet de créer des objets (ou instances de classe) au moyen d'un
constructeur appelé à l’aide de l’opérateur new suivi du nom de la classe :
$objet = new MaClasse();
▪ Pour détruire cet objet en mémoire :
unset($objet);
▪ En PHP, soit on met la classe dans le même fichier que l'instance, soit on la
met dans un autre fichier et on fait un include ou un require pour inclure le
fichier contenant la classe. (à la différence de Java où les classes peuvent être
instanciées dans d'autres fichiers du même package).

20/01/2023 Prof. Hafida ZROURI 3

Classes et objets
♦ Accès aux méthodes | propriétés de la classe :
▪ On accède aux membres par l'intermédiaire de l'opérateur flèche (->). Au
sein d'une classe, le mot clé $this permet d'accéder au membres d'instance
en cours ($this représente en fait l'objet).
▪ À l’intérieur de la classe :
$this->maMethode();
$this->monAttribut;
▪ De l’extérieur :
$monObjet = new MaClasse();
$monObjet->maMethode();
$monObjet->monAttribut;

20/01/2023 Prof. Hafida ZROURI 4

Classes et objets
Exemple :
<?php
class User {
public $name;
function getName() {
return ucfirst($this->name); // ucfirst rend la première lettre en majuscule
}
}

$mohamed = new User(); // Création d'un objet à partir de la classe

$mohamed->name = 'mohamed'; // Modification d'une propriété
echo $mohamed->getName(); // Accès à une méthode
?>

20/01/2023 Prof. Hafida ZROURI 5

Classes et objets
♦ Visibilité :
La visibilité d’un membre (propriété ou méthode) est définie en préfixant
la déclaration avec un mot-clé : public, protected, ou private.
▪ Privé (private) : le membre n’est accessible que dans la classe courante.
▪ Protégé (protected) : le membre est accessible dans la classe courante
et dans les classes dérivées.
▪ Publique (public) : le membre est accessible partout, même à
l’extérieur de la classe.

Remarque :
En absence de déclaration de visibilité, l'attribut ou la méthode est
considéré comme public (compatibilité avec PHP 4).

20/01/2023 Prof. Hafida ZROURI 6

Classes et objets
♦ Constructeur :
▪ En PHP5 (et >5), le constructeur a pour syntaxe :
function __construct($arg1, $arg2, …) { … }
▪ Le constructeur est appelée automatiquement lors de la création d'un objet à
l'aide du mot clef new :
$objet = new NomDeLaClasse(param1, param2, …)
▪ La surcharge n’existe pas en PHP : pas de constructeurs multiples à paramètres
différents.
♦ Destructeur :
▪ Syntaxe [en PHP5 (et >5)] :
function __destruct() { [… ] }
▪ Elle est appelée automatiquement soit lors de la destruction explicite d'un objet
à l'aide de la fonction unset(), soit après la fin du script.

20/01/2023 Prof. Hafida ZROURI 7

Classes et objets
Exemple :
<?php
class Employe {
private string $nom;
private float $salaire;
public function __construct($n, $s) {
$this->nom = $n;
$this->salaire = $s;
}
public function toHTML() {
return "<strong> Le nom : </strong><em> $this->nom </em><br>".
"<strong> Le salaire : </strong><em> $this->salaire </em>";
}
}
$emp1 = new Employe("Namir", 6000);
echo $emp1->toHTML();
?>

20/01/2023 Prof. Hafida ZROURI 8

Classes et objets
♦ Membres statiques :
▪ Certains membres peuvent être statiques
▪ Ils deviennent accessibles sans instance
▪ Ils sont communs à toutes les instances
▪ Déclarés à l’aide du mot clé static et accessibles via l’opérateur ::
Exemple de déclaration : public static $staticVar = '300';
Pour y accéder :
self::$staticVar; // Dans la classe
NomDeLaClasse::$staticVar; // A l’extérieur de la classe
parent::$staticVar; // Dans la classe fille
▪ Une méthode statique ne peut pas interagir avec les attributs et les méthodes de
l’instance (sauf les attributs et méthodes statiques). Il n'y a pas de variable $this dans
la méthode statique car elle est faite pour agir sur la classe et non sur un objet. On
utilisera donc le mot-clé self.
▪ Un attribut statique est un attribut indépendant de tout objet : si l'un des objets modifie
sa valeur, tous les autres objets qui accèderont à cet attribut obtiendront la nouvelle
valeur.
20/01/2023 Prof. Hafida ZROURI 9
Classes et objets
Exemple :
<?php
class Compteur {
private static int $compt = 0;
//…
public function __construct() {
//...
self::$compt++;
}
public static function getCompteur() {
return self::$compt;
}
//…
}
$obj1 = new Compteur(); echo Compteur::getCompteur()."<br />"; // affiche 1
$obj2 = new Compteur(); echo Compteur::getCompteur(); // affiche 2
?>
20/01/2023 Prof. Hafida ZROURI 10
Classes et objets
♦ Les constantes de classe :

▪ PHP permet de définir des constantes dans une classe en utilisant le mot clé const. Le
nom de la constante ne commence pas par un $.
▪ Les constantes s’utilisent de manière statique et peuvent être définies comme publique,
privée ou protégée. Les constantes déclarées sans mot clé de visibilité explicite sont
définies en tant que public.
Exemple :
class Personne {
const NBRE_YEUX = 2;
const NBRE_MAINS = 2;
…
public function __construct() { … }
public function affiche() {
echo self:: NBRE_YEUX. ",… ". self:: NBRE_MAINS;
}
…
}
20/01/2023 Prof. Hafida ZROURI 11
Classes et objets
♦ Clonage d’objet :
▪ Permet d'effectuer une copie exacte d'un objet mais en lui affectant une zone de
mémoire différente de celle de l'objet original.
▪ Contrairement à la copie avec "=" ou à la référence avec "&", les modifications
sur l'objet cloné ne sont pas répercutées sur l'original.
Remarque : Avec PHP5 (et >5) les objets sont passés (par défaut) par référence
aux fonctions.
▪ Syntaxe :
$objetclone = clone $objet;
▪ Exemple :
class Voiture { public $marque = "ford"; }
$MaVoiture1 = new Voiture();
$MaVoiture2 = clone $MaVoiture1;
$MaVoiture2->marque = 'ferrari';
echo $MaVoiture1->marque; // affiche "ford"

20/01/2023 Prof. Hafida ZROURI 12

Classes et objets
♦ Comparaison d’objets :

▪ Opérateur de comparaison "=="

deux objets sont égaux s'ils ont les mêmes attributs et valeurs, et qu'ils
sont des instances de la même classe.

▪ Opérateur d'identité "==="

les objets sont identiques uniquement s'ils font référence à la même
instance de la même classe.

20/01/2023 Prof. Hafida ZROURI 13

Classes et objets
Exemple :
$p1 = new Personne();
$p2 = new Personne();
$p3 = $p1;
$a = new Animal();
Deux instances de la même classe :
$p1 == $p2 ---> TRUE
$p1 === $p2 ---> FALSE
Deux références sur le même objet :
$p1 == $p3 ---> TRUE
$p1 === $p3 ---> TRUE
Instances de classes différentes :
$p1 == $a ---> FALSE
$p1 === $a ---> FALSE

20/01/2023 Prof. Hafida ZROURI 14

Classes et objets
♦ Affichage d’un objet :
▪ Quand on essaie d’afficher un objet, PHP fait appel à la méthode __tostring() de
l’objet et s’il ne la trouve pas, il renvoie une erreur.

Exemple :
<?php
class Voiture {
function __tostring() {
return "Vous êtes dans la classe 'voiture' ";
}
}
$maVoiture = new Voiture();
echo $maVoiture; // affiche : Vous êtes dans la classe 'voiture'
?>

20/01/2023 Prof. Hafida ZROURI 15

Classes et objets
♦ Héritage :
▪ L’héritage consiste à réutiliser une classe de base (plus générale) pour en faire une
version plus spécialisée (classe fille).
▪ Une classe peut être déclarée comme étant une sous-classe d’une autre classe en
spécifiant le mot clé extends :
class sous_classe extends super_classe {
// …
}
▪ La classe sous_classe hérite des attributs et des méthodes appartenant à la classe
super_classe et possède ses propres attributs et méthodes.
▪ Pas d'héritage multiple.
▪ Si un membre (méthode ou attribut) est redéfini dans la sous_classe, c’est sa dernière
définition qui est utilisée. Pour appeler un membre définie dans la super-classe à partir
d'une sous_classe, il suffit d’utiliser le suffixe parent::
▪ Le constructeur de la classe super_classe n’est pas appelé implicitement si la classe
sous_classe définit un constructeur. Par contre, si sous_classe ne définit pas un
constructeur alors il peut être hérité de la classe mère.

20/01/2023 Prof. Hafida ZROURI 16

Classes et objets
Exemple :
<?php
class Personne {
protected $nom;
protected $adresse;
protected $tel;
public function __construct($n, $a, $t) {
$this->nom = $n;
$this->adresse = $a;
$this->tel = $t;
}
public function toHTML() { // … }
}
$toto = new Personne( "toto", "123 rue Elqods", "0514…");
echo $toto->toHTML(); // ici on a accès à toHTML mais pas à nom, adresse ou tel
?>

20/01/2023 Prof. Hafida ZROURI 17

Classes et objets
Exemple (suite) :
<?php
class Employe extends Personne {
private $salaire;
private $poste;
public function __construct($n, $a, $t, $s, $p) {
parent::__construct($n, $a, $t);
$this->salaire = $s;
$this->poste = $p;
}
public function toHTML() {
return parent::toHTML( ) . $this->salaire . $this->poste;
}
}
$empl1 = new Employe("toto", "123…", "0514…", 6000, "prog");
echo $empl1->toHTML();
// ici on a accès à toHTML mais pas à nom, adresse, tel, salaire ou poste
?>
20/01/2023 Prof. Hafida ZROURI 18
Classes et objets
♦ Classes abstraites :
▪ Une classe abstraite ne permet pas l'instanciation d'objets mais sert
uniquement de classe de base pour la création de classes dérivées.
▪ La déclaration d’une classe abstraite se fait avec le mot clé abstract :
abstract class nom_classe {
abstract function maMethode();
// Définition des attributs et de d’autres méthodes
}
▪ Une classe contenant une méthode abstraite doit être déclarée comme
abstraite.
▪ Une classe dérivée n’implémentant pas toutes les méthodes abstraites
doit aussi être déclarée comme abstraite.

20/01/2023 Prof. Hafida ZROURI 19

Classes et objets
♦ Interfaces :
▪ L'interface définie une structure à laquelle la classe qui l'implémente doit se conformer.
▪ Ne contient aucune déclaration de propriétés.
▪ Ne contient aucune implémentation de méthode.
▪ Déclaration avec le modificateur public uniquement.
▪ Peut contenir des constantes.
▪ Structure d'une interface : interface nom_interface {
[public] function methode1([$var1, $var2,…]);
…
}
▪ Il est possible de définir une classe implémentant une ou plusieurs interfaces :
class nom_classe implements interface1, interface2, … {
// Implémentation de toutes les méthodes des interfaces
}
Remarque : si l’une des méthodes des interfaces n’est pas implémentée, la classe doit être
déclarée abstraite.
▪ Les interfaces peuvent être étendues comme des classes, en utilisant l'opérateur extends :
interface interface2 extends interface1 {…}
20/01/2023 Prof. Hafida ZROURI 20
Classes et objets
♦ Méthodes et classes finales :
▪ Une classe finale (déclarée par le mot clé final) est une classe qui ne peut pas avoir de
classes filles.
Exemple :
final class A {… }
class B extends A {…} // Erreur

▪ Une méthode finale (déclarée par le mot clé final) est une méthode qui ne peut pas être
redéfinie dans les sous-classes.
Exemple :
class A {//…
final public function f($x) {…}
}
class B extends A { //…
public function f($x) {…} // Erreur
}

20/01/2023 Prof. Hafida ZROURI 21

Exceptions
♦ Une exception peut être lancée ("throw") et attrapée ("catch") dans PHP.
Le code devra être entouré d'un bloc try. Chaque try doit avoir au moins
un bloc catch ou finally correspondant.

♦ L'objet lancé doit être une instance de la classe Exception (ou une de ses
sous-classes). Autrement, on aura une erreur fatale émise par PHP.

♦ PHP nous offre la possibilité d'hériter la classe Exception afin de

personnaliser nos exceptions. On peut réécrire les méthodes __construct
et __toString. Toutes les autres méthodes sont finales.

20/01/2023 Prof. Hafida ZROURI 22

Exceptions
Exemple :
<?php
function inverse($x) {
if (!$x) { throw new Exception('Division par zéro.'); }
else return 1/$x;
}
try {
echo inverse(5) . "<br>";
echo inverse(0) . "<br>";
} catch (Exception $e) {
echo 'Exception reçue : ' . $e->getMessage() . "<br>";
}
echo 'Bonjour le monde !';
?>
Affichage :
0.2
Exception reçue : Division par zéro.
Bonjour le monde !
20/01/2023 Prof. Hafida ZROURI 23
PDO (PHP Data Object) :
accès aux bases de données depuis PHP
♦ PDO (PHP Data Object) est une couche d'abstraction des fonctions d'accès aux
bases de données en programmant avec un style orienté objet, et surtout qui
permet de s'affranchir du SGBD. PDO n'utilise pas des fonctions au nom
trop explicite comme mysqli_query() ou mysqli_connect(), ce qui facilite
grandement la migration d'un SGBD à l'autre.

♦ L'utilisation d’un SGBD avec PHP s'effectue en plusieurs étapes :

1. Connexion au serveur de données et sélection de la base de données
2. Effectuer des requêtes
[3. Exploitation des résultats de la requête]
4. Déconnexion

20/01/2023 Prof. Hafida ZROURI 24

PDO (PHP Data Object) :
accès aux bases de données depuis PHP
♦ Connexion au serveur de données :
▪ Avant de travailler avec un serveur de gestion de base de données (comme
MySQL), il faut ouvrir une connexion.
▪ Ouvrir une connexion se fait automatiquement lorsqu'on instancie un objet PDO.
▪ Syntaxe :
$connexion = new PDO("DSN", "NomUtilisateur", "MotDePasse");
Le DSN (Data Source Name) permet de décrire la base de données à laquelle
nous allons nous connecter et son type. Chaque SGBD a ses propres paramètres.
Nous ne verrons que le DSN MySQL.
▪ Exemple :
// Préparation des informations nécessaires
$dsn = 'mysql:host=localhost;dbname=nomDeMaBase';
$utilisateur = 'root';
$mdp = '';
// Création d'un objet PDO et connexion
$connexion = new PDO($dsn, $utilisateur, $mdp);
20/01/2023 Prof. Hafida ZROURI 25
PDO (PHP Data Object) :
accès aux bases de données depuis PHP
♦ Étant donné que la connexion à la base de données est utilisée sur plusieurs pages
différentes du site, il serait judicieux de créer un fichier de connexion et d'y faire
appel à chaque fois que nous en avons besoin. De plus, si les données permettant de
configurer notre accès changent, il nous suffira de mettre à jour ce simple fichier.
Voici un petit exemple reprenant le code précédent. Ici nous créons des constantes
pour les paramètres à passer plutôt que des variables. On peut aussi améliorer ce
code en ajoutant une structure de test de type try / catch.
// Préparation des informations nécessaires
define('DSN', 'mysql:host=localhost;dbname=test');
define('USER', 'root');
define('MDP', '');
// Création d'un objet PDO et connexion
try {
$connexion = new PDO(DSN, USER, MDP);
} catch (PDOException $e) {
echo "Erreur : ".$e -> getMessage();
exit();
}
20/01/2023 Prof. Hafida ZROURI 26
PDO (PHP Data Object) :
accès aux bases de données depuis PHP
♦ Déconnexion :
▪ Pour se déconnecter, il suffit de détruire l'objet PDO que nous avons
créé. Affecter la valeur null à cet objet suffira.
▪ Syntaxe :
// Fermeture de la connexion
if ($connexion) {
$connexion = NULL;
}
Remarque : Nous vérifions l'existence de notre objet avant de changer sa
valeur, évitant ainsi la génération d'une erreur si la connexion avait déjà
été précédemment fermée.

20/01/2023 Prof. Hafida ZROURI 27

PDO (PHP Data Object) :
accès aux bases de données depuis PHP
♦ Effectuer des requêtes :
▪ Une fois connecté au serveur de données (ex : MySQL) avec notre objet PDO,
nous allons pouvoir commencer à envoyer des requêtes SQL au serveur.
▪ PDO distingue deux types de requêtes :
1- Les requêtes de mise à jour (UPDATE, INSERT, DELETE) :
$connexion->exec("Requête");
- Requête : une chaîne de caractères, syntaxe SQL.
- La méthode exec() retourne un entier qui correspond au nombre de lignes
affectées par la requête.
- Exemple :
$nbLignes = $connexion->exec("DELETE FROM personne WHERE id=2");

20/01/2023 Prof. Hafida ZROURI 28

PDO (PHP Data Object) :
accès aux bases de données depuis PHP
2- Les requêtes de sélection (SELECT) : $connexion->query("Requête")
- La méthode query() retourne FALSE en cas d’erreur ou, sinon, un jeu de résultats en tant qu’objet de
la classe PDOStatement.
Exemple :
$resultats = $connexion->query("SELECT nom, prenom FROM personne");
- Pour connaître le nombre de lignes de résultats : $resultats->rowCount()
- Pour parcourir ligne par ligne les résultats de la requête : $resultats->fetch()
- Pour récupérer, en tant qu'objet, ligne par ligne les résultats de la requête : $resultats->fetchObject()
Exemple :
while($ligne=$resultats->fetch()){echo $ligne[0].' '.$ligne[1] .'<br />';}
ou while($ligne=$resultats->fetch()){echo $ligne['nom'].' '.$ligne['prenom'] .'<br />';}
ou while($ligne=$resultats->fetchObject()){echo $ligne->nom.' '.$ligne->prenom.'<br />';}
- Pour mettre toutes les lignes dans un tableau : $resultats->fetchAll()
Exemple :
$lignes = $resultats->fetchAll();
foreach($lignes as $ligne) {echo $ligne['nom'].' '.$ligne['prenom'].'<br />'; }
- Pour libérer la connexion au serveur, permettant ainsi à d'autres requêtes SQL d'être exécutées :
$resultats->closeCursor()
20/01/2023 Prof. Hafida ZROURI 29
PDO (PHP Data Object) :
accès aux bases de données depuis PHP
♦ Requêtes préparées :
▪ Lorsqu'on exécute une requête, la base de données va l'analyser, la compiler,
l'optimiser puis l'exécuter. Le but des requêtes préparées est de ne pas répéter
toutes ces actions lorsqu'on exécute des requêtes identiques.
▪ Une requête préparée ou requête paramétrable est utilisée pour exécuter la même
requête plusieurs fois.
▪ Deux étapes sont nécessaires : la préparation et l’exécution.
Les méthodes que nous aurons besoin sont :
La méthode prepare() va préparer une requête qui contient soit des paramètres ou
noms (:nom) soit des marqueurs (?), qui sera ensuite exécutée au travers de la
méthode execute(). Les noms et les marqueurs seront substitués par leurs valeurs à
l’exécution ou avec la méthode bindParam().
Remarque : vous ne pouvez pas utiliser les noms et les marqueurs dans une même
requête SQL ; choisissez l'un ou l'autre.

20/01/2023 Prof. Hafida ZROURI 30

PDO (PHP Data Object) :
accès aux bases de données depuis PHP
▪ Exemple 1 :
$c = new PDO('mysql:host=localhost;dbname=test', 'root', '');
$stmt=$c->prepare("INSERT INTO personne (nom, prenom) VALUES (:nom, :prenom)");
$stmt->bindParam(':nom', $nom); //bindParam : Lie un paramètre à un nom de variable spécifique
$stmt->bindParam(':prenom', $prenom);
// Insertion d’une ligne
$nom = 'Azaiis';
$prenom = 'Mohamed';
$stmt->execute();
// Insertion d’une autre ligne
$nom = 'Essoufi';
$prenom = 'Amina';
$stmt->execute();

20/01/2023 Prof. Hafida ZROURI 31

PDO (PHP Data Object) :
accès aux bases de données depuis PHP
▪ Exemple 2 :
- On peut utiliser « ? » comme marqueur de paramètre dans la requête :
$c = new PDO('mysql:host=localhost;dbname=test', 'root', '');
$stmt = $c->prepare("INSERT INTO personne (nom, prenom) VALUES (?, ?)");
$stmt->bindParam(1, $nom);
$stmt->bindParam(2, $prenom);
// Insertion d’une ligne
$nom = 'Azaiis'; $prenom = 'Mohamed';
$stmt->execute();
- On peut passer les paramètres de la requête dans la méthode execute() :
$stmt = $c->prepare("INSERT INTO personne (nom, prenom) VALUES (?, ?)");
// Insertion d’une ligne
$nom = 'Azaiis'; $prenom = 'Mohamed';
$stmt->execute(array($nom, $prenom));
20/01/2023 Prof. Hafida ZROURI 32
PDO (PHP Data Object) :
accès aux bases de données depuis PHP
▪ Exemple 3 :

$c = new PDO('mysql:host=localhost;dbname=test', 'root', '');

$stmt = $c->prepare("SELECT nom, prenom FROM personne WHERE nom = ?");
if($stmt->execute(array($_GET['name']))) {
while($ligne = $stmt->fetch()) {
print($ligne['nom'].' '.$ligne['prenom'] .'<br />');
}
}

Remarques :
- La méthode prepare() retourne un objet de type PDOStatement si le serveur de
base de données prépare avec succès la requête. Dans le cas contraire elle retourne
FALSE ou émet une exception PDOException.
- La méthode execute() retourne TRUE en cas de succès ou FALSE sinon.

20/01/2023 Prof. Hafida ZROURI 33