Support tutoriel : Maîtriser PHP MySQL - Tome 2

2
Aucune représentation ou reproduction, même partielle, autre que celles prévues dans
l’article L. 122-5 2° et 3°a) du code de la propriété intellectuelle ne peut être faite sans
l’autorisation expresse de Mediaforma ou, le cas échéant, sans le respect des modalités
prévues dans l’article L. 122-10 dudit code.
Il est également interdit de vendre ou de donner cet eBook, ni les vidéos qui vont avec.
Aidez-moi à lutter contre le piratage et le vol en me contactant sur :
admin@mediaforma.com
Vos informations personnelles (nom, adresse et e-mail) ne seront aucunement divulguées ni
publiées.
Publié par Mediaforma Learning
Auteur : Michel Martin
Copyright © 2014
Mediaforma est une marque déposée
Tous droits réservés

3
Premiers pas en PHP............................................................................................................ 5
Exceptions ......................................................................................................................... 5
Exercice............................................................................................................................. 6
Fonctions............................................................................................................................... 8
Exercice............................................................................................................................. 8
Passage de paramètres par référence............................................................................... 9
Portée des variables .........................................................................................................10
Les fonctions mathématiques ...........................................................................................14
Les fonctions de traitement de chaînes.............................................................................15
Evitement du Cross-Site Scripting (XSS).......................................................................16
Exercice............................................................................................................................17
Encryptage des mots de passe .....................................................................................17
Protéger une adresse e-mail .........................................................................................18
Affichage avec mise en forme .......................................................................................18
Extraction de valeurs mises en forme............................................................................20
Exercice............................................................................................................................21
Les autres fonctions dédiées aux chaînes de caractères...............................................21
Exercice............................................................................................................................22
Les expressions régulières............................................................................................23
Recherche d'une séquence dans une chaîne................................................................24
Modification de données dans une chaîne.....................................................................24
Classes abrégées..........................................................................................................25
Exercice 1.........................................................................................................................25
Exercice 2.........................................................................................................................27
Exercice 3.........................................................................................................................27
Exercice 4.........................................................................................................................28
Les fonctions de traitement des dates et heures...............................................................29
La fonction date() ..........................................................................................................29
Exercice............................................................................................................................32
Travailler avec une autre date que la date courante ......................................................35
Exercice............................................................................................................................35
Inclusion de code avec l'instruction include.......................................................................36
Transmission de données par l'URL.....................................................................................37
Transmission de données simples par formulaires ...........................................................39
Exercice............................................................................................................................42

4
Transmission de fichiers par formulaire.............................................................................43
Envoyer un E-mail à partir d'un formulaire ........................................................................46
Superglobales, cookies et sessions......................................................................................48
Sessions Web...................................................................................................................49
Exercice............................................................................................................................49
Cookies.............................................................................................................................52
Exercice............................................................................................................................53
Manipulation de fichiers........................................................................................................57
Droits d'accès sur un serveur distant ................................................................................57
Accéder à un fichier ..........................................................................................................57
Lecture de données dans un fichier ..................................................................................58
Exercice............................................................................................................................58
Une erreur classique.........................................................................................................60
Ecriture de données dans un fichier..................................................................................60
Exercice............................................................................................................................61
Programmation Orientée Objet.............................................................................................62
Classes, instances et composants....................................................................................62
Encapsulation ...................................................................................................................62
Getter et setter..................................................................................................................62
Héritage............................................................................................................................63
Polymorphisme.................................................................................................................63
Interfaces..........................................................................................................................64

5
Premiers pas en PHP5
Exceptions
La gestion des exceptions dans PHP est comparable à celle qui a cours dans les autres
langages de programmation :
 Le code qui peut provoquer une exception doit être entouré d'une structure try.
 Une exception peut être déclenchée par l'instruction suivante :
throw new Exception("message");
 L'instruction catch(exception $e) permet de capturer une exception. Si une
instruction throw new Exception a été générée, le message peut être récupéré dans
la cellule
$e->getMessage() du tableau $e.
 Chaque instruction try doit avoir une instruction catch correspondante.
Un exemple va mettre en pratique tout ce qui vient d'être dit :
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>Gestion des exceptions</title>
</head>
<body>
<?php
function inverse($nombre){
if ($nombre == 0)
throw new exception("division par zéro");
else
echo "1/$nombre = ".(1/$nombre)."<br>";
}
try{
echo inverse(12);
echo inverse(0);
echo inverse(3);
}

6
catch(exception $e){
echo "Une exception a été générée : ".$e->getMessage()."<br>";
}
?>
</body>
</html>
Voici le résultat de ce code :
Comme vous pouvez le voir, la division par zéro provoque l'exécution de l'instruction throw.
Le bloc catch est alors exécuté et le message défini dans l'instruction throw est affiché.
Remarquez également que le programme est interrompu par l'exception et que la valeur 1/3
n'est jamais calculée.
Exercice
Modifiez le code pour que la valeur 1/3 soit également calculée.
Voici la solution :
<!DOCTYPE html>
<html>
<head>
<title>Gestion des exceptions avec bloc finally</title>
</head>
<body>
<?php
function inverse($nombre){

7
if ($nombre == 0)
throw new exception("division par zéro");
else
echo "1/$nombre = ".(1/$nombre)."<br>";
}
echo inverse(12);
try{
echo inverse(0);
}
catch(exception $e){
echo "Une exception a été générée : ".$e->getMessage()."<br>";
}
echo inverse(3);
?>
</body>
</html>

8
Fonctions
Les fonctions sont définies par le mot-clé function :
function nom(param1, param2, … paramN){
//Une ou plusieurs instructions
return $valeur;
}
Où :
 nom est le nom de la fonction ;
 les paramI sont les éventuels paramètres passés à la fonction ;
 $valeur, si elle est spécifiée, est la valeur retournée par la fonction.
Par exemple, pour calculer le cube de la valeur passée en paramètre, vous pouvez mettre en
place cette fonction :
function cube($nombre){
return $nombre*$nombre*$nombre;
}
Pour calculer et afficher le cube de 5, vous appellerez la fonction cube() comme ceci :
echo cube(5);
Exercice
Définissez une fonction qui calcule les racines d'une équation du second degré du type :
ax² + bx + c = 0
Les valeurs a, b et c seront passées en paramètres de la fonction.
Rappel
Pour résoudre ce problème, calculez
delta = b*b – 4*a*c
Si delta est négatif, il n'y a pas de solution.
Si delta est nul, il y a une racine unique égale à –b/2*a
Si delta est positif, il y a deux racines égales à :
(-b – racine(delta))/2*a et (-b + racine(delta))/2*a

9
Voici la solution :
<?php
function racines($a, $b, $c) {
echo "Recherche des solutions de l'équation $a x² + $b x + $c<br>";
$delta = $b*$b - (4 * $a * $c);
if ($delta < 0)
echo "Cette équation n'a pas de solution.";
if ($delta == 0)
echo "Cette équation a une racine double égale à ".-$b/(2*$a);
if ($delta > 0){
$racine1 = (-$b - sqrt($delta))/(2*$a);
$racine2 = (-$b + sqrt($delta))/(2*$a);
echo "Cette équation a deux racines : $racine1 et $racine2";
}
}
racines(1, 2, 1);
?>
Passage de paramètres par référence
Lorsqu'une variable est passée à une fonction, elle peut être utilisée dans la fonction, mais sa
valeur n'est pas altérée en dehors de la fonction. Si vous voulez qu'une fonction puisse
modifier la variable qui lui est passée, vous devez faire un passage de paramètre par référence
en ajoutant un "&" devant le paramètre, dans les arguments de la fonction :
function passageParReference(&$variable) {
}
Saisissez le code suivant. D'après vous, que vont afficher les deux instructions echo en fin de
listing ?
<?php
function ajouterRef(&$a) {
$a = $a . " texte à la fin";
}

10
function ajouter($a) {
$a = $a . " texte à la fin";
}
$chaine = "texte au début,";
ajouter($chaine);
echo $chaine."<br>";
ajouterRef($chaine);
echo $chaine."<br>";
?>
Comme vous pouviez le supposer, la variable $chaine n'est pas affectée par la fonction
ajouter() à l'extérieur de la fonction. Par contre, la variable $chaine est affectée par la
fonction ajouterRef() en dehors de la fonction puisque le passage de paramètre se fait par
référence.
Portée des variables
Les variables définies dans le code sont utilisables partout, hormis dans les fonctions.
<?php
$a = 10;
function test() {
echo "Dans la fonction, $a = ".$a;
}
echo "En dehors de la fonction, $a = ".$a."<br>";

11
test();
?>
Voici le résultat de ce code.
Comme vous pouvez le voir, la variable $a est inaccessible dans la fonction. Son utilisation
provoque une erreur à l'exécution. Pour corriger ce problème, il suffit de déclarer la variable
$a globale à l'intérieur de la fonction. Il est alors possible de lire, mais également de modifier
la variable dans la fonction.
<?php
$a = 10;
function test() {
global $a;
echo "Dans la fonction, $a = ".$a."<br>";
$a = 20;
}
echo "Avant l'exécution de la fonction, $a = ".$a."<br>";
test();
echo "Après l'exécution de la fonction, $a = ".$a."<br>";
?>
Voici le résultat :

12
Une autre solution consiste à utiliser le tableau associatif $GLOBALS[] :
<?php
$a = 10;
function test() {
echo "Dans la fonction, $GLOBALS["a"] = ".$GLOBALS["a"]."<br>";
$GLOBALS["a"] = 20;
}
test();
?>
Les variables définies à l'intérieur d'une fonction ont une portée limitée à cette fonction.
Examinez ce code :
<?php
function test() {

13
$a = 10;
echo "Dans la fonction, $a = ".$a."<br>";
}
test();
?>
A l'exécution, deux erreurs sont détectées : une sur la première instruction echo (car la variable
$a n'est pas encore définie) et une sur la dernière instruction echo (car la variable $a n'est pas
accessible en dehors de la fonction) :
Nous allons en terminer avec la portée des variables en parlant des variables statiques. La
portée d'une variable statique est locale à une fonction, mais elle ne perd pas sa valeur lorsque
la fonction est à nouveau appelée.
Examinez ce code :
<?php
function test() {
static $a = 10;

14
echo "$a = ".$a."<br>";
$a++;
}
test();
test();
test();
test();
?>
La variable $a est définie statique lors de son initialisation dans la fonction. Cette instruction
ne sera exécutée qu'une fois. Les quatre appels de la fonction test() affichent donc
successivement les valeurs 10, 11, 12 et 13 pour la variable $a :
Essayez de supprimer le mot static. Que se passe-t-il ?
Les fonctions mathématiques
Les fonctions mathématiques de PHP sont résumées sur cette page :
http://php.net/manual/fr/ref.math.php.

15
Les fonctions de traitement de chaînes
Les fonctions de traitement des chaînes de PHP sont résumées sur cette page :
http://php.net/manual/fr/ref.strings.php.

16
Dans les pages qui suivent, nous allons examiner quelques-unes de ces fonctions.
Evitement du Cross-Site Scripting (XSS)
Supposons qu'un internaute entre le code suivant dans une zone de saisie :
<script>alert('Le vengeur masqué est sur le point de formater votre disque
!!!');</script>
Et que ces informations soient stockées dans une variable PHP :
$saisie = "<script>alert('Le vengeur masqué est sur le point de formater
votre disque !!!');</script>";
Si vous affichez cette chaîne telle quelle, vous obtiendrez l'affichage d'une boîte de dialogue :
Pour éviter ce genre de problème, vous devez appliquer une fonction d'échappement à tout
ce qui est saisi par l'utilisateur. Vous pouvez utiliser la fonction :

17
 htmlspecialchars() qui transforme les caractères spéciaux en entités HTML :
o & devient &
o le guillemet devient "
o l'apostrophe devient &#039 ;
o < devient <
o > devient >
 htmlentities() qui transforme tous les caractères spéciaux (ceux transformés par
htmlspecialchars() mais aussi les caractères accentués) en entités HTML.
Exercice
Appliquez la fonction htmlspecialchars() à la variable $saisie suivante et affichez le
résultat avec un echo :
Voici la solution :
echo htmlspecialchars($saisie);
Voici ce que vous obtenez :
Il faut avouer que c'est bien moins impressionnant que la boîte de dialogue précédente !
Encryptage des mots de passe
Les mots de passe entrés par l'utilisateur ne devraient jamais être stockés tels quels dans une
base de données. Il est en effet possible que la base de données soit piratée et que les mots
de passe soient utilisés à des fins malhonnêtes.
Pour crypter une chaîne (ici la chaîne "monMotDePasse"), utilisez la fonction crypt() :
$mdpCrypte = crypt("monMotDePasse");
La chaîne $mdpCrypte peut être stockée en toute sécurité dans la base de données.
Dans un deuxième temps, lorsque l'utilisateur saisit son mot de passe (pour se connecter à
son espace membre ou accéder à ses données), vous devez le comparer à sa version cryptée
en utilisant la fonction crypt() :

18
If (crypt($mdpSaisiParUtilisateur, $mdpCrypte) == $mdpCrypte)
echo "Le mot de passe est correct.";
else
echo "Le mot de passe est incorrect.";
Ici, $mdpCrypte représente le mot de passe crypté qui a été obtenu dans l'étape précédente
et $mdpSaisiParUtilisateur le mot de passe saisi par l'utilisateur.
Protéger une adresse e-mail
Pour éviter qu'une adresse e-mail ne soit subtilisée par les robots qui parcourent le Web, le
plus simple est de la convertir en une suite de caractères ASCII de type "g". Pour cela,
vous pouvez définir une fonction PHP dans laquelle les caractères de l'adresse e-mail sont
parcourus un par un (avec la fonction substr()) et convertis en une suite de caractères ASCII
avec la fonction ord() :
 substr(chaine, position, longueur)
Où :
 chaîne est la chaîne à parcourir, position la position du caractère à extraire et
longueur est égal à 1 pour extraire un seul caractère.
 ord(caractère) retourne le code ASCII du caractère qui lui est passé en argument.
 strlen(chaine) retourne la longueur de la chaîne qui lui est passée en argument.
Remarque
Pour connaitre le nombre de caractères de l'adresse e-mail, vous utiliserez la fonction
strlen().
<?php
function proteger($adr) {
$adresseCodee = "";
for ($i=0; $i<strlen($adr); $i++)
$adresseCodee .= "&#" . ord(substr($adr, $i, 1)) . ";";
return $adresseCodee;
}
echo "<a href='" . proteger("mailto:admin@mediaforma.com") . "'>Pour nous
joindre, cliquez ici</a>";
?>
Affichage avec mise en forme
La fonction printf() permet d'afficher des données mises en forme :

19
printf(format, el1, el2, …, elN);
Où :
 format est une chaîne qui contient une ou plusieurs directives de mise en forme,
comme indiqué dans le tableau ci-après
 les elI sont les éléments qui doivent être mis en forme par les directives données dans
le premier paramètre.
Directive de
mise en forme
Effet
%b L'argument est traité comme un entier et affiché en binaire
%c L'argument est traité comme un entier et affiché en tant que code ASCII
%d L'argument est traité comme un entier et affiché en entier base 10 signé
%e L'argument est traité comme une notation scientifique
%E Identique à %e, mais affiché en majuscules
%u L'argument est traité comme un entier et affiché en entier base 10 non
signé
%f L'argument est traité comme un nombre à virgule flottante (type float)
et affiché comme tel, en tenant compte de la locale
%F L'argument est traité comme un nombre à virgule flottante (type float)
et affiché comme tel, sans tenir compte de la locale
%g Equivalent à %e et %f
%G Equivalent à %E et %F
%o L'argument est traité comme un entier et affiché en octal
%s L'argument est traité et affiché comme une chaîne de caractères
%x L'argument est traité comme un entier et affiché en hexadécimal, avec
les lettres en minuscules
%X L'argument est traité comme un entier et affiché en hexadécimal, avec
les lettres en majuscules
Quelques exemples :
<?php
$entier = 125;
$flottant = 12.45;
$chaine = "Ceci est une chaîne";
printf("125 affiché en binaire : %b<br>",$entier);
printf("125 interprété comme un code ASCII : %c<br>",$entier);
printf("125 affiché en octal : %o<br>",$entier);
printf("125 affiché en hexadécimal : %x<br>",$entier);
printf("12.45 affiché en notation scientifique : %e<br>",$flottant);
printf("12.45 affiché en nombre à virgule flottante : %f<br>",$flottant);

20
?>
Extraction de valeurs mises en forme
La fonction sscanf() permet d'extraire des données d'une chaîne en utilisant une ou plusieurs
directives de mise en forme :
sscanf(chaine, directives, vex1, … vexN);
Où :
 chaine est la chaîne qui contient les données à extraire ;
 directives est une chaîne qui contient une ou plusieurs directives de mise en forme
(voir tableau précédent) ;
 vex1 à vexN sont les valeurs extraites en fonctions des directives données dans le
deuxième paramètre.
Un exemple va vous aider à y voir plus clair. Ici, nous allons extraire trois données entières de
la variable $uneDate et les afficher avec une instruction echo :
<?php
$uneDate = "12/08/2013";
sscanf($uneDate, "%d/%d/%d", $jour, $mois, $annee);
echo "Jour : ".$jour.", Mois : ".$mois.", Année : ".$annee;
?>

21
Exercice
Voyons si vous avez compris.
Définissez les instructions nécessaires pour extraire et afficher la date et l'heure de cette
chaîne :
$dateEtHeure = "15 Juin 2014 20:12:15";
Voici la solution :
<?php
sscanf($dateEtHeure, "%d %s %d %d:%d:%d", $jour, $mois, $annee, $heures,
$minutes, $secondes);
echo "Jour : ".$jour.", Mois : ".$mois.", Année : ".$annee."<br>";
echo "Heures : ".$heures.", Minutes : ".$minutes.", Secondes :
".$secondes."<br>";
?>
Les autres fonctions dédiées aux chaînes de caractères
Comme nous venons de le voir, la fonction sscanf() permet d'effectuer des recherches dans
une chaîne et d'extraire dans des variables des données mises en forme. Les fonctions
d'extraction de chaînes ne se limitent pas à la fonction sscanf(). Vous devriez également
vous intéresser aux fonctions suivantes :
Fonction Effet

22
ltrim() Suppression des espaces en début de chaîne
rtrim() Suppression des espaces en fin de chaîne
str_replace() Remplace toutes les occurrences d'une sous-chaîne dans une chaîne
strlen() Longueur d'une chaîne
strpos() Recherche de la première position d'une sous-chaîne dans une
chaîne
strrchr() Dernière occurrence d'un caractère dans une chaîne
strrev() Inverse la chaîne spécifiée
strrpos Recherche de la dernière position d'une sous-chaîne dans une chaîne
substr() Extrait une sous-chaîne d'une chaîne
trim() Supprime les espaces en début et en fin de chaîne
Pour en savoir plus sur ces fonctions, consultez la page
http://php.net/manual/fr/ref.strings.php.
Exercice
En utilisant les fonctions strpos() et substr() et en vous aidant de la documentation en
ligne, écrivez quelques lignes de code pour extraire chacun des éléments de date et heure de
la chaîne suivante :
Voici la solution :
<?php
$premierBlanc = strpos($dateEtHeure," ");
$deuxiemeBlanc = strpos($dateEtHeure," ",$premierBlanc+1);
$troisiemeBlanc = strpos($dateEtHeure," ",$deuxiemeBlanc+1);
$premierDeuxPoints = strpos($dateEtHeure,":");
$deuxiemeDeuxPoints = strpos($dateEtHeure,":",$premierDeuxPoints+1);
echo "Jour = ".substr($dateEtHeure,0,$premierBlanc)."<br>";
echo "Mois = ".substr($dateEtHeure,$premierBlanc+1, $deuxiemeBlanc-
$premierBlanc)."<br>";
echo "Année = ".substr($dateEtHeure,$deuxiemeBlanc+1, $troisiemeBlanc-
$deuxiemeBlanc)."<br>";
echo "Heure = ".substr($dateEtHeure,$troisiemeBlanc+1, $premierDeuxPoints-
$troisiemeBlanc-1)."<br>";

23
echo "Minutes = ".substr($dateEtHeure,$premierDeuxPoints+1,
$deuxiemeDeuxPoints-$premierDeuxPoints-1)."<br>";
echo "Secondes = ".substr($dateEtHeure,$deuxiemeDeuxPoints+1,
strlen($dateEtHeure) - $deuxiemeDeuxPoints)."<br>";
?>
Les expressions régulières
Les expressions régulières permettent de faire des recherches très précises et très efficaces
dans des chaînes de caractères.
Expression Signification Exemple
# Caractère de début et de fin de
l'expression
#expression régulière#
^ Début de la chaîne ^a sera vrai si la chaîne commence
par un a
$ Fin de la chaîne t$ sera vrai si la chaîne se termine
par un t
. N'importe quel caractère a, b, z, T, 1, @, etc
? Répète 0 ou 1 fois le caractère
précédent
xy? Signifie x ou xy
* Répète 0, 1 ou plusieurs fois le
caractère précédent
xy* signifie x, xy, xyy, xyyy, etc.
+ Répète 1 ou plusieurs fois le
caractère précédent
xy+ signifie xy, xyy, xyyy, etc.
Le caractère d'échappement
autorise l'utilisation de caractères
réservés
. Est équivalent au point décimal
[xyz] Un caractère unique de l'expression [xyz] signifie x, y ou z
[^xyz] Un caractère unique à l'exclusion des
caractères de l'expression
[^xyz] signifie un caractère
quelconque sauf x, y et z
[a-z] Un caractère unique compris entre
les deux bornes
[a-zA-Z] signifie une lettre
minuscule ou majuscule
quelconque
exp1|exp2 exp1 ou exp2 PHP4|PHP5 signifie PHP4 ou
PHP5

24
{min, max} Répétition du caractère précédent
entre min et max fois
x{2,3} signifie xx ou xxx
x{1,} signifie x, xx, xxx, xxxx, etc.
x{,3} signifie chaîne vide, x, xx ou
xxx
Recherche d'une séquence dans une chaîne
Par exemple, pour savoir si une adresse e-mail est valide, vous pouvez utiliser l'expression
régulière suivante :
#^[a-z0-9._-]+@[a-z0-9._-]{2,}.[a-z]{2,4}$#
Examinons cette séquence :
 L'adresse e-mail commence (^) par un nombre quelconque de lettres minuscules, de
chiffres, de points décimaux, de caractères de soulignement et de tirets : ^[a-z0-9._-
]+
 Elle est suivie du caractère @
 D'une séquence de deux ou plus de deux lettres : [a-z0-9._-]{2,}
 D'un point décimal : .
 Et enfin d'une séquence de 2 à 4 caractères qui termine ($) l'adresse e-mail: [a-
z]{2,4}
Supposons que l'adresse e-mail à tester se trouve dans la variable $email. Pour tester sa
validité, vous utiliserez la fonction preg_match() :
preg_match(expReg, ch)
Où expReg est l'expression régulière à utiliser et ch la chaîne dans laquelle se trouve l'adresse
e-mail. Voici le code que vous pourriez mettre en place :
<?php
$email = "nom.prenom@fai.com";
if (preg_match("#^[a-z0-9._-]+@[a-z0-9._-]{2,}.[a-z]{2,4}$#", $email))
echo "l'Adresse e-mail est valide.";
else
echo "L'adresse e-mail n'est pas valide.";
?>
Modification de données dans une chaîne
La fonction preg_replace() permet de rechercher des données dans une chaîne et de les
modifier. Voici sa syntaxe de cette fonction :
$resultat = preg_replace(exprReg, rempl, ch);
Où :
 $resultat est la chaîne modifiée par preg_replace ;
 exprReg est l'expression régulière à utiliser ;

25
 rempl est l'expression qui décrit comment remplacer les éléments trouvés dans la
chaîne. Cette expression contient un ou plusieurs éléments du type $i (où i représente
le ième élément entre parenthèses dans l'expression régulière).
 ch est la chaîne concernée par l'expression régulière.
A titre d'exemple, pour transformer une date au format américain (MM-JJ-AAAA) en une date
au format français (JJ-MM-AAAA), vous utiliserez le code suivant :
<?php
$dateUS = "08-12-2013";
$dateFR = preg_replace("#(^[0-9]*)-([0-9]*)-([0-9]*)$#", "$2-$1-
$3",$dateUS);
echo "Date US : ".$dateUS."<br>";
echo "Date FR : ".$dateFR;
?>
Classes abrégées
Pour simplifier l'écriture des expressions régulières, vous pouvez utiliser des classes
abrégées, comme indiqué dans le tableau suivant :
Classe abrégée Correspondance
d [0-9]
D [^0-9]
w [a-zA-Z0-9_]
W [^a-zA-Z0-9_]
t Tabulation
n Saut de ligne
r Retour chariot
s Espace blanc (correspond à tnr)
S Un caractère différent d'un espace
Pour savoir si vous avez compris, vous allez faire plusieurs exercices :
Exercice 1
Définissez une fonction qui teste si une date est bien formée, c'est-à-dire qu'elle respecte le
format suivant :
JJ/MM/AAAA
Si la chaîne est bien formée, la fonction doit retourner le texte suivant, affiché en vert :
La chaîne … est une date valide
Où … représente la chaîne testée.

26
Dans le cas contraire, la fonction doit retourner le texte suivant, affiché en rouge :
La chaîne … n'est pas une date valide
Où … représente la chaîne testée.
Passez consécutivement les trois chaînes suivantes à la fonction :
$ch1 = "125/12/45"; // Mal formée
$ch2 = "14/09/2016"; // Bien formée
$ch3 = "18:06:13"; // Mal formée
Vous devriez obtenir le résultat suivant :
Voici la solution :
<?php
function testDate($d){
if (preg_match("#d{1,2}/d{1,2}/d{4}#",$d))
return "<font color="green">La chaîne $d est une date
valide</font><br>";
else
return "<font color="red">La chaîne $d n'est pas une date
valide</font><br>";
}
$ch1 = "125/12/45"; // Mal formée
$ch2 = "14/09/2016"; // Bien formée
$ch3 = "18:06:13"; // Mal formée

27
echo testDate($ch1);
?>
Exercice 2
Remplacez toutes les adresses http:// par des liens cliquables.
Voici la chaîne concernée :
$ch = "Les moteurs de recherche http://www.google.fr et http://www.bing.com
sont aujourd'hui les plus utilisés.";
Voici la solution :
<?php
$ch = "Les moteurs de recherche http://www.google.fr et http://www.bing.com
sont aujourd'hui les plus utilisés.";
$ch2 = preg_replace("#(http://[a-zA-Z0-9._-]*)#", "<a
href='$1'>$1</a>",$ch);
echo "AVANT : ".$ch."<br>";
echo "APRES : ".$ch2;
?>
Exercice 3
Supposons maintenant que vous vouliez transformer en lien les adresses qui commencent par
http://, https:// et ftp://.
Voici la chaîne à transformer :
$ch="Les URL http://www.mediaforma.com, mais aussi https://google.fr et
ftp://ftp.cdrom.com peuvent être transformés en des liens cliquables.";

28
Voici la solution :
<?php
$ch="Les URL http://www.mediaforma.com, mais aussi https://google.fr et
ftp://ftp.cdrom.com peuvent être transformés en des liens cliquables.";
$ch2 = preg_replace("#((https?|ftp)://[a-zA-Z0-9._-]*)#", "<a
href='$1'>$1</a>",$ch);
echo "AVANT : ".$ch."<br>";
?>
Exercice 4
Remplacez tous les espaces consécutifs multiples par un seul espace dans la chaîne suivante
:
$ch = "Cette chaîne contient un peu trop d'espaces, mais
preg_replace va la simplifier !";
Voici la solution :
<?php
$ch = "Cette chaîne contient un peu trop d'espaces, mais
preg_replace va la simplifier !";
$ch2 = preg_replace("# +#", " ",$ch);
echo "<pre>";
echo "AVANT : ".$ch."<br><br>";
echo "</pre>";

29
?>
Les fonctions de traitement des dates et heures
Les fonctions de traitement des dates et heures de PHP sont résumées sur cette page :
http://php.net/manual/fr/ref.datetime.php.
Nous allons passer en revue quelques fonctions dignes d'intérêt.
La fonction date()
La fonction date() retourne une date sous la forme d'une chaîne, en se conformant à la mise
en forme demandée dans le paramètre :

30
laDate = date(format);
Où format est une chaîne qui indique les informations de date souhaitées (voir tableau ci-
dessous) et laDate est la chaîne contenant les éléments demandés.
Caractères pour le
paramètre format
Description Exemple de valeurs
retournées
JOUR
d Jour du mois, sur deux
chiffres (avec un zéro initial)
01 à 31
D Jour de la semaine, en trois
lettres (et en anglais)
Mon à Sun
j Jour du mois sans les zéros
initiaux
1 à 31
l (L minuscule) Jour de la semaine, textuel,
version longue, en anglais
Sunday à Saturday
N Représentation numérique
ISO-8601 du jour de la
semaine
1 (pour Lundi) à 7 (pour
Dimanche)
S Suffixe ordinal d'un nombre
pour le jour du mois, en
anglais, sur deux lettres
st, nd, rd ou th. Fonctionne
bien avec j
w Jour de la semaine au format
numérique
0 (pour dimanche) à 6 (pour
samedi)
z Jour de l'année 0 à 365
SEMAINE
W Numéro de semaine dans
l'année ISO-8601, les
semaines commencent le
lundi
Exemple : 42 (la 42ème
semaine de l'année)
MOIS
F Mois, textuel, version longue;
en anglais (January ou
December par ex.)
January à December
m Mois au format numérique,
avec zéros initiaux
01 à 12
M Mois, en trois lettres, en
anglais
Jan à Dec
n Mois sans les zéros initiaux 1 à 12
t Nombre de jours dans le
mois
28 à 31
ANNEE
L Année bissextile ? 1 si bissextile, 0 sinon.
o L'année ISO-8601. C'est la
même valeur que Y, excepté
que si le numéro de la
semaine ISO (W) appartient
à l'année précédente ou
suivante, cette année sera
utilisé à la place.
Exemples : 1999 ou 2003
Y Année sur 4 chiffres Exemples : 1999 ou 2003
y Année sur 2 chiffres Exemples : 99 ou 03
HEURE

31
a Ante meridiem et Post
meridiem en minuscules
am ou pm
A Ante meridiem et Post
meridiem en majuscules
AM ou PM
B Heure Internet Swatch 000 à 999
g Heure, au format 12h, sans
les zéros initiaux
1 à 12
G Heure, au format 24h, sans
les zéros initiaux
0 à 23
h Heure, au format 12h, avec
les zéros initiaux
01 à 12
H Heure, au format 24h, avec
les zéros initiaux
00 à 23
i Minutes avec les zéros
initiaux
00 à 59
s Secondes, avec zéros
initiaux
00 à 59
u Microsecondes. Notez que la
fonction date() génèrera
toujours 000000 vu qu'elle
prend un paramètre de type
entier, alors que la méthode
DateTime::format() supporte
les microsecondes.
Exemple : 654321
FUSEAU HORAIRE
e Identifiant du fuseau horaire Exemples : UTC, GMT,
Atlantic/Azores
I (i majuscule) Heure d'été activée ? 1 si oui, 0 sinon.
O Différence d'heures avec
l'heure de Greenwich (GMT),
exprimée en heures
Exemple : +0200
P Différence avec l'heure
Greenwich (GMT) avec un
deux-points entre les heures
et les minutes
Exemple : +02:00
T Abréviation du fuseau
horaire
Exemples : EST, MDT ...
Z Décalage horaire en
secondes. Le décalage des
zones à l'ouest de la zone
UTC est négative, et à l'est, il
est positif.
-43200 à 50400
DATE ET HEURE
COMPLETE
c Date au format ISO 8601
(ajouté en PHP 5)
2004-02-12T15:19:21+00:00
r Format de date » RFC 2822 Exemple : Thu, 21 Dec 2000
16:01:07 +0200
U Secondes depuis l'époque
Unix (1er Janvier 1970, 0h00
00s GMT)
Voir aussi time()

32
Par exemple, pour afficher la date au format JJ/MM/AAAA hh:mm:ss, vous utiliserez
l'instruction suivante :
echo date("d/m/Y H:i:s");
Il est parfois nécessaire d'afficher du texte dans la chaîne de formatage passée à la fonction
date(). Pour ce faire, vous devez échapper tous les caractères à afficher en utilisant le
caractère "". Utilisez un double échappement si le caractère est une commande de formatage
() :
Par exemple, pour afficher :
Il est 10 heures 5 minutes et 14 secondes
Utilisez l'instruction suivante :
echo date("Il est H heures i minutes
secondes");
Ici, les caractères e, t, r et n sont doublement échappés car ils correspondent à des
commandes de formatage.
Exercice
Affichez la date selon ce format :
C'est le 1er jour du mois
ou
C'est le xème jour du mois
Utilisez ces instructions :
<?php
if (date("j") ==1)
echo date("C'est le jer jour du mois.");
else
echo date("C'est le jème jour du mois.");
?>
Localisation de dates
Pour connaître la locale à utiliser en fonction de la langue souhaitée, interrogez la fonction
setlocale() :
$sl = setlocale(LC_TIME, code);
Où code est le code du pays sur trois lettres : "FRA", "USA", "DEU", etc.
Initialisez alors la locale avec la valeur retournée par setlocale() :

33
setlocale(LC_TIME, $sl);
Vous pouvez maintenant utiliser la fonction strftime() pour obtenir une date en accord avec
la locale spécifiée :
$dateEtHeure = strftime(ch);
Où ch est une chaîne de formatage qui reprend les valeurs de la colonne Format dans le
tableau ci-après.
Format Description Valeurs retournées
JOUR
%a Nom abrégé du jour de la semaine De Sun à Sat
%A Nom complet du jour de la semaine De Sunday à Saturday
%d Jour du mois en numérique, sur 2 chiffres
(avec le zéro initial)
De 01 à 31
%e Jour du mois, avec un espace précédant le
premier chiffre.
De 1 à 31
%j Jour de l'année, sur 3 chiffres avec un zéro
initial
001 à 366
%u Représentation ISO-8601 du jour de la
semaine
De 1 (pour Lundi) à 7 (pour
Dimanche)
%w Représentation numérique du jour de la
semaine
De 0 (pour Dimanche) à 6
(pour Samedi)
SEMAINE
%U Numéro de la semaine de l'année donnée, en
commençant par le premier Lundi comme
première semaine
13 (pour la 13ème semaine
pleine de l'année)
%V Numéro de la semaine de l'année, suivant la
norme ISO-8601:1988, en commençant
comme première semaine, la semaine de
l'année contenant au moins 4 jours, et où
Lundi est le début de la semaine
De 01 à 53 (où 53 compte
comme semaine de
chevauchement)
%W Une représentation numérique de la semaine
de l'année, en commençant par le premier
Lundi de la première semaine
46 (pour la 46ème semaine
de la semaine commençant
par un Lundi)
MOIS
%b Nom du mois, abrégé, suivant la locale De Jan à Dec
%B Nom complet du mois, suivant la locale De January à December
%h Nom du mois abrégé, suivant la locale (alias
de %b)
De Jan à Dec
%m Mois, sur 2 chiffres De 01 (pour Janvier) à 12
(pour Décembre)
ANNEE
%C Représentation, sur 2 chiffres, du siècle
(année divisée par 100, réduit à un entier)
19 pour le 20ème siècle
%g Représentation, sur 2 chiffres, de l'année,
compatible avec les standards ISO-
8601:1988
Exemple : 09 pour la
semaine du 6 janvier 2009
%G La version complète à quatre chiffres de %g Exemple : 2008 pour la
semaine du 3 janvier 2009

34
%y L'année, sur 2 chiffres Exemple : 09 pour 2009, 79
pour 1979
%Y L'année, sur 4 chiffres Exemple : 2038
HEURE
%H L'heure, sur 2 chiffres, au format 24 heures De 00 à 23
%k Une représentation de l'heure sur 2 chiffres,
au format 24 heures, avec un espace
précédant un seul chiffre
De 0 à 23
%I Heure, sur 2 chiffres, au format 12 heures De 01 à 12
%l ('L'
minuscule)
Heure, au format 12 heures, avec un espace
précédant un seul chiffre
De 1 à 12
%M Minute, sur 2 chiffres De 00 à 59
%p 'AM' ou 'PM', en majuscule, basé sur l'heure
fournie
Exemple : AM pour 00:31,
PM pour 22:23
%P 'am' ou 'pm', en minuscule, basé sur l'heure
fournie
Exemple : am pour 00:31,
pm pour 22:23
%r Identique à "%I:%M:%S %p" Exemple : 09:34:17 PM pour
21:34:17
%R Identique à "%H:%M" Exemple : 00:35 pour 12:35
AM, 16:44 pour 4:44 PM
%S Seconde, sur 2 chiffres De 00 à 59
%T Identique à "%H:%M:%S" Exemple : 21:34:17 pour
09:34:17 PM
%X Représentation de l'heure, basée sur la
locale, sans la date
Exemple : 03:59:16 ou
15:59:16
HEURE ET
DATE
%c Date et heure préférées, basées sur la locale Exemple : Tue Feb 5
00:45:10 2009 pour le 5
Février 2009 à 12:45:10 AM
%D Identique à "%m/%d/%y" Exemple : 02/05/09 pour le 5
Février 2009
%F Identique à "%Y-%m-%d" (utilisé
habituellement par les bases de données)
Exemple : 2009-02-05 pour
le 5 février 2009
%s Timestamp Unix (identique à la fonction
time())
Exemple : 305815200 pour
le 10 Septembre 1979
08:40:00 AM
%x Représentation préférée de la date, basée sur
la locale, sans l'heure
Exemple : 02/05/09 pour le 5
Février 2009
Par exemple, pour afficher une date en français, utilisez le code suivant :
<?php
$sl = setlocale(LC_TIME, "FRA");
echo "setlocale retourne ".$sl."<br>";
setlocale(LC_TIME,$sl);
echo strftime("Nous sommes le %A %#d %B %Y");
?>

35
Travailler avec une autre date que la date courante
Bien entendu, il est possible de travailler avec une date différente de la date du jour. Pour cela,
vous devez passer un deuxième paramètre à la fonction strftime() :
$dateEtHeure = strftime(ch, d);
Où ch est une chaîne de formatage et d est la date (timestamp UNIX) à formater.
Remarque
Vous pouvez utiliser la fonction strtotime() pour convertir une chaîne contenant une date
au format MM/JJ/AAAA en un timestamp UNIX.
Exercice
Utilisez les fonctions setlocale(), strftime() et strtotime() pour afficher le nom du jour
qui correspond à une date quelconque. Par exemple, si la date passée est 10/01/2013,
affichez quelque chose comme ceci :
Voici la solution :
<?php
$sl = setlocale(LC_TIME, "FRA");
setlocale(LC_TIME,$sl);
echo strftime("Le %#d %B %Y est un %A", strtotime("10/01/2013"));
?>

36
Inclusion de code avec l'instruction include
L'instruction include permet d'insérer un fichier PHP dans un autre fichier PHP et de l'exécuter.
Supposons que le fichier initialisation.php contienne le code suivant :
<?php
$a = 10;
$b = "Cette valeur a été définie dans le fichier initialisation.php";
?>
Nous allons inclure le fichier initialisation.php dans un script PHP et afficher les valeurs des
deux variables :
<?php
include "initialisation.php";
echo "$a = ".$a."<br>";
echo "$b = ".$b;
?>

37
Transmission de données par l'URL
La façon la plus simple de transmettre des données à une page PHP consiste à les insérer
dans l'URL :
http://www.adressedusite.com/unepage.php?param1=valeur1&param2=14
Ici par exemple, deux données sont transmises à la page unepage.php : param1 et param2.
Ces deux données ont pour valeur "valeur1" et "14".
Remarque
Vous pouvez transmettre autant de données que vous voulez, mais la taille des URL doit être
inférieure à 256 caractères, sans quoi, certains navigateurs risquent de tronquer les URL trop
longues.
Pour récupérer les données, vous utiliserez le tableau superglobal $_GET[] en lui
l'interrogeant sur le nom de la donnée dont vous voulez récupérer la valeur :
<?php
echo "La donnée param1 a pour valeur ".$_GET["param1"]."<br>";
?>
Si vous affichez la même page en supprimant les données de l'URL, deux erreurs sont
générées :

38
Pour éviter ces problèmes, utilisez la fonction isset() pour tester si les données qui sont
supposées être transmises dans l'URL sont effectivement présentes :
<?php
if (isset($_GET["param1"]))
if (!isset($_GET["param1"]) && !isset($_GET["param2"]))
echo "Aucune donnée n'a été transmise à ce script PHP";
?>
Etant donné que l'utilisateur peut modifier l'URL affiché dans la barre d'adresses du navigateur,
il est vital d'échapper les données reçues pour éviter les problèmes d'injection de type Cross-
Site Scripting. Pour cela, vous appliquerez la fonction htmlspecialchars() à chacune des
données récupérées. Le code à utiliser est le suivant :
<?php
echo "La donnée param1 a pour valeur
".htmlspecialchars($_GET["param1"])."<br>";

39
echo "La donnée param2 a pour valeur
".htmlspecialchars($_GET["param2"])."<br>";
if (!isset($_GET["param1"]) && !isset($_GET["param2"]))
echo "Aucune donnée n'a été transmise à ce script PHP";
?>
Transmission de données simples par formulaires
Dans la section précédente, vous avez appris à transmettre des données par l'URL. Cette
technique fonctionne parfaitement, mais elle a deux principaux désavantages :
 Le nombre de paramètres transmissibles est limité par la longueur de l'URL.
 Les paramètres transmis apparaissent en clair et l'utilisateur peut, s'il le souhaite, les
modifier en agissant sur l'URL.
Pour résoudre ces deux problèmes, on utilise une transmission de données par formulaires.
Voici le code d'un formulaire traditionnel. Lorsque l'utilisateur clique sur le bouton Envoyer, les
données contenues dans le formulaire sont transmises au script traitement.php en utilisant la
méthode POST :
<!DOCTYPE html>
<html>
<head>
<title>Transission de données par un formulaire</title>
</head>
<body>
<form name="MonFormulaire" method="post" action="traitement.php">
<table><tr><td><label>Prénom</label></td>
<td><input type="text" name="prenom"></td></tr>
<tr><td><label>Nom</label></td>
<td><input type="text" name="nom"></td></tr>
<tr><td><label>Mot de passe</label></td>
<td><input type="password" name="mdp"></td></tr>

40
<tr><td><label>Age</label></td>
<td><select name="age">
<option><20 ans</option>
<option>20 à 50 ans</option>
<option>>50 ans</option>
</select></td></tr>
<tr><td><label>Observations</label></td>
<td><textarea name="observations" cols="40"
rows="4"></textarea></td></tr>
<tr><td><input type="submit" name="Nom" value="Envoyer"></td>
<td><input type="reset" name="Nom" value="Annuler"></td></tr>
</table>
</form>
</body>
</html>
Voici le code du script traitement.php :
<!DOCTYPE html>
<html>
<head>
<title>Traitement des données envoyées par formulaire</title>
</head>
<body>
<?php
$prenom = $_POST["prenom"];
$nom = $_POST["nom"];
$motDePasse = $_POST["mdp"];
$age = $_POST["age"];
$obs = $_POST["observations"];

41
echo "<b>Données reçues :</b><br><br>";
echo "Prénom : $prenom<br>";
echo "Nom : $nom<br>";
echo "Mot de passe : $motDePasse<br>";
echo "Age : $age<br>";
echo "Observations : $obs<br>";
?>
</body>
</html>
Et voici un exemple d'exécution :
Pour éviter les problèmes d'injection de type Cross-Site Scripting, pensez à convertir les
données entrées par l'utilisateur en appliquant (systématiquement !) la fonction
htmlspecialchars() à chacune des données récupérées. Le code du script
traitement.php devient alors le suivant :
<?php
$prenom = htmlspecialchars($_POST["prenom"]);

42
$nom = htmlspecialchars($_POST["nom"]);
$motDePasse = htmlspecialchars($_POST["mdp"]);
$age = htmlspecialchars($_POST["age"]);
$obs = htmlspecialchars($_POST["observations"]);
echo "<b>Données reçues :</b><br><br>";
echo "Prénom : $prenom<br>";
echo "Nom : $nom<br>";
echo "Mot de passe : $motDePasse<br>";
echo "Age : $age<br>";
echo "Observations : $obs<br>";
?>
Exercice
Définissez le code nécessaire pour accéder à une page Web protégée par un mot de passe.
Pour cela :
1) Vous définirez une page contenant un formulaire dans lequel sera saisi le mot de
passe.
2) Vous passerez le mot de passe à la page protégée. Si le mot de passe est "champion",
vous afficherez la page. Dans le cas contraire, vous afficherez un message indiquant
que le mot de passe n'est pas le bon.
Voici la page dans laquelle est saisi le mot de passe :
<!DOCTYPE html>
<html>
<head>
<title>Formulaire d'accès à la page protégée</title>
</head>
<body>
<form name="MonFormulaire" method="post" action="page-protegee.php">
<table><tr><td><label>Entrez le mot de passe</label></td>
<td><input type="password" name="mdp"></td></tr>
<tr><td></td><td><input type="submit" name="Nom" value="Envoyer"></td>

43
</table>
</form>
</body>
</html>
Et voici le code de la page protégée par le mot de passe :
<!DOCTYPE html>
<html>
<head>
<title>Formulaire d'accès à la page protégée</title>
</head>
<body>
<?php
if(isset($_POST["mdp"]))
if ($_POST["mdp"] == "champion")
echo "Vous avez accès au contenu protégé de cette page.";
else
echo "Le mot de passe entré n'est pas le bon. Réessayez...";
?>
</body>
</html>
Transmission de fichiers par formulaire
Pour transmettre un fichier à un script PHP, vous devez mettre en place un formulaire spécial
dans lequel l'attribut enctype est initialisé à multipart/form-data :
<form action="ouverture-fichier.php" method="post"
enctype="multipart/form-data">
</form>
Voici le code complet d'un formulaire qui demande à l'utilisateur de choisir un fichier texte dans
les unités de masse de son ordinateur :
<!DOCTYPE html>

44
<html>
<head>
<title>Ouverture d'un fichier par formulaire</title>
</head>
<body>
<form action="ouverture-fichier.php" method="post"
enctype="multipart/form-data">
Choisissez un fichier texte (extension .txt)<br>
<input type="file" name = "fichierTexte"><br>
<input type="submit" value="Envoyer">
</form>
</body>
</html>
Voici le résultat de ce code :
Lorsque l'utilisateur clique sur le bouton Envoyer, le script ouverture-fichier.php est
exécuté. Pour télécharger sur le serveur le fichier choisi dans le formulaire, vous utiliserez :
1) Les informations contenues dans la variable superglobale $_FILES[] dont voici le
détail :
Elément du tableau Signification
$_FILES["nomFichier"]["name"] Le nom original du fichier, tel qu'il a été défini sur
la machine du client web.
$_FILES["nomFichier"]["type"] Le type MIME du fichier, si le navigateur a fourni
cette information. Par exemple, "image/gif".
$_FILES["nomFichier"]["size"] La taille, en octets, du fichier téléchargé.
$_FILES["nomFichier"]["tmp_name"] Le nom temporaire du fichier qui sera chargé sur
la machine serveur.

45
$_FILES["nomFichier"]["error"] Le code d'erreur associé au téléchargement de
fichier.
Remarque
Dans ce tableau, on suppose que le nom du fichier à télécharger a été saisi dans un champ
input de type file nommé nomFichier.
2) La fonction move_uploaded_file() dont voici le gabarit :
move_uploaded_file(temp, nom);
Où temp est le nom du fichier à télécharger et nom est la destination du fichier téléchargé.
Voici le code utilisé pour sauvegarder le fichier choisi par l'utilisateur sur le serveur :
<?php
if (isset($_FILES["fichierTexte"])) {
$tmp_name = $_FILES["fichierTexte"]["tmp_name"];
$name = $_FILES["fichierTexte"]["name"];
move_uploaded_file($tmp_name, $name);
}
?>
Pour rendre ce code plus robuste, vous pourriez :
 tester si aucun code d'erreur n'a été émis concernant le fichier ;
 vérifier que le fichier spécifié par l'utilisateur est bien un fichier texte ;
 vérifier que la taille du fichier n'est pas trop imposante :
Voici le code à utiliser pour tenir compte de ces remarques :
<?php
if (isset($_FILES["fichierTexte"]) AND $_FILES["fichierTexte"]["error"] ==
0) {
if (($_FILES["fichierTexte"]["size"]<10000) AND
($_FILES["fichierTexte"]["type"] == "text/plain")) {
$tmp_name = $_FILES["fichierTexte"]["tmp_name"];
$name = $_FILES["fichierTexte"]["name"];
move_uploaded_file($tmp_name, $name);
}
else

46
echo "Le fichier spécifié n'est pas un fichier texte ou sa taille
dépasse les 10000 octets<br>";
}
else
echo "Une erreur s'est produite pendant le téléchargement. Ressayez...";
?>
Vous pouvez vérifier que le fichier choisi dans les unités de masse se trouve maintenant sur
le serveur. Reportez-vous à la section sur la gestion de fichiers sur le serveur pour voir
comment ouvrir ce fichier et l'afficher dans une zone de texte éditable.
Envoyer un E-mail à partir d'un formulaire
Pour envoyer un e-mail à partir d'un script PHP, vous utiliserez la fonction mail() :
$resultat = mail(destin, titre, texte, de);
Où :
 destin est l'adresse du destinataire du message ;
 titre est le titre du message ;
 texte est le texte (brut ou HTML) envoyé dans le corps du message ;
 de est l'en-tête du message, composée des éléments suivants, séparés entre eux par
un retour charriot (n) :
o L'adresse mail de l'émetteur du message ;
o Le type MIME du message ;
o Le type du contenu ;
o Le charset utilisé dans le message.
Voici un exemple de code :
<?php
$titre = "Envoi de mail par PHP";
$texte = "<font color="red">Ce mail a été envoyé depuis <b>un script
PHP</b>.</font>";
$destinataire="prenom.nom.@fai.com";
$delapartde = "expediteur@fai.com";
$from = "From:".$delapartde."n";
$from .= "MIME-version: 1.0n";
$from .= "Content-type: text/html;
charset= UTF-8n";
if (!mail($destinataire,$titre,$texte,$from))

47
echo "Un problème s'est produit lors de l'envoi du message. Recommencez
SVP.";
?>

48
Superglobales, cookies et sessions
Vous avez déjà utilisé des variables superglobales dans les sections précédentes : $_GET[],
$_POST[], $_FILES[]. Ces variables sont dites superglobales car elles sont disponibles
partout dans le script : dans le corps du script, mais aussi dans les fonctions sans qu'il soit
nécessaire d'utiliser l'instruction global pour y accéder.
Vous utiliserez également les variables superglobales suivantes :
Superglobale Signification
$GLOBALS Tableau associatif de toutes les variables globales du script (les noms des
variables sont les index du tableau)
$_SERVER Tableau associatif créé par le serveur et contenant différentes
informations comme les en-têtes, dossiers et chemins du script. Reportez-
vous à la page
http://www.php.net/manual/fr/reserved.variables.server.php pour avoir le
détail des entrées de ce tableau.
$_COOKIE Tableau associatif des cookies enregistrés sur l'ordinateur client.
$_SESSION Tableau associatif des valeurs stockées sur le serveur pour la session d'un
utilisateur.
$_ENV Tableau associatif de variables d'environnement du serveur. Cette
superglobale n'est que très peu utile.
Pour afficher le contenu d'une superglobale, le plus simple consiste à utiliser la fonction
var_dump(). Par exemple, pour afficher le contenu de la variable $_SERVER, utilisez cette
instruction :
var_dump($_SERVER);

49
Sessions Web
Les sessions sont très pratiques pour mémoriser des données relatives à une session
utilisateur. Ces données pourront être librement utilisées tant que l'utilisateur est connecté.
Elles seront automatiquement supprimées du serveur à la déconnexion de l'utilisateur ou au
bout d'un certain temps d'inactivité (time-out).
Le principe d'utilisation des sessions est simple :
 Que ce soit pour mémoriser ou pour lire des données des variables de session, vous
devez appeler la fonction session_start() au début de chaque page, avant la
déclaration du DOCTYPE !
 Pour mémoriser une donnée dans une variable de session, utilisez une instruction du
type suivant : $_SESSION["nomVariable"] = valeur;
 Pour lire le contenu d'une variable de session, il suffit de consulter la superglobale
$_SESSION[] en précisant le nom de la variable entre les crochets et entre guillemets.
Par exemple : echo $_SESSION["nomVariable"];
Exercice
Définissez un formulaire dans lequel l'utilisateur pourra saisir son prénom et son nom. Créez
des variables de session avec les valeurs entrées lorsque l'utilisateur clique sur le bouton
Envoyer et vérifiez que ces variables de session sont bien accessibles dans une autre page.

50
Voici le code responsable de la saisie des données :
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<form name="MonFormulaire" method="post" action="traitement.php">
<td></td></tr>
</table>
</form>
</body>
</html>
Voici le code exécuté lorsque l'utilisateur clique sur le bouton Envoyer :
<?php
session_start();
?>
<!DOCTYPE html>
<html>
<head>
</head>
<body>

51
<?php
$prenom = htmlspecialchars($_POST["prenom"]);
$nom = htmlspecialchars($_POST["nom"]);
$_SESSION["prenom"] = $prenom;
$_SESSION["nom"] = $nom;
echo "Les données du formulaire ont été mémorisées.<br>";
echo "<a href="lecture-session.php">Cliquez sur ce lien pour
vérifier.</a>";
?>
</body>
</html>
Et voici le code de la page annexe, affichée lorsque l'utilisateur clique sur le lien de la page
traitement.php :
<?php
session_start();
?>
<!DOCTYPE html>
<html>
<head>
<title>Lecture des variables de session prenom et nom</title>
</head>
<body>
<?php
$prenom = $_SESSION["prenom"];
$nom = $_SESSION["nom"];
echo "Les données mémorisées dans les variables de session sont bien
accessibles :<br><ul>";
echo "<li>$_SESSION["prenom"] vaut ".$_SESSION["prenom"]."</li>";
echo "<li>$_SESSION["nom"] vaut ".$_SESSION["nom"]."</li></ul>";
?>
</body>

52
</html>
Voici le résultat affiché lors de l'exécution de ces trois pages :
Cookies
Les cookies sont comparables aux variables de session, à quelques détails près :
 Ils sont stockés sur l'ordinateur des visiteurs et donc propres à chaque visiteur ;
 Ils ont une durée de vie programmable.
Tout comme les variables de session, ils doivent être déclarés avant la déclaration du
doctype.
Pour mémoriser un cookie, vous utiliserez la fonction setcookie() :
setcookie(nom, valeur, expiration, chemin, domaine, securite, httponly);
Où :
 nom est le nom du cookie.
 valeur est la valeur à mémoriser dans le cookie.
 expiration est le temps après lequel le cookie n'est plus valable. Cette valeur est un
timestamp Unix, calculé en nombre de secondes depuis le 1 Janvier 1970. Pour obtenir
facilement cette valeur, ajoutez la durée de vie du cookie à la fonction time(). Par

53
exemple, pour obtenir une durée de vie de 30 jours, affectez la valeur time() +
30*24*3600 à ce paramètre.
 chemin est le chemin sur le serveur sur lequel le cookie doit être disponible ("/" pour
l'ensemble du domaine, "rep" pour limiter le cookie au dossier rep du serveur et à ses
sous-dossiers.
 domaine est le domaine pour lequel le cookie est disponible ("www.mondomaine.com"
par exemple).
 securite indique si le cookie doit être transmis à travers une connexion sécurisée
https (true) ou non (false).
 httponly indique si le cookie ne doit être accessible que par le protocole http (true)
ou également via les langages de scripts, comme JavaScript (false). Initialisez ce
paramètre à true pour limiter les attaques de type XSS.
Remarques
Tous les paramètres à l'exception du premier sont optionnels. Les paramètres chemin et
domaine peuvent être initialisés à null s'ils ne sont pas utilisés.
Par exemple, pour définir le cookie prenom, l'initialiser avec la valeur "pierre" et lui donner une
durée de vie d'une heure, vous utiliserez l'instruction suivante :
setcookie("prenom", "pierre", time() + 3600, null, null, false, true);
Pour afficher tous les cookies enregistrés sur l'ordinateur, utilisez la fonction var_dump() :
var_dump($_COOKIE);
Pour afficher un cookie donné, utilisez la superglobale $_COOKIE en précisant le nom du cookie
:
echo $_COOKIE["nom"];
Pour modifier un cookie, il suffit de le redéfinir avec la fonction setcookie().
Enfin, pour supprimer un cookie, vous utiliserez également la fonction setcookie(), en
précisant une durée de vie inférieure au timestamp actuel. Par exemple :
setcookie("prenom", "pierre", time() - 3600, null, null, false, true);
Exercice
Définissez un formulaire dans lequel sont saisis le prénom et le nom de l'utilisateur. Mémorisez
ces informations dans la page de traitement du formulaire. Ajoutez dans cette page un lien
vers une troisième page et vérifiez que les cookies ont bien été mémorisés.
Voici le code correspondant au formulaire de saisie :
<!DOCTYPE html>
<html>
<head>

54
</head>
<body>
<form name="MonFormulaire" method="post" action="traitement2.php">
<td></td></tr>
</table>
</form>
</body>
</html>
Voici le code de traitement du formulaire :
<?php
if (isset($_POST["prenom"]))
setcookie("prenom", $_POST["prenom"], time()+24*3600, null, null, false,
true);
if (isset($_POST["nom"]))
setcookie("nom", $_POST["nom"], time()+24*3600, null, null, false, true);
?>
<!DOCTYPE html>
<html>
<head>
</head>
<body>

55
Les cookies nom et prenom ont été mémorisés.<br><br>
<a href="verif-cookies.php">Cliquez ici pour le vérifier</a>
</body>
</html>
Et enfin, voici la page permettant de tester l'existence des cookies :
<!DOCTYPE html>
<html>
<head>
<title>Affichage des cookies</title>
</head>
<body>
<?php
echo "Le cookie prenom a pour valeur ".$_COOKIE["prenom"]."<br>";
echo "Le cookie nom a pour valeur ".$_COOKIE["nom"]."<br>";
?>
</body>
</html>
Les copies d'écran suivantes représentent l'enchaînement de ces trois pages :

56
Une erreur classique
L'erreur "Headers already sent by" sera envoyée par PHP si les cookies ne sont pas définis
avant la balise <html>.

57
Manipulation de fichiers
Cette section va vous montrer comment créer et manipuler des fichiers à accès séquentiel (les
seuls autorisés) sur le serveur.
Droits d'accès sur un serveur distant
Si vous travaillez sur un serveur distant, vous allez devoir modifier les droits d'accès aux
fichiers que vous manipulez en utilisant l'instruction CHMOD.
Lancez votre client FTP (FileZilla par exemple) et connectez-vous sur la page qui contient le
fichier dont vous voulez modifier les droits d'accès. Cliquez du bouton droit sur ce fichier et
sélectionnez Droits d'accès au fichier dans le menu. Une boîte de dialogue s'affiche :
Entrez la valeur 777 dans la zone de texte Valeur numérique et validez en cliquant sur OK.
Vous disposez maintenant de tous les droits nécessaires pour manipuler le fichier en PHP.
Si vous travaillez avec un serveur local WAMP, cette opération est inutile.
Accéder à un fichier
Comme dans tous les langages, vous devez ouvrir un fichier pour pouvoir lire son contenu ou
y stocker des données. Pour cela, vous utiliserez la fonction fopen() :
$handle = fopen(nom, mode);
Où :
 handle est une variable qui représentera le fichier lorsque vous voudrez lire son
contenu ou y écrire des données ;

58
 nom est le nom du fichier ;
 mode est le mode d'accès au fichier. Les modes autorisés sont les suivants :
o r : lecture seule
o r+ : lecture et écriture. Si le fichier n'existe pas, il est créé.
o a : écriture seule. Si le fichier n'existe pas, il est créé.
o a+ : lecture et écriture. Si le fichier n'existe pas, il est créé. S'il existe, les
nouvelles données seront ajoutées après la dernière donnée existante.
Lorsque les manipulations sur le fichier sont terminées, vous devez le fermer avec la fonction
fclose() :
fclose($handle);
Lecture de données dans un fichier
Vous pouvez lire les données caractère par caractère avec la fonction fgetc() ou ligne par
ligne avec la fonction fgets() :
$car = fgetc("handle");
$ligne = fgets("handle);
Si le fichier contient plusieurs caractères et/ou lignes, vous devrez utiliser une boucle pour
parcourir les données. La fonction feof($handle) retourne la valeur false si la fin du fichier
n'est pas atteinte et la valeur true dans le cas contraire.
Exercice
En utilisant Notepad++, créez un fichier texte dans lequel vous écrirez quelques lignes de
données. Par exemple :

59
Enregistrez ce fichier sous le nom data.txt. Ouvrez-le et affichez son contenu avec quelques
lignes de PHP.
Voici le code à utiliser :
<!DOCTYPE html>
<html>
<head>
<title>Lecture d'un fichier en PHP</title>
</head>
<body>
<?php
$handle=fopen("data.txt","r");
while (!feof($handle))
echo fgets($handle)."<br>";
fclose($handle);
?>
</body>
</html>

60
Une erreur classique
Si les accents sont mal affichés dans le résultat, assurez-vous que le fichier contenant les
données a été sauvegardé avec un encodage UTF-8 (sans BOM).
Remarque
BOM signifie Byte Order Mark. Un codage UTF avec BOM ajoute un espace insécable de
largeur nulle (zero-width no-break space) en début de fichier. Ce caractère n'est utile que dans
les encodages UTF-16 ou UTF-32. L'encodage UTF-8 standard (donc avec BOM) peut
produire des erreurs dans certains cas particuliers, comme par exemple la redirection PHP :
<?php
header("page-cible.php");
?>
<!DOCTYPE html>
<html>
…
L'espace insécable en début de fichier provoque une erreur de type "Cannot modify header
information – headers already sent by" car ce caractère est envoyé avant le code PHP.
Ecriture de données dans un fichier
Pour écrire des données dans un fichier PHP, vous utiliserez la fonction fputs() :
fputs($handle, texte);
Où $handle est le handle du fichier retourné par la fonction fopen() et texte est le texte à
écrire dans le fichier.

61
Si vous ouvrez le fichier en mode a ou a+, les données sont écrites à la fin du fichier, après
les (éventuelles) données existantes. Si vous ouvrez le fichier en mode r+, les données sont
écrites à l'emplacement spécifié par la fonction fseek() :
fseek($handle, position);
Où position est la position d'écriture (en caractères, à partir de 0). Si des données sont
présentes à cette position, elles sont écrasées par les nouvelles données.
Exercice
En utilisant Notepad++, créez le fichier compteur.txt.
Ecrivez quelques lignes de PHP pour créer un compteur de visite.
Voici la solution :
<!DOCTYPE html>
<html>
<head>
<title>Compteur de visite</title>
</head>
<body>
<?php
$handle=fopen("compteur.txt","r+");
$visites = fgets($handle);
echo "Cette page a été visitée $visites fois.";
$visites++;
fseek($handle, 0);
fputs($handle, $visites);
fclose($handle);
?>
</body>
</html>

62
Programmation Orientée Objet
La programmation orientée objet (POO) a essentiellement deux avantages. Elle :
 facilite l'organisation du code et donc le développement ;
 permet de définir des modules réutilisables.
La programmation orientée objets repose sur trois notions fondamentales : l'encapsulation,
l'héritage et le polymorphisme.
Classes, instances et composants
Les classes définissent des structures composées de variables et de fonctions. Pour utiliser les termes
propres à la POO, les variables d'une classe sont appelées propriétés. Quant aux fonctions de la classe,
elles sont appelées méthodes.
Les instances, c'est-à-dire les utilisations d'un type classe, sont appelées des objets. Les variables et
fonctions d'une classe sont appelés composants ou membres de la classe.
Si vous avez du mal à vous y retrouver avec tous ces nouveaux termes, nous allons faire une analogie.
Considérez une classe comme une usine qui fabrique des voitures. Les instances de l'usine (la classe) sont
des voitures (les objets). La cylindrée, la couleur, le type des pneus, etc. sont des caractéristiques
(propriétés) propres à chaque voiture. Selon les caractéristiques des voitures à fabriquer, il faut appliquer
différents procédés de fabrication (méthodes).
Encapsulation
Le terme "encapsulation" désigne le regroupement des variables et des fonctions au sein d'une
seule et même entité : une classe.
Par défaut, toutes les propriétés et méthodes d'une classe sont de type public. Ils sont donc
utilisables et modifiables par toutes les instances de la classe. Si nécessaire, vous pouvez
également définir des propriétés et méthodes d'un autre type :
 private : les propriétés et méthodes ne sont utilisables et modifiables que par la classe
elle-même (pas dans les classes dérivées ni dans les objets) ;
 protected : les propriétés et méthodes sont utilisables et modifiables par la classe elle-
même et par ses classes dérivées. Par contre, elles sont inaccessibles aux objets qui
découlent de la classe.
Getter et setter
Lorsqu'une propriété est de type private, seule la classe dans laquelle elle est définie peut lire
son contenu ou la modifier. Pour cela, on utilise des fonctions un peu particulières appelées
getter et setter.

63
Héritage
Il est possible de créer un nouveau type d'objet en prenant comme modèle un type objet déjà existant.
Le nouvel objet possèdera (héritera) les mêmes propriétés et les mêmes méthodes que son modèle,
avec toutefois la possibilité d'ajouter de nouvelles propriétés et/ou de nouvelles méthodes ou de
redéfinir les méthodes existantes. On dira que le nouvel objet est un objet dérivé ou un descendant
de l'ancien.
Cette notion d'héritage permet de ne pas avoir à réécrire des méthodes déjà écrites. D'autre part les
corrections ou modifications du code pourront être réalisées plus rapidement et de façon plus sûre.
Polymorphisme
La notion de polymorphisme est assez abstraite et peu utile en PHP. Elle découle de la notion
d'héritage. Supposons qu'une classe Laser et trois classes dérivées CD, DVD et Blue aient été définies.
Les trois classes dérivées ont toutes les caractéristiques de la classe Laser. Ainsi, des objets de type CD,
DVD et Blue peuvent être traités comme des objets de type Laser. Cependant, il est possible de
surcharger les méthodes d'instance de la classe parente afin d'induire des comportements spécifiques
aux classes dérivées.
class Laser {
public function caracteristiques() {
echo "Disque laser<br>";
}
}
class CD extends Laser{
parent::caracteristiques();
echo "Capacité : 700 Mo<br>";
}
}
class DVD extends Laser {
echo "Capacité : 4,7 Go<br>";

64
}
}
class Blue extends Laser {
echo "Capacité : 25 Go<br>";
}
}
Sans entrer dans le détail du code, vous pouvez comprendre que les classes héritées CD, DVD et Blue
surchargent la méthode publique caracteristiques de la classe parente laser. Elles conservent le
comportement de la méthode parente (parent::caracteristiques();) et la complètent avec
des informations qui leur sont spécifiques.
Interfaces
En programmation objet, les interfaces permettent d'indiquer quelles méthodes publiques une
classe doit implémenter. Leur principal intérêt est de garantir que toutes les classes qui
l'implémentent donneront accès aux méthodes spécifiées dans l'interface.
L'utilisation d'interfaces trouve son utilité dans des projets impliquant plusieurs programmeurs
ou développés de façon modulaire.
Voyons comment mettre en œuvre une interface dédiée à la formation PHP. Les classes qui
implémenteront cette interface devront elles-mêmes implémenter les méthodes publiques
programme() et pratique().
Voici le fichier interface.php correspondant :
<?php
interface formationPHP{
public function programme();
public function pratique();
}
?>
Nous allons maintenant définir deux classes qui implémentent l'interface formationPHP.
Voici le code de la classe debutant (debutant.class.php) :
<?php

65
require_once "interface.php";
class debutant{
public function programme() {
return "<ul><li>Instructions</li><li>Fichiers</li><li>Transmission de
données</li></ul>";
}
public function pratique() {
return "Exercices pour appréhender le langage.<br>";
}
}
?>
Remarquez l'instruction require_once au début du listing, pour faire référence à l'interface.
Et voici le code de la classe avance (avance.class.php) :
<?php
require_once "interface.php";
class avance{
public function programme() {
return "<ul><li>Superglobales</li><li>POO</li><li>BDD</li></ul>";
}
public function pratique() {
return "Nombreux exercices de tous niveaux.<br>";
}
}
?>
Il ne reste plus qu'à utiliser les classes debutant et avance en définissant un quatrième fichier
PHP (formation.php) :
<!DOCTYPE html>
<html>

66
<head>
<title>Utilisation des classes debutant et avance</title>
</head>
<body>
<?php
include_once("debutant.class.php");
include_once("avance.class.php");
$coursDebutant = new debutant;
$coursAvance = new avance;
echo "<b>Formation pour débutants PHP</b><br>";
echo "<i>Programme :</i><br>";
echo $coursDebutant->programme();
echo "<i>Pratique :</i><br>";
echo $coursDebutant->pratique();
echo "<br><b>Formation avancée PHP</b><br>";
echo "<i>Programme :</i><br>";
echo $coursAvance->programme();
echo "<i>Pratique :</i><br>";
echo $coursAvance->pratique();
?>
</body>
</html>

67
Pour terminer ce deuxième tome, sachez que tous les jours, Mediaforma Learning publie de
nouveaux articles sur Windows 7, Windows 8, Office 2010 et 2013, les langages HTML5,
CSS3 et JavaScript, WordPress, PhotoFiltre et OSX Mavericks. Retrouvez- nous sur
http://www.mediaforma.com/testez-nos-produits/.
Tous nos produits (packs eBook + vidéos, livres et CD) sont disponibles à cette adresse :
http://www.mediaforma.com/.
Pour toute remarque ou question, n'hésitez pas à nous joindre en vous rendant sur la page
http://www.mediaforma.com/contact/.
Bonne continuation !

Support tutoriel : Maîtriser PHP MySQL - Tome 2

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Support tutoriel : Maîtriser PHP MySQL - Tome 2

Similaire à Support tutoriel : Maîtriser PHP MySQL - Tome 2 (20)

Plus de SmartnSkilled

Plus de SmartnSkilled (20)

Dernier

Dernier (16)

Support tutoriel : Maîtriser PHP MySQL - Tome 2