Vous êtes sur la page 1sur 54

Monoem YOUNEB monoem.youneb@gmail.

com
Ingénieur études et développement tn.linkedin.com/in/monoemyouneb
Plan
Partie 1 – Notion de base de la POO

I. Introduction à la POO
II. Les classes en php
III. Les constantes de classe en php
IV. L'héritage
V. Les interfaces
VI. Les exceptions

Partie 2 - Techniques avancées

I. Les design patterns


II. Manipulation des données stockées
III. Le PDO
IV. Le modèle MVC

Neto graphie

2
Monoem YOUNEB
Partie 1 – Notion de base de la POO

I. Introduction à la POO

1. La POO
La programmation orienté objet (POO) est une façon de programmation qui
consiste à définir et assembler des briques de code appelés « Objet »

2. Qu'est-ce qu'un objet


Dans notre vie, nous sommes entourés d'objets. Certains très simples, comme
un bouton ou une zone de texte. D'autres très complexes comme une
automobile, un ordinateur.

3
Monoem YOUNEB
Partie 1 – Notion de base de la POO
3. Une classe
Tous les objets possédant les mêmes caractéristiques et avec lesquels on peut
faire les même choses forment un groupe qu'on appelle en informatique une
Classe.
Exemple
Les Etudiants chacun a un cin, nom, prénom, adresse,tel etc.
Donc ils ont en commun de posséder certaines caractéristiques et de pouvoir
effectuer certaines actions  Ils font donc partie d'une classe unique qu’on
peut l'appeler « Etudiant »
Syntaxe

<?php
class MaClasse{
$maVariable;
function maMethode(){
//code
}
}
?> 4
Monoem YOUNEB
Partie 1 – Notion de base de la POO

4. Une Instance
C’est le fait de créer un objet a partir d’une classe.

5. Création d’une Classe PHP

a. Syntaxe PHP

<?php

class Etudiant // Présence du mot-clé class suivi du nom de la classe.


{

// Déclaration des attributs et méthodes ici.

?>

5
Monoem YOUNEB
Partie 1 – Notion de base de la POO

4. Encapsulation en PHP
La déclaration d'attributs dans une classe :
private $nom
- le nom de l'attribut à créer, précédé de sa visibilité.
- Les propriétés au sein d'une classe sont généralement déclarées private. Elles sont accessibles de
l'extérieur de la classe via les accesseurs

private $nom

Visibilité le nom de l'attribut

6
Monoem YOUNEB
Partie 1 – Notion de base de la POO

La visibilé public
On a un accès depuis n'importe où, depuis l'intérieur de l'objet (dans les méthodes
qu'on a créées), comme depuis l'extérieur.

La visibilé private
L’accès aux attributs et méthodes seulement depuis l'intérieur de la classe.

La visibilé protégée
L’accès aux données est réservé aux fonctions des classes héritières

7
Monoem YOUNEB
Partie 1 – Notion de base de la POO

7. Attribut Etudiant en PHP

<?php

class Etudiant
{
private $identifiant;
private $cin;
private $nom;
private $prenom;
private $adresse;
private $dateNaissance;
private $tel;
}

?>

8
Monoem YOUNEB
Partie 1 – Notion de base de la POO
8. Les méthodes en PHP

L'accès à une méthode à l'intérieur d'une classe se fait de la manière suivante:

<?php
$this->nomMethode();
?>

<?php
class Etudiant
{
private $identifiant;
private $cin;
private $nom;
private $prenom;
private $adresse;
private $dateNaissance;
private $tel;

// déclaration des méthodes


public function afficheInfo () // Une méthode qui affiche un étudiant.
{
echo $this->nom.$this-> afficheAdresse();
}
public function afficheAdresse() // Une méthode qui affiche l’adresse d’un étudiant.
{
return $this-> adresse;
}
}
?> 9
Monoem YOUNEB
Partie 1 – Notion de base de la POO
II. Utilisation des classes en PHP

1. Les propriétés
L'accès à une propriété à l'intérieur d'une classe se fait de la manière suivante:
$this->nomPropriété
$this est une référence à l'objet appelant auquel appartient la méthode.

2. Les constantes
Les constantes sont déclarées de la manière suivante:
const NOMCONSTANTE;
L'accès aux constantes se fait de la manière suivante:
nomClass:: NOMCONSTANTE

3. Instance
<?php
$et = new Etudiant;
$et est un objet de type Etudiant, On dit que l'on instancie la classe Etudiant.
Le constructeur New s'appelle unconstructeur 10
Monoem YOUNEB
Partie 1 – Notion de base de la POO
II. Utilisation des classes en PHP
2. Appels des méthodes en PHP

<?php
class Etudiant
{
private $identifiant;
private $cin;
private $nom;
private $prenom;
private $adresse;
private $dateNaissance;
private $tel;

// déclaration des méthodes


public function inscription()
{ echo "inscription encours"
}
$et = new Etudiant;
$et-> inscription();
}
?>
11
Monoem YOUNEB
Partie 1 – Notion de base de la POO
II. Utilisation des classes en PHP
3. Accéder à un élément depuis la classe en PHP

<?php
class Etudiant
{
private $identifiant;
private $cin;
private $nom;
private $prenom;
private $adresse;
private $dateNaissance;
private $tel;

// déclaration des méthodes


public function inscription()
{ echo "inscription encours"
}
$et = new Etudiant;
$et-> nom= "Toto";
}
?>
12
Monoem YOUNEB
Partie 1 – Notion de base de la POO
II. Utilisation des classes en PHP
4. Les constructeurs et les destructeurs
Le constructeur d'une classe permet l'initialisation d'une instance (objet) de la classe.
En gros c'est la méthode qui sera appelée lors de l'instanciation de la classe.
- Un constructeur doit avoir comme nom « __construct ».

public function __construct($nom, $prenom) // Constructeur demandant 2 paramètres


{
echo ‘Afficher le constructeur !'; // Message s'affichant une fois que tout objet est créé.
$this->setNom($nom); // Initialisation du nom.
$this->setPrenom($prenom); // Initialisation du prenom.
$this->tel= 0; // Initialisation de tel à 0.
}
}

Le destructeur est appelée aussitôt que toutes les références à un objet particulier sont effacées ou
lorsque l'objet est explicitement détruit.
- Un destructeur doit avoir comme nom « __destruct ».

public function __destruct () // Destructeur


{
print "Destruction de " . $this->nom . $this->prenom "\n" ;
}
13
Monoem YOUNEB
Partie 1 – Notion de base de la POO
II. Utilisation des classes en PHP
5. Syntaxe Les accesseurs et mutateurs en PHP
L’encapsulation empêche l'accès direct aux attributs privés.
Les accesseurs permettent l'accès aux propriétés déclarées private. Ces méthodes sont
généralement nommées de la manière suivante:

<?php
function getNomPropriete();
?>

Les mutateurs permettent la modification des propriétés déclarées private. Ces méthodes sont
généralement nommées de la manière suivante:

<?php
function setNomPropriete($valeur);
?>

14
Monoem YOUNEB
Partie 1 – Notion de base de la POO
II. Utilisation des classes en PHP
6. Exemple Les accesseurs et mutateurs en PHP
<?php
class Etudiant
{
private $identifiant;
private $cin;
private $nom;
private $prenom;
private $adresse;
private $dateNaissance;
private $tel;

public function getCin()


{
return $this->cin;
}
public function setCin($cin){

if (!is_int($ cin)) // S'il ne s'agit pas d'un nombre entier.


{
trigger_error('La cin d\'un personnage doit être un nombre entier', E_USER_WARNING);
return;
}
$this->cin= $cin;
}
}
?> 15
Monoem YOUNEB
Partie 1 – Notion de base de la POO
II. Utilisation des classes en PHP
7. L'auto-chargement de classe en PHP
Pour mieux organiser le code, il est conseiller de créer un fichier par classe « MaClasse.php »
exemple « Etudiant.php » et dans se cas on va l’inclure.

<?php
// inlusion simple
require ‘Etudiant.php'; // J'inclus la classe.
$Etud= new Etudiant; // Puis, seulement après, je me sers de ma classe.
?>

<?php
// inclusion avec fonction
function chargerClasse($classe)
{
require $classe . '.php'; // On inclut la classe correspondante au paramètre passé.
}
?>

16
Monoem YOUNEB
Partie 1 – Notion de base de la POO
III. Les constantes de classe en php
1. Les constantes de classe en PHP
Une constante est une sorte d'attribut dont la valeur ne change jamais.

<?php
class Etudiant
{
private $identifiant;
private $cin;
private $nom;
private $prenom;
private $adresse;
private $dateNaissance;
private $tel;
// déclaration des constantes
const Taille = 180;
}
?>

• Accès à une constantes de classe en PHP


Contrairement aux attributs, on ne peut pas accéder à ces valeurs avec l'opérateur « -> » mais avec
l'opérateur « :: » car une constante appartient à la classe et non à un quelconque objet.
Pour accéder à une constante, on spécifie le nom de la classe, suivi du symbole double deux points,
17
suivi du nom de la constante.
Monoem YOUNEB
Partie 1 – Notion de base de la POO
III. Les constantes de classe en php
2. Les constantes de classe en PHP
• Les méthodes statiques
Ce sont des méthodes qui sont faites pour agir sur une classe et non sur un objet.

<?php
public static function parler()
{
echo 'Je suis une méthode statique!';
}
?>

<?php
Etudiant ::parler();
?>

18
Monoem YOUNEB
Partie 1 – Notion de base de la POO
III. Les constantes de classe en php
3. Les attributs statiquesen PHP
• Déclaration
Ce sont des méthodes qui sont faites pour agir sur une classe et non sur un objet.
<?php
// Variable statique PRIVÉE.
private static $Moyenne= 12;
// Affichage
echo Compteur :: getMoyenne();

public static function getCompteur() // Méthode statique qui renverra la valeur du compteur.
{
return self :: $Moyenne;
}

?>

self représente la classe tandis que $this représente l'objet actuellement créé.

19
Monoem YOUNEB
Partie 1 – Notion de base de la POO
III. Les constantes de classe en php

En résumé
 L'opérateur « -> » permet d'accéder à un élément de tel objet, tandis que l'opérateur « :: » permet
d'accéder à un élément de telle classe.
 Au sein d'une méthode statique, on accède à l'objet grâce à la pseudo-variable $this, tandis
qu'on accède à la classe grâce au mot-clé self.
 Les attributs et méthodes statiques ainsi que les constantes de classe sont des éléments propres
à la classe, c'est-à-dire qu'il n'est pas utile de créer un objet pour s'en servir.
 Les attributs et méthodes statiques sont utiles lorsque l'on ne veut pas avoir besoin d'un objet
pour s'en servir.

20
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php
- L'héritage est un principe de la programmation orientée objet.
- Une classe B hérite d'une classe A. La classe A est donc considérée comme la classe mère et la
classe B est considérée comme la classe fille.
- Lorsqu'on dit que la classe B hérite de la classe A, c'est que la classe B hérite de tous les
attributs et méthodes de la classe A. Si l'on déclare des méthodes dans la classe A, et qu'on crée une
instance de la classe B, alors on pourra appeler n'importe quelle méthode déclarée dans la classe
A du moment qu'elle est publique.

NB: En PHP, l’héritage multiple n’est pas supporté. C’est-à-dire qu’une classe ne peut pas
être l’enfant directe de plusieurs classes.
Exemple d’utilisation de l’héritage : <?php

class ClasseA {
public function fctHerite(){
echo "heritage";
}
...
}

class ClasseB extends ClasseA{


...
}
$enfant = new ClasseB();
$enfant->fctHerite();
?> 21
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php
1. Méthode Final
Le mot clé Final permet d’empêcher qu’une méthode soit réécrite dans une sous-classe. L’utilisation
de ce mot clé se fait de la manière suivante :

<?php

class maClass{
final public function maFonction(){
...
}
}
?>

2. Classe Final
On peut utiliser ce mot clé afin qu’une classe ne puisse pas être héritée par une autre classe.

<?php

Final class maClass{


...

}
?>

22
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php
3. L’auto-chargement de classe
L’auto-chargement de classe consiste à définir une méthode « __autoload » qui sera appelée lorsqu'on utilise une
classe ou une interface qui n’a pas encore été définie.

<?php

Function __autoload($class_name) {
include $class_name.'.php';
}

$a = new ClasseA();
$b = new ClasseB();
?>

4. Les classes abstraites


Une classe abstraite est une classe qui ne peut pas être instanciée. On peut donc dire qu'elle sert de modèle aux
classes qui en hériteront. De plus, le mot clef abstract sert peut aussi servir à forcer les classes filles à réécrire une
fonction. Dans notre cas, un gardien de but tirant dans le ballon différemment qu'un attaquant par exemple, nous
devons réécrire la fonction :

23
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php

• Déclaration1 d'une classe abstraite


La déclaration d'une classe abstraite se réalise au moyen du mot-clé « abstract ». Prenons l'exemple d'une classe
abstraite « joueurDeFoot » qui sera, par exemple, dérivée par une classes concrètes «joueurDeFoot »

<?php

abstract class joueurDeFoot


{
private $_champ1; //Ses classes filles n'en hériteront pas
protected $_champ2; //Ses classes filles en hériteront
abstract public function tirerDansLeBallon();
}
class gardienDeBut extends joueurDeFoot
{
//Ici les spécifités de la classe
//Obligation de réécrire la fonction:
public function tirerDansLeBallon()
{
//Code à exécuter...
}
}

?>

24
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php

• Déclaration2 d'une classe abstraite


La déclaration d'une classe abstraite se réalise au moyen du mot-clé « abstract ». Prenons l'exemple d'une classe
abstraite « Personne » qui sera, par exemple, dérivée par deux classes concrètes «Etudiant » et « Eleve ».

<?php

abstract class Personne


{
protected $sexe;
protected $nom;

public function setNom($nom)


{
$this->nom = $nom;
}
public function getNom()
{
return $this->nom;
}
public function getSexe()
{
return $this->sexe;
}
}
?>

25
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php
4. Déclaration et redéfinition des méthodes abstraites
- Une méthode abstraite est une méthode partiellement définie dans la classe. En effet, lorsque l'on déclare une
méthode abstraite, on ne définit que son prototype (sa signature). Les classes dérivées devront obligatoirement
redéfinir entièrement (prototype + corps) toutes les méthodes abstraites de la classe parente.
- La déclaration d'une classe abstraite se réalise au moyen du mot-clé « abstract ». Prenons l'exemple d'une classe
abstraite « Personne » qui sera, par exemple, dérivée par deux classes concrètes «Etudiant » et « Eleve ».
• Déclaration de méthodes abstraites
<?php
abstract class Personne
{
protected $sexe; Notre classe dispose à présent de deux nouvelles méthodes abstraites Lire() et Courir().
protected $nom; Le corps de ces deux méthodes n'est pas défini.
abstract function Lire(); Nous devrons les définir dans les classes dérivées.
abstract function courir();
public function setNom($nom) Rq : toute classe qui définit une ou plusieurs méthodes abstraites doit obligatoirement
{ être déclarées abstraite elle aussi.
$this->nom = $nom;
}
public function getNom()
{
return $this->nom;
}
public function getSexe()
{
return $this->sexe;
}
} 26
?>
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php
• Déclaration des classes dérivées
• Redéfinition des méthodes abstraites dans les classes dérivées

<?php
<?php
class Eleve extends Personne
class Etudiant extends Personne
{
{
public function __construct($nom)
public function __construct($nom)
{
{
$this->nom = $nom;
$this->nom = $nom;
$this->sexe = ‘F';
$this->sexe = 'M';
}
}
public function Lire()
public function Lire()
{
{
echo $this->nom .' Lire une Hostoire';
echo $this->nom .' Lire un Roman';
}
}
public function Courir()
public function Courir()
{
{
echo ‘Faire du sport scolaire';
echo ‘Faire du sport';
}
}
}
}

?>
?>

27
Monoem YOUNEB
Partie 1 – Notion de base de la POO
IV. L’héritage en php
5. Instances des classes Etudiant et Eleve

<?php Le résultat obtenu est bien celui attendu :

$_Jame= new Etudiant(' Jame '); Jame Fait du sport


$_Jame>Lire (); Sexe :M
echo '<br/>';
$_Jame->Courir();
echo '<br/>';
echo 'Sexe : ', $_Jame->getSexe();
echo '<br/><br/>';
$_Enis = new Lire (' Enis ');
$_Enis -> Courir();
echo '<br/>';
$_Enis -> Courir();
echo '<br/>';
echo 'Sexe : ', $_Enis ->getSexe();

?>

28
Monoem YOUNEB
Partie 1 – Notion de base de la POO
V. Les interfaces
1. Définition
C’est un moyen d'imposer une structure à une classes: obliger une classes à implémenter certaines méthodes
sans avoir à définir comment ces méthodes fonctionneront.
2. Création d’une interface

<?php
interface Courir
{
public function vitesse($v);

?>

Régles
1. Toutes les méthodes présentes dans une interface doivent être publiques.
2. Une interface ne peut pas contenir de méthodes abstraites ou finales.
3. Une interface ne peut pas avoir le même nom qu'une classe.
3. Implémenter une interface
<?php
class Etudiant implements Courir
{
public function vitesse($v)
{
}
}
?> 29
Monoem YOUNEB
Partie 1 – Notion de base de la POO
V. Les interfaces
3. Implémenter une interface
Régles
1. Lors de l’héritage d’une classe et l’implémentation d’une interface, alors il faut d'abord spécifier la classe à hériter
avec le mot-clé extends puis les interfaces à implémenter avec le mot-clé implements.
2. Il est obligatoire d’écrire toutes ses méthodes, comme il est possible de rajouter autant de plus.
4. Hériter des interfaces
Comme pour les classes, on peut hériter des interfaces grâce à l'opérateur extends. On ne peut réécrire ni une
méthode ni une constante qui a déjà été listée dans l'interface parente. Exemple :
Contrairement aux classes, les interfaces peuvent hériter de plusieurs interfaces à la fois. Il suffit de séparer leur nom par une
virgule. : <?php
interface i1{
public function test1();
}
interface iB extends i1{
public function test1 ($param1, $param2); // Erreur fatale : impossible de réécrire cette méthode.
}
interface i2 extends i1{
public function test2();
}
class MaClasse implements i2{
// Pour ne générer aucune erreur, on doit écrire les méthodes de i2 et aussi de i1.
public function test1() {
}
public function test2() {
}
?> 30
Monoem YOUNEB
Partie 1 – Notion de base de la POO
V. Les interfaces
4. Hériter des interfaces
Contrairement aux classes, les interfaces peuvent hériter de plusieurs interfaces à la fois. Il suffit de séparer leur nom
par une virgule. Exemple :

<?php
interface i1
{
public function test1();
}

interface i2
{
public function test2();
}

interface i3 extends i1, i2


{
public function test3();
}
?>

31
Monoem YOUNEB
Partie 1 – Notion de base de la POO
VI. Les interfaces
1. Définition
Ce sont des erreurs lancées par PHP lorsque qu’une instruction qui ne va pas et qui génère de chose survenu.
2. Provocation des exeptions
- Une exception peut être lancée depuis n'importe où dans le code.
- Il faut lancer une instance de la classe Exception qui contient un message d'erreur ainsi que son code.
Activité
- Créer une fonction qui calcule <?php
function Somme($x, $y)
la somme de deux nombres.
{
- Si l'un des deux nombres if (!is_numeric($x) || !is_numeric($y))
{
n'est pas numérique, alors on // On lance une nouvelle exception grâce à throw et on instancie directement un objet de la
classe Exception.
lancera une exception de type
throw new Exception('Les deux paramètres doivent être des numérique');
Exception à l'aide du mot }
return $x + $y;
throw et un message d'erreur }
comme paramètre du try // Nous allons essayer d'effectuer les instructions situées dans ce bloc.
{
constructeur de la classe Echo Somme(8, 2), '<br />';
Echo Somme(‘Auteur', 54), '<br />';
Exception. }
catch (Exception $e) // On va attraper les exceptions "Exception" s'il y en a une qui est levée
{
echo 'Une exception a été lancée. Message d\'erreur : ', $e->getMessage();
}
?>sont des
32
Monoem YOUNEB
Partie 2 - Techniques avancées

I. Les design patterns

1. Définition
Dans la plupart des développements professionnels ou de grande envergure, il est nécessaire de savoir structurer
correctement son application dans le but de faciliter sa conception et sa maintenance. Les « design patterns », où
« patrons de conception » en français, constitue l'une des meilleures solutions à cette problématique. Avec le nouveau
modèle orienté objet de PHP 5 proche de celui de Java, l'implémentation des design patterns est facilitée.

- C’est un schéma qui forme une solution à un problème connu ou récurrent afin de de fournir un objet prêt à
l’emploi et configuré correctement.
- C’est un arrangement caractéristique de modules, reconnu comme bonne pratique en réponse à un problème de
conception d'un logiciel. Il décrit une solution standard, utilisable dans la conception de différents logiciels.
- Ce sont des solutions connues et dont la conception est due à l'expérience de programmeurs.

33
Monoem YOUNEB
Partie 2 - Techniques avancées

I. Les design patterns

3. Les modèles de construction


Les patterns de construction déterminent comment faire l'instanciation et la configuration des classes et des objets.
Ces patterns permettent également d'encapsuler les classes concrètes et de rendre indépendant la façon dont les
objets sont créés..

On distingue les modèles suivants:


- Fabrique abstraite (Abstract Factory)
- Monteur (Builder)
- Fabrique (Factory Method)

34
Monoem YOUNEB
Partie 2 - Techniques avancées

I. Les design patterns


4. Fabrique abstraite (Abstract Factory)
L'un des modèles de conception les plus couramment utilisés est le modèle de Factory .Dans ce modèle, une classe
crée simplement l'objet que vous souhaitez utiliser. Prenons l'exemple suivant du modèle Factory
: Classe usine (Factory)

Ce code utilise une usine pour créer l'objet


Automobile. Il y a deux avantages possibles pour la
construction de votre code de cette façon; la première
est que si vous avez besoin de changer, renommer ou
remplacer la classe Automobile plus tard, vous pouvez
le faire et vous ne devez modifier le code dans l'usine,
au lieu de tous les lieux de votre projet qui utilise la
classe Automobile. Le deuxième avantage possible est
// Ont l'usine créer l'objet Automobile que si la création de l'objet est une tâche complexe que
vous pouvez faire tout le travail en usine, au lieu de le
$ Veyron = AutomobileFactory:: create ('Bugatti', 'Veyron');
répéter chaque fois que vous voulez créer une nouvelle
print_r ($veyron- > getMakeAndModel ()); // outputs "Bugatti Veyron" instance.
35
Monoem YOUNEB
Partie 2 - Techniques avancées

I. Les design patterns


5. Singleton
Lors de la conception d'applications Web, il est souvent judicieux sur le plan conceptuel et architectural pour permettre l'accès à
une et une seule instance d'une classe particulière. Le pattern singleton nous permet de le faire.

36
Monoem YOUNEB
Partie 2 - Techniques avancées

I. Les design patterns


SingletonChild

Le code ci - dessus met en œuvre le modèle singleton à l' aide d' une statique variables et la méthode de création
statique getInstance(). Notez ce qui suit:
Le constructeur __construct()est déclarée comme protégée pour empêcher lacréation d' une nouvelle instance en dehors de la classe
via l' newopérateur.
La méthode magique __clone()est déclarée comme privée pour empêcher leclonage d'une instance de la classe via l' newopérateur.
La méthode magique __wakeup()est déclarée comme privée pour empêcher Désérialisation d'une instance de la classe via la fonction
globale unserialize() .
Une nouvelle instance est créée via la liaison tardive statique dans la méthode de création statique getInstance() avec le mot -
clé static. Cela permet à la sous -classes de la classe Singleton dans l'exemple.
Le pattern singleton est utile lorsque nous devons nous assurer que nous avons une seule instance d'une classe pour la demande dans
le cycle de vie complet d'une application web. Cela se produit généralement lorsque nous avons des objets globaux (comme une classe
de configuration) ou une ressource partagée (comme une file d'attente d'événements).
37
Monoem YOUNEB
Partie 2 - Techniques avancées

I. Les design patterns


6. Strategy/ Stratégie
Avec le modèle de stratégie que vous encapsuler familles spécifiques des algorithmes permettant la classe client responsable de
l'instanciation d'un algorithme particulier de ne pas avoir connaissance de la mise en œuvre effective. Il existe plusieurs
variations sur le modèle de la stratégie, la plus simple qui est décrit ci-dessous:
Ce premier extrait de code décrit une famille d'algorithmes; vous voudrez peut-être un tableau sérialisé, certains JSON ou peut-
être juste un tableau de données:

38
Monoem YOUNEB
Partie 2 - Techniques avancées
I. Les design patterns
6. Strategy/ Stratégie
En encapsulant les algorithmes ci-dessus vous faites agréable et clair dans votre code que d'autres développeurs peuvent
facilement ajouter de nouveaux types de sortie sans affecter le code client.
Vous verrez comment chaque classe concrète "de sortie" implémente une OutputInterface - cela sert à deux fins, surtout il offre
un contrat simple qui doit être obéi par de nouvelles implémentations concrètes. Deuxièmement en mettant en œuvre une
interface commune , vous verrez dans la section suivante que vous pouvez maintenant utiliser typeHinting pour veiller à ce que
le client qui est l' utilisation deces comportements est du type correct dans ce cas 'OutputInterface'.
Le prochain extrait de code décrit comment une classe de client appelant peut utiliser un de ces algorithmes et même mieux
définir le comportement nécessaire à l'exécution:

La classe client appelant ci-dessus a une propriété privée


qui doit être définie à l'exécution et être de type 'OutputInterface'
une fois que cette propriété est définie un appel à loadOutput ()
va appeler la méthode load () dans la classe de béton du type de sortie qui a été fixée.
39
Monoem YOUNEB
Partie 2 - Techniques avancées
II. Manipulation des données stockées
1. Connexion à la base de données

2. Les requêtes simples


SELECT

40
Monoem YOUNEB
Partie 2 - Techniques avancées
II. Manipulation des données stockées
INSERT

41
Monoem YOUNEB
Partie 2 - Techniques avancées
II. Manipulation des données stockées

42
Monoem YOUNEB
Partie 2 - Techniques avancées
II. Manipulation des données stockées
Fermer la connexion

Se protéger des injections SQL

Requête préparée
Voici un exemple de requête à trous, préparée utilisant l'extension MySQLi:

Tester le nombre de lignes

43
Monoem YOUNEB
Partie 2 - Techniques avancées

III. Comprendre le PDO

1. Définition
- PDO signifie Php Data Object. Il s'agit d’une couche d'abstraction des fonctions d'accès aux bases de données;
- Les fonctions d'accès seront universelles: mysql_connect(), mysql_query(), mysql_result(), mysql_fetch_array(),
mysql_real_escape_string(), etc;
- Permet de se connecter à plusieurs bases de données;
- Il ne retourne aucune erreurs.

2. Manipulation de données
a. Connexion à la base de données

<?php
// try et catch pour les exeptions et les erreurs de connexions
Try{
// lancInitialiser PDO et préciser le type de la base de données dans notre cas mysql
$DB=new PDO(‘mysql:host=localhost;dbname=tuto’ , ‘root’ , ‘’);
}
Catch{ (PDOExeption $e)
Echo ‘La base de données n’\est pas disponible ressayer plutart’;
}
?>

44
Monoem YOUNEB
Partie 2 - Techniques avancées

III. Comprendre le PDO


b. La requête SELECT
<?php
Try{
// On ajoute un attribut pour cacher les erreurs d’exceptions
$DB=new PDO(‘mysql:host=localhost;dbname=tuto’ , ‘root’ , ‘’);
$DB->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
}
Catch{ (PDOExeption $e)
Echo ‘La base de données n’\est pas disponible ressayer plutart’;
}
?>

<?php
$sql=(‘Select login,password FROM personne’);
Try{
$req=$DB->query($sql);
While($d=$req->(fetch(PDO:: FETCH_OBJECT)){
Echo’<pre>;
Print_r $d;
Echo $d->mail;
Echo’</pre>;
}
}
Catch{ (PDOExeption $e)
Echo ‘Erreurs de la reqête ’;
}
?>
45
Monoem YOUNEB
Partie 2 - Techniques avancées

III. Comprendre le PDO


b. La requête INSERT
- Methode1
<?php
$d=array(‘ TOTO’ ,’hhhh’ );

$d=$DB->prepare(‘INSERT INTO personne (login, password) VALUES (?,?)’);


$res=execute($d);
?>

- methode2
<?php
$d=array(
‘ login’ =>‘ TOTO’ ,
‘password’=>’hhhh’ );

$d=$DB->prepare(‘INSERT INTO personne (login, password) VALUES (:login, :password)’);


$res=execute($d);
?>

46
Monoem YOUNEB
Partie 2 - Techniques avancées

III. Comprendre le PDO


c. La requête UPDATE

<?php
$DB=beginTransaction();
$DB=execute (‘UPDATE personne SET login= " mmm" ,assword= " yyy" where id= " 129" ’);
?>

47
Monoem YOUNEB
Partie 2 - Techniques avancées

IV. Le modèle MVC


1. Définition
C'est une architecture et une méthode de conception (design pattern) pour le développement d'applications qui sépare le modèle
de données, l'interface utilisateur et la logique de contrôle.

- La couche du modèle est représentée par la base de données, les librairies de fonctions, les classes, les fichiers, les
structures de données... Ce sont en fait tous les composants qui permettent de stocker et de manipuler les données.

- La couche vue est la couche logicielle qui assure l'affichage des données à l'utilisateur et l'interface Homme / Machine.

- La couche contrôleur est le moteur principal de l'application. Il fait la liaison entre le modèle et la vue.
Le contrôleur a la tâche d'analyser la requête de l'utilisateur, d'appeler le modèle adéquat et de retourner la valeur de ce dernier
à la vue qui prendra en charge son affichage.

48
Monoem YOUNEB
Partie 2 - Techniques avancées

IV. Le modèle MVC


2. Cas pratique Système de news
a. Créer des dossiers

b. Créer un fichier index.php sur la racine (elle va lier toutes les pages de notre site)

<?php
// lancement de la session
session_start();
// connexion avec le PDO
$bdd=new PDO(‘mysql:host=localhost;dbname=tuto’ , ‘root’ , ‘’);
// redirection vers les pages de notre site et vérifier si le fichier existe dans le serveur
if(!empty($_GET[‘page’]) AND is_File(‘controlleurs/’.$_GET[‘page’].’.php’)){
include (‘controlleurs/’.$_GET[‘page’].’.php) ’);
}
Else{
include (‘controlleurs/index.php ’);

}
?>

49
Monoem YOUNEB
Partie 2 - Techniques avancées

IV. Le modèle MVC


c. Créer un fichier index.php sous le répertoire controlleurs

<?php include (dirname(__FILE__).’/../vues/index.php’); ?>

d. Créer une page news sous le répertoire controlleurs


<?php
include (dirname(__FILE__).’/../modeles/news.php’);
// declarer la fonction afficherNews qui existe dans le fichier news sous le dossier modeles
$news=afficherNews();
include (dirname(__FILE__).’/../vues/news.php’);
?>
e. Créer la page news sous le répertoire modeles

<?php
Function afficherNews()
{
// On signe a php qu’on va utiliser la connexion sur cette page
Global $bdd;
$news=array();
$req=$bdd->query(‘SELECT * FROM news’);
While ($data=$req->fetch())
{
$news[]=$data;
}
Return $news;
}
?> 50
Monoem YOUNEB
Partie 2 - Techniques avancées

IV. Le modèle MVC


f. Créer une page news.php sous le répertoire vues

<h1>Les news</h1>
<?php
Foreach($news as $n)
{
Echo $n[‘Titre’].’<br/>’;
Echo $n[‘Description’].’<br/>’;

}
?>

g. Créer une page index.php sous le répertoire vues

<h1>Accueil</h1>
<h2>Menu</h2>
<ul>
<li><a href="index.php?page=news">News</a></li>
<li><a href="#">Contact</a></li>
</ul>

51
Monoem YOUNEB
Partie 2 - Techniques avancées
IV. Le modèle MVC
Schéma de communication des page selon le modèle mvc
1- News Controlleurs
2- News Modele

3- News vues

52
Monoem YOUNEB
Partie 2 - Techniques avancées

IV. Le modèle MVC


Controlleurs de redirection des pages selon le modèle mvc
Index.php

53
Monoem YOUNEB
VI. Netoghraphie
1. http://jormes.developpez.com/articles/design-pattern-construction/
2. http://tahe.developpez.com/web/php/mvc/?page=page_1

54
Monoem YOUNEB