2024 / 2025

Programmation Web II

CODE UE : IGL235
MODULE : Programmation III
CREDITS : 02
CIBLES : GL 2 / GSI 2 / IWD 2

M. Marc TEJIOGNI
Email : mtejiogni@[Link]
Tél : 693 90 91 21 / 682 66 37 31
 Programmation Web II 2024 / 2025

PLAN DU COURS
OBJECTIF GENERAL ........................................................................................................................ 6
OBJECTIFS SPECIFIQUES ............................................................................................................... 6
CHAPITRE I : NOTIONS DE BASE EN PHP ................................................................................... 7
Objectif du chapitre.......................................................................................................................... 7
Objectifs spécifiques ........................................................................................................................ 7
I. Définition et principe de fonctionnement ..................................................................................... 7
II.1. Qu’est-ce que PHP ?............................................................................................................. 7
II.2. Script CGI............................................................................................................................. 7
II.3. Principe du modèle Client / Serveur..................................................................................... 9
III. Environnement de Développement Intégré (EDI) ................................................................... 10
IV. Quelques règles à respecter...................................................................................................... 10
V. Ecrire du code PHP ................................................................................................................... 10
VI. Quelques instructions usuelles en PHP .................................................................................... 11
VII. Notions de base....................................................................................................................... 12
VII.1. Les variables .................................................................................................................... 12
VII.1.1. Définition.................................................................................................................. 12
VII.1.2. Déclaration et initialisation d'une variable ............................................................... 12
VII.1.3. Les types de données ................................................................................................ 13
VII.1.4. Déterminer le type de variable ................................................................................. 15
VII.1.5. Tester le type de variable avec gettype..................................................................... 16
VII.2. Les constantes.................................................................................................................. 16
VII.2.1. Définition.................................................................................................................. 16
VII.2.2. Initialiser et afficher une constante........................................................................... 16
VII.2.3. Constantes prédéfinies .............................................................................................. 17
VII.3. Mise en forme de PHP avec HTML et CSS .................................................................... 18
VII.3.1. Définition.................................................................................................................. 18
VII.3.2. La concaténation....................................................................................................... 18
VII.4. Les fonctions en PHP ...................................................................................................... 19
VII.4.1. Fonctions mathématiques en PHP ............................................................................ 19
VII.4.2. Fonctions de date en PHP ......................................................................................... 20
VII.4.3. Fonctions sur les chaînes de caractères .................................................................... 23
VII.4.4. Autres fonctions pratiques en PHP ........................................................................... 24
VII.4.5. Fonctions personnalisées en PHP ............................................................................. 25
VII.5. Les structures conditionnelles ......................................................................................... 26
2 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

VII.5.1. if else ........................................................................................................................ 26

VII.5.2. if elseif else ............................................................................................................... 26
VII.5.3. switch........................................................................................................................ 26
VII.5.4. Les opérateurs de comparaison ................................................................................ 27
VII.5.5. Les opérateurs logiques ............................................................................................ 27
VII.5.6. Quelques fonctions utiles ......................................................................................... 27
VII.6. Les boucles ...................................................................................................................... 28
VII.6.1. Boucle « for » ........................................................................................................... 28
VII.6.2. Boucle « while » ....................................................................................................... 29
VII.6.3. Boucle « do.. while » ................................................................................................ 29
Tests de connaissances ................................................................................................................... 30
CHAPITRE II : TECHNIQUES AVANCEES EN PHP ................................................................... 31
Objectif du chapitre........................................................................................................................ 31
Objectifs spécifiques ...................................................................................................................... 31
I. Les tableaux ................................................................................................................................ 31
I.1. Les tableaux à indices numériques ...................................................................................... 32
I.2. Les tableaux associatifs ....................................................................................................... 32
I.3. Tableau multi-dimensionnelle indicé .................................................................................. 33
I.4. Boucle foreach ..................................................................................................................... 33
I.5. Trier un tableau .................................................................................................................... 34
II. Les variables superglobales ....................................................................................................... 35
II.1. Envoyer des variables dans l'url avec GET ........................................................................ 35
II.2. Envoyer des données via un formulaire avec POST .......................................................... 37
II.3. Les variables de serveur : $_SERVER ............................................................................... 37
II.4. Les sessions ........................................................................................................................ 39
II.5. Les cookies ......................................................................................................................... 41
III. Manipulation des fichiers ......................................................................................................... 43
III.1. Ouvrir et fermer un fichier ................................................................................................ 43
III.2. Afficher le contenu d'un fichier dans un navigateur ......................................................... 44
III.3. Extraire une chaîne de caractère dans un fichier............................................................... 45
III.4. Ecrire dans un fichier ........................................................................................................ 46
III.5. Vérifier l'existence d'un fichier ......................................................................................... 47
III.6. Copier et coller des fichiers .............................................................................................. 47
III.7. Renommer un fichier ........................................................................................................ 48
III.8. Supprimer un fichier ......................................................................................................... 48
Tests de connaissances ................................................................................................................... 49
CHAPITRE III : PROGRAMMATION ORIENTE OBJET (POO) EN PHP ................................... 50

3 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Objectif du chapitre........................................................................................................................ 50
Objectifs spécifiques ...................................................................................................................... 50
I. Introduction à la POO ................................................................................................................. 50
I.1. Définitions ........................................................................................................................... 50
I.1.1. Les Objets ..................................................................................................................... 50
I.1.2. Les classes .................................................................................................................... 51
I.1.3. Les instances ................................................................................................................. 51
I.2. Exemple de création d’une classe ........................................................................................ 52
I.3. Le principe d'encapsulation ................................................................................................. 52
I.4. Exemple pratique : création d’une classe ............................................................................ 53
I.4.1. Syntaxe de base............................................................................................................. 53
I.4.2. Visibilité d'un attribut ou d'une méthode ...................................................................... 53
I.4.3. Création d'attributs ........................................................................................................ 54
I.4.4. Création des méthodes .................................................................................................. 54
II. Comment utiliser une classe en POO ? ..................................................................................... 55
II.1. Créer et manipuler un objet ................................................................................................ 56
II.1.1. Créer un objet .............................................................................................................. 56
II.1.2. Appeler les méthodes de l'objet ................................................................................... 56
II.1.3. Accéder à un élément depuis la classe ........................................................................ 57
II.1.4. Autres méthodes .......................................................................................................... 58
II.2. Les accesseurs et mutateurs ................................................................................................ 59
II.2.1. Accéder à un attribut : l'accesseur ............................................................................... 59
II.2.2. Modifier la valeur d'un attribut : les mutateurs ........................................................... 60
II.3. Le constructeur ................................................................................................................... 62
II.4. L'auto-chargement de classes ............................................................................................. 63
III. Les exceptions .......................................................................................................................... 66
III.1. Gestion des exceptions ...................................................................................................... 66
III.2. Des exceptions spécialisées .............................................................................................. 68
III.3. Convertir une erreur en exception ..................................................................................... 70
Tests de connaissances ................................................................................................................... 71
CHAPITRE IV : PHP ET MYSQL ................................................................................................... 72
Objectif du chapitre........................................................................................................................ 72
Objectifs spécifiques ...................................................................................................................... 72
I. Système de Gestion de Base de Données (SGBD) ..................................................................... 72
II. L’objet PDO (PHP Data Object) ............................................................................................... 73
III. Utilisation de l'objet PDO ........................................................................................................ 73
III.1. Chaîne de connexion (Instance PDO) ............................................................................... 74

4 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.2. Gestion d'erreurs éventuelles lors de l'instanciation d’un objet PDO ............................... 75
III.3. Préparation et exécution des requêtes (Requêtes préparées) ............................................ 77
III.4. Les requêtes de sélections ................................................................................................. 79
Tests de connaissances ................................................................................................................... 80

5 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

OBJECTIF GENERAL

Le cours de Programmation Web vise à donner à l’apprenant des outils et techniques lui permettant
de mettre sur pied un site web ou une application web complète.

OBJECTIFS SPECIFIQUES

 Les bases du langage PHP ;

 PHP et la Programmation Orienté Objet (POO)
 PHP et les bases de données (MySQL)
 Hébergement en ligne de sites web ou applications web.

6 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

CHAPITRE I : NOTIONS DE BASE EN PHP

Objectif du chapitre
Présenter de quelques éléments de base associés au langage PHP.

Objectifs spécifiques
 Connaître le principe de fonctionnement du PHP;
 Mise en place du PHP dans une page Web
 Quelques instructions usuelles en PHP
 Maîtrisez les outils nécessaires à la mise en place d’un projet en PHP : WampServer, ….
 Manipulation des variables et les constantes
 Définition des opérations possibles sur les variables et constantes
 Les structures conditionnelles et itératives
 Les fonctions

I. Définition et principe de fonctionnement

II.1. Qu’est-ce que PHP ?
PHP (acronyme récursif pour PHP Hypertext Preprocessor ou Personal Home Page), est un
langage de scripts libre principalement utilisé pour produire des pages web dynamiques via un
serveur HTTP, mais pouvant également fonctionner comme n'importe quel langage interprété de
façon locale, en exécutant les programmes en ligne de commande. PHP est un langage impératif
disposant depuis la version 5 de fonctionnalités de modèle objet complètes. En raison de la richesse
de sa bibliothèque, on désigne parfois PHP comme une plate-forme plus qu'un simple langage.

Inventé par Rasmus Lerdorf, il trouvait le CGI (Common Gateway Interface) trop long, c'est
pour ça qu'il a développé PHP, il a publié la première version en 1993 et 1995 selon les sites.

II.2. Script CGI

Un script CGI (Common Gateway Interface, traduit en interface de passerelle commune) est un
programme exécuté par le serveur web (on dit généralement « côté serveur »), permettant d'envoyer
au navigateur de l'internaute un code HTML créé automatiquement par le serveur (basé par exemple
sur une autre application, telle qu'un système de gestion de base de données, d'où le nom de
passerelle).
7 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

Un des principaux intérêts de l'utilisation de CGI est la possibilité de fournir des pages dynamiques,
c'est-à-dire des pages personnalisées selon un choix ou une saisie de l'utilisateur. L'application la
plus fréquente de cette technique repose sur l'utilisation de formulaires HTML permettant à
l'utilisateur de choisir ou de saisir des données, puis de cliquer sur un bouton de soumission du
formulaire, envoyant alors les données du formulaire en paramètre du script CGI.

Langage de programmation des CGI

Un programme CGI peut être écrit dans à peu près n'importe quel langage de programmation
pourvu que celui-ci soit :
 Capable de lire le flux de données d'entrée ;
 Capable de traiter des chaînes de caractères ;
 Capable d'écrire sur le flux standard de sortie ;
 Exécutable ou interprétable par le serveur web.

Les langages de programmation les plus utilisés pour l'écriture des CGI sont les suivants :
 Le langage Perl, particulièrement adapté à la manipulation de chaînes de caractères ;
 Les langages C et C++ ;
 Le langage Java.

Principe de fonctionnement des CGI

Lorsqu'une requête est envoyée au serveur, celui-ci examine l'extension du fichier demandé afin de
déterminer l'action qu'il va effectuer. Ainsi, par exemple :
 Dans le cas d'un fichier HTML (extension .htm ou .html) : le serveur va générer des en-
têtes de réponse HTTP qu'il va envoyer au navigateur demandant un fichier, puis envoyer le
fichier HTML.
 Dans le cas d'un fichier CGI écrit en Perl (extension .pl) : le serveur va exécuter
l'interpréteur Perl, celui-ci va interpréter le code contenu dans le fichier portant l'extension
.pl, puis envoyer les données au serveur, qui va les envoyer au navigateur, comme dans le
cas d'un fichier HTML
 Dans le cas d'un fichier CGI écrit en langage C (extension .exe sous Windows) : le
serveur va exécuter le CGI, puis envoyer vers le navigateur les données que le programme
lui aura transmis.

Ainsi, le rôle d'un script CGI est de recevoir des données envoyées par le serveur, de les traiter, puis
de renvoyer des en-têtes de réponses et des tags HTML valides. En effet, lorsqu'un programme CGI
renvoie un fichier, il doit commencer par envoyer un en-tête HTTP permettant de préciser le type de
contenu envoyé au navigateur (appelé type MIME), c'est-à-dire :
 Dans le cas d'un fichier html, la chaîne suivante :
content-type : text/html

8 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

 Dans le cas d'un fichier gif (pour faire de la création dynamique d'images par exemple,
comme dans le cas d'histogrammes ou de diagrammes divers), la chaîne suivante :
content-type : image/gif
 Dans le cas d'un fichier quicktime, la chaîne suivante :
content-type : text/quicktime

II.3. Principe du modèle Client / Serveur

Le Langage PHP est basé sur le principe du modèle Client / Serveur.

L'environnement Client / Serveur désigne un mode de communication organisé par l'intermédiaire

d'un réseau et d'une interface Web entre plusieurs ordinateurs.

Cela signifie que des machines clientes (machines faisant partie du réseau) contactent un serveur,
(une machine généralement très puissante en termes de capacités d'entrées-sorties) qui leur fournit
des services. Lesquels services sont exploités par des programmes, appelés programmes clients,
s'exécutant sur les machines clientes.

De nombreux langages de programmation fonctionnent selon l’environnement Client / Serveur :

notamment le PHP.

9 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III. Environnement de Développement Intégré (EDI)

Pour éditer notre code, l'interpréter et visualiser le résultat, nous aurons besoin :
 Un éditeur de code PHP (Notepad++, Sublime Text, Brackets, Netbeans ...)
 Un serveur web qui gère PHP et MySQL, ou un serveur d'évaluation ( tel que WampServer,
XAMP ou EasyPHP)
 Différents navigateurs pour tester le rendu de nos pages (Firefox, Chrome, Internet explorer,
safari ...)

IV. Quelques règles à respecter

Pour chacun de vos projets PHP en local, il faudra créer un dossier à la racine du répertoire de votre
serveur Web.

Exemple :

« C:\wamp\www\tpweb » contenu dans WampServer sous Windows où « C:\wamp\www\ » est le

répertoire racine et « tpweb » le dossier crée.

Pour afficher le rendu de la page dans un navigateur, il faudra consulter lien URL de page.

Exemple :

[Link]

NB : Le nom de votre répertoire ne doit pas contenir d'espaces ni de caractères spéciaux.

V. Ecrire du code PHP

Pour que vos fichiers en PHP soient interprétés, il faut leur ajouter l'extension ".php".

Exemple :

« [Link] »

Pour indiquer que vous écrivez du code PHP, vous devez ajouter ces 2 balises :

<?php

?>

10 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VI. Quelques instructions usuelles en PHP

Afficher les informations sur la configuration de PHP

« phpinfo() » permet d'afficher les informations sur la configuration de PHP.

<?php
phpinfo();
?>

Afficher du texte avec « echo »

L'instruction « echo » permet d'afficher un élément.

<?php
echo "Bonjour";
?>

Les commentaires

Les commentaires permettent de vous repérer dans votre code PHP, vous pouvez l'écrire
différemment selon le cas, regarder l'exemple ci-dessous :

<?php
// Commentaire sur 1 ligne

/*
Commentaires sur plusieurs lignes
*/
?>

Les caractères d'échappement

Le caractère antislash (\) a de nombreuses utilisations. En premier lieu, s'il est suivi d'un caractère
non alphanumérique, il ne prendra pas la signification spéciale qui y est rattachée. Cette utilisation
de l'antislash comme caractère de protection s'applique à l'intérieur et à l'extérieur des classes de
caractères.

<?php
// Placer le caractére d'échappement devant le caracrtére guillemet
echo " Bonjour, \"<b>Jean</b>\", nous te souhaitons une bonne journee ";

// Autre exemple
echo "<img src=\"images/[Link]\" width=\"100\" height=\"40\" alt=\"Photo\" />";
?>

11 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Les séquences d'échappement, quant à elles, font de la mise en page

Séquence Effet
\t Insère une tabulation
\r Effectue un retour chariot
\n Effectue un retour à la ligne

Si vos séquences d'échappement ne fonctionnent pas, encadrez votre code des balises HTML <pre>
et </pre>.

VII. Notions de base

VII.1. Les variables
VII.1.1. Définition
Une variable est une petite information stockée en mémoire temporairement. Ca n'a pas une grande
durée de vie. En PHP, la variable (l'information) existe tant que la page est en cours de génération.

Dés que la page PHP est générée, toutes les variables sont supprimées de la mémoire car elles ne
servent plus à rien.

Ce n'est donc pas un fichier qui reste stocké sur le disque dur mais une petite information
temporaire.

VII.1.2. Déclaration et initialisation d'une variable

En PHP, les variables sont représentées par un signe dollar "$" suivi du nom de la variable. Le
nom est sensible à la casse.

Une variable est toujours constituée de 2 choses :

 Son nom : pour pouvoir la reconnaître, vous devez donner un nom à votre variable précédé
du caractère "$". Exemple : $Prenom
 Sa valeur : c'est l'information qu'elle contient, qui peut changer. Exemple : "toto".

12 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

L'affectation se fait toujours de la droite vers la gauche.

<?php
$Prenom="toto"; // La variable $Prenom a comme valeur "toto"

$a=$a+$b; // La variable $a à la valeur de la somme de $a + $b

$a-=$b; // La variable $a à la valeur de $b
?>

NB : Donner un nom évocateur à vos variables, les noms exotiques seront sources de perte de temps
si vous êtes amener à redévelopper ce script ultérieurement.

La syntaxe correcte pour nommer des variables

Erreur Correct Explication

Variable $variable Une variable doit commencer par $
$Variable 1 $Variable1 Les espaces sont interdits
$variable-suite $variable_suite Le tiret est interdit
$-variable $_variable Le tiret est interdit
$2-variable $variable2 Il ne peut y avoir de chiffre aprés le $

VII.1.3. Les types de données

Une variable peut contenir différents types de données.

Chaînes de caractère

Une chaîne (ou séquence) de caractéres doit être encadrée de guillemets :

 Simples (' ') si elle ne contient rien qui nécessite d'être échappé
 Doubles (" ") si l'on veut que les séquences d'échappement et les variables qu'elle contient
soient interprétées (on parle de "substitution de variables") :

<?php>
// Type string, permet d'afficher un texte, ne pas oublier les '' ou ""
$Prenom="toto";
$Prenom='toto';
?>

Entiers

Un entier (integer, ou int) est un nombre de l'ensemble des entiers naturels {..., -2, -1, 0, 1, 2, ...}.
On peut l'exprimer de trois manières :

13 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php
$a = 1234; // nombre entier en base décimale
$a = 02322; // le même en base octale, préfixé 0
$a = 0x4D2; // le même en base hexadécimale, préfixé 0x

$Valeur=123;
$Valeur1=1000/$Valeur;
$Valeur4=$Valeur+$Valeur1;

@$b = 10/0; // En cas d'erreur, le @ permet de ne pas afficher de message d'erreur

echo @$b;
?>

Les opérateurs arithmétiques

Signe Exemple Description

+ (addition) $a + $b additionne $a et $b
- (soustraction) $a - $b soustrait $b de $a
* (multiplication) $a * $b multiplie $a par $b
/ (division) $a / $b divise $a par $b
% (modulo) $a % $b reste de la division de $a par $b

Incrémentation décrémentation

Signe Exemple Description

++ $i ++ Ajoute 1 à $i
-- $i -- soustrait 1 à $i

<?php
$a = $a+1 ; // identique à la ligne ci dessous
$a ++ ; // Permet d'incrémenter
$a -- ; // Permet de décrémenter
?>

Réels

Un nombre réel (float, ou double), appelé aussi "à virgule flottante", peut être exprimé de deux
manières :

<?php
$a = 1.234;
$a = 1.2e3; // Notation scientifique
?>

NB : En PHP, Il faut mettre un point et non une virgule pour les décimales.

14 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Boolean

Permet d’exprimer si quelque chose est vrai (true en anglais), ou si c'est faux (false en anglais)
 Affiche 1 pour true
 N'affiche rien pour false

<?php
$Homme=true; // Boolean, TRUE
$Femme=false; // Boolean, TRUE
echo $Homme; // Affiche 1 "Vrai", la condition est respectée

$a = ($b<100) ; // Le résultat est 1 "Vrai"

echo $a;
?>

VII.1.4. Déterminer le type de variable

Fonction retourne TRUE si la variable est :
is_array() un tableau
is_bool() de type booléen
is_double() un nombre réel, ou à virgule flottante
alias de is_float()
et de is_real()
is_int() un nombre entier
alias de is_long()
is_null() sans valeur
is_numeric() un nombre, ou une chaîne numérique
is_object() un objet
is_resource() une ressource PHP (pointeur, requête SQL...)
is_scalar() une variable scalaire
is_string() une chaîne de caractère

<?php
$var=10;
echo is_int($var); // Affiche 1, la variable $var est un entier
?>

15 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VII.1.5. Tester le type de variable avec gettype

gettype permet de tester le type de variable, il ressort (string, int ...)

<?php
$Prenom="toto"; // Variable string
$Valeur=123; // Variable integer
// Affiche le type de la variable
echo gettype($Prenom);
echo "<br />";
echo gettype($Valeur);
?>

VII.2. Les constantes

VII.2.1. Définition
Seuls les types de données scalaires peuvent être placés dans une constante : c'est à dire les types
booléen, entier, double et chaîne de caractères (soit bool, int, double et string.)

Contrairement à une variable, une constante ne peut pas être redéclarée.

Pour définir des constantes, on utilise la fonction define().

Par convention, un nom de constante s'écrit en majuscule.

Vous pouvez accéder à la valeur d'une constante en spécifiant simplement son nom. Contrairement
aux variables, vous ne devez PAS préfixer le nom de la constante avec $.

NB : Ne pas entourer de ' ' ou " " le nom de la constante, sinon elle s'affichera comme du texte.

VII.2.2. Initialiser et afficher une constante

<?php
define('CONSTANTE', 'toto');
// Affichage d'une constante, ne pas mettre de $
echo CONSTANTE;
?>

16 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VII.2.3. Constantes prédéfinies

Il existe beaucoup de constantes prédéfinies, en voici quelques unes
 __FILE__ (__ représente ici double underscore)
 __LINE__ (__ représente ici double underscore)
 PHP_VERSION
 PHP_OS

__FILE__

C’est le chemin complet de la page en cours.

<?php
echo __FILE__;
?>

__LINE__

Retourne le numéro de la ligne de la constante.

<?php
echo "la ligne " . __LINE__ . " ne contient aucune erreur ;-)";
?>

PHP_VERSION

Affiche la version de l'analyseur PHP

<?php
echo "la version de l'analyseur PHP est la : " . PHP_VERSION;
?>

PHP_OS

Affiche le système d'exploitation du serveur

<?php
echo "le systéme d'exploitation du serveur est : " . PHP_OS;
?>

17 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VII.3. Mise en forme de PHP avec HTML et CSS

VII.3.1. Définition
Pour mettre en forme votre code PHP, on y insère tout simplement du code HTML ou du code CSS.
Nous avons 2 possibilités, soit mettre du HTML et CSS dans le code PHP, soit insérer du code PHP
dans HTML.

Exemple 1 : du HTML et CSS dans le code PHP

<?php
// Exemple avec HTML
echo "<h1>Bonjour</h1>";
echo "<p><strong>Toto écrit du code PHP</strong></p>";
// Exemple avec CSS
echo "<i class='fa fa-wrench'></i>";
?>

Exemple 2 : du code PHP dans le HTML

<h1>Bonjour <?php $prenom= 'Pierre'; echo $prenom; ?> <h1>

VII.3.2. La concaténation
Le terme concaténation (substantif féminin), du latin cum (« avec ») et catena (« chaîne, liaison »),
désigne l'action de mettre bout à bout au moins deux chaînes de caractères.

Exemple :

<?php
$nom = 'Dupont';
$prenom = 'Pierre';
echo $nom.$prenom; //va afficher "DupontPierre"
echo $nom.' '.$prenom; //va afficher "Dupont Pierre"

echo '$nom.$prenom'; //va afficher "$nom.$prenom"

echo '$nom$prenom'; //va afficher $nom$prenom

$nom .= $prenom; //est équivalent à $nom = $nom . $prenom;

echo $nom; //affichera "DupontPierre"

$nom = 'Dupont';
$nom .= ' '.$prenom;
echo $nom; //affichera "Dupont Pierre"

$a = 10;
$a.= 30; Le résultat serait 1030
$a=$a.$b; // La variable $a a la valeur de la concaténation de $a et $b
echo $a;
?>

18 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Concaténer des chaines de caractères et des variables

<?php
$tauxeuro=6.5957;
echo "le taux de l'euro est " .$tauxeuro ;
?>

Concaténer des chaines de caractères et des fonctions

<?php
$tauxeuro=6.5957;
echo "le taux de l'euro arrondi est " .round($tauxeuro,2);
?>

Concaténation avec du HTML

<?php
$tauxeuro=6.5957;
echo "<b>le taux de l'euro arrondi est </b>" .round($tauxeuro,2);
?>

Concaténation avec du CSS

<?php
$tauxeuro=6.5957;
echo " <p class='alert alert-info'>le taux de l'euro arrondi est
".round($tauxeuro,2) ."</p>";
?>

VII.4. Les fonctions en PHP

VII.4.1. Fonctions mathématiques en PHP
Il existe une plaitore de fonctions mathématiques en PHP donc certaines des plus importantes sont :
 round() : permet d'arrondir une valeur numérique

round($variable, Nb_decimales);

 rand() : permet de générer un nombre aléatoire

int rand (int $min , int $max);

19 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VII.4.2. Fonctions de date en PHP

date()

Permet d'afficher une date, l'heure, le numéro de semaine ...

Caractère Signification Exemples de valeurs possibles

JOUR
J Jour du mois sur deux chiffres sans les zéros 1 à 31
initiaux
D Jour du mois sur deux chiffres avec un zéro 01 à 31
initial en fonction du jour
l (en minuscule) Jour de la semaine en anglais Sunday à Saturday
W Jour de la semaine au format numérique 0 (dimanche) à 6 (samedi)
Z Jour de l'année 0 à 366
SEMAINE
W Numéro de semaine dans l'année (les semaines Exemple : 42 (la 42éme semaine de
commencent le lundi) l'année)
MOIS
F Mois, textuel, version longue; en anglais, January à December
comme January ou December
M Mois au format numérique, avec zéros initiaux 01 à 12
N Mois sans les zéros initiaux 1 à 12
T Nombre de jours dans le mois 28 à 31
ANNEE
L Est ce que l'année est bissextile 1 si bissextile, 0 sinon.
Y Année sur 4 chiffres Exemples : 1999 et 2003
Y Année sur 2 chiffres Exemples : 99 et 03
HEURE
A Ante méridien et Post méridien (minuscules) am ou pm
A Ante méridien et Post méridien (majuscules) AM ou PM
G Heure (format 12h) sans les zéros initiaux 1 à 12
G Heure (format 24h) sans les zéros initiaux 0 à 23
H Heure (format 12h) avec les zéros initiaux 01 à 12
H Heure (format 24h) avec les zéros initiaux 00 à 23
S Secondes avec zéros initiaux 00 à 59
I Minutes avec zéros initiaux 00 à 59
I (en majuscule) l'heure d'été est activée ou pas 1 si oui, 0 sinon.

<?php
echo date("d/m/Y"); // Affiche la date du jour
echo "Il est " . date("H:i:s") ; // Affiche l'heure
?>

Le timestamp PHP

Un timestamp, c'est un nombre. C'est le nombre de secondes écoulées depuis le 1er Janvier 1970 à
Minuit.
Pourquoi depuis le 1er Janvier 1970 à Minuit ? C'est symbolique, il fallait bien prendre un point
de départ. En fait, ça représente le début de l'époque où le systéme d'exploitation Unix a été créé.

20 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Le 1er Janvier 1970 à Minuit, le timestamp avait pour valeur 0. Aujourd'hui, beaucoup beaucoup
de secondes se sont écoulées.

Afficher le timestamp avec time

<?php
echo time(); //Affiche le nombre de secondes écoulées depuis le 1er janvier 1970
?>

Le timestamp avec la fonction date

Il est possible de fournir un second paramétre à date (aprés les lettres) : le timestamp sur lequel vous
voulez obtenir des informations.

Par défaut, date utilise le timestamp actuel : elle renvoie donc l'heure actuelle, le jour actuel etc...
Mais si vous lui donnez un timestamp, elle fera des calculs sur ce moment-là.

Allez, pour faire un test grandeur nature, je vous donne le timestamp qu'il était au moment où j'ai
écrit ces lignes.

<?php
$timestamp= 1544467069; // Timestamp affiché quand j'ai écris ce cours
echo date('d/m/Y-H:s:i',$timestamp);
?>

Récupérer le timestamp à partir d'une date avec mktime

Enfin, une dernière chose qu'il peut être très utile de savoir faire : vous aimeriez connaître le
timestamp qu'il était le 5 Février 1998 à 13h 45min 26s.

Pour récupérer le timestamp correspondant, on va utiliser la fonction mktime. On va lui donner en

paramètre une date, et elle va nous ressortir le timestamp correspondant.

Cette fonction peut prendre pas mal de paramètres, en voici la liste dans l'ordre :

mktime(heure, minutes, secondes, mois, jour, an, heure d'hiver)

Dans la pratique, vous pouvez oublier le dernier paramètre (heure d'hiver) qui ne vous sera pas utile
en général.

Sachez qu'il faut mettre 1 si l'heure d'hiver est activée, 0 si elle ne l'est pas.

Mais passons. Si on enlève l'heure d'hiver pour éviter de s'embrouiller, il reste 6 paramètres
possibles qu'on retiendra :

Nous voulons le timestamp du 5 Février 1998 à 13h 45min 26s.

21 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

<?php
$vieux_timestamp = mktime(13, 45, 26, 2, 5, 1998);
echo 'Le timestamp du 05/02/1998 à 13h 45min 26s était : ' . $vieux_timestamp;
?>

getdate()

getdate retourne un tableau associatif contenant les informations de date et d'heure du timestamp
(lorsqu'il est fourni, sinon, le timestamp de la date/heure courante), avec les champs suivants :

array getdate ( int timestamp )

Clé Description Exemple de valeur retournée

« seconds » Représentation numérique des secondes 0 à 59
« minutes » Représentation numérique des minutes 0 à 59
« hours » Représentation numérique des heures 0 à 23
« mday » Représentation numérique du jour du mois courant 1 à 31
« wday » Représentation numérique du jour de la semaine 0 (pour Dimanche) à 6 (pour
courante Samedi)
« mon » Représentation numérique du mois 1 à 12
« year » Année, sur 4 chiffres Exemples: 1999 ou 2003
« yday » Représentation numérique du jour de l'année 0 à 365
« weekday » Version texte du jour de la semaine Sunday à Saturday
« month » Version texte du mois, comme January ou March January à December
0 Nombre de secondes depuis l'époque Unix, similaire à Dépend du système, typiquement
la valeur retournée par la fonction time et utilisée par de -2147483648 à 2147483647
date

print_r()

Permet d’afficher des informations à propos d'une variable, de manière à ce qu'elle soit lisible. Pour
une chaîne, un entier ou un double, la valeur elle même sera affichée.

Pour les tableaux, les valeurs seront présentées dans un format qui montre les clés et les valeurs.

Gardez en tête que print_r place le pointeur de tableau à la fin du tableau. Utilisez reset pour le
ramener au début.

<?php
$today = getdate();
print_r($today); //Array ( [seconds] => 25 [minutes] => 17 [hours] => 7 [mday] =>
10 [wday] => 1 [mon] => 12 [year] => 2018 [yday] => 343 [weekday] => Monday
[month] => December [0] => 1544426245 )
?>

strtotime()

Transforme un texte anglais en timestamp. Retourne un timestamp en cas de succès, FALSE sinon.
22 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

<?php
echo strtotime("now"), "\n";
echo strtotime("10 September 2000"), "\n";
echo strtotime("+1 day"), "\n";
echo strtotime("+1 week"), "\n";
echo strtotime("+1 week 2 days 4 hours 2 seconds"), "\n";
echo strtotime("next Thursday"), "\n";
echo strtotime("last Monday"), "\n";
?>

date_diff()

Permet de faire un calcul entre 2 dates.

<?php
$datetime1 = date_create('05-12-2018');
$datetime2 = date_create('10-12-2018');
$interval = date_diff($datetime1, $datetime2);

echo $interval->format('%R%a days'); //+5 days

?>

VII.4.3. Fonctions sur les chaînes de caractères

Il existe une pléthore de fonctions sur les chaînes de caractères en PHP donc certaines des plus
importantes sont :
 « implode(string $delimiter , array $tableau ) : string » : rassemble les éléments d'un
tableau en une chaîne
 « explode(string $delimiter , string $subject) : array » : coupe une chaîne en segments
 « str_replace(string $search , string $replace , string $subject) : string » : remplace
toutes les occurrences dans une chaîne
 « strpos(string $subject , string $search) : int » : cherche la position de la première
occurrence d’un caractère ou chaîne dans une chaîne
 « substr(string $subject , int $start) : string » : retourne la partie extraite de la chaîne dans
le segment de string défini par $start ou FALSE si une erreur survient
 « strrchr(string $subject , string $search) : string » : trouve la dernière occurrence d'un
caractère dans une chaîne
 « strlen(string $subject ) : int » : affiche le nombre de caractères contenu dans une chaîne
 « strtolower(string $subject ) : string » : permet de passer une chaîne de caractères en
minuscule,
 « strtoupper(string $subject ) : string » : permet de passer une chaîne de caractères en
majuscule,
 « ucfirst(string $subject ) : string » : permet de passer la première lettre d'une chaîne de
caractères en majuscule
 « strcmp(string $subject ) : string » : permet de comparer des chaînes de caractères

23 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Bien sur ceci ne constitue pas l’ensemble des fonctions existantes sur les chaînes de caractères ou
tout autre objet. Pour avoir plus d’informations, bien vouloir consulter le lien suivant :
[Link]

VII.4.4. Autres fonctions pratiques en PHP

include()

Permet d’inclure du code PHP. La fonction include() est similaire à require(), à ceci prés qu'avec
include() le traitement ne s'interrompra pas en cas d'erreur, et le reste de la page s'affichera
normalement.

En cas d'erreur avec include() le script continuera de s'éxecuter, il n'émettra qu'une alerte de type
E_WARNING

<?php
include('[Link]'); // Cette page n'existe pas
?>

require()

La fonction require() appelle et exécute un code contenu dans un fichier externe.

require permet à la différence d'include de couper l'exécution du script PHP si le fichier à inclure
n'a pu être inclus.

En cas d'erreur, le script se coupera complètement

<?php
/* Coupe l'exécution du script PHP si le fichier à inclure
n'a pu être inclus */
require('[Link]');
?>

NB : Par convention on met un « .inc » avant le « .php » pour indiquer que le fichier est à inclure.

require_once()

L'instruction require_once() est identique à require() mise à part que PHP vérifie si le fichier a
déjà été inclus et si c'est le cas, ne l'inclut pas une deuxième fois.

24 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php
/* Vérifie si le fichier a déjà été inclus et si
c'est le cas, ne l'inclut pas une deuxiéme fois */
require_once('[Link]');
?>

mail()

La fonction mail permet comme son nom l'indique : l'envoi d'emails

<?php
$destinataire="toto@[Link]";
$sujet="Envoi de mail avec PHP";
$message = "Contenu de mon email";
$entete = "From: webmaster@[Link]";
mail($destinataire, $sujet, $message,$entete);
?>

VII.4.5. Fonctions personnalisées en PHP

PHP permet de créer ses propres fonctions.

function Nomfonction ($parametre, ...)

{
/* Les commandes sont placées ici */
return $resultat
/* Si la fonction retrourne une valeur, indiquez là dans la
commande return */
}
echo Nomfonction(valeur);

Exemple :

<?php
function ConvDollar($prix) {
// Taux de change le 30 Décembre 2009 1.341
$calcul=$prix*1.341;
return $calcul;
}
// 10.54 est la valeur a calculé avec la fonction
echo ConvDollar(10.51);
?>

25 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VII.5. Les structures conditionnelles

VII.5.1. if else
if else, permet de tester si une condition est respectée ou non. Dans notre exemple ci dessous, si la
condition est respectée, elle renvoit "instruction1", sinon "instruction2".

<?php
if(condition) {
// instruction1;
}
else{
// instruction2;
}
?>

VII.5.2. if elseif else

Nous pouvons combiner un certains nombre de conditions avec if elseif else ....
Si la condition1 est respectée, elle renvoit "instruction1", sinon on teste la condition2
Si la condition2 est respectée, elle renvoit "instruction2"
Sinon elle renvoit enfin le dernier test "instruction3"

<?php
if(condition1) {
// instruction1;
}
elseif (condition2){
// instruction2;
}
else {
// instruction3;
}
?>

VII.5.3. switch
switch($variable){
case "condition1":
// instruction;
break;

case "condition2":
// instruction;
break;

case "condition3":
// instruction;
break;

default:
// instruction;
break;
}

26 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VII.5.4. Les opérateurs de comparaison

Signe Exemple Retourne TRUE si :
== (égal) $a == $b $a est égal à $b
=== (identique) $a === $b $a est égal et du même type que $b
!= (différent) $a != $b $a est différent de $b
< > (différent) $a < > $b $a est différent de $b
< (inférieur) $a < $b $a est inférieur à $b
> (supérieur) $a > $b $a est supérieur à $b
<= (inférieur ou égale) $a <= $b $a est inférieur ou égal à $b
>= (supérieur ou égale) $a >= $b $a est supérieur ou égal à $b

VII.5.5. Les opérateurs logiques

Signification Symbole Explication Exemple Retourne TRUE
équivalent si :
Et && Vérifie que toutes les conditions $a && $b $a et $b
sont réalisées retournent TRUE
Ou || Vérifie qu'une des conditions est $a || $b $a ou $b retourne
réalisée TRUE

VII.5.6. Quelques fonctions utiles

isset()

La fonction isset() verifie si une variable est bien définie, ce n'est que dans ce cas qu'elle renvoie la
valeur vrai (true), dans le cas inverse, le résultat du test est false.

Exemple :

<?php
$var="toto";
if(isset($var) && $var=="toto"){
echo "C'est bien toto<br>";
}
else{
echo "Ce n'est pas toto";
}
?>

27 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

empty()

La fonction empty() détermine si une variable est vide ou non. Elle retourne TRUE si la chaîne
passée en argument est vide.

Exemple :

<?php
$prenom="Paul";
if(empty($prenom)){
echo "La variable est vide";
}
else{
echo "La variable n'est pas vide, elle est de type "
.gettype($prenom);
}
?>

VII.6. Les boucles

Les boucles vont nous permettre d'effectuer un certain nombre de fois les mêmes opérations, par
exemple afficher une suite de nombres que l'on incrémentera à chaque tour de boucle. Nous allons
pouvoir répéter autant d'instructions que nous souhaitons et nous nous arrêterons lorsque nous
l'aurons décidé, selon une condition bien précise par exemple. Voyons maintenant différents types
de boucles que nous expliquerons au fur et à mesure.

VII.6.1. Boucle « for »

Cette boucle est très utile lorsque vous souhaitez incrémenter une variable sur une certaine plage de
valeurs connue à l'avance.

<?php
for(initialisation; condition de continuité; incrémentation) {
// Bloc d'instructions;
}
?>

Exemple :

<?php
for($i=0; $i<10; $i++){
echo $i;
}
?>

28 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

VII.6.2. Boucle « while »

Cette boucle qui est une des plus utilisées en PHP va nous permettre d'effectuer une ou plusieurs
actions tant que la condition que nous placerons à l'intérieur des parenthèses sera vérifiée.

C'est pour cela que, quel que soit le type de boucle (While ou For), il faut indiquer une condition.
Tant que la condition est remplie, les instructions sont réexécutées. Dés que la condition n'est plus
remplie, on sort de la boucle

<?php
while(condition) {
// Bloc d'instruction
}
?>

Exemple :

<?php
$j=1;
while($j<7){
echo $j++ ." ";
}
?>

VII.6.3. Boucle « do.. while »

Elle a des similitudes avec la boucle while. Néanmoins, une différence de taille les séparent.

Si l'on reprend l'exemple avec la boucle while, nous constaterons que si on initialise $i à 8, la
boucle ne sera jamais exécutée, car dés l'analyse de la condition, 8 < 7 renverra FALSE (8 est bien
supérieur à 7).

La boucle do while permet d'effectuer au moins une fois une opération, et si une condition est vraie,
reboucler autant de fois que vous le souhaitez.

Avec le do while, il sera au minimum exécuté une fois.

Dans le cas de la boucle while, la condition est examinée avant la boucle tandis que pour la boucle
do while elle est éxaminée à la fin.

29 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Donc même si cette condition n'est pas vérifiée, la boucle s'exécutera une fois.

<?php
do {
// instruction 1;
// instruction 2;
} while(condition);
?>

Exemple :

<?php
$i=8;
$j=7;
do {
echo 'la boucle a bouclé une fois, même si la condition n\'a pas été
respectée,<br />
la variable $i < n\'est pas inférieur à $j';
} while ($i < $j);
?>

Tests de connaissances
1. Définir : PHP, Script CGI
2. Quel est le rôle du PHP en Programmation Web ?
3. Comment mettre en place un script PHP dans une page Web ?
4. Pourquoi dit-t-on que PHP est un langage côté serveur ?
5. Pourquoi dit-t-on PHP est basé sur le principe client / serveur ?
6. Citer quelques serveurs Web que vous connaissez ?
7. Quelle différence faites-vous les fonctions « print_r » et « var_dump » en PHP ?

30 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

CHAPITRE II : TECHNIQUES AVANCEES EN PHP

Objectif du chapitre
Découvrir des concepts plus avancés du langage PHP.

Objectifs spécifiques
 Définition et manipulation des tableaux
 Utilisation des variables superglobales
 Gestion des fichiers

I. Les tableaux
Il s'agit de variables qui peuvent contenir plusieurs valeurs. On peut donc imaginer leur
représentation sous forme d'un tableau.

Pour différencier les valeurs, pour savoir comment on va dire à PHP "je veux telle valeur de cette
variable" il faut bien distinguer les valeurs par des indices.

Indice Valeur
0 Maurice
1 Jean
2 Marc
3 William
4 Romeo

31 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

I.1. Les tableaux à indices numériques

<?php
// Syntaxe 1
$Prenom=array();

$Prenom[0]='Maurice';
$Prenom[1]='Jean';
$Prenom[2]='Pierre';
$Prenom[3]='Paul';
$Prenom[4]='Gérard';
echo $Prenom[4];

// Syntaxe equivalente
$Prenom=array(0=>'Maurice',
1=>'Jean',
2=>'Pierre',
3=>'Paul',
4=>'Gérard');
echo $Prenom[4];

/* Dans le cas où vous souhaitez garder le premier indice à zéro (et les suivants
incrémentés de 1 à chaque fois) vous pouvez également utiliser la syntaxe suivante
*/
$Prenom=array('Maurice','Jean','Pierre','Paul','Gérard');
echo $Prenom[4];
?>

La fonction « count »

Compte le nombre d'éléments d'un tableau ou le nombre de propriétés d'un objet.

<?php
echo count($Prenom) ." prénoms dans le tableau";
?>

NB : La fonction « sizeof », au mettre titre que la fonction « count » permet de compter le nombre
d’éléments d’un tableau

I.2. Les tableaux associatifs

PHP peut également vous permettre de distinguer les différentes valeurs de vos tableaux par des
indices associatifs. Ils sont constitués de chaînes de caractères.

Prenons l'exemple d'un article. On va le différencier par plusieurs choses :

 Son numéro unique
 Son nom
 Son prix

32 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php
// 1ère syntaxe
$Article=array();
$Article['Numero']=77;
$Article['Nom']="Cable rond";
$Article['Prix']=7;
echo "Ref: ".$Article['Numero'] ." Article: " .$Article['Nom'] ." Prix: "
.$Article['Prix'];

// Seconde syntaxe
$Articles=array('Numero' =>77,
'Nom' => "Cable rond",
'Prix' => 7);
echo "Ref: ".$Articles['Numero'] ." Article: " .$Articles['Nom'] ." Prix:
" .$Articles['Prix'];
?>

I.3. Tableau multi-dimensionnelle indicé

Nous allons représenter le tableau ci-dessous sous forme d'un tableau multi-dimensionnelle indicé.

Pays Capitale Population en million

France Paris 80
Japon Tokyo 90
UK Londres 70

<?php
// 1ère ligne
$tab1=array();
$tab1[0][0]="France";
$tab1[0][1]="Paris";
$tab1[0][2]=80;

// 2ème ligne
$tab1[1][0]="Japon";
$tab1[1][1]="Tokyo";
$tab1[1][2]=90;

// 3ème ligne
$tab1[2][0]="UK";
$tab1[2][1]="Londres";
$tab1[2][2]=70;

echo $tab1[1][2];
?>

I.4. Boucle foreach

<?php
foreach( $array as $value ){…………}
?>

33 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Boucle foreach version 1 : avec tableau indicé

<?php
$array = array( 1, 2, 3, 5, 8, 12 );
foreach( $array as $value ){
echo $value . '<br >';
}
?>

Ainsi, nous parcourons le tableau $array et la valeur de l'élément courant est copié dans $value, qui
est ensuite affiché.

Bouche foreach version 2 : avec tableau associatif

Contrairement au tableau précédant, les indices des éléments ne sont pas des nombres (0, 1, 2, ...)
mais des chaînes de caractères (on appelle un tel tableau un tableau associatif). Ainsi, si je veux
accéder au deuxième élément, je dois procéder comme suit: $array['deuxieme'] .

Il est donc impossible ici d'utiliser for, par contre, avec foreach, aucun problème.

<?php
$array = array( 'premier' => 'N° 1', 'deuxieme' => 'N° 2', 'troisieme' => 'N° 3');
// on parcourt $array, la valeur de l'item courant est copiée dans $value
foreach($array as $value) {
echo $value . '<br>';
}
?>

foreach permet également de connaître, en plus de la valeur de l'élément courant, sa clé. Dans ce
cas, on parcourt le tableau $array et la clé de l'élément courant est copiée dans $key tandis que sa
valeur est copiée dans $value.

<?php
$array = array( 'premier' => 'N° 1', 'deuxieme' => 'N° 2', 'troisieme' => 'N° 3');

foreach( $array as $key => $value ) {

echo 'Cet élément a pour clé "' . $key . '" et pour valeur "' . $value .
'"<br>';
}
?>

I.5. Trier un tableau

sort

sort permet de trier un tableau dans l’ordre croissant. Elle ne s’applique qu’au tableau numérique.

bool sort ( array &$array [, int $sort_flags = SORT_REGULAR ])

34 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

rsort

rsort permet de trier un tableau dans l’ordre déroissant. Elle ne s’applique qu’au tableau numérique.

bool rsort ( array &$array [, int $sort_flags = SORT_REGULAR ])

ksort

ksort permet de trier un tableau par ordre croissant suivant les clés. Elle ne s’applique qu’au tableau
associatif.

bool ksort ( array &$array [, int $sort_flags = SORT_REGULAR ])

krsort

krsort trie un tableau par ordre décroissant suivant les clés. Elle ne s’applique qu’au tableau
associatif.

bool krsort ( array &$array [, int $sort_flags = SORT_REGULAR ] )

II. Les variables superglobales

Elles sont écrites en majuscules et commencent toutes par un underscore (_). Exemple : $_GET,
$_POST, … Les superglobales sont toutes des array.

Ces variables sont automatiquement créées par PHP à chaque fois qu'une page est chargée. Ces
variables existent donc sur toutes les pages et sont accessibles partout : au milieu de votre code, au
début, dans les fonctions etc...

II.1. Envoyer des variables dans l'url avec GET

$_GET : c'est elle qui vous donne les valeurs des informations indiquées dans l'url. Un simple lien
hypertexte vous permet d'envoyer une variable par l'url.

Exemple

Nous allons créer 2 pages :

1. [Link] : qui contient le lien à envoyer dans l'url (Nous n'avons pas forcément besoin
d'une page en php).
2. [Link] : qui va traiter l'information envoyée dans l'url.

35 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

[Link]

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>GET</title>
</head>
<body>
<a href="[Link]?prenom=Marc">
Envoyer des données via une url
</a>
</body>
</html>

[Link]

<?php
echo $_GET['prenom'];
?>

Il est possible d’envoyer plusieurs variables. Ainsi on a :

[Link]

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>GET</title>
</head>
<body>
<a href="[Link]?prenom=Marc&amp;nom=TEJIOGNI&amp;annee=2018">
Envoyer des données via une url
</a>
</body>
</html>

NB : Dans le code HTML, il n’est pas conseillé d’écrire directement le symbole « & », Il faut le
remplacer par son code HTML : « &amp; »

[Link]

<?php
echo $_GET['prenom'];
echo $_GET['nom'];
echo $_GET['annee'];
?>

36 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

II.2. Envoyer des données via un formulaire avec POST

A la différence du GET, on récupère les variables ici à l’aide de $_POST['Variable'].

Exemple

Nous allons crée une page HTML nommé : [Link].

Dans cette page, nous ajouterons un formulaire constitué d’un champ de texte nommé "nom" ainsi
qu'un bouton d'envoi.

Dans la balise form, action doit pointer vers une page en PHP (Exemple: [Link]") qui va
traiter l'information.

[Link]

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>POST</title>
</head>
<body>
<form name="formulaire" method="post" action="[Link]">
<input type="text" name="nom" />
<input type="submit" name="envoyer" value="Envoyer" />
</form>
</body>
</html>

[Link]

<?php
echo $_POST['nom'];
?>

II.3. Les variables de serveur : $_SERVER

Ce sont des valeurs utiles que nous donne le serveur. Pour les afficher, il faut indiquer ce qu'on
demande entre crochets puisque que c'est un tableau associatif.

Comme valeurs on peut avoir :

37 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Le nom relatif du serveur qui exécute le script courant

<?php
echo $_SERVER['SERVER_NAME'];
?>

Le chemin du répertoire racine du serveur

<?php
echo $_SERVER['DOCUMENT_ROOT'];
?>

Chemin de la page exécutée par rapport à la racine du site web.

<?php
echo $_SERVER['PHP_SELF'];
?>

Obtenir l'adresse IP du client

<?php
echo $_SERVER['REMOTE_ADDR'];
?>

Obtenir le type de navigateur

<?php
echo $_SERVER['HTTP_USER_AGENT'];
?>

Nom de la page précédente

<?php
echo $_SERVER['HTTP_REFERER'];
?>

Il est possible d’afficher la liste complète des valeurs de $_SERVEUR.

<?php
var_dump($_SERVER);
?>

38 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

II.4. Les sessions

Les sessions en PHP permettent de sauvegarder des variables de page en page pendant une certaine
durée prédéfinie par PHP (et modifiable bien entendu).

Chaque utilisateur ayant besoin des sessions se voit attribuer un identifiant unique appelé ID de
session. Cet identifiant est stocké sur le poste de l'internaute sous forme d'un cookie ou URL si
l'option session.use_trans_sid est à 1 (ou On) dans le fichier [Link].

Utiliser la méthode du cookie est plus que recommandée : un identifiant de session dans l'URL
empêche de retenir l'adresse d'une page simplement par le visiteur néophyte, cela rallonge donc
l'adresse de votre page. Cela nuit également au référencement de votre page. En effet, l'identifiant
étant unique, lorsque le robot du moteur de recherche scanne votre site, il ne retombera jamais sur la
même URL plusieurs fois de suite.

Démarrer une session avec session_start

Avant d'utiliser les sessions sur une page, on doit toujours utiliser la fonction session_start() placée
avant tout envoi de code HTML, et donc généralement tout en haut de votre page PHP.

session_start();

Syntaxe pour créer une variable de session

$_SESSION['nom']="Valeur";

Pourquoi session_start() doit-elle être placée de la sorte ? Et bien parce que si PHP utilise les
cookies pour repérer quel est l'id de session utilisé par l'internaute, il va écrire cet id de session dans
un cookie. Or, le protocole HTTP fonctionne de telle sorte que les en-têtes (qui permettent de dire à
votre navigateur "crée un cookie ayant tel nom et telle valeur") sont envoyés avant le premier
caractère HTML transmis.
Cela veut dire que dés que vous transmettrez un caractère HTML, les en-têtes seront envoyés et
vous ne pourrez plus les modifier, vous ne pourrez donc plus écrire le cookie de session.
En général, si vous faites une maladresse de ce style, vous vous retrouverez avec une erreur de
« headers already sent ».

Quelle est la durée de vie d'une session ?

Dés que l'on ferme le navigateur la session est détruite.

Sauf si on configure le fichier [Link] avec [Link] qui fixe la durée de vie, en secondes,
du cookie envoyé au client. La valeur 0 signifie "jusqu'à ce que le client soit fermé". Par défaut il
est à 0.

39 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Donc si on le laisse à zéro la session dure jusqu'à la fermeture du navigateur, pour laisser les
données durant 30 minutes, il faut remplacer 0 par 1800 (car 1800 = 30 minutes * 60 secondes).

Afficher l'identifiant de session avec id_session

echo session_id();

Supprimer une variable de session

La commande session_unregister() supprime une variable dans la session courante.

Elle retourne TRUE si success, FALSE sinon.

boolean session_unregister(string name);

Autre méthode si vous utilisez le tableau superglobale $_SESSION, il suffit alors d'utiliser unset().

unset($_SESSION["mavariable"])

Il est aussi possible de purger (supprimer) toutes les variables de la session avec :

session_unset();

Fermer une session

Il existe plusieurs manières de fermer une session à savoir :

1. Fermeture conservatrice avec session_write_close : La commande session_write_close()

écrit les valeurs des variables de session sur le serveur et ferme la session.

session_write_close();

2. Fermeture destructive avec session_destroy : si vous voulez détruire la session du

visiteur, vous pouvez faire un lien "Déconnexion" qui améne vers une page qui fait appel à
la fonction session_destroy(). La commande session_destroy() détruit toutes les données
enregistrées d'une session. Cette dernière commande est la plus utilisée car n'impose aucune
sauvegarde au serveur. Retourne TRUE en cas de succés, et FALSE sinon.

session_ destroy();

40 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Exemple

<?php
// On démarre la session AVANT toute chose,
session_start();

// On crée dans cette exemple 3 variables de session :

$_SESSION['prenom'] = 'Marc';
$_SESSION['nom'] = 'TEJIOGNI';
$_SESSION['age'] = 19;

// Maintenant on peut taper du code HTML

?>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Variables de session</title>
</head>
<body>
<p>
Bonjour <?php echo $_SESSION['prenom']; ?>
</p>

<p>Tu es à l'accueil de mon site </p>

</body>
</html>

II.5. Les cookies

Un cookie est un petit fichier texte que l'on stocke sur le poste du visiteur.

Exemple : Vous stockez le pseudo du visiteur. Lorsqu'il revient sur votre site, vous pouvez lire dans
le cookie et lui afficher « Bonjour votre_pseudo ».

Contrairement à certaines légendes, les cookies sont totalement inoffensifs, ce ne sont pas des virus
ou troyens ou je ne sais quoi !

Ecrire un cookie avec setcookie

La fonction PHP qui permet d'écrire un cookie est setcookie qui signifie Placer un cookie en
français.

setcookie (string nom, string valeur, string expiration, string chemin, string
domaine, string securise);

On utilise généralement les 3 premiers paramètres en respectant l'ordre:

1. Le nom du cookie (exemple : "Nom")
2. La valeur du cookie (exemple : "TEJIOGNI")
3. La date d'expiration du cookie, sous forme de timestamp (exemple : 1090521508)

41 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

NB : Comme pour session_start que nous avons vu précédemment, setcookie doit être placé avant
votre code HTML. Placer le avant la balise <!DOCTYPE>.

Afficher un cookie

$_COOKIE['Nom_cookie'];

PHP va lire l'information stockée dans le cookie du visiteur. Ces informations sont placées dans la
superglobale $_COOKIE, sous forme d'array (tableau).

Modifier la valeur d'un cookie

Pour modifier la valeur d'un cookie, il faut faire appel à setcookie en conservant le même nom de
cookie et en modifiant simplement sa valeur.

Suprimer un cookie

Pour supprimer un cookie, Il suffit de déclarer le cookie sans mettre de valeur.

setcookie("Nom_cookie");

Exemple :

<?php
$timestamp = time() + 365*24*3600; // Le cookie a une durée de vie de 1an
setcookie('nom', 'TEJIOGNI', $timestamp); // On écrit un cookie
setcookie('prenom', 'Marc', $timestamp); // On en écrit un autre
// Vous remarquez que tout est bien noté avant le début du code HTML
?>

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Les Cookies</title>
</head>
<body>
<p>
Bonjour <?php echo $_COOKIE['prenom']; ?>
<?php echo $_COOKIE['nom']; ?>
</p>
</body>
</html>

42 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III. Manipulation des fichiers

III.1. Ouvrir et fermer un fichier
Ouvrir un fichier avec fopen

La fonction fopen() permet d’ouvrir un fichier. Elle renvoie true si l'ouverture est possible et false si
elle ne l'est pas.

fopen(string filename, string mode);

 « filename » représente le nom du fichier à ouvrir ou le chemin d’accès vers le fichier.

 « mode » représente le mode d’ouverture du fichier. On peut avoir comme valeurs :
o a : Ouvre le fichier en écriture seule et place le pointeur à la fin du fichier. Si le
fichier n'existe pas, on tente de le créer.
o a+ : Ouvre le fichier en mode lecture et en écriture et place le pointeur à la fin du
fichier. Si le fichier n'existe pas, on tente de le créer.
o r : Ouvre le fichier en lecture seule et place le pointeur en début de fichier.
o r+ : Ouvre le fichier en lecture et écriture et place le pointeur en début de fichier.
o w : Ouvre le fichier en écriture seule, place le pointeur en début du fichier. Si le
fichier existe déjà, son contenu est écrasé, dans le cas contraire il crée le fichier.
o w+ : Ouvre le fichier en mode lecture et écriture, place le pointeur au début du
fichier. Si le fichier existe déjà, son contenu est écrasé, dans le cas contraire, il crée
le fichier.

Exemple

<?php
$source= "[Link]";

/* Le @ permet de ne pas afficher l'erreur et

renvoie le statut que nous définisons en dessous */

if($fichier=@fopen($source,"r")) {
echo "L'ouverture du fichier est possible car la fonction
fopen retourne TRUE<br />";
}
else {
echo "Ouverture du fichier impossible car fopen retourne
FALSE";
}
?>

43 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Fermer un fichier avec fclose

Après tout traitement effectué sur un fichier, on doit le fermer avec la fonction fclose().

fclose(string filename);

Exemple

<?php
$source= "[Link]";

/* Le @ permet de ne pas afficher l'erreur et

renvoie le statut que nous définisons en dessous */

if($fichier=@fopen($source,"r")) {
echo "L'ouverture du fichier est possible car la fonction
fopen retourne TRUE<br />";
fclose($fichier);
}
else {
echo "Ouverture du fichier impossible car fopen retourne
FALSE";
}
?>

III.2. Afficher le contenu d'un fichier dans un navigateur

La fonction fpassthru() permet d’afficher le contenu d’un fichier dans un navigateur.

fpassthru(string pointeur);

Exemple

<?php
$source= "[Link]";
$fichier=fopen($source,"r");
fpassthru($fichier);
fclose($fichier);
?>

44 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.3. Extraire une chaîne de caractère dans un fichier

fgets

La fonction fgets() permet d'extraire une chaîne d'une certaine longueur d’un fichier.
Il faut aussi savoir que la fonction extrait la chaîne de la longueur précise définie en argument, plus
un caractère et que la fonction s'arrête aux sauts de lignes

fgets(string pointeur, int longueur);

Exemple

< ?php
$source= "[Link]";
$fichier= fopen($source,"r+");
echo fgets($fichier,4);
fclose($fichier);
?>

Il est possible d’utiliser également la fonction fgetss() (même syntaxe que fgets) pour extraire une
chaîne d’une certaine longueur d’un fichier. La fonction fgetss() a quasiment la même utilité que la
fonction fgets() sauf qu'elle n'extrait ni les balises HTML, ni les balises PHP.

Exemple

Pour un fichier contenant : '<strong>Bonjour !< /strong>< br>Test de la fonction fgetss', la fonction
ne renverra que les caractères, la mise en forme HTML sera ignorée : 'Bonjour !Test de la fonction
fgetss'.

fgetc

La fonction fgetc() permet d'extraire le premier caractère d’un fichier.

fgetc(string pointeur);

Exemple

< ?php
$source= "[Link]";
$fichier = fopen($source,"r");
$premier = fgetc($fichier);
echo "Premier Caractére : " . $premier;
fclose($fichier);
?>

45 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

fread

La fonction fread() permet de lire une chaîne de caractère dans un fichier ouvert, jusqu'a la
longueur indiquée en argument.

fread(string pointeur, int longueur);

Exemple

<?php
$source= "[Link]";
$fichier = fopen($source,"r");
$premier = fread($fichier, 10);
echo "Dix Premiers Caractéres : " . $premier;
fclose($fichier);
?>

III.4. Ecrire dans un fichier

Pour écrire dans un fichier, on peut utiliser au choix la fonction fwrite() ou fputs(). Dans le cadre
ce cours nous utiliserons la fonction fwrite().

int fwrite(string pointeur, string chaîne [, int longueur]);

Elle retourne une valeur de type int qui correspond au nombre d’octets écrits ou FALSE en cas
d'erreur. Le troisième paramètre qui est facultatif est la longueur. Lorsqu'il est spécifié, il indique le
nombre maximal d'octets à écrire.

Attention : Le fichier doit bien être ouvert en mode écriture : w, a ou r+.

Exemple

<?php
$source= "[Link]";
$fichier = fopen($source, "a");

if($octets = @fwrite($fichier, "TEXTE A ECRIRE")){

echo "Taille de la chaîne insérée : " . $octets . " Octets";
}
else {
echo "Erreur";
}
fclose($fichier);
?>

46 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.5. Vérifier l'existence d'un fichier

Pour vérifier si un fichier existe, on utilise la fonction file_exists(). La fonction retourne TRUE si le
fichier existe et sinon FALSE.

file_exists(string filename);

Exemple

<?php
if(file_exists("[Link]")) {
echo "Fichier existant";
}
else {
echo "Introuvable !";
}
?>

III.6. Copier et coller des fichiers

Pour copier un fichier, il faut utiliser la fonction copy(). La fonction retourne TRUE si tout se passe
correctement et sinon FALSE.

copy(string filename_source, string filename_destination);

Exemple

<?php
$source= "[Link]";

if(@copy($source, "../copy_fichier.txt")) {
echo "Le fichier " . $source . " a été copié ";
echo "dans le répertoire ../copy_fichier.txt.";
}
else {
echo "Erreur";
}
?>

Le fichier a été ainsi copié dans le répertoire père du répertoire courant où se trouve le fichier.

47 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.7. Renommer un fichier

Pour renommer un fichier, il faut utiliser la fonction rename().

rename(string nom_source, string nom_nouveau);

Exemple

<?php
$source= "[Link]";

if(@rename($source,"nouveau_fichier.txt")) {
echo "Le fichier " . $source . "a été renommé ";
echo "en nouveau_fichier.txt.";
}
else {
echo "Erreur";
}
?>

III.8. Supprimer un fichier

Pour supprimer un fichier, on utilise la fonction unlink().

unlink(string filename);

Exemple

<?php
$source= "[Link]";

if(@unlink($source)) {
echo "Le fichier a bien été supprimé.";
}
else {
echo "Erreur";
}
?>

48 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Tests de connaissances
1. Quelle différence faites-vous entre un tableau numérique et un tableau associatif en PHP ?
Donner un exemple pour chacun.
2. Quelle différence faites-vous entre « $_POST » et « $_GET » ?
3. Quelle différence faites-vous entre une session et un cookie en PHP ?
4. Selon vous quel est l’intérêt d’utiliser un fichier pour stocker les données ?

49 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

CHAPITRE III : PROGRAMMATION ORIENTE OBJET

(POO) EN PHP
Objectif du chapitre
Maîtriser les concepts liés la Programmation Orienté Objet (POO) en PHP.

Objectifs spécifiques
 Définir les notions telles que : classe, objet, instance, encapsulation, héritage et
polymorphisme ;
 Appréhender les notions d’auto-chargement de classes, et d’exceptions.

I. Introduction à la POO
Nous commencerons ce chapitre en vous posant une question : comment est représenté votre code ?
La réponse est unique : vous avez utilisé la « représentation procédurale » qui consiste à séparer le
traitement des données des données elles-mêmes. Par exemple, vous avez un système de news sur
votre site. D'un côté, vous avez les données (les news, une liste d'erreurs, une connexion à la BDD,
etc.) et de l'autre côté vous avez une suite d'instructions qui viennent modifier ces données. Si je ne
me trompe pas, c'est de cette manière que vous codez.

Eh bien, il existe une autre manière de coder : la Programmation Orienté Objet (POO). La POO,
c'est tout simplement faire de son site un ensemble d'objets qui interagissent entre eux. En d'autres
termes : tout est objet.

I.1. Définitions
I.1.1. Les Objets
Vous en avez pas mal à côté de vous : je suis sûr que vous avez un ordinateur, une lampe, une
chaise, un bureau, ou que sais-je encore. Ce sont tous des objets. En programmation, les objets sont
sensiblement la même chose.

L'exemple le plus pertinent quand on fait un cours sur la POO est d'utiliser l'exemple du personnage
dans un jeu de combat. Ainsi, imaginons que nous ayons un objet « Personnage » dans notre
application. Un personnage a des caractéristiques :
50 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

 Une force ;
 Une localisation ;
 Une certaine expérience ;
 Et enfin des dégâts.

Toutes ses caractéristiques correspondent à des valeurs. Comme vous le savez sûrement, les valeurs
sont stockées dans des variables. C'est toujours le cas en POO. Ce sont des variables un peu
spéciales, mais nous y reviendrons plus tard.

Mis à part ces caractéristiques, un personnage a aussi des capacités. Il peut :

 Frapper un autre personnage ;
 Gagner de l'expérience ;
 Se déplacer.
Ces capacités correspondent à des fonctions. Comme pour les variables, ce sont des fonctions un
peu spéciales et on y reviendra en temps voulu. En tout cas, le principe est là.
Vous savez désormais qu'on peut avoir des objets dans une application. Mais d'où sortent-ils ? Dans
la vie réelle, un objet ne sort pas de nulle part. En effet, chaque objet est défini selon des
caractéristiques et un plan bien précis. En POO, ces informations sont contenues dans ce qu'on
appelle des classes.

I.1.2. Les classes

Comme on vient de le dire, les classes contiennent la définition des objets que l'on va créer par la
suite. Prenons l'exemple le plus simple du monde : les gâteaux et leur moule. Le moule est unique.
Il peut produire une quantité infinie de gâteaux. Dans ce cas-là, les gâteaux sont les objets et le
moule est la classe : le moule va définir la forme du gâteau. La classe contient donc le plan de
fabrication d'un objet et on peut s'en servir autant qu'on veut afin d'obtenir une infinité d'objets.

Une classe est une entité regroupant des variables et des fonctions. Chacune de ces fonctions aura
accès aux variables de cette entité. Dans le cas du personnage, nous aurons une fonction
« frapper() ». Cette fonction devra simplement modifier la variable « $degats » du personnage en
fonction de la variable « $force ». Une classe est donc un regroupement logique de variables et
fonctions que tout objet issu de cette classe possédera.

I.1.3. Les instances

Une instance, c'est tout simplement le résultat d'une instanciation. Une instanciation, c'est le fait
d'instancier une classe. Instancier une classe, c'est se servir d'une classe afin qu'elle nous crée un
objet. En gros, une instance est un objet.

51 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

I.2. Exemple de création d’une classe

Nous allons créer une classe « Personnage » (sous forme de schéma). Celle-ci doit contenir la liste
des variables et des fonctions que l'on a citées plus haut : c'est la base de tout objet « Personnage ».
Chaque instance de cette classe possédera ainsi toutes ces variables et fonctions. Voici donc cette
fameuse classe à la figure suivante :

Vous voyez donc les variables et fonctions stockées dans la classe « Personnage ». Sachez qu'en
réalité, on ne les appelle pas comme ça : il s'agit d'attributs (ou propriétés) et de méthodes. Un
attribut désigne une variable et une méthode désigne une fonction.

Ainsi, tout objet « Personnage » aura ces attributs et méthodes. On pourra modifier ces attributs et
invoquer ces méthodes sur notre objet afin de modifier ses caractéristiques ou son comportement.

I.3. Le principe d'encapsulation

L'un des gros avantages de la POO est que l'on peut masquer le code à l'utilisateur. Le concepteur
de la classe a englobé dans celle-ci un code qui peut être assez complexe et il est donc inutile voire
dangereux de laisser l'utilisateur manipuler ces objets sans aucune restriction. Ainsi, il est important
d'interdire à l'utilisateur de modifier directement les attributs d'un objet. L'encapsulation garantit
ainsi la validité des types et des valeurs des données des objets.

Prenons l'exemple d'un avion où sont disponibles des centaines de boutons. Chacun de ces boutons
constituent des actions que l'on peut effectuer sur l'avion. C'est l'interface de l'avion. Le pilote se
moque de quoi est composé l'avion : son rôle est de le piloter. Pour cela, il va se servir des boutons
afin de manipuler les composants de l'avion. Le pilote ne doit pas se charger de modifier
manuellement ces composants : il pourrait faire de grosses bêtises.

52 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Le principe est exactement le même pour la POO : l'utilisateur de la classe doit se contenter
d'invoquer les méthodes en ignorant les attributs. Comme le pilote de l'avion, il n'a pas à les
trifouiller. Pour instaurer une telle contrainte, on dit que les attributs sont privés. Pour l'instant, ceci
peut sans doute vous paraître abstrait, mais nous y reviendrons.

I.4. Exemple pratique : création d’une classe

Il s’agit de traduire la figure précédente en code PHP.

I.4.1. Syntaxe de base

<?php
class Personnage { //Présence du mot-clé class suivi du nom de la classe.
// Déclaration des attributs et méthodes ici.
}
?>

Cette syntaxe est à retenir. Ce qu'on vient de faire est donc de créer le moule, le plan qui définira
nos objets.

La déclaration d'attributs dans une classe se fait en écrivant le nom de l'attribut à créer, précédé de
sa visibilité.

I.4.2. Visibilité d'un attribut ou d'une méthode

La visibilité d'un attribut ou d'une méthode indique à partir d'où on peut y avoir accès. Nous allons
voir ici deux types de visibilité : public et private (on a aussi protected mais nous le verrons dans
la notion d’héritage).

Le premier, public, est le plus simple. Si un attribut ou une méthode est public, alors on pourra y
avoir 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. Quand on crée un objet, c'est principalement pour pouvoir exploiter ses
attributs et méthodes. L'extérieur de l'objet, c'est tout le code qui n'est pas dans votre classe. En
effet, quand vous créerez un objet, cet objet sera représenté par une variable, et c'est à partir d'elle
qu'on pourra modifier l'objet, appeler des méthodes, etc. Vous allez donc dire à PHP « dans cet
objet, donne-moi cet attribut » ou « dans cet objet, appelle cette méthode » : c'est ça, appeler des
attributs ou méthodes depuis l'extérieur de l'objet.

Le second, private, impose quelques restrictions. On n'aura accès aux attributs et méthodes
seulement depuis l'intérieur de la classe, c'est-à-dire que seul le code voulant accéder à un attribut

53 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

privé ou une méthode privée écrit(e) à l'intérieur de la classe fonctionnera. Sinon, une jolie erreur
fatale s'affichera disant que vous ne pouvez pas accéder à telle méthode ou tel attribut parce qu'il ou
elle est privé(e).

I.4.3. Création d'attributs

Pour déclarer des attributs, on va donc les écrire entre les accolades, les uns à la suite des autres, en
faisant précéder leurs noms du mot-clé private.

<?php
class Personnage {
private $_force; // La force du personnage
private $_localisation; // Sa localisation
private $_experience; // Son expérience
private $_degats; // Ses dégâts
}
?>

Vous pouvez constater que chaque attribut est précédé d'un underscore (« _ »). Ceci est une notation
qu'il est préférable de respecter (il s'agit de la notation PEAR) qui dit que chaque nom d'élément
privé doit être précédé d'un underscore.

Vous pouvez initialiser les attributs lorsque vous les déclarez.

<?php
class Personnage {
private $_force = 50; // La force du personnage, par défaut à 50.
private $_localisation = 'Lyon'; // Sa localisation, par défaut à Lyon.
private $_experience = 1; // Son expérience, par défaut à 1.
private $_degats = 0; // Ses dégâts, par défaut à 0.
}
?>

NB : La valeur par défaut que vous donnez à vos variables doit être une expression scalaire statique.
Par conséquent, leur valeur ne peut par exemple pas être issue d'un appel à une fonction (private
$_attribut = strlen('azerty')) ou d'une variable, superglobale ou non (private $_attribut =
$_SERVER['REQUEST_URI']). Si votre version de PHP est antérieure à la 5.6, vous ne pouvez
spécifier que des valeurs statiques, ce qui rend impossible l'assignation du résultat d'une opération.
Par exemple, vous ne pouvez pas faire de private $_attribut = 1 + 1 ou bien private $_attribut =
'Hello ' . 'world !'

I.4.4. Création des méthodes

Pour la déclaration de méthodes, il suffit de faire précéder le mot-clé « function » à la visibilité de
la méthode. Les types de visibilité des méthodes sont les mêmes que les attributs. Les méthodes
n'ont en général pas besoin d'être masquées à l'utilisateur, vous les mettrez souvent en public (à
54 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

moins que vous teniez absolument à ce que l'utilisateur ne puisse pas appeler cette méthode, par
exemple s'il s'agit d'une fonction qui simplifie certaines tâches sur l'objet mais qui ne doit pas être
appelée n'importe comment).

<?php
class Personnage
{
private $_force; // La force du personnage
private $_localisation; // Sa localisation
private $_experience; // Son expérience
private $_degats; // Ses dégâts

public function deplacer() /* Une méthode qui déplacera le personnage

(modifiera sa localisation). */
{

public function frapper() /* Une méthode qui frappera un personnage

(suivant la force qu'il a). */
{

public function gagnerExperience() /* Une méthode augmentant l'attribut

$experience du personnage. */
{

}
}
?>

De même que l'underscore précédant les noms d'éléments privés, vous pouvez remarquer que le
nom des classes commence par une majuscule. Il s'agit aussi du respect de la notation PEAR.

II. Comment utiliser une classe en POO ?

Une classe, c'est bien beau mais, au même titre qu'un plan de construction pour une maison, si on ne
sait pas comment se servir de notre plan pour construire notre maison, cela ne sert à rien ! Nous
verrons donc ainsi comment se servir de notre classe, notre modèle de base, afin de créer des objets
et pouvoir s'en servir.

55 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

II.1. Créer et manipuler un objet

II.1.1. Créer un objet
Nous allons voir comment créer un objet, c'est-à-dire que nous allons utiliser notre classe afin
qu'elle nous fournisse un objet. Pour créer un nouvel objet, vous devez faire précéder le nom de la
classe à instancier du mot-clé « new ».

<?php
$perso = new Personnage;
?>

Ainsi, « $perso » sera un objet de type « Personnage ». On dit que l'on instancie la classe
Personnage ou que l'on crée une instance de la classe Personnage.

II.1.2. Appeler les méthodes de l'objet

Pour appeler une méthode d'un objet, il va falloir utiliser un opérateur : il s'agit de l'opérateur « -> »
(une flèche composée d'un tiret suivi d'un chevron fermant). Celui-ci s'utilise de la manière
suivante. À gauche de cet opérateur, on place l'objet que l'on veut utiliser et à droite de l'opérateur,
on spécifie le nom de la méthode que l'on veut invoquer.

<?php
/* Nous créons une classe « Personnage ». */
class Personnage {
private $_force;
private $_localisation;
private $_experience;
private $_degats;

/* Nous déclarons une méthode dont le seul but

est d'afficher un texte. */
public function parler() {
echo 'Je suis un personnage !';
}
}

$perso = new Personnage;

$perso->parler();
?>

La ligne « $perso->parler(); » signifie donc « va chercher l'objet $perso, et invoque la méthode

parler() sur cet objet ». Notez donc bien quelque part l'utilisation de cet opérateur : de manière
générale, il sert à accéder à un élément de la classe. Ici, on s'en est servi pour atteindre une méthode,
mais nous verrons plus tard qu'il nous permettra aussi d'atteindre un attribut.

56 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

II.1.3. Accéder à un élément depuis la classe

Nous venons de créer un objet, et nous sommes maintenant capables d'appeler une méthode.
Cependant, le contenu de cette dernière était assez simpliste : elle ne faisait qu'afficher un message.
Ici, nous allons voir comment une méthode peut accéder aux attributs de l'objet.

Lorsque vous avez un objet, vous savez que vous pouvez invoquer des méthodes grâce à l'opérateur
« -> ». Nous avons par ailleurs dit que c'était également grâce à cet opérateur qu'on accédait aux
attributs de la classe. Cependant, rappelez-vous : nos attributs sont privés. Par conséquent, le code
ci-dessous lèvera une erreur fatale.

<?php
class Personnage {
private $_force;
private $_experience;
private $_degats;
}

$perso = new Personnage;

$perso->_experience = $perso->_experience + 1; /* Une erreur fatale est
levée suite à cette instruction. */
?>

Ici, on essaye d'accéder à un attribut privé hors de la classe. Ceci est interdit, donc PHP lève une
erreur. Dans notre exemple (qui essaye en vain d'augmenter de 1 l'expérience du personnage), il
faudra demander à la classe d'augmenter l'expérience. Pour cela, nous allons écrire une méthode
« gagnerExperience() », nous allons y ajouter également la méthode « afficherExperience() »
pour afficher l’expérience.

<?php
class Personnage {
private $_experience = 50;

public function afficherExperience() {

echo $this->_experience;
}

public function gagnerExperience() {

/* On ajoute 1 à notre attribut $_experience. */
$this->_experience = $this->_experience + 1;
}
}

$perso = new Personnage;

$perso->gagnerExperience(); /* On gagne de l'expérience. */
$perso->afficherExperience(); /* On affiche la nouvelle valeur de
l'attribut. */
?>

57 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

II.1.4. Autres méthodes

Soit la classe ci-dessous :

<?php
class Personnage {
private $_degats = 0; /* Les dégâts du personnage. */
private $_experience = 0; /* L'expérience du personnage. */
private $_force = 20; /* La force du personnage (plus elle est grande,
plus l'attaque est puissante). */

public function gagnerExperience() {

/* On ajoute 1 à notre attribut $_experience. */
$this->_experience = $this->_experience + 1;
}
?>

On désire implémenté une méthode « frapper() », qui devra infliger des dégâts à un personnage.
Cette méthode doit accepter un argument : le personnage à frapper. La méthode aura juste pour rôle
d'augmenter les dégâts du personnage à frapper passé en paramètre en fonction de la force du
personnage qui frappe c'est-à-dire ajouter aux dégâts du personnage à frapper, la force du
personnage qui frappe.

Ainsi on aura :

<?php
class Personnage {
private $_degats; /* Les dégâts du personnage. */
private $_experience; /* L'expérience du personnage. */
private $_force; /* La force du personnage (plus elle est grande, plus
l'attaque est puissante). */

public function frapper(Personnage $persoAFrapper) {

$persoAFrapper->_degats += $this->_force;
}

public function gagnerExperience() {

/* On ajoute 1 à notre attribut $_experience. */
$this->_experience = $this->_experience + 1;
}
}

$perso1 = new Personnage; /* Un premier personnage */

$perso2 = new Personnage; /* Un second personnage */

$perso1->frapper($perso2); /* $perso1 frappe $perso2 */

$perso1->gagnerExperience(); /* $perso1 gagne de l'expérience */

$perso2->frapper($perso1); /* $perso2 frappe $perso1 */

$perso2->gagnerExperience(); /* $perso2 gagne de l'expérience */

?>

58 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Cette expression « Personnage $persoAFrapper » permet de s’assurer qui s’agit bel et bien d’un
personnage passé en paramètre à la fonction « frapper »

Puisque, à la base, les deux personnages ont le même niveau de dégâts, la même expérience et la
même force, ils seront à la fin toujours égaux. Pour pallier ce problème, il faudrait pouvoir assigner
des valeurs spécifiques aux deux personnages, afin que le combat puisse les différencier. Or, vous
ne pouvez pas accéder aux attributs en-dehors de la classe ! Pour savoir comment résoudre ce
problème, nous allons apprendre deux nouveaux mots : accesseur et mutateur.

II.2. Les accesseurs et mutateurs

Comme vous le savez à l’exemple précédent, le principe d'encapsulation nous empêchait d'accéder
directement aux attributs de notre objet puisqu'ils étaient privés : seule la classe pouvait les lire et
les modifier. Par conséquent, si on voulait récupérer un attribut, il fallait le demander à la classe, de
même si on voulait les modifier.

II.2.1. Accéder à un attribut : l'accesseur

À votre avis, comment peut-on faire pour récupérer la valeur d'un attribut ? La solution est simple :
nous allons implémenter des méthodes dont le seul rôle sera de nous donner l'attribut qu'on leur
demande ! Ces méthodes ont un nom bien spécial : ce sont des accesseurs (ou getters). Par
convention, ces méthodes portent le même nom que l'attribut dont elles renvoient la valeur. Par
exemple, voici la liste des accesseurs de notre classe Personnage :

59 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php
class Personnage {
private $_force;
private $_experience;
private $_degats;

public function frapper(Personnage $persoAFrapper) {

$persoAFrapper->_degats += $this->_force;
}

public function gagnerExperience() {

/* Ceci est un raccourci qui équivaut à écrire « $this->_experience =
$this->_experience + 1 » */
/* On aurait aussi pu écrire « $this->_experience += 1 » */
$this->_experience++;
}

/* Ceci est la méthode getDegats() : elle se charge de renvoyer le

contenu de l'attribut $_degats. */
public function getDegats() {
return $this->_degats;
}

/* Ceci est la méthode getForce() : elle se charge de renvoyer le

contenu de l'attribut $_force. */
public function getForce() {
return $this->_force;
}

/* Ceci est la méthode getExperience() : elle se charge de renvoyer le

contenu de l'attribut $_experience. */
public function getExperience() {
return $this->_experience;
}
}
?>

II.2.2. Modifier la valeur d'un attribut : les mutateurs

Maintenant, comment cela se passe-t-il si vous voulez modifier un attribut ? Encore une fois, il va
falloir que vous demandiez à la classe de le faire pour vous. Je vous rappelle que le principe
d'encapsulation est là pour vous empêcher d'assigner un mauvais type de valeur à un attribut : si
vous demandez à votre classe de le faire, ce risque est supprimé car la classe « contrôle » la valeur
des attributs. Comme vous l'aurez peut-être deviné, ce sera par le biais de méthodes que l'on
demandera à notre classe de modifier tel attribut.

La classe doit impérativement contrôler la valeur afin d'assurer son intégrité car, si elle ne le fait
pas, on pourra passer n'importe quelle valeur à la classe et le principe d'encapsulation n'est plus
respecté ! Ces méthodes ont aussi un nom spécial : il s'agit de mutateurs (ou setters). Par exemple,
voici la liste des mutateurs de notre classe Personnage :

60 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php
class Personnage {
private $_force;
private $_experience;
private $_degats;

public function frapper(Personnage $persoAFrapper) {

$persoAFrapper->_degats += $this->_force;
}

public function gagnerExperience() {

/* Ceci est un raccourci qui équivaut à écrire
« $this->_experience = $this->_experience + 1 » */
/* On aurait aussi pu écrire « $this->_experience += 1 » */
$this->_experience++;
}

/* Mutateur chargé de modifier l'attribut $_force. */

public function setForce($force) {
if (!is_int($force)) {
trigger_error('La force d\'un personnage doit être un nombre entier', E_USER_WARNING);
return;
}

if ($force > 100) {

trigger_error('La force d\'un personnage ne peut dépasser 100', E_USER_WARNING);
return;
}
$this->_force = $force;
}

/* Mutateur chargé de modifier l'attribut $_experience. */

public function setExperience($experience) {
if (!is_int($experience)) {
trigger_error('L\'expérience d\'un personnage doit être un nombre entier',
E_USER_WARNING);
return;
}

if ($experience > 100) {

trigger_error('L\'expérience d\'un personnage ne peut dépasser 100', E_USER_WARNING);
return;
}

$this->_experience = $experience;
}

/* Ceci est la méthode getDegats() :

elle se charge de renvoyer le contenu de l'attribut $_degats. */
public function getDegats() {
return $this->_degats;
}

/* Ceci est la méthode getForce() :

elle se charge de renvoyer le contenu de l'attribut $_force. */
public function getForce() {
return $this->_force;
}

/* Ceci est la méthode getExperience() :

elle se charge de renvoyer le contenu de l'attribut $_experience. */
public function getExperience() {
return $this->_experience;
}
}
?>

61 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Maintenant que nous avons vu ce qu'étaient des accesseurs et des mutateurs, nous pouvons écrire un
petit script de combat à travers la classe Personnage de la manière suivante :

<?php

$perso1 = new Personnage; // Un premier personnage

$perso2 = new Personnage; // Un second personnage

$perso1->setForce(10);
$perso1->setExperience(2);

$perso2->setForce(90);
$perso2->setExperience(58);

$perso1->frapper($perso2); // $perso1 frappe $perso2

$perso1->gagnerExperience(); // $perso1 gagne de l'expérience

$perso2->frapper($perso1); // $perso2 frappe $perso1

$perso2->gagnerExperience(); // $perso2 gagne de l'expérience

echo 'Le personnage 1 a '.$perso1->force().' de force, contrairement au personnage

2 qui a '.$perso2->force().' de force.<br />';
echo 'Le personnage 1 a '.$perso1->experience().' d\'expérience, contrairement au
personnage 2 qui a '.$perso2->experience().' d\'expérience.<br />';
echo 'Le personnage 1 a '.$perso1->degats().' de dégâts, contrairement au
personnage 2 qui a '.$perso2->degats().' de dégâts.<br />';

?>

II.3. Le constructeur
Imaginez un objet pour lequel vous avez besoin d'initialiser les attributs dès sa création, sans
connaitre leurs valeurs à l'avance. Par exemple, vous souhaiteriez pouvoir spécifier la force et les
dégâts d'un personnage dès sa création. Actuellement, la seule possibilité qui s'offre à vous est de
modifier ces attributs manuellement, une fois l'objet créé. Il existe en PHP une méthode, appelée le
constructeur, qui remplira ce rôle. Ce constructeur n'est autre qu'une méthode écrite dans votre
classe.

Effectuons un retour sur notre classe Personnage. Ajoutons-lui un constructeur. Ce dernier ne peut
pas avoir n'importe quel nom (sinon, comment PHP sait quel est le constructeur ?). Il a tout
simplement le nom suivant :__construct, avec deux underscores au début.

Comme son nom l'indique, le constructeur sert à construire l'objet. Ce que nous voulons dire par là,
c'est que si des attributs doivent être initialisés ou qu'une connexion à la BDD doit être faite, c'est
par ici que ça se passe. Comme dit plus haut, le constructeur est exécuté dès la création de l'objet et
par conséquent, aucune valeur ne doit être retournée, même si ça ne génèrera aucune erreur. Bien
sûr, et comme nous l'avons vu, une classe fonctionne très bien sans constructeur, il n'est en rien
obligatoire ! Si vous n'en spécifiez pas, cela revient au même que si vous en aviez écrit un vide
(sans instruction à l'intérieur).

62 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php

class Personnage {
private $_force;
private $_localisation;
private $_experience;
private $_degats;

/* Constructeur demandant 2 paramètres */

public function __construct($force, $degats) {
echo 'Voici le constructeur !'; /* Message s'affichant une fois que tout
objet est créé. */
$this->setForce($force); /* Initialisation de la force. */
$this->setDegats($degats); /* Initialisation des dégâts. */
$this->_experience = 1; /* Initialisation de l'expérience à 1. */
}

/* reste du code précédent de la classe à charger ici */

Notez que nous n’avons pas réécrit toutes les méthodes, ce n'est pas le but de ce que nous voulons
vous montrer ici.
Ici, le constructeur demande la force et les dégâts initiaux du personnage que l'on vient de créer. Il
faudra donc lui spécifier ceci en paramètre :

<?php

$perso1 = new Personnage(60, 0); // 60 de force, 0 dégât

$perso2 = new Personnage(100, 10); // 100 de force, 10 dégâts

Notez quelque chose d'important dans la classe : dans le constructeur, les variables (attributs) sont
initialisées en appelant les mutateurs correspondant. En effet, si on assignait directement à ces
variables des valeurs, le principe d'encapsulation ne serait plus respecté et n'importe quel type de
valeur pourrait être assigné !

Attention : Ne mettez jamais la méthode __construct avec le type de visibilité private car elle ne
pourra jamais être appelée, vous ne pourrez donc pas instancier votre classe ! Cependant, sachez
qu'il existe certains cas particuliers qui nécessitent le constructeur en privé, mais ce n'est pas pour
tout de suite.

II.4. L'auto-chargement de classes

Pour une question d'organisation, il vaut mieux créer un fichier par classe. Vous appelez votre
fichier comme bon vous semble et placez votre classe dedans. Pour ma part, mes fichiers sont
toujours appelés « [Link] ». Ainsi, si je veux pouvoir utiliser la classe MaClasse, je
n'aurais qu'à inclure ce fichier :

63 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php
// On inclut la classe.
require '[Link]';

// Puis, seulement après, je me sers de ma classe.

$objet = new MaClasse;
?>

Maintenant, imaginons que vous ayez plusieurs dizaines de classes… Pas très pratique de les
inclure une par une ! Vous vous retrouverez avec des dizaines d'inclusions, certaines pouvant même
être inutile si vous ne vous servez pas de toutes vos classes. Et c'est là qu'intervient l'auto-
chargement des classes. Vous pouvez créer dans votre fichier principal (c'est-à-dire celui où vous
créerez une instance de votre classe) une ou plusieurs fonction(s) qui tenteront de charger le fichier
déclarant la classe. Dans la plupart des cas, une seule fonction suffit. Ces fonctions doivent accepter
un paramètre, c'est le nom de la classe qu'on doit tenter de charger. Par exemple, voici une fonction
qui aura pour rôle de charger les classes :

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

Si nous essayons maintenant de créer un objet pour voir si il sera chargé automatiquement (nous
prenons pour exemple la classe Personnage et prenons en compte le fait qu'un fichier
[Link] existe), nous aurons une jolie erreur du genre : « erreur fatale, la classe n’a pas été
trouvée ». Ce qui est normal quand on y réfléchi.

PHP ne sait pas qu'il doit appeler cette fonction lorsqu'on essaye d'instancier une classe non
déclarée. Ainsi, pour palier à ce problème, on va donc utiliser la fonction « spl_autoload_register »
en spécifiant en premier paramètre le nom de la fonction à charger :

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

/* On enregistre la fonction en autoload pour qu'elle soit appelée dès

qu'on instanciera une classe non déclarée. */
spl_autoload_register('chargerClasse');

$perso = new Personnage;

?>

Et là, aucune erreur ne s'affiche ! Notre auto-chargement a donc bien fonctionné.

64 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Décortiquons ce qui s'est passé. En PHP, il y a ce qu'on appelle une « pile d'autoloads ». Cette pile
contient une liste de fonctions. Chacune d'entre elles sera appelée automatiquement par PHP
lorsque l'on essaye d'instancier une classe non déclarée. Nous avons donc ici ajouté notre fonction à
la pile d'autoloads afin qu'elle soit appelée à chaque fois qu'on essaye d'instancier une classe non
déclarée.

Schématiquement, la figure suivante montre ce qui s'est passé.

NB : Sachez que vous pouvez enregistrer autant de fonctions en autoload que vous le voulez avec
spl_autoload_register. Si vous en enregistrez plusieurs, elles seront appelées dans l'ordre de leur
enregistrement jusqu'à ce que la classe soit chargée. Pour y parvenir, il suffit d'appeler
spl_autoload_register pour chaque fonction à enregistrer.

Attention : Pour que l’auto-chargement des classes fonctionne, il faut que le nom de la classe et le
fichier .php qui contient la classe porte exactement le même nom et que chaque classe corresponde
à un et un seul fichier .php.

65 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III. Les exceptions

Les exceptions sont pour beaucoup de personnes un système élaboré de gestion d'erreur. Ce n'est
pas le cas. Et même si dans la pratique, on peut, comme nous le verrons, établir des liens entre ces
deux concepts, leurs buts sont totalement différents. Une erreur est dans la majorité des cas
assimilable à un bug, c'est à dire une réaction non désirée. Une exception est un traitement qui sera
appelé lorsqu'un cas particulier est détecté pendant le déroulement du programme.

Pour synthétiser, une erreur est le résultat d’un fonctionnement anormal alors qu'une exception est
un fonctionnement normal, mais exceptionnel.

III.1. Gestion des exceptions

Les exceptions, comme nous l'avons évoqué sont une façon différente de gérer les erreurs. Celles-ci
sont en fait des erreurs lancées par PHP lorsque quelque chose qui ne va pas est survenu. Nous
allons commencer par lancer nos propres exceptions. Pour cela, on va devoir s'intéresser à la classe
« Exception ».

Lancer une exception

Une exception peut être lancée depuis n'importe où dans le code. Quand on lance une exception, on
doit, en gros, lancer une instance de la classe « Exception ». Cet objet lancé contiendra le message
d'erreur.

<?php
function additionner($a, $b) {
if (!is_numeric($a) || !is_numeric($b)) {
// On lance une nouvelle exception grâce à throw et on instancie directement un
objet de la classe Exception.
throw new Exception('Les deux paramètres doivent être des nombres');
}

return $a + $b;
}

echo additionner(12, 3) . '<br />';

echo additionner('azerty', 54) . '<br />';
echo additionner(4, 8);
?>

Attention : Ne lancez jamais d'exception dans un destructeur. Si vous faites une telle chose, vous
aurez une erreur fatale : Exception thrown without a stack frame in Unknown on line 0.

66 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Attraper une exception

Afin d'attraper une exception, il faut d'abord qu'elle soit lancée. Le problème, c'est qu'on ne peut pas
dire à PHP que toutes les exceptions lancées doivent être attrapées : c'est à nous de lui dire que l'on
va essayer d'effectuer telle ou telle instruction et, si une exception est lancée, alors on attrapera
celle-ci afin qu'aucune erreur fatale ne soit lancée et que de tels messages ne s'affichent plus.

Pour attraper une exception on utilise le bloc d’instructions suivant :

try {

// Instructions

}catch(<type exception>){

// Instructions

Où <type exception> correspond au type d’exception à attraper. Une fois le type d’exception
attrapé il faut afficher le message d'erreur. Pour ce faire, il faut appeler la méthode
« getMessage() ». Si vous souhaitez récupérer le code d'erreur, il faut appeler « getCode() ».

<?php
function additionner($a, $b){
if (!is_numeric($a) || !is_numeric($b)) {
/* On lance une nouvelle exception si l'un des deux paramètres n'est pas un
nombre. */
throw new Exception('Les deux paramètres doivent être des nombres');
}

return $a + $b;
}

/* On va essayer d'effectuer les instructions situées dans ce bloc. */

try {
echo additionner(12, 3), '<br />';
echo additionner('azerty', 54), '<br />';
echo additionner(4, 8);
}

/* On va attraper les exceptions "Exception" s'il y en a une qui est levée. */

catch (Exception $e) {
echo 'Une exception a été lancée. Message d\'erreur : ', $e->getMessage();
}
?>

67 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.2. Des exceptions spécialisées

PHP nous offre la possibilité d'hériter la classe Exception afin de personnaliser nos exceptions. Par
exemple, nous pouvons créer une classe « MonException » qui réécrira des méthodes de la
classe Exception ou en créera de nouvelles qui lui seront propres.

Avant de ce lancer dans ce genre de pratique, encore faut-il savoir quelles méthodes et attributs
seront disponibles dans la classe Exception. Voici la liste des attributs et méthodes de la classe
Exception tirée de la documentation :

<?php
class Exception {
protected $message = 'exception inconnu'; // Message de l'exception.
protected $code = 0; // Code de l'exception défini par l'utilisateur.
protected $file; // Nom du fichier source de l'exception.
protected $line; // Ligne de la source de l'exception.

final function getMessage(); // Message de l'exception.

final function getCode(); // Code de l'exception.
final function getFile(); // Nom du fichier source.
final function getLine(); // Ligne du fichier source.
final function getTrace(); // Un tableau de backtrace().
final function getTraceAsString(); // Chaîne formattée de trace.

/* Remplacable */
function __construct ($message = NULL, $code = 0);
function __toString(); // Chaîne formatée pour l'affichage.
}
?>

Nous allons donc créer notre classe MonException qui, par exemple, réécrira le constructeur en
rendant obligatoire le premier argument ainsi que la méthode __toString pour n'afficher que le
message d'erreur

<?php
class MonException extends Exception {
public function __construct($message, $code = 0) {
parent::__construct($message, $code);
}

public function __toString() {

return $this->message;
}
}
?>

Maintenant que nous avons crée notre classe MonException, nous n'allons pas lancer d'exception
Exception mais une exception de type MonException.

68 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

<?php
class MonException extends Exception {
public function __construct($message, $code = 0) {
parent::__construct($message, $code);
}

public function __toString() {

return $this->message;
}
}

function additionner($a, $b) {

if (!is_numeric($a) || !is_numeric($b)) {
/* On lance une exception "MonException". */
throw new MonException('Les deux paramètres doivent être des nombres');
}

return $a + $b;
}

/* Nous allons essayer d'effectuer les instructions situées dans ce bloc. */

try {
echo additionner(12, 3), '<br />';
echo additionner('azerty', 54), '<br />';
echo additionner(4, 8);
}

/* Nous allons attraper les exceptions "MonException" s'il y en a une qui est
levée. */
catch (MonException $e) {
/* On affiche le message d'erreur grâce à la méthode __toString que l'on a
écrite. */
echo $e;
}

/* Ce message s'affiche, ceci prouve bien que le script est exécuté jusqu'au
bout. */
echo '<br />Fin du script';
?>

Si jamais une exception est lancée dans un bloc try mais non attrapée dans un bloc catch, alors une
erreur fatale sera levée car l'exception ne sera pas attrapée. Il existe une façon d'exécuter du code
avant de lever l'erreur fatale grâce au bloc finally.

<?php
function additionner($a, $b){
if (!is_numeric($a) || !is_numeric($b)) {
throw new Exception('Les deux paramètres doivent être des nombres');
}
return $a + $b;
}

try { echo additionner('azerty', 54), '<br />'; }

finally { echo 'Action effectuée quoi qu\'il arrive''; }

?>

69 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.3. Convertir une erreur en exception

Etant donné que les messages de type warning sont très laids à voir, il faudrait trouver un moyen de
mieux les gérer pour éviter qu’ils n’apparaissent. Ainsi, afin de les gérer au mieux d'un point de vue
qualité du code, il est possible de les convertir en exception.

Pour cela, nous allons avoir besoin de la fonction « set_error_handler ». Celle-ci permet
d'enregistrer une fonction en callback qui sera appelée à chaque fois qu’une erreur sera lancée.
Cette fonction permet de changer tous les messages d'erreurs en « ErrorException » qui est une
classe qui hérite de la classe « Exception ».

Le prototype de la classe « ErrorException » est le suivant :

ErrorException extends Exception {

/* Propriétés */
protected int $severity ;
/* Propriétés héritées */
protected string $message ;
protected int $code ;
protected string $file ;
protected int $line ;
/* Méthodes */
public __construct ([ string $message = "" [, int $code = 0 [, int $severity = E_ERROR [,
string $filename = __FILE__ [, int $lineno = __LINE__ [, Exception $previous = NULL ]]]]]] )
final public getSeverity ( void ) : int
/* Méthodes héritées */
final public Exception::getMessage ( void ) : string
final public Exception::getPrevious ( void ) : Throwable
final public Exception::getCode ( void ) : mixed
final public Exception::getFile ( void ) : string
final public Exception::getLine ( void ) : int
final public Exception::getTrace ( void ) : array
final public Exception::getTraceAsString ( void ) : string
public Exception::__toString ( void ) : string
final private Exception::__clone ( void ) : void
}

La fonction « set_error_handler » doit être placée avant le début du bloc try-catch, en lui passant
en paramètre le nom d'une fonction que nous allons utiliser pour convertir l’erreur en exception.

Pour illustrer au mieux cette conversion, prenons l’exemple d’une erreur assez évidente à détecter
qu’est la division d’un nombre par 0.

<?php
function error2exception($code, $message, $fichier, $ligne) {
throw new Exception($message);
}

set_error_handler('error2exception');

try { echo 8/0; }

catch(Exception $e) { echo $e->getMessage(); }
?>

70 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Tests de connaissances
1. Définir : POO, classe, objet, instance.
2. Quel est la syntaxe de déclaration d’une classe ?
3. Décrire le principe d’encapsulation et appliquer ce principe dans un exemple de votre
choix ?
4. A quoi sert le constructeur d’une classe ?
5. Comment mettre en place l’auto-chargement des classes en POO ?
6. Quelle différence faites-vous entre erreur et exception ?
7. Comment mettre en place une exception ? Illustrer avec un exemple.
8. Quelle méthode permet de convertir une erreur en exception ?

71 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

CHAPITRE IV : PHP ET MYSQL

Objectif du chapitre
Manipulation des données stockées dans une base de données (MySQL).

Objectifs spécifiques
 Définition et manipulation de l’objet PDO
 Définition du principe de connexion et de gestion une base de données à l’aide de l’objet
PDO
 Utilisation du langage SQL pour la gestion des requêtes

I. Système de Gestion de Base de Données (SGBD)

Tout Site Web dynamique doit être capable de sauvegarder des données afin de les utiliser
ultérieurement. Comme vous le savez sans doute, l'un des moyens les plus simples et efficaces est
la base de données (BDD) permettant de sauvegarder des centaines de données et de les récupérer
en un temps très court.

Les Sites Web dynamiques reposent généralement sur des bases de données qui sont interrogées par
les scripts utilisés pour leur développement (comme PHP). Le contenu ainsi visible sur la page
provient partiellement (voir entièrement) de la base de données. Donc, le fait de modifier les
données stoquées dans celle-ci revient à modifier le contenu du site Web.

Le SGBD (Système de Gestion de Base de Données) le plus connu pour accompagner le langage
PHP est MySQL. Cependant, PHP peut aussi dialoguer avec plusieurs autres SGBD comme
PostgreSQL, Oracle, SQL Server...

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

Bien que ces fonctions marchaient très bien, leurs limites n'ont pas mis beaucoup de temps pour se
manifester, en particulier quand on souhaite migrer vers un SGBD autre que MySQL. En effet,
toutes ces fonctions préfixées par mysql_ n'auraient pas marché. Il faut par conséquent repasser en
vue une grande partie du code déjà développé.
72 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

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

II. L’objet PDO (PHP Data Object)

PDO signifie PHP Data Object. Il s'agit d'une interface qui permet au script PHP d’interroger une
base de données via des requêtes SQL.

PDO est une extension qui s'ajoute au PHP pour que ses différentes fonctionnalités soient
disponibles dans le langage. Il constitue une interface d'abstraction de la base de données, c'est à
dire qu'on peut utiliser l'ensemble de ses fonctions pour exécuter des requêtes SQL quelque soit le
SGBD. Autrement dit, si l'application Web repose sur le SGBD MysQL, on peut migrer vers le
SGBD PostgreSQL sans modifier le code source (quelques modifications mineures sont requises).

L'abstraction de la base de données constitue un point fort par rapport aux anciennes méthodes
d'accès à celles-ci. D'ailleurs, il constitue l'ultime avantage du PDO, sans en être le seul.

Le bon fonctionnement de PDO repose sur la disponibilité du pilote de la base de données. Il faut
que celui-ci soit pris en charge pour pouvoir interroger le SGBD souhaité.

Pour déclarer le pilote du SBGD MySQL par exemple, il faut aller dans le fichier [Link] et ajouter
la ligne suivante (si elle n'est pas déjà déclarée) :

extension = php_pdo_mysql.dll

Dans certains cas il faudrait également ligne suivante :

extension = php_pdo.dll

III. Utilisation de l'objet PDO

Pour simplifier l'explication, nous allons nous basé sur un exemple :

Supposons que le serveur de base de données est le serveur local (WampServer) et que la base
données (MySQL) que l'on souhaite interroger s'appelle "mabase".

CREATE DATABASE mabase;

73 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Pour arriver à interroger cette base de données on utilisera le nom d'utilisateur "root" (valeur par
défaut lors de l’installation) et le mot de passe "" (valeur par défaut lors de l’installation). Bien
entendu, l'utilisateur "root" dispose de tous les privilèges pour interroger la base de données via les
scripts PHP.

On suppose maintenant que dans la base de données "mabase" on a créé une table nommée
"utilisateurs" dont la structure est la suivante :

USE mabase;
CREATE TABLE utilisateurs (
id integer not null auto_increment,
nom varchar(128) not null,
prenom varchar(128) not null,
login varchar(128) not null,
pass varchar(128) not null,
PRIMARY KEY (id)
);

Maintenant que tous les paramètres de notre base de données sont là. On va voir comment
l'interroger à l'aide de PHP via l'objet PDO.

III.1. Chaîne de connexion (Instance PDO)

La Chaîne de connexion est la représentation textuelle des informations de connexion à la base de
données installée sur un serveur. La déclaration de la chaîne de connexion dans ce cas revient à
créer une instance PDO comme ceci:

<?php
$pdo = new PDO("mysql:host=localhost;dbname=mabase","root","");
?>

$pdo correspond à l'instance PDO créée en passant au constructeur les paramètres qui constituent la
chaîne de connexion. Trois paramètres sont renseignés :

1. Le premier paramètre correspond à la chaîne de caractères

"mysql:host=localhost;dbname=mabase". Le mot clé « mysql » s'appelle DSN (pour
Data Source Name). Il indique qu'on a affaire à une base de données MySQL. Si vous
utilisez un autre SGBD vous renseignez le DSN correspondant. D'ailleurs, c'est
pratiquement le seul paramètre qui change quand on passe d'un SGBD à un autre (d'où le
nom abstraction de la base de données).

Après le DSN on met deux points « : » suivis des mots clés « host » et « dbname »
auxquels on affecte respectivement le nom du serveur de base de données (localhost dans ce
cas) et le nom de la base de données (mabase).

74 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Il est possible d'ajouter d'autres mots clés comme port pour désigner un numéro de port
particulier (sur lequel le SBGD écoute les requêtes) ou charset pour spécifier l'encodage (ou
jeux de caractères). Ces différents paramètres sont espacés par point virgule.

2. Le deuxième paramètre correspond au nom d'utilisateur qui doit être préalablement créé
sur le serveur de base de données. Cet utilisateur détient un certains nombre de privilèges et
il ne peut passer au serveur que les requêtes définies par les privilèges qui lui sont attribués.

3. Le troisième paramètre correspond au mot de passe de l'utilisateur.

III.2. Gestion d'erreurs éventuelles lors de l'instanciation

d’un objet PDO
Si les paramètres renseignés au constructeur de la classe PDO sont corrects et que le serveur de base
de données fonctionne normalement alors l'objet $pdo sera créé sans encombre. Par contre si les
paramètres ne sont pas bien déclarés ou que le serveur de base de données n'est pas accessible alors
une exception de type PDOException est lancée automatiquement. Il faut donc la rattraper comme
ceci :

<?php
try {
$pdo=new PDO("mysql:host=localhost;dbname=mabase","root","");
}
catch(PDOException $e){
echo $e->getMessage();
}
?>

Certes PDOException permet de capturer l’exception lors de la création de l’objet PDO c'est-à-dire
lors de la connexion du script PHP avec la base de données. Mais cependant les exceptions
soulevées lors de l’exécution des requêtes (INSERT, SELECT, UPDATE, DELETE) avec l’objet
PDO ne seront pas capturées. Donc si vous essayez le code suivant vous n’aurez aucune exception
soulevée :

<?php
try {
$pdo=new PDO("mysql:host=localhost;dbname=mabase","root","");
$pdo->exec('insert into utilisateursxxx(nom, prenom, login, pass)
values("User", "User", "test","test")');
}
catch(PDOException $e){
echo $e->getMessage();
}
?>

75 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

Et pourtant il ya bien erreur au niveau du nom de la table « utilisateurs ». Ceci est dû au fait que le
rapport d’erreurs de l’objet PDO nouvellement crée est par défaut à l’état
« ERRMODE_SILENT » : ce qui signifie qu’il assigne simplement les codes d’erreur et ne
soulève donc aucune exception.

Ainsi, pour palier à ce problème il faudrait changer l’état du rapport d’erreurs de l’objet PDO après
sa création à « ERRMODE_EXCEPTION ». Pour cela on utilise la méthode « setAttribute » qui
permet de configurer un attribut PDO. On a donc le code suivant :

<?php
try {
$pdo=new PDO("mysql:host=localhost;dbname=mabase","root","");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
catch(PDOException $e){
echo $e->getMessage();
}
?>

Il arrive également dans certains cas où l’on ne parvient à manipuler des caractères suivant
l’encodage UTF-8 avec l’objet PDO pas mauvaise configuration des paramètres d’encodage soit sur
le serveur Web (WampServer), soit la base de données créée avec MySQL.

Pour palier à ce problème, il suffit de configurer l’encodage directement lors de la création de

l’objet PDO. On a donc le code suivant :

<?php
try {
$pdo=new PDO("mysql:host=localhost;dbname=mabase","root","",
array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8"));
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
catch(PDOException $e){
echo $e->getMessage();
}
?>

On imagine que si notre projet Web est composé de plusieurs pages, alors la plupart d'entre elles
aura besoin de dialoguer avec la base de données. Le code précédent sera donc déclaré dans
chacune d'elles. Il faut alors songer à mettre ce code dans un fichier à part qu'on inclura au besoin (à
l'aide de include() ou require()...).

76 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.3. Préparation et exécution des requêtes (Requêtes

préparées)
L'un des points fort de PDO est les requêtes préparées. En effet, une requête préparée est plus
rapide et, aussi, plus sûre (surtout contre les tentatives d'injections SQL1).

Pour préparer une requête, il est recommandé de ne pas y spécifier les valeurs, mais plutôt
remplacer celle-ci par des marqueurs interrogatifs (?) ou des paramètres nommés.
Pour mieux comprendre, supposons que l'on veut insérer dans la table "utilisateurs" les valeurs
suivantes:
 Nom: Einstein
 Prénom: Albert
 Login: [Link]
 Mot de passe: 2020

Nous allons donc préparer la requête puis l’exécuter comme ceci :

<?php
try {
$pdo=new PDO("mysql:host=localhost;dbname=mabase","root","");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

$req = $pdo->prepare("insert into utilisateurs (nom,prenom,login,pass)

values(?,?,?,?)");
$req->execute(array(
"Einstein",
"Albert",
"[Link]",
md5("2020")
));
}
catch(PDOException $e){
echo $e->getMessage();
}
?>

La méthode prepare() de l'objet PDO permet de préparer une requête. Elle accepte comme
paramètre une chaîne de caractères qui correspond à la requête souhaitée. Les marqueurs
interrogatifs sont là pour désigner les valeurs à passer à la requête. Ces valeurs seront ensuite
passées lors de l’exécution de la requête. $req est l'objet correspondant à la requête préparée.

La méthode execute() est appelée par l'objet $req qui correspond à la requête préparée. Elle accepte
comme paramètre une variable de type tableau qui contient les valeurs qui remplaceront, dans

1
L'injection SQL est une méthode d'attaque très connue. C'est un vecteur d'attaque extrêmement puissant quand il est
bien exploité. Il consiste à modifier une requête SQL en injectant des morceaux de code non filtrés, généralement par le
biais d'un formulaire.
77 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31
 Programmation Web II 2024 / 2025

l'ordre, les marqueurs interrogatif. Première entrée pour le premier marqueur, deuxième entrée pour
le deuxième marqueur et ainsi de suite.

Si la requête préparée ne contient aucun marqueur interrogatif alors la méthode execute() est laissée
vide.

Remarque : Vous avez sans doute remarqué que le mot de passe a été haché par la fonction md5().
Il ne faut jamais stocker les mots de passe en claire (ni dans un fichier, ni dans la base de données).

Le traitement précédent peut être fait à l'aide des paramètres nommés au lieu des marqueurs
interrogatifs comme ceci :

<?php
try {
$pdo=new PDO("mysql:host=localhost;dbname=mabase","root","");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

$req = $pdo->prepare("insert into utilisateurs (nom,prenom,login,pass)

values(:nom,:prenom,:login,:pass)");
$req->execute(array(
":nom"=>"Einstein",
":prenom"=>"Albert",
":login"=>"[Link]",
":pass"=>md5("2020")
));
}
catch(PDOException $e){
echo $e->getMessage();
}
?>

Dans la requête préparée, on déclare à la place des valeurs des séquences qui commencent par deux
points (:nom ou :prenom par exemple). Lors de l’exécution, on passe en paramètre un tableau
associatif dont les clés sont les paramètres nommés (en tant que chaînes de caractères). Les valeurs
du tableau seront les valeurs que l'on veut passer à la requête.

Cette technique ne nous oblige pas de déclarer les valeurs au sein du tableau passé lors de
l’exécution dans l'ordre établi dans la requête. C'est utile quand la requête contient un nombre
important de paramètres, ce qui rend le respect de l'ordre peu compliqué.

De la même manière on peut passer des requêtes de modification, suppression, vidage de la table...

78 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

III.4. Les requêtes de sélections

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 :

<?php
try {
$pdo=new PDO("mysql:host=localhost;dbname=mabase","root","");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

$req = $pdo->prepare("select * from utilisateurs order by id");

$req->execute();

}
catch(PDOException $e){
echo $e->getMessage();
}
?>

Maintenant, il faut récupérer les enregistrements dans une variable PHP. En fait, on va récupérer
toute la table dans une seule variable.

<?php
$req->setFetchMode(PDO::FETCH_ASSOC);
$tab = $req->fetchAll();
?>

setFetchMode() est une méthode qui permet de définir le mode de récupération par défaut de
données pour une requête. Cette méthode est appelée par l'objet $req (PDOStatement) et elle
accepte comme paramètre une constante de classe. Ainsi comme constantes de classe on peut
citer :
 PDO::FETCH_ASSOC : permet de récupérer les données sous forme de tableau de tableau
(c'est-à-dire un tableau numérique qui contient un tableau associatif) où les lignes
représentent les lignes de la table dans la base de données et les colonnes représentent les
clés qui ne sont rien d’autre que les valeurs des attributs de la table. Exemple :
$tab[0]["nom"].
 PDO::FETCH_OBJ : permet de récupérer les données sous forme de tableau numérique
d’objets où les propriétés des objets sont les attributs de la table. Exemple : $tab[0]->nom.
 PDO::FETCH_CLASS : permet de récupérer les données sous forme de tableau numérique
d’objets de type classe où les propriétés des objets sont les attributs et méthodes de la classe.
Syntaxe de déclaration : $req->setFetchMode(PDO::FETCH_CLASS, ‘NomDeLaClasse’);
Exemple :
$tab = $req->fetchAll();
$tab[0]->getNom().

79 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31

 Programmation Web II 2024 / 2025

La méthode fetchAll() appelée par l'objet requête retourne un tableau contenant toutes les lignes
retournées par la requête.

Désormais que nous disposons de la variable $tab, on peut en faire ce qu'on veut. Si nous
choisissons d'afficher toutes les lignes sur la page. Le code ressemblerait donc à ceci:

<?php
for($i=0;$i<count($tab);$i++){
echo implode(" | ",$tab[$i])."<br />";
}
?>

Tests de connaissances
1. Définir : SGBD, PDO.
2. Pourquoi est-t-il préférable de stocker les données dans une base données au lieu d’un
fichier ?
3. Citez quelques SGBD que vous connaissez ?
4. A quoi sert l’objet PDO ? Comment déclarer objet PDO ?
5. Quel est l’avantage des requêtes préparées ?

80 M. Marc TEJIOGNI | mtejiogni@[Link] | Tél : 693 90 91 21 – 682 66 37 31