PHP avancé

1. Concepts de base du PHP Orienté Objet

2. PHP Orienté Objet – Encapsulation (Visibilité)
3. PHP Orienté Objet – Héritages
4. Constantes de classe, attributs et méthodes statiques
5. Méthodes magiques
6. Les classes et méthodes abstraites : définition et intérêt
7. Gérer une DB avec PDO
8. CRUD (Create, Read, Update, Delette)
9. Les interfaces en PHP
10. Les traits en PHP
11. Classe anonyme en PHP
12. Clonage d’objet en PHP
13. Les sessions en PHP
14. Les cookies en PHP
15. Gestion des exceptions en PHP
16. Les filtres en PHP

Projets :
MVC En PHP
Blog En PHP
API Rest

Version 0.1
Janvier 2023

1 PHP Avancé
 1- Concepts de base du PHP Orienté Objet
 Qu'est-ce qu'un objet ?
Les objets pourraient être comparés à des variables dans lesquelles on pourra non seulement écrire
ou lire des valeurs, mais également effectuer des actions.
Exemples de la vie quotidienne
Dans notre vie quotidienne, nous utilisons des objets tous les jours. Notre cafetière, notre voiture,
notre téléviseur sont autant d'objets "quotidiens" qui pourraient se comparer à un objet PHP.
En effet, chacun de ces objets aura des caractéristiques qui lui sont propres, sa couleur, son énergie,
sa taille, le nombre de places de la voiture. Chacune de ces caractéristiques vont définir notre objet.
Nous pourrons également effectuer des actions avec chacun de ces objets, démarrer, allumer, changer
de chaine, accélérer...
 Et le PHP dans tout ça ?
En PHP, les caractéristiques s'appelleront des propriétés et les actions s'appelleront des méthodes.
Nos objets pourront posséder ces propriétés et ces méthodes en fonction de ce que nous souhaitons.
 Conventions
Avant d'aller plus loin, voici quelques conventions importantes dans le développement orienté objet.
• Chaque objet aura son propre fichier
• Le nom de fichier sera le nom de l'objet
• Le nom de l'objet sera écrit en UpperCamelCas
 Premier Classe
Une classe en PHP se définit par le mot clé "class".
Nous allons donc créer la Classe "Compte" dans un fichier intitulé "Compte.php" (notez-le C
majuscule). Nous placerons ce fichier dans un dossier "classes" qui contiendront tous nos fichiers de
classes.
Le fichier "Compte.php" contiendra donc la déclaration de classe "Compte" comme ceci

Une fois la classe déclarée, à l'intérieur nous allons pouvoir déclarer les propriétés de l'objet. Notre
compte pourra avoir un titulaire et un solde. Nous allons donc les déclarer comme ci-dessous (nous
reviendrons sur le mot clé "public" dans la partie "Visibilité").

2 PHP Avancé
  Instancier l'objet
Après avoir déclaré la classe, nous pourrons l'appeler à plusieurs reprises dans des variables
différentes. On appellera cette manipulation "Instancier l'objet" qui permet de créer plusieurs
exemplaires de notre objet, chaque exemplaire étant appelé "instance".

 Modifier la valeur des propriétés

Lorsque nous avons instancié l'objet "Compte", nous n'avons pas défini de valeurs pour les
propriétés "titulaire" et "solde".
Nous allons pouvoir les modifier comme ceci

 Le constructeur
Comme nous l'avons vu précédemment, lorsque nous instancions notre classe, ses propriétés ne
sont pas remplies.

3 PHP Avancé
Nous allons pouvoir utiliser une méthode (fonction) spécifique appelée "constructeur" qui va nous
permettre de "construire" notre objet lorsque nous l'instancions.
Cette méthode sera exécutée automatiquement lors de l'instanciation de l'objet.

Vous remarquerez l'utilisation de "this" qui représente l'instance de classe que nous utilisons.
Pour instancier notre classe, nous devrons donc maintenant préciser un titulaire et un solde de cette
façon

 Ajouter des méthodes

Une fois notre objet créé, nous pouvons avoir besoin d'effectuer des actions sur celui-ci.
Dans le cas de notre "Compte", nous devrions pouvoir afficher le solde, déposer et retirer de l'argent.
Pour afficher le solde du compte, nous allons créer une méthode que nous placerons directement sous
le constructeur.
Notre méthode affichera le solde du compte sous la forme d'un "echo" et sera créée comme ceci

Pour afficher le solde de notre "compte1", nous allons donc utiliser la méthode de la façon suivante

4 PHP Avancé
Pour pouvoir ajouter de l'argent à notre solde, nous allons créer une méthode "deposer"

Et l'utiliser comme ceci

Pour le retrait, nous allons créer une méthode "retirer" qui vérifiera le solde avant d'autoriser le retrait

Et l'utiliser comme ceci

5 PHP Avancé
 2- Encapsulation (Visibilité)
Dans la 1ère partie nous avons vu comment créer un objet et comment l'instancier.
Nous avons utilisé un mot clé "public" pour déclarer nos propriétés et nos méthodes.
Ce mot clé permet de définir la visibilité de nos propriétés et méthodes, élément indispensable au
bon fonctionnement de nos objets et de notre logique, basé sur le principe d'encapsulation.
Une bonne gestion de l'encapsulation permet de protéger l'utilisation de votre objet par les
développeurs qui seraient amenés à en faire usage.
 Les différentes visibilités

Il existe 3 visibilités pour nos propriétés et méthodes :

 public : la propriété ou la méthode pourront être accédés depuis l'intérieur et l'extérieur de la
classe
 private : l'accès à la propriété ou la méthode est possible uniquement depuis l'intérieur de la
classe
 protected : équivalent à private mais accessible également dans les classes héritées

 Private et Protected

Nous allons traiter des visibilités "private" et "protected" simultanément, leur fonctionnement étant
identique.
Si nous passons les propriétés "titulaire" et "solde" en private, il ne sera plus possible de les modifier
ni d'y accéder directement.
Ainsi, si notre classe est définie comme ceci

Nous ne pourrons pas accéder à nos propriétés de cette façon

Nous aurons une erreur d'accès

6 PHP Avancé
  Les accesseurs

Afin de pouvoir définir et lire nos propriétés en "private", nous allons créer des "accesseurs",
méthodes permettant d'y accéder.
Les getters
La convention veut que la méthode s'appelle "getPropriete" où "Propriete" est à remplacer par le
nom de la propriété concernée. Nous aurons donc "getSolde" et "getTitulaire" dans notre cas.
Les méthodes seront crées comme ceci

Nous pourrons donc accéder, par exemple, au titulaire du compte en écrivant

Les setters
Les "setters" permettent de définir la valeur des propriétés privées. Faire un "setter" permet, par
exemple, de s'assurer que la valeur stockée dans la propriété est cohérente avec ce qui est prévu.
La convention veut que la méthode s'appelle "setPropriete" où "Propriete" est à remplacer par le
nom de la propriété concernée. Nous aurons donc "setSolde" et "setTitulaire" dans notre cas.
Nous écrirons les "setters" de cette façon

Nous accéderons donc à notre "setter" de cette façon

7 PHP Avancé
  La méthode __toString
La question ayant été posée lors du live, voici une description de la méthode magique __toString.
Cette méthode permet de définir ce qui sera renvoyé par notre objet si quelqu'un essaie de l'afficher
au moyen d'un "echo" par exemple.
Nous retournerons une chaîne de caractères de notre choix de la façon suivante

8 PHP Avancé
 3- Héritages
Héritages
L'héritage en PHP permet de créer une nouvelle classe qui héritera des propriétés et des
méthodes d'une classe parent et qui pourra, si on le souhaite, redéfinir certaines propriétés et
méthodes.
Dans les diapositives précédentes, nous avons créé un objet "Compte" qui permet de créer un compte
bancaire.
Il existe cependant plusieurs types de comptes bancaires, certains offrent une possibilité de
découvert, d'autres permettent de toucher des intérêts.

Nous allons donc modifier notre objet "Compte" pour pouvoir gérer des "sous-objets" qui en
hériteront.
Pour éviter d'instancier notre classe "Compte", nous allons la passer en classe abstraite par le mot clé
"abstract".
Elle ne pourra donc plus être instanciée directement.

Une classe abstraite n’’est pas « instanciable » et ne pourra donc pas « fabriquer » d’objets.
la classe Compte sera abstraite.
Elle servira de classe modèle pour celles qui en hériteront
De plus, toutes les propriétés qui pourront être manipulées dans le "sous-objet" devront être en
visibilité "public" ou "protected". En effet, les propriétés en visibilité "private" ne sont pas
disponibles par héritage.

Nous allons créer deux classes qui hériteront de la classe "Compte". Elles s'appelleront
"CompteCourant" et "CompteEpargne" dans les fichiers du même nom.

9 PHP Avancé
Nous devrons, pour le moment, appeler chacun des fichiers avant de pouvoir les utiliser. Nous verrons
dans l'article suivant une méthode pour charger automatiquement tous les fichiers nécessaires.
Le compte courant
Focalisons-nous sur le compte courant.
C'est un compte bancaire dans lequel nous allons autoriser un découvert.
Son constructeur nécessitera au moins les informations du compte bancaire (titulaire et solde).
Le constructeur sera donc le suivant

Nous pourrons donc instancier un compte courant de cette façon

Etant donné que notre compte devra bénéficier d'un découvert, nous pourrons avoir un solde négatif
jusqu'au montant du découvert.
Nous devrons donc modifier la méthode "retirer" pour le "CompteCourant" spécifiquement.
Nous écrirons donc

SURCHARGER UNE METHODE

Appelé aussi « override ».
Lors d’un héritage, surcharger une méthode permet d’utilise une fonction existante de la classe mère
dans la classe fille tout en modifiant le comportement initialement prévu de celle-ci.
Enfin, la propriété "decouvert" étant privée, nous allons écrire ses accesseurs (Getter et Setter)

10 PHP Avancé
Le compte épargne
Pour le compte épargne, nous allons procéder de façon similaire afin de mettre en place le versement
des intérêts.
Nous aurons donc une propriété "taux_interets" qui correspondra au taux d'intérêts du compte et un
constructeur en conséquence. Nous allons choisir de rendre obligatoire la déclaration de ce taux
dans le constructeur.

Enfin, pour verser les intérêts, nous écrivons une méthode comme ceci

Sans oublier les accesseurs du taux d'intérêts

11 PHP Avancé
 4- Constantes de classe, attributs et méthodes statiques
Nous avons vu précédemment que les attributs et méthodes définis dans une classe appartiennent en
fait à l'objet qui sera l'instance de cette classe. On s'est donc servi de l'opérateur -> pour désigner un
membre à partir de l'objet créé.

Cependant, on peut spécifier les membres qui appartiennent à la classe et non à l'objet. On appelle ces
membres, attributs et méthodes statiques. Pour y accéder on se sert de l'opérateur de résolution
statique :: appelé simplement double deux points.
Membres statiques d'une classe: constantes de classe, attributs et méthodes statiques
 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.
Pour définir une constante on utilise le mot clé const suivi du nom de la constante à laquelle on affecte
la valeur souhaitée. Par convention l'identifiant de la constante est déclaré en majuscule.

La constante de classe peut être appelée de l'intérieur comme de l'extérieur de la classe grâce à
l'opérateur de résolution de portée ::

 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.
Pour spécifier si un membre est statique on déclare le mot clé static après la visibilité. Par exemple:

Vous avez remarqué que nous avons appelé lé méthode statique message() de l'extérieur de la classe, il
est dont évident de déclarer le nom de la classe (Voiture) avant l'opérateur de résolution de portée. En
revanche, l'attribut statique $roues a été appelé de l'intérieur de la classe. Là aussi on a mis le nom de
12 PHP Avancé
la classe avant l'opérateur de résolution de portée. Néanmoins, on aurait pu mettre le mot clé self qui
désigne la classe courante.
L'exemple précédent peut donc devenir:

Généralement, si on veut faire un appel statique (d'une constante, attribut ou méthode) à l'intérieur de
la classe, il est préférable de mettre le mot clé self au lieu du nom de 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 PHP Avancé
 5- Méthodes magiques
Les méthodes magiques sont des outils très pratiques pour simplifier le code et automatiser certaines
tâches.
Elles sont appelées automatiquement lorsque certaines actions sont effectuées et permettent d’évite
certaines erreurs.
__construct () : Constructeur de la classe ;
__destruct () : Destructeur de la classe ;
__set () : Déclenchée lors de l'accès en écriture à une propriété de l'objet ;
__get () : Déclenchée lors de l'accès en lecture à une propriété de l'objet ;
__call () : Déclenchée lors de l'appel d'une méthode inexistante de la classe (appel non statique) ;
__callstatic () : Déclenchée lors de l'appel d'une méthode inexistante de la classe (appel statique)
__isset () : Déclenchée si on applique isset () à une propriété de l'objet ;
__unset () : Déclenchée si on applique unset () à une propriété de l'objet ;
__sleep () : Exécutée si la fonction serialize () est appliquée à l'objet ;
__wakeup () : Exécutée si la fonction unserialize () est appliquée à l'objet ;
__toString () : Appelée lorsque l'on essaie d'afficher directement l'objet echo $Object;
__set_state () : Méthode statique lancée lorsque l'on applique la fonction var_export () à l'objet ;
__clone () : Appelé lorsque l'on essaie de cloner l'objet ;
__autoload () : Cette fonction n'est pas une méthode, elle est déclarée dans le scope global et permet
d'automatiser les "include/require" de classes PHP.

14 PHP Avancé
 6- Les classes et méthodes abstraites : définition et intérêt

Une classe abstraite est une classe qui ne peut pas être instanciée.
Elle est utilisée pour être héritée.
Une classe abstraite a au moins une opération abstraite. Mais elle peut aussi avoir des opérations
concrètes.

1- Voici quelques règles importantes sur les classes abstraites en PHP.

Lors de l’héritage d’une classe abstraite (B –> A), la méthode de la classe fille doit être définie avec le
même nom. Ainsi, si la méthode abstraite est définie comme « protected », la méthode de la classe
fille doit être définie comme « protected » ou « public », mais pas « private ». En plus, le type et le
nombre d’arguments requis doivent être les mêmes. Pourtant, les classes fille peuvent avoir des
arguments optionnels en plus.
2- Une classe abstraite ne peut pas contenir une méthode avec un corps. Si nous exécutons
l’exemple suivant, alors il affichera un message d’erreur.

15 PHP Avancé
 7- Gérer une DB avec PDO

Gérer une DB avec PDO

Il existe de très nombreux SGBD sur le marché et autant de méthodes spécifiques permettant de
manipuler et gérer les bases de données.
Heureusement est apparue avec la version 5.1 de PHP une extension désormais systématiquement
installée et bien pratique : PDO (PHP Data Object).
PDO nous permet de gérer pour nous la plupart des connecteurs possibles existant (IBM, Informix,
MySQL, ODBC et DB2, PostgreSQL, SQLite Oracle...).
De plus il a été écrit en C, ce qui le rend rapide et efficace.
Il est orienté objet, facilitant sa manipulation et son utilisabilité.
Il est facile de vérifier si PDO est installé sur un serveur et quels sont les connecteurs disponibles avec
respectivement les fonctions : phpinfo() et PDO::getAvailableDrivers().
1- Les étapes
Pour toute manipulation, 5 étapes sont à respecter :
- Connexion
- Sélection de la DB
- Requête
- Exploitation des résultats
- Déconnexion

Note : Lorsque le moteur PHP arrive à la fin de l'exécution du script, il ferme automatiquement les
éventuelles connexions, rendant la dernière étape optionnelle. Il peut cependant être judicieux de
fermer la connexion dès qu'elle n'est plus nécessaire afin d'économiser des ressources. (Tout ce qui
touche aux bases de données est en général extrêmement gourmand en terme de ressources pour le
serveur)
2- Connexion
Avant de travailler avec un serveur de gestion de base de données comme MySQL, il faut ouvrir une
connexion. C'est par elle que PHP et MySQL communiqueront.
Ouvrir une connexion se fait automatiquement lorsqu'on instancie un objet PDO, nécessaire à toutes
les manipulations à venir.
Syntaxe
mon_objet = new PDO (DSN, utilisateur, mot_de_passe)
DSN permet de décrire la base de donnée à laquelle nous allons nous connecter et son type.
Chaque SGBD a ses propres paramètres.
Nous ne verrons que le DSN MySQL.
utilisateur et mot_de_passe doivent être renseignés.

16 PHP Avancé
Exemple

Dans le DSN, on retrouve en premier le nom du ''pilote'' suivi de 2 points. (ici mysql:)
host Nom ou adresse IP de l'hôte (''localhost'' en local)
dbname Le nom de la base de donnée
port Le port TCP/IP (facultatif)
unix_socket Adresse du socket unix (facultatif)
Etant donné que nous allons certainement utiliser une connexion à notre DB sur plusieurs pages
différentes, 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.

Nous allons encore améliorer ce code en ajoutant une structure de test de type try / catch qui va nous
permettre de récupérer le code d'erreur si la connexion devait échouer.

17 PHP Avancé
Note : Nous avons rajouté die () en cas d'erreur pour arrêter
L’exécution du script et ne pas enchaîner sur l'éventuel code qui pourrait suivre.
3- Déconnexion
Pour se déconnecter, il suffit de détruire l'objet PDO que nous avons crée. Affecter la valeur null à cet
objet suffira.

Note : Ici 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.
4- Effectuer une requête
Une fois la connexion établie, nous allons pouvoir communiquer avec notre DB pour modifier, créer,
supprimer ou lire des données. Il n'y à pas de fonctions d'écriture/lecture comme avec les fichiers,
tout passe par le langage SQL.
4.1- Préparer sa requête
Avant d'envoyer notre requête il est préférable de la préparer et de la ''ranger'' dans une variable. Ce
n'est pas nécessaire mais fortement conseillé pour conserver une bonne segmentation/lisibilité de votre
code.
4.2- Envoyer sa requête
Il existe 2 fonctions permettant d'envoyer notre requête au serveur.
Si nous faisons une sélection et avons donc besoin de récupérer des données en retour, nous utiliserons
query (). Dans tous les autres cas, nous utiliserons exec ().
4.2.1- exec ()
Cette fonction nous renvoie quand même une information : le nombre de lignes qui ont été modifiées
suite à l'exécution de la requête.

18 PHP Avancé
Attention : Si aucune modification n'a été faite suite à la requête, le résultat renvoyé sera 0. Dans le
cas où la requête a générée une erreur, c'est false qui est renvoyé. Or avec un opérateur de
comparaison classique (==) ces 2 valeurs sont identiques !
Il nous faut donc utiliser l'opérateur de comparaison de type (===).
4.2.2- query ()
Pour toutes les requêtes renvoyant des données autres que le nombre d'enregistrements concernés,
nous allons utiliser query ().
Cette fonction ne renvoie pas directement les données prêtes à être affichées mais un sous objet PDO
qui dispose de 2 méthodes permettant de manipuler ces données.
 Méthode fetchAll () : Toutes les données sont rangées dans un tableau et le SGBD est libéré.
Avantage : nous avons toutes les données d'un coup et pouvons travailler dessus. Inconvénient
: toutes les données
sont présentes en mémoire.
 Méthode fetch () : Les résultats sont lus de manière séquentielle, un par un.
Avantage : parfait pour traiter des résultats très nombreux sans surcharger la mémoire.
Inconvénient : on ne peut pas faire d'autres requêtes pendant le traitement de ces résultats.

Notes : Si on souhaite manipuler que les noms des champs, on passera PDO::FETCH_ASSOC en
paramètre pour optimiser les requêtes. (PDO::FETCH_BOTH par défaut)

4.3- Sécuriser sa requête

Le SQL a ses propres caractères spéciaux et délimiteurs, rendant par là possible les mauvaises
interprétations ou, pire, les injections.
Il faudra donc éviter au possible d'insérer directement des données sans les avoir au préalable
vérifié/formaté.

Note : La fonction s'est chargée de remplacer les quottes.

5- Méthodes avancées
5.1- 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. Nous allons donc créer un "modèle", qui sera supprimé à la fermeture de la
connexion. Etapes de la préparation :
- Création de la requête et substitution des valeurs
19 PHP Avancé
- Lecture des données
- Exécution de la requête
- Exploitation des résultats
La première étape n'est pas répétée à chaque exécution, rendant cette méthode avantageuse si elles
sont nombreuses.
5.1.1 Valeurs passées dans un tableau
Remplacement des valeurs par des paramètres nommés. Ceux-ci doivent être précédés de 2 points (:)
Préparation de la requête

:
Exécution en associant des valeurs aux paramètres nommés

Cette méthode est un peu lourde, voyons les suivantes...

5.1.2 Valeurs définies par BindValue
Le principe est de lier une variable ou une valeur à un paramètre nommé sans passer par un tableau.
Les premières étapes ne changent pas.
Préparation de la requête

Association des valeurs avec bindValue

Exécution de la requête

20 PHP Avancé
5.1.3 Valeurs définies par BindParam
1- Une variante où les valeurs ne sont pas passées directement, mais au sein de variables.

2- Préparation de la requête

3- Association des valeurs avec bindParam

4- Exécution de la requête

Requête de sélection
Supposons maintenant que nous souhaitons afficher toutes ces lignes dans une pages Web. On va donc
procéder ainsi:
Tout d'abord on va préparer puis exécuter la requête de sélection:

On affiche toutes ces lignes

21 PHP Avancé
Requête de mise à jour

Requête de suppression

5.2- Transactions
Une transaction est un bloc d'instructions que l'on souhaite exécuter de manière unie. L'ensemble doit
être réalisé sans erreur sans quoi toutes
Les opérations sont annulée (notion d'atomicité) ce qui ne serait pas le cas si nous exécution
classiquement nos opérations, de manière séquentielle.
Etapes d'une transaction :
- Déclaration de début de transaction
- Ecriture de toutes les opérations souhaitées
- Exécution de la transaction

5.3- Gestion des erreurs

D'une base de données à une autre, la gestion des erreurs peut être inexistante comme extrêmement
poussée. PDO là encore va nous aider de manière transparente et nous permettre d'avoir des messages
d'erreurs unifiés. Il existe 3 modes de gestion des erreurs :
ERRMODE_SILENT Pas d'affichage des erreurs (par défaut)
ERRMODE_WARNING Mode d'erreur classique

22 PHP Avancé
ERRMODE_EXCEPTION Utilisation des exceptions
On utilise la méthode setAttribute () de notre objet PDO pour modifier le mode.
Exemple pour le mode ''exception'' :

Plutôt que de laisser les erreurs s'afficher ou non à l'écran, là encore il est préférable de gérer cela avec
une structure adaptée try / catch.
Modifions notre précédent exemple de transaction :

23 PHP Avancé
24 PHP Avancé
25 PHP Avancé
 8- CRUD en PHP

 Create (créer)
 Read ou Retrieve (lire)
 Update (mettre à jour)
 Delete ou Destroy (supprimer)

Etape 1
Création de la base de données : inscription
Et une table user dont la structure est la suivante :

 Id type Int auto incrémente

 username type varchar
 email de type varchar
 motpass de type varchar
 statut de type varchar

CREATE TABLE `instription`.`user` ( `id` INT NOT NULL AUTO_INCREMENT , `username`

VARCHAR(100) NOT NULL , `email` VARCHAR(100) NOT NULL , `motpass` VARCHAR(100) NOT
NULL , `statut` VARCHAR(50) NOT NULL , PRIMARY KEY (`id`)) ENGINE = MyISAM;

Etape 2
Création fichier de connexion à la base de données :
connexion.php

26 PHP Avancé
Etape 3
Ajouter des users dans la table user.
 ajout.php
 1er méthode :
On ajout directement dans la table user les données des différents champs.

 2eme méthode :
On va faire une requête préparée

27 PHP Avancé
  3eme méthode :
On va utiliser bindvalue

 4eme méthode :
On va utiliser bindParam

Etape 4
Supprimer des users de la table user.
 supprimer.php
Sélectionner un id qui existe dans la table user.

Etape 5
 Modifier.php
Modifier un user de la table user connaissant son id.

28 PHP Avancé
Etape 6
 Rechercher.php
Rechercher un user de la table user connaissant son id.

Etape 7
 Lister.php
Lister les users de la table user.

29 PHP Avancé
 9- Les interfaces en PHP
Une interface permet aux utilisateurs de créer des programmes, en spécifiant les méthodes publiques
qu’une classe doit implémenter, sans impliquer la complexité et les détails de l’implémentation des
méthodes. Une interface est définie comme une classe, mais avec le mot-clé interface. L’interface ne
contient pas de propriétés ou de variables comme le cas dans une classe.
Exemple: Création d’une interface
L’exemple suivant définit une interface à l’aide du mot-clé interface.

Quelques points importants à retenir sur les interfaces en PHP :

• Une interface est constituée de méthodes qui n’ont pas d’implémentations, ce qui signifie que
les méthodes d’interface sont des méthodes abstraites.
• Toutes les méthodes dans les interfaces doivent avoir une portée de visibilité public.
• Les interfaces sont différentes des classes car une classe peut hériter d’une seule classe alors
que la classe peut implémenter une ou plusieurs interfaces.
Pour implémenter une interface, utilisez le mot-clé implements comme suit :

Exemple complète:

Implémenter plusieurs interfaces

Une classe peut implémenter plusieurs interfaces, séparées par des virgules.

30 PHP Avancé
 10- Les traits en PHP
PHP ne supporte que l’héritage simple, c’est à dire, une classe fille ne peut hériter que d’une seul
classe mère. Donc, que faire si une classe a besoin d’hériter de plusieurs classes mères ? Les traits
résolvent ce problème.
Les traits sont utilisés pour déclarer les méthodes qui peuvent être utilisées dans plusieurs classes. Les
traits peuvent avoir des méthodes et des méthodes abstraites qui peuvent être utilisées dans plusieurs
classes, et les méthodes peuvent avoir n’importe quel modificateur d’accès (public, private, or
protected).
Les traits sont déclarés avec le mot-clé trait :

Pour utiliser un trait dans une classe, utilisez le mot-clé use :

Regardons un exemple :

Ici, nous déclarons un trait appelé « school ». Ensuite, nous créons une classe appelée « Person ». La
classe utilise le trait, et toutes les méthodes du trait seront disponibles dans la classe.
Si d’autres classes ont besoin d’utiliser la fonction learn(), utilisez simplement le trait « school » dans
ces classes. Cela réduit la duplication du code, car il n’est pas nécessaire de redéclarer la même
méthode encore et encore.
Utiliser plusieurs traits en PHP

Ici, nous avons déclaré deux traits appelés school et company. Ensuite, nous avons crée une classe
appelée « Person ». La classe utilise les deux traits school et company qui sont séparés par une virgule.

31 PHP Avancé
 11- Classe anonyme en PHP
Les classes anonymes sont des classes définies sans aucun nom. Elles ont été introduites dans PHP 7
pour permettre la création rapide des objets. Elles peuvent prendre des arguments via le constructeur,
hériter d’autres classes, implémenter des interfaces, et utiliser des traits comme dans une classe
normale.
En PHP 7, nous pouvons définir une classe anonyme en utilisant le mot-clé new class.
La syntaxe de base d’une classe anonyme est comme suite :

Nous utilisons le mot-clé « new », suivi du mot-clé « class », suivi des paramètres optionnels du
constructeur, et enfin le corps de la classe qui est entre des accolades. Les objets instanciés par une
classe anonyme ne sont pas différentes de celle des objets instanciés par une classe normale.
Exemple complète:

Comparées aux classes nommées, les classes anonymes sont à peu près pareils, Dans un sens où elles
peuvent passer des paramètres au constructeur, hériter d’autres classes, implémenter des interfaces et
utiliser des traits. Pourtant, les classes anonymes ne peuvent pas être sérialisées. Essayer de sérialiser
une instance d’une classe anonyme, PHP génère une erreur fatale « Serialization of class@anonymous
is not allowed… »
Les classes finales et les méthodes finales en PHP
Le mot-clé final est utilisé en PHP pour les méthodes et les classes. Le mot-clé final pour les
méthodes empêche la surcharge des méthodes, alors que le mot-clé final pour les classes empêche
l’héritage.
Méthode finale
On ne peut pas surcharger la méthode de la classe mère.

32 PHP Avancé
Dans l’exemple ci-dessus, la classe MathClass qui est la classe mère. Dans laquelle la méthode
calculer est marquée comme finale. Cela implique que nous ne pouvons pas surcharger la méthode
calculer dans aucune de ses classes filles. Pour identifier l’erreur, la classe fille School tente de définir
la méthode calculer(). Cela produira une erreur fatale, cela implique que la méthode finale de la classe
mère ne peut pas être définie dans sa classe fille.
Classe finale
Une classe fille ne peut pas hériter une classe mère déclarée final.

Dans l’exemple ci-dessus la classe A est définit avec le mot-clé final. Lorsque la classe B essaie
d’hériter la classe mère A, PHP lève un message d’erreur qui dit : « La classe B ne peut pas hériter de
la classe finale (A) », ce qui implique qu’il ne permet pas de créer une classe fille à partir de la classe
mère.

33 PHP Avancé
 12- Clonage d’objet en PHP
Les objets sont inconstants, ce qui signifie que l’objet a la capacité de changer l’état de l’information.
Dans la programmation PHP orientée objet POO, il peut arriver que vous ayez besoin de copies des
objets. Nous pouvons créer une copie d’un objet en utilisant l’opérateur « = », pourquoi utiliser le
clonage d’objet? Voici un exemple qui montre comment l’opérateur ‘=’ fonctionne pour créer des
copies d’un objet:
Commençons par créer une classe Personne simple.

Maintenant, nous pouvons créer des objets Personne:

Nous avons créé deux objets: $personne1 et $personne2. $personne1 et $personne2 sont des références
qui pointent vers différents objets « Personne ».

Que se passera-t-il si nous faisons comme ça:

$personne1 et $personne2 référençant le même objet. Pourtant, le destructeur de $personne2 est appelé
car l’objet indiqué par $personne2 n’est plus utilisé.

Comme nous l’avons vu, aucun objet réel n’a été créé lorsque nous avons affecté $personne1 à
$personne2, seule la référence a été modifiée. La manière dont nous avons copié l’objet est appelée
copie superficielle.

34 PHP Avancé
Pour effectuer une copie en profondeur entraînant la création d’un nouvel objet, nous utilisons
l’opérateur clone comme suit:

Lorsque nous exécutons l’instruction ci-dessus, la référence $personne2 pointe vers le nouvel objet
créé. En plus, lors de l’exécution, la méthode magique __clone() est invoquée automatiquement.
Nous pouvons ajouter la méthode magique __clone() à la classe Personne pour voir comment cela
fonctionne.

35 PHP Avancé
 13- Les sessions en PHP
Une session est un moyen de stocker des informations (dans des variables) à utiliser sur plusieurs
pages. Contrairement à un cookie, l’information n’est pas stockée sur l’ordinateur de l’utilisateur.
Qu’est-ce qu’une session en PHP ?
Une autre façon de rendre les données accessibles à travers les différentes pages d’un site web est
d’utiliser une Session PHP.
Une session crée un fichier dans un répertoire temporaire sur le serveur où les variables de session
enregistrées et leurs valeurs sont stockées. Ces données seront disponibles pour toutes les pages du site
pendant cette session.
Une session se termine lorsque l’utilisateur ferme le navigateur ou après avoir quitté le site, le serveur
mettra fin à la session après une période de temps prédéterminée, généralement une durée de 30
minutes.
Démarrer une session PHP
Avant de pouvoir enregistrer des informations dans les variables de session, vous devez d’abord
démarrer la session. Pour démarrer une nouvelle session, appelez simplement la fonction
session_start() de PHP. Elle va créer une nouvelle session et générer un identifiant de session unique
pour l’utilisateur.
Le code PHP suivant démarre simplement une nouvelle session.

La fonction session_start() vérifie d’abord si une session existe déjà en recherchant la présence d’un
ID de session. Si elle en trouve un, c’est à dire que la session est déjà démarrée, elle met en place les
variables de session et si ce n’est pas le cas, elle démarre une nouvelle session en créant un nouvel ID
de session.
Stockage et accès aux données de session
Vous pouvez stocker toutes vos données de session sous forme de paires clé-valeur dans le tableau
$_SESSION[]. Les données stockées sont accessibles pendant la durée de vie d’une session.
Considérons le script suivant, qui crée une nouvelle session et enregistre deux variables de session.

Pour accéder aux données de session que nous avons définies dans l’exemple ci-dessus depuis
n’importe quelle autre page, il suffit de recréer la session en appelant session_start() puis de passer la
clé correspondante au tableau associatif $_SESSION.

36 PHP Avancé
Détruire une session
Si vous souhaitez supprimer certaines données de session, il suffit d’indiquer la clé correspondante du
tableau associatif $_SESSION, comme indiqué dans l’exemple suivant :

Pour supprimer toutes les variables de session globales et détruire la session, utilisez session_unset()
et session_destroy() :

Chaque session PHP a une duré de vie, mesurée en secondes – qui détermine combien de temps une
session doit rester en vie en l’absence de toute activité de l’utilisateur. Vous pouvez ajuster cette durée
en changeant la valeur de la variable session.gc_maxlifetime dans le fichier de configuration
(php.ini).

37 PHP Avancé
 14 Les cookies en PHP
Un cookie est un petit fichier texte qui vous permet de stocker une petite quantité de données (près de
4Ko) sur l’ordinateur de l’utilisateur. Ils sont généralement utilisés pour garder une trace des
informations telles que le nom d’utilisateur que le site peut récupérer pour personnaliser la page lors
de la prochaine visite de l’utilisateur sur le site.
Créer un cookie en PHP
La fonction setcookie() est utilisée pour créer un cookie en PHP. Assurez-vous d’appeler la fonction
setcookie() avant toute sortie générée par votre script sinon le cookie ne sera pas crée. La syntaxe de
base de cette fonction est comme suite :
setcookie(name, value, [expire], [path], [domain], [secure]);
La fonction setcookie() nécessite six arguments :
• Name : Il est utilisé pour définir le nom du cookie.
• Value : Il est utilisé pour définir la valeur du cookie.
• Expire : Il est utilisé pour définir l’heure d’expiration du cookie au-delà le cookie n’est plus
accessible.
• Path : Il est utilisé pour spécifier le chemin sur le serveur pour lequel le cookie sera
disponible.
• Domain : Il est utilisé pour spécifier le domaine pour lequel le cookie est disponible.
• Security : Il est utilisé pour indiquer que le cookie ne doit être envoyé que si une connexion
HTTPS sécurisée existe.

Voici un exemple qui utilise la fonction setcookie() pour créer un cookie nommé « username » et lui
assigner la valeur « Jean Babtise ». Elle spécifie aussi que le cookie expirera après 2 jours (2 jours *
24 heures * 60 minutes * 60 secondes).
Remarque : Seul l’argument name de la fonction setcookie() est obligatoire. Pour ignorer un argument,
l’argument peut être remplacé par une chaîne vide("").

Accès aux valeurs des cookies

La variable superglobale $_COOKIE en PHP est utilisée pour récupérer la valeur d’un cookie. C’est
typiquement un tableau associatif qui contient une liste de toutes les valeurs de cookies envoyées par
le navigateur dans la requête courante, avec le nom du cookie comme clé. La valeur du cookie est
accessible en utilisant la notation standard des tableaux, par exemple pour afficher le cookie
« username » défini dans l’exemple précédent, vous pourriez utiliser le code suivant.

38 PHP Avancé
Il est recommandé de vérifier si un cookie est défini ou non avant d’accéder à sa valeur. Pour faire
cela, vous pouvez utiliser la fonction PHP isset(), comme ceci:

Suppression de cookies
Vous pouvez supprimer un cookie en appelant la même fonction setcookie() avec le nom du cookie et
n’importe quelle valeur (telle qu’une chaîne vide), mais cette fois, vous devez définir la date
d’expiration dans le passé, comme indiqué dans l’exemple ci-dessous:

39 PHP Avancé
 14- Gestion des exceptions en PHP
Une exception est une erreur logique/système survenue lors de l’exécution normale d’un script.
L’exception peut être levée par le système ou par le programme lui-même. Si l’exception ne peut pas
être gérée, la fonction appelante doit informer le système.
L’utilisation du bloc Try{…} Catch{…}
PHP5 introduit le bloc Try{…} Catch{…} pour intercepter les exceptions. Voir l’exemple ci-dessous.

Dans l’exemple ci-dessus, la méthode division() est appelée dans le bloc try{}. Le bloc try{} est la
zone dans laquelle vous mettez votre code susceptible de générer une exception. En dessous du bloc
try{} se trouve le bloc catch(){}. Le bloc catch attend un objet de type Exception en tant que
paramètre. Dans le bloc catch(){}, vous mettez votre logique pour résoudre le problème ou l’erreur.
Dans la fonction division(), nous soulevons une exception à l’aide du mot clé « throw ». L’instruction
qui suit « throw » est la syntaxe de création d’un nouvel objet de type Exception. La classe
« Exception » accepte deux paramètres. Le premier paramètre est le message d’erreur et le deuxième
paramètre est le code d’erreur que vous souhaitez affecter à cette erreur.

40 PHP Avancé
 15- Les filtres en PHP
Les filtres PHP sont utilisés pour « Nettoyer » ou « assainir » et valider les données provenant des
sources non sécurisées, comme les entrées des utilisateurs. Depuis PHP 5.2.0, les fonctions de filtrage
sont activées par défaut. Vous pouvez les utiliser directement dans votre code sans aucune installation
supplémentaire.
Pour valider les données en utilisant l’extension « filter », vous devez utiliser la fonction filter_var()
de PHP. La syntaxe de base de cette fonction est comme suite :
filter_var(variable, filter, options)
Cette fonction prend trois paramètres dont les deux derniers sont optionnels. Le premier paramètre est
la valeur à filtrer, le deuxième paramètre est l’ID du filtre à appliquer, et le troisième paramètre est le
tableau des options liées au filtre. Regardons comment cela fonctionne.
Nettoyer une chaîne
L’exemple suivant va nettoyer une chaîne de caractères en supprimant toutes les balises HTML de
celle-ci :

Validation de valeurs entières

L’exemple suivant permettra de valider si la valeur est un entier valide ou non.

Dans l’exemple ci-dessus, si la variable $nbr est définie à 0, le code affichera « 0 n’est pas un entier
valide ». Pour résoudre ce problème, vous devez tester explicitement la valeur 0, comme suit :

Valider les adresses IP

L’exemple suivant permettra de valider si la valeur est une adresse IP valide ou non.

41 PHP Avancé
Nettoyer et valider les adresses e-mails
L’exemple suivant vous montrera comment nettoyer et valider une adresse e-mail.
Nettoyer et valider les URL
L’exemple suivant vous montrera comment nettoyer et valider une url.

42 PHP Avancé
 Le MVC en PHP
Le MVC ? Qu'est-ce donc ?
Il s'agit d'abord d'un acronyme, qui signifie "Model View Controller", ou "Modèle Vue Contrôleur"
en français.
Il s'agit surtout de la structure que nous donnerons à notre projet pour séparer clairement ses
principaux composants.
En utilisant une structure MVC, nous allons séparer les accès à la base de données de notre code
HTML et de toute "l'intelligence" de l'application.
Les Modèles
Les modèles seront les éléments et classes qui se chargeront de tous les échanges avec la base de
données (CRUD). C'est le seul endroit de notre projet qui contiendra du SQL.
Les vues
Les vues contiendront uniquement le code HTML destiné à structurer les pages.
Les contrôleurs
Les contrôleurs, contiendront toute l'intelligence de l'application, le traitement des données en vue
de leur affichage, par exemple.
Le routeur
Dans la structure MVC, un seul et unique fichier est le point d'entrée de l'application, quelle que soit la
page affichée. Il est systématiquement appelé, et envoie la demande au bon contrôleur. Il est chargé de
trouver le bon chemin pour que l'utilisateur récupère la bonne page, d'où le nom de routeur.
Voici un schéma qui récapitule tout ceci.

Pour ce premier routeur, nous allons faire simple. Nous allons mettre le nom du contrôleur et la
méthode souhaitée en paramètres d'URL.
Les adresses seront donc formatées comme ceci

43 PHP Avancé
Cette structure d'URL permettra à notre routeur de savoir où diriger la demande.
Cependant, notre serveur ne contiendra pas les dossiers correspondants, il nous faudra utiliser une
technique de réécriture d'URL pour parvenir à nos fins.
Mais comment passer de l'une à l'autre.
En insérant ces deux lignes dans notre fichier .htaccess

Sur ces deux lignes, nous avons :

• RewriteEngine On : permet de démarrer la réécriture d'URL
• RewriteRule : permet de définir une règle de réécriture d'URL et fonctionne comme suit
• ^([a-zA-Z0-9\-\_\/]*)$ : il s'agit des différents caractères pris en compte dans l'URL
pour sa réécriture
• a-z : caractères minuscules
• A-Z : caractères majuscules
• 0-9 : chiffres
• \-\_\/ : tiret, underscore et / (caractère \ pour l'échappement)
• Tout ceci entre ^( pour le début de chaîne et )$ pour la fin de chaîne
• index.php?p=$1 : $1 contiendra le résultat de la réécriture notre chaîne

44 PHP Avancé
 1- On crée une classe model pour la connexion à la base de données :
Model.php
<?php
abstract Class Model
{
protected $bdd ;
//Connexion...............................................................
public function Connexion()
{
$pdo_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION;
$bdd = new PDO('mysql:host=localhost;dbname=inscription', 'root',
'',$pdo_options);
//$this->_connexion->exec('set names utf8');
return $bdd;
}
}

45 PHP Avancé
 2- On crée une classe Utilisateur :
Utilisateur.php

<?php
require_once 'model.php';
class Utilisateur extends Model
{
private $id;
private $username;
private $email;
private $motpass;
private $statut;

public function __construct(string $username,string $email,string

$motpass,string $statut){

$this->username= $username;
$this->email= $email;
$this->motpass= $motpass;
$this->statut= $statut;
}
public function getId()
{
return $this->id;
}
public function setId($id)
{
$this->id= $id;
}
public function getUsername()
{
return $this->username;
}
public function setUsername($username)
{
$this->username= $username;
}

public function getEmail()

{
return $this->email;
}
public function setEmail($email)
{
$this->email= $email;
}

public function getMotpass()

{

46 PHP Avancé
 return $this->motpass;
}
public function setMotpass($motpass)
{
$this->motpass= $motpass;
}

public function getstatut()

{
return $this->statut;
}
public function setstatut($statut)
{
$this->statut= $statut;
}
}
?>

3- On crée une classe UtilisateurManager :

UtilisateurManager.php

<?php
require_once 'utilisateur.php';
Class UtilisateurManager extends Utilisateur
{
public function AjoutUtilisateur(Utilisateur $utilisateur)
{
try {
$bdd = $this->Connexion();
$req = $bdd->prepare("INSERT INTO user
(username,email,motpass,statut) VALUES (:username,:email,:motpass,:statut)");
var_dump($req);
$req->execute(
array(
':username' => $utilisateur->getUsername(),
':email' => $utilisateur->getEmail(),
':motpass' => md5($utilisateur->getMotpass()),
':statut' => $utilisateur->getstatut(),
)
);
$req->closeCursor();
} catch (Exception $e) {
die('Erreur : ' . $e->getMessage());
}
}

public function RechercheUtilisateur($id){

try
{

47 PHP Avancé
 $bd = $this->Connexion();
$sql = $bd->prepare("SELECT * from user WHERE (id = ?)");
$sql->execute(array($id));
$user = $sql->fetch();
$sql->closeCursor();
return $user;
}catch(Exception $e)
{
die('Erreur : '.$e->getMessage());
}
}

public function SupprimerUtilisateur($id){

try {
$bdd = $this->Connexion();
$req = $bdd->prepare('DELETE FROM user WHERE id = ? ');
$req->execute(array($id));
$req->closeCursor();
} catch (Exception $e) {
die('Erreur : ' . $e->getMessage());
}
}

public function ModiferUtilisateur($utilisateur){

try {
$bdd = $this->Connexion();
$req = $bdd->prepare('UPDATE user SET username = :username,email =
:email,motpass = :motpass,statut = :statut WHERE id = :id');
$req->execute(array(
':id' => $utilisateur->getId(),
':username' => $utilisateur->getUsername(),
':email' => $utilisateur->getEmail(),
':motpass' => md5($utilisateur->getMotpass()),
':statut' => $utilisateur->getStatut()
));
$req->closeCursor();
} catch (Exception $e) {
die('Erreur : ' . $e->getMessage());
}
}

public function ListeUtilisateur(){

try {

$bdd = $this->Connexion();
$req = $bdd->query('SELECT * FROM user');
return $req;
} catch (Exception $e) {
die('Erreur : ' . $e->getMessage());
}

48 PHP Avancé
 }
}
?>

4- On crée un Controller

Controller.php

<?php
abstract class Controller
{
function render($path,$variables=array()){
extract($variables);

var_dump($path);
//die('ff');
require(ROOT.'/View/'.$path.'.php');
}
function redirect ($url){
//echo ($url);
//die('url');

header("Location: $url");
exit();
}
}

5- On crée un ControllerUtilisateur

ControllerUtilisateur.php

<?php
include_once(ROOT.'/Controller/Controller.php');
require_once(ROOT.'/Model/Utilisateur.php');
require_once(ROOT.'/Model/UtilisateurManager.php');
Class ControllerUtilisateur extends Controller
{
public function index()
{
echo'index con';

$user =new Utilisateur('','','','','');

$usermanager=new UtilisateurManager('','','','','');

$users=$usermanager->ListeUtilisateur();
var_dump($users);
//die('index');
$this->render('Utilisateur/index',compact('users'));
}

49 PHP Avancé
 public function valider()
{
echo ('valider');
die('hhhh');
}
public function ajout(){

$this->render('Utilisateur/ajout');
}
}

6- On crée une template

Layout.php

<!DOCTYPE html>
<html>

<head>
<meta charset="UTF-8">
<title><?php echo $titre ?></title>
<link rel="stylesheet"
href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css
" integrity="sha384-
Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh"
crossorigin="anonymous">

</head>

<body>
<nav class="navbar navbar-expand-lg navbar-dark bg-primary">
<a class="navbar-brand" href="#">Gestion utilisateur</a>
<button class="navbar-toggler" type="button" data-toggle="collapse"
data-target="#navbarColor01" aria-controls="navbarColor01" aria-
expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>

<div class="collapse navbar-collapse" id="navbarColor01">

<ul class="navbar-nav mr-auto">
<li class="nav-item ">
<a class="nav-link"
href="../ControllerEcriture/maj">Utilisateur <span class="sr-
only">(current)</span></a>
</li>

</ul>

</div>
</nav>
<div class="container">

50 PHP Avancé
 <?php echo $content ?>
</div>

<script src="https://code.jquery.com/jquery-3.2.1.slim.min.js"
integrity="sha384-
KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
crossorigin="anonymous"></script>
<script
src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js
" integrity="sha384-
ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
crossorigin="anonymous"></script>
<script
src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js"
integrity="sha384-
JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
crossorigin="anonymous"></script>

</body>

</html>
7- On crée le routeur
Index.php
<?php
ob_start();
?>
<h1>Liste Utilisateurs</h1>

<table class="table">

<thead>
<tr>
<th>Username</th>
<th>Email</th>
<th>Mot passe</th>
<th>Statut</th>
</tr>
</thead>
<tbody>
<?php while ($user = $users->fetch()) {
?>
<tr>
<td><?php echo $user['username']?></td>
<td><?php echo $user['email']?></td>
<td><?php echo $user['motpass']?></td>
<td><?php echo $user['statut']?></td>
</tr>
<?php
}
?>
</tbody>

51 PHP Avancé
 </table>
<?php
$content = ob_get_clean();
require_once ROOT .'/View/layout.php';
?>

8- Les vues

Ajout.php
<?php
ob_start();
?>
<form method="post" action="../ControllerUtilisateur/valider">
<div class="form-group">
<label for="username">Username</label>
<input type="text" class="form-control"
name="username" id="username" placeholder="username">
</div>
<div class="form-group">
<label for="email">Email address</label>
<input type="email" class="form-control" name="email"
id="email" placeholder="name@example.com">
</div>
<div class="form-group">
<label for="motpass">Mot de passe</label>
<input type="password" class="form-control"
name="motpass" id="motpass">
</div>
<div class="form-group">
<label for="statut">Statut</label>
<select class="form-control" name="statut"
id="statut">
<option
value="Administrateur">Administrateur</option>
<option value="Utilisateur">Utilisateur</option>
</select>
</div>
<input type="submit" name="Enregistrer"
value="Enregistrer">
<input type="reset" name="Annuler" value="Annuler">
</form>

<?php
$content = ob_get_clean();
require_once ROOT .'/View/layout.php';
?>

.htaccess
RewriteEngine On

52 PHP Avancé
RewriteRule ^([a-zA-Z0-9\-\_\/]*)$ index.php?p=$1

Index.php

<?php
var_dump($_GET);
echo $_SERVER['SCRIPT_FILENAME'];

// on génère une constante qui contiendera le chemin vers index.php

define('ROOT',str_replace('index.php','',$_SERVER['SCRIPT_FILENAME']));
var_dump(ROOT);

require_once(ROOT.'Model/Model.php');
require_once(ROOT.'Controller/Controller.php');
echo ROOT.'root <br>';

//on sépare les paramétres de url

$params = explode('/', $_GET['p']);

var_dump($params);
//die('test');
//est ce que un parametre existe

if ( $params[0] != ""){
$controller = ucfirst($params[0]);
$action = isset($params[1]) ? $params[1] : 'index';
echo $controller.'<br>';
echo $action.'<br>';

//echo ROOT.'controles/'.trim($controller).'.php';

require_once(ROOT.'Controller/'.trim($controller).'.php');

$controller= new $controller();

var_dump($controller);

if (method_exists($controller,$action)){
unset($params[0]);
unset($params[1]);
var_dump($params);

call_user_func_array([$controller,$action], $params);
die('test');

53 PHP Avancé
 //$controller->$action();
}
else
{
http_response_code(404);
echo "La page demandée n'existe pas";
}
}
else{
echo 'index else';
}

54 PHP Avancé