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){
foreach ($vecteur as $element){
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

Développement côté serveur Chapitre 7.L’orienté objet avec PHP
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

Cours développement côté serveur

Cours développement côté serveur

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Cours développement côté serveur

Similar a Cours développement côté serveur (20)

Último

Último (19)

Cours développement côté serveur