IAI-TOGO

COURS DE
PROGRAMMATION WEB 2
PHP-MySQL

AMEVOR Kossi Amèdomè : enseignant permanent à l’IAI-TOGO

Année académique : 2019-2020
Table des matières
Généralités sur les langages informatiques .......................................................................... 3
1. Langage interprété........................................................................................................... 4
2. Langage compilé ............................................................................................................... 4
I. Qu’est-ce que PHP ..................................................................................................................... 6
I.1 Définition .............................................................................................................................. 6
I.2 Utilisation pratique ........................................................................................................... 6
I.3 Pages statiques vs pages dynamiques ........................................................................ 7
I.4 Pages dynamiques et PHP .............................................................................................. 7
I.5 Le nécessaire serveur ....................................................................................................... 7
I.6 Le nécessaire client ........................................................................................................... 8
I.7 Le respect des standards ................................................................................................ 8
II. Les Bases : Présentation ........................................................................................................ 9
II.1 Syntaxe de base ........................................................................................................... 9
III. Les variables ........................................................................................................................... 12
III.1 Déclarer une variable.................................................................................................... 12
III.2 Portée des variables ....................................................................................................... 14
III.3 Variables prédéfinies ................................................................................................... 15
III.4 Variables dynamiques ................................................................................................. 16
III.5 Types de variables ........................................................................................................ 16
III.5.1 booléens ................................................................................................................... 16
III.5.2 Entiers ...................................................................................................................... 17
III.5.3 Virgule flottante .................................................................................................... 17
III.5.5 Les tableaux ........................................................................................................... 20
III.5.6 La variable objet ..................................................................................................... 22
III.6 Les constantes ............................................................................................................... 22
III.7 Obtenir le type d'une variable .................................................................................. 23
III.8 Conversion de type ............................................................................................................ 24
III.9 Définir et supprimer une variable ............................................................................ 25
IV. Les opérateurs....................................................................................................................... 26
IV.1 Opérateurs arithmétiques ........................................................................................... 26
IV.2 Opérateurs d'assignation ............................................................................................ 26
IV.3 Opérateurs de comparaison ....................................................................................... 27
IV.4 Opérateur d'erreur ......................................................................................................... 27
IV.5 Opérateurs d'incrémentation/décrémentation .................................................... 27
IV.7 Opérateurs de chaînes ................................................................................................ 29
V. Les instructions de contrôle .............................................................................................. 30
V.1 L’instruction if .................................................................................................................. 30
V.2 Les instructions de boucles ........................................................................................ 35
V.2.1 La boucle for .................................................................................................................. 35
V.2.2 La boucle while ........................................................................................................ 36
V.2.3 La boucle do ... while ............................................................................................. 37
V.2.4 foreach ........................................................................................................................... 38
V.3 L’instruction break.......................................................................................................... 38

Cours Programmation PHP Page 1/60

V.4 L’instruction continue ....................................................................................................... 39
V.5 require et include (_once).............................................................................................. 40
VI. Gestion des formulaires ..................................................................................................... 41
VI.1 Formulaire avec la méthode GET ............................................................................ 41
VI.2 Formulaire avec la méthode POST .......................................................................... 42
VI.3 Les éléments d’un tableau ......................................................................................... 42
VI.4 Récupération des données ......................................................................................... 43
VII. Les fonctions ........................................................................................................................ 45
VII.1 Syntaxe et portée .......................................................................................................... 45
VII.2 Arguments ....................................................................................................................... 45
VII.3 Valeur de retour ............................................................................................................ 46
VII.4 Fonction retournant plusieurs valeurs ................................................................ 47
VII.5 Fonction à paramètre de type array ....................................................................... 47
VII.6 Fonctions de lecture de tableau ............................................................................. 47
VII.7 Les variables statiques .............................................................................................. 48
VIII. Les bases de données MySQL ....................................................................................... 50
VIII.1 Présentation .................................................................................................................. 50
VIII.2 Outils.............................................................................................................................. 51
VIII.3 Créer une base ............................................................................................................ 51
VIII.4 MySQL et PHP ............................................................................................................. 52
VIII.4.1 Connexion à une base de données ............................................................... 52
VIII.4.1.1 Connexion au serveur MySQL ............................................................... 52
VIII.4.1.2 Choix d'une base ........................................................................................ 53
VIII.4.1.3 Fermeture d'une connexion .................................................................... 53
VIII.4.1.4 Séquence complète pour une base ....................................................... 53
VIII.4.2 Les requêtes .......................................................................................................... 54
VIII.4.2.1 Exécuter une requête ................................................................................ 54
VIII.4.2.2 Nombre de lignes affectées ...................................................................... 54
VIII.4.2.3 Nombre de lignes retournées .................................................................. 55
VIII.4.2.4 Récupérer les résultats ............................................................................. 55
VIII.4.2.5 Insertion avec auto-incrément .............................................................. 57
VIII.4.3 Récupération des erreurs ................................................................................. 57
IX. Sessions PHP .......................................................................................................................... 58
IX.1 Principe ............................................................................................................................. 58
IX.2 Utilisation ......................................................................................................................... 58
IX.2.1 Ouverture ................................................................................................................. 58
IX.2.2 Variables de session ............................................................................................. 59
IX.2.3 Expiration de la session ...................................................................................... 60

Cours Programmation PHP Page 2/60

Généralités sur les langages informatiques
On appelle langage informatique un langage destiné à décrire
l’ensemble des actions consécutives qu’un ordinateur doit exécuter.
Les langages naturels (l’anglais, le français) représentent l’ensemble
des façons qu’ont un groupe d’individu de communiquer. Les langages
servant aux ordinateurs à communiquer n’ont rien à voir avec des
langages informatiques, on parle dans ce cas de protocoles, ce sont
deux notions totalement différentes. Un langage informatique est une
façon pratique pour nous (humains) de donner des instructions à un
ordinateur. Un langage informatique est rigoureux : à CHAQUE
instruction correspond UNE action du processeur. Le langage utilisé
par le processeur, c’est-à-dire les données telles qu’elles lui arrivent,
est appelé langage machine. Il s’agit d’une suite de 0 et de 1 (du binaire)
mais pour plus de « clarté » il peut être décrit en hexadécimal. Toutefois
le langage machine n’est pas compréhensible facilement par l’humain
moyen. Ainsi il est plus pratique de trouver un langage intermédiaire,
compréhensible par l’homme, qui sera ensuite transformé en langage
machine pour être exploitable par le processeur. L’assembleur est le
premier langage informatique qui ait été utilisé. Celui-ci est encore très
proche du langage machine mais il permet déjà d’être plus
compréhensible. Toutefois un tel langage est tellement proche du
langage machine qu’il dépend étroitement du type de processeur utilisé
(chaque type de processeur peut avoir son propre langage machine).
Ainsi un programme développé pour une machine ne pourra pas être
porté sur un autre type de machine (on désigne par portable un
programme qui peut être utilisé sur un grand nombre de machines).

Cours Programmation PHP Page 3/60

Pour pouvoir l’utiliser sur une autre machine il faudra alors parfois
réécrire entièrement le programme. Les langages informatiques
peuvent grossièrement se classer en deux catégories : les langages
interprétés et les langages compilés.

1. Langage interprété
Un langage informatique est par définition différent du langage
machine. Il faut donc le traduire pour le rendre intelligible du point de
vue du processeur. Un programme écrit dans un langage interprété a
besoin d’un programme auxiliaire (l’interpréteur) pour traduire au fur
et à mesure les instructions du programme

2. Langage compilé
Un programme écrit dans un langage dit « compilé » va être traduit une
fois pour toutes par un programme annexe (le compilateur) afin de
générer un nouveau fichier qui sera autonome, c’est-à-dire qui n’aura
plus besoin d’un programme autre que lui pour s’exécuter (on dit
d’ailleurs que ce fichier est exécutable). Un programme écrit dans un
langage compilé a comme avantage de ne plus avoir besoin, une fois
compilé, de programme annexe pour s’exécuter. De plus, la traduction
étant faite une fois pour toute, il est plus rapide à l’exécution. Toutefois
il est moins souple qu’un programme écrit avec un langage interprété
car à chaque modification du fichier source (fichier intelligible par
l’homme : celui qui va être compilé) il faudra recompiler le programme
pour que les modifications prennent effet.

D’autre part, un programme compilé a pour avantage de garantir la

sécurité du code source. En effet, un langage interprété, étant
directement intelligible (lisible), permet à n’importe qui de connaître les

Cours Programmation PHP Page 4/60

secrets de fabrication d’un programme et donc de copier le code voire
de le modifier. Il y a donc risque de non-respect des droits d’auteur.
D’autre part, certaines applications sécurisées nécessitent la
confidentialité du code pour éviter le piratage (transaction bancaire,
paiement en ligne, communications sécurisées, etc.).

Cours Programmation PHP Page 5/60

I. Qu’est-ce que PHP

I.1 Définition
PHP est un langage de script HTML exécuté du côté du serveur. Il veut
dire « PHP : Hypertext Preprocessor ». Sa syntaxe est largement inspirée
du langage C, de Java et de Perl, avec des améliorations spécifiques. Le
but du langage est d'écrire rapidement des pages HTML dynamiques.

I.2 Utilisation pratique

– Forums et Messageries
– Commerce électronique
– Banque / Comptes en ligne
– Publication en ligne
– Moteurs de recherche
– Tout ce que vous voulez, (sauf les jeux)

Résumons quelques sigles que nous allons utiliser par la suite.

• HTML : Hypertext Markup Language
• PHP : Hypertext PreProcessor
• SQL : Structured Query Language
• MySQL : serveur de base de données et les outils pour y accéder
• WAMP : Windows – Apache – MySQL – PHP, le quatuor gagnant des
serveurs web.

APACHE PHP MySQL

WINDOWS

Cours Programmation PHP Page 6/60

I.3 Pages statiques vs pages dynamiques
Une page statique est une page écrite directement en HTML. Elle peut
éventuellement incorporer du code Javascript lui donnant un semblant
de « dynamisme » mais uniquement du côté du navigateur et des
données locales.

Pour des traitements plus lourds nécessitant l'accès à une base de

données, un formatage de tableau en fonction de résultats, une
recherche poussée, du graphisme, il faut passer par des pages
dynamiques et par un langage qui sera exécuté du côté du serveur :
ASP sur les serveurs Microsoft/IIS, Perl, PHP...

I.4 Pages dynamiques et PHP

PHP est un langage Server Side ou côté serveur. Lors du chargement
d'une page PHP, c'est le serveur qui va lire, interpréter et exécuter le
code. Puis il renvoie le résultat, généralement sous la forme de code
HTML au navigateur. Ainsi le navigateur et l'utilisateur ne voient
jamais le véritable code PHP exécuté. De plus le résultat étant une page
web classique en HTML, pas besoin d'installer sur le client des
composants spécifiques (java, ...). Il n'y a donc pas de notion de vitesse
d'exécution du côté du client, mais celle du serveur est prépondérante.

I.5 Le nécessaire serveur

PHP ne sert pas seulement à faire des pages dynamiques. C'est un
langage interprété qui au même titre que Perl, Python ou TCL est
capable de lancer des scripts intéractifs ou non. Le minimum
nécessaire et vital pour apprendre PHP est donc l'interpréteur PHP lui-
même sur un environnement supporté (Unix, Windows, Mac, ...).

Cours Programmation PHP Page 7/60

I.6 Le nécessaire client
Pour développer il suffit d'un simple éditeur mais il vaut mieux préférer
un éditeur plus évolué supportant la coloration syntaxique et quelques
fonctions évoluées. L'accès aux bases MySQL peut se faire soit depuis
un navigateur (phpMyAdmin) soit depuis une interface MySQLCC ou
encore DBDesigner pour la conception.

Pour les tests : un simple navigateur respectant les standards du web.

I.7 Le respect des standards

Le W3C est l'organisme international faisant loi dans le monde des
standards du web. Il a défini une série de normes dont le HTML, le
XML, le XHTML, les CSS, etc. Pourquoi respecter un standard ? C'est
la garantie d'un bon fonctionnement et du bon affichage de manière
identique de vos pages sur tous les navigateurs supportant ce standa

Cours Programmation PHP Page 8/60

II. Les Bases : Présentation
PHP est un langage très souple prenant ses sources dans divers
langages comme le C, le Perl, le C++. Il est donc possible d'avoir
plusieurs styles de scripts (programmation classique dite procédurale
ou programmation objet, ou programmation bordélique). Cette
souplesse permet une très grande liberté, un peu comme en Perl.
L'inconvénient est qu'on peut très vite obtenir du code illisible
(bordélique), même si ça marche très bien. Prenez donc l'habitude de
commenter votre code, de l'indenter et de ne placer qu'une instruction
par ligne.

II.1 Syntaxe de base

➢ Intégration à HTML
Une page php porte l'extension « .php ». Une page PHP peut être
entièrement programmée en PHP ou mélangée avec du code html. PHP
est un langage « Embedded HTML », c'est à dire qu'il apparaît à
n'importe quel endroit de la page HTML. Pour ça on le place dans des
balises particulières : <?php et ?>. On peut aussi utiliser les balises
<script language="php"> et </script>. La première forme est préférable
pour plus de simplicité et une compatibilité XHTML. On écrit donc une
page HTML dans laquelle on intègre du code PHP.

<html>
<head>
<title>Titre</title>
</head>
<body>

Cours Programmation PHP Page 9/60

 <?php
echo "Hello World !";
?>
</body>
</html>

Le code HTML généré sera le suivant

<html>
<head>
<title>Titre</title>
</head>
<body>
Hello word!
</body>
</html>

L'utilisation de balises pour l'intégration de code dans une page web

est très souple et permet de jongler facilement avec du code PHP et du
code HTML :

<?php
if ( expression ) {
?>
<strong>Ceci est vrai.</strong>
<?php
} else {
?>
<strong>Ceci est faux.</strong>
<?php

Cours Programmation PHP Page 10/60

 }
?>

➢ Séparateur d'instructions
Comme en C une instruction se termine par un point-virgule « ; ». Notez
que la balise fermante ?> implique la fin d'une instruction.

<?php
echo "Ceci est un test";
?>
<?php echo "Ceci est un test" ?>

➢ Bloc d'instructions
Un bloc d'instructions se place entre accolades { et }. Un bloc
d'instructions peut contenir du code de n'importe quelle longueur et
est considéré dans le reste du code comme une instruction unique. Si
c'est une expression (qui a une valeur) on peut donc assigner le bloc,
faire des calculs, ...

➢ Commentaires
Les commentaires s'utilisent comme en C et en C++ avec /* .. */ et //.
Notez qu'une balise fermante ferme le commentaire en cours.

<?php
/* echo "salut !" */
// Commentaire sur cette ligne
?>

Cours Programmation PHP Page 11/60

III. Les variables

III.1 Déclarer une variable

Une variable commence par un dollar « $ » suivi d'un nom de variable.
Les variables ne sont pas typées au moment de leur création. Attention
PHP est sensible à la casse : var et Var ne sont pas les mêmes variables.

Voici les règles à respecter :

• Une variable peut commencer par une lettre

• Une variable peut commencer par un souligné (underscore) « _ »

• Une variable ne doit pas commencer par un chiffre.

// Déclaration et règles
$var=1; // $var est à 1
$Var=2; // $ Var est à 2
$_toto='Salut'; // Ok
$3petitscochons=5; // Invalide : commence par un chiffre

Leur type dépend de leur valeur et de leur contexte d'utilisation. Mais

on peut forcer (cast) ponctuellement une variable à un type de données,
ce qui s'appelle le transtypage. De même comme le type de variable
peut changer en fonction de son utilisation ou du contexte, PHP
effectue automatiquement un transtypage, ce qui peut parfois fournir
des résultats surprenants. On affecte une valeur à une variable avec le
signe égal « = » avec ou sans espace avant ou après.

// Déclaration et transtypage
$var = '2'; // Une chaîne 2

Cours Programmation PHP Page 12/60

$var + = 1; // $var est maintenant un entier 3
$var = $var + 0.3; // $var est maintenant un réel de type double 3.3
$var = 5 + "3 petits cochons"; // $var est un entier qui vaut 8

Par défaut les variables sont assignées par valeur : la valeur assignée à
la variable est recopiée dans la variable. PHP peut aussi travailler par
référence. Une variable peut donc référencer une autre variable. On dit
alors que la variable devient un alias, ou pointe sur une autre variable.
On assigne par référence en utilisant le signe « & » devant la variable
assignée.

Exemple d’affectation par valeur et par référence

//Affectation par valeur de $mavar1 et $mavar2

$mavar1="Paris";
echo "\$mavar1= ",$mavar1,"<br />";
$mavar2="Lyon";
echo "\$mavar2= ",$mavar2,"<br />";
//Affectation par référence de $mavar2
$mavar2 = &$mavar1;
echo "Affectation par référence de \$mavar2 <br />";
echo "\$mavar1= ",$mavar1,"<br />";
echo "\$mavar2= ",$mavar2,"<br />";
echo "modification de \$mavar1 <br />";
$mavar1="Nantes";
echo "\$mavar1= ",$mavar1,"<br />";
echo "\$mavar2= ",$mavar2,"<br />";
echo "modification de \$mavar2 <br />";
$mavar2="Marseille";
echo "\$mavar1= ",$mavar1,"<br />";
echo "\$mavar2= ",$mavar2,"<br />";

Le résultat de l’exécution de ce script montre l’évolution des valeurs des

deux variables après plusieurs affectations :
$mavar1= Paris
$mavar2= Lyon
affectation par référence de $mavar2
$mavar1= Paris
$mavar2= Paris

Cours Programmation PHP Page 13/60

modification de $mavar1
$mavar1= Nantes
$mavar2= Nantes
modification de $mavar2
$mavar1= Marseille
$mavar2= Marseille

III.2 Portée des variables

La portée d'une variable dépend du contexte. Une variable déclarée
dans un script et hors d'une fonction est globale mais par défaut sa
portée est limitée au script courant, ainsi qu'au code éventuellement
inclus (include, require) et n'est pas accessible dans les fonctions ou
d'autres scripts.
$a = 1; // globale par défaut
function foo() {
echo $a; // c'est une variable locale à la fonction : n'affiche rien

}
Pour accéder à une variable globale dans une fonction, il faut utiliser
le mot-clé global.

$a=1; // globale par défaut

$b=2; // idem
function foo() {
global $a,$b; // on récupère les variables globales
$b=$a+$b;
}

echo $b;//affiche 3

PHP accepte les variables statiques. Comme en C une variable statique

ne perd pas sa valeur quand on sort d'une fonction.

Cours Programmation PHP Page 14/60

function test_static() {
static $a=0;
echo $a; // +1 à chaque passage dans la fonction
$a++;
}

III.3 Variables prédéfinies

PHP dispose d'un grand nombre de variables prédéfinies. Ces variables
sont généralement de type scalaires ou des tableaux. Elles sont souvent
de type superglobales, c'est à dire accessible depuis n'importe où sans
notion de portée. Voici quelques tableaux prédéfinis (voir au point
Tableaux pour comprendre leur utilisation).

• $_GLOBALS : tableau des variables globales. La clé est le nom de la

variable.
• $_SERVER : variables fournies par le serveur web, par exemple
'SERVER_NAME'
• $_GET : variables fournies par HTTP par la méthode GET
(formulaires)
• $_POST : idem mais pour la méthode POST
• $_COOKIE : les variables fournies par un cookie
• $_FILES : variables sur le téléchargement d'un fichier (upload)
• $_ENV : accès aux variables d'environnement du serveur
• $_SESSION : les variables de session (voir cours sur les sessions)

Cours Programmation PHP Page 15/60

III.4 Variables dynamiques
Une variable dynamique utilise la valeur d'une variable comme nom
d'une autre variable. On utilise les variables dynamiques en rajoutant
un « $ » devant le nom de la première variable.

$a = "var";
$$a = 1; // $$a=1 equivaut en fait à $var=1
echo $a; // affiche var
echo $$a; // affiche 1
echo $var; // affiche 1

III.5 Types de variables

III.5.1 booléens
Un booléen peut prendre deux valeurs TRUE ou FALSE. Les deux
constantes TRUE et FALSE peuvent être utilisées sans aucune
distinction de casse (pas de différences entre les majuscules et les
minuscules).

$var=FALSE; // FALSE, False, false, ...

$var2=True; // TRUE, True, true, ...

Comme en C, les tests de conditions dans les structures de contrôles

effectuent une conversion booléenne de la condition.

if($var == true) echo "ok";

if($var) echo "ok"; // Identique

Exemple :
<?php
$a = 80;
$b = ($a<95);

Cours Programmation PHP Page 16/60

 echo $b; // Affiche 1
?>

III.5.2 Entiers
Un entier est l'ensemble des nombres naturels, c'est à dire sans virgule,
positifs ou négatifs. Les entiers sont généralement codés sur 32 bits
mais cela dépend de l'architecture. Si on affecte un nombre entier qui
dépasse la capacité de la variable, celle-ci sera transformée en réel
(float). Enfin il n'y a pas de notion d'entier non signé.

Lors de la conversion d'un booléen en entier, FALSE devient 0 et TRUE

devient 1. Lors de la conversion d'un nombre à virgule flottante, le
nombre sera arrondi à la valeur inférieure s'il est positif, ou supérieure
s'il est négatif (conversion vers zéro). Pour la conversion depuis les
chaînes, voir à ce type.

Exemple : $varint = 1789;

$varint = –758;

III.5.3 Virgule flottante

On parle ici des nombres réels, double ou float, c'est à dire les nombres
à virgules. La virgule est spécifiée par le point « . ». La puissance de 10
s'exprime avec le « e » ou le « E ».

<?php
$vardbl = 1952.36;
$vardbl2= 1.95236E3;//Soit 1.95236 x 1000
echo $vardbl2,"<br />";//Affiche 1952.36
$vardbl3= 1.95236e3;
echo $vardbl3,"<br />";//Affiche 1952.36
echo $vardbl3*100000000000,"<br />";//Affiche 1.95236E14
?>

Cours Programmation PHP Page 17/60

III.5.4 Chaînes de caractères
Une chaîne est une séquence de caractères. PHP travaille en ASCII soit
256 caractères, mais ne supporte pas encore le format Unicode, prévu
dans la version 5. Il n'y a pas de limite théorique pour la taille de la
chaîne.

On distingue trois syntaxes pour utiliser une chaîne

• Les guillemets simples '...' (apostrophes) : Comme en shell, tous les

caractères inclus dans la chaîne sont sortis tels quels sans
interprétation. Si vous devez afficher un guillemet simple, il faudra
l'échapper : \'

• Les guillemets doubles "..." : Certaines séquences de caractères sont

interprétées et les variables sont substituées (remplacées par leur
valeur).

• HereDoc : Identique aux HereScripts en Shell. Le texte saisi jusqu'à

un délimiteur spécifié est placé dans la variable.

Voici le tableau issu de la documentation PHP des séquences pouvant

être utilisés avec les guillemets doubles.

Séquence Valeur

\n Nouvelle ligne (linefeed, LF ou 0x0A (10) en ASCII)

\r Retour à la ligne (carriage return, CR ou 0x0D

(13) en ASCII)

\t Tabulation horizontale (HT ou 0x09 (9) en ASCII)

\\ Antislash

\$ Caractère $

Cours Programmation PHP Page 18/60

\" Guillemets doubles

Une séquence de caractères qui permet de

\[0-7]{1,3}
rechercher un nombre en notation octale.

\x[0-9A-Faf]{1,2} Une séquence de caractères qui permet de

rechercher un nombre en notation hexadécimale.

echo 'Attention l\'abus d\'alcool est dangereux';

$var = 2345;
echo "la valeur de \$var est $var\n";

N'importe quelle variable peut être affichée dans une chaîne comme ci-
dessus mais attention si deux variables ont un nom proche ! Il faut
alors utiliser les accolades { } comme en shell. Enfin on peut accéder à
n'importe quel caractère dans une chaîne en indiquant sa position (qui
commence à zéro) entre deux accolades collées juste après le nom de la
variable.

$fic = 'toto.fic';
$fics = 'riri fifi loulou';
echo "$fics ${fic}s"; // affiche riri fifi loulou toto.fics

On peut facilement concaténer deux chaînes avec l'opérateur point «.

». On peut ajouter du texte à une chaîne avec l'opérateur point égal
«.=».

$str="Salut les Amis !\n";

$str.="Comment ça va ?"; // "Salut les Amis !\nComment ça va ?
$str2 = $str."\n"; // "Salut les Amis !\nComment ça va ?\n

Cours Programmation PHP Page 19/60

Si vous devez utiliser une chaîne de caractères comme valeur
numérique (dans une addition par exemple, attention à son contenu.
La chaîne sera de type double (réel) si elle contient un 'e' ou un 'E'.
Sinon ce sera un entier. La valeur numérique est ensuite définie par le
début de la chaîne. Si la chaîne commence par une valeur numérique,
elle sera utilisée, sinon elle sera égale à 0 zéro. Si la première expression
est une chaîne, le type de variable dépend de la seconde expression.

$val = 10+"2.55"; // float, 12.55

$val = 1+"toto2"; // 1 + 0 = 1
$val = 2+"3 petits cochons"; // 2 + 3 = 5 (le 3 est en premier dans la
chaîne)

III.5.5 Les tableaux

Un tableau PHP est une association ordonnée. Une association fait
correspondre des valeurs à des clés.

Un tableau est créé avec la fonction array() qui prend comme

arguments des paires « key => value » séparées par des virgules. La clé
peut être soit un entier soit du texte. Attention, 8 est un entier, 08 une
chaîne ! Si la clé est absente alors c'est la dernière clé entière plus 1
qui est choisie. Si c'est la première, c'est 0 zéro.

On accède aux éléments d'un tableau à l'aide des crochets « [ et ] ». On

place entre ces crochets la clé entière ou la chaîne.

$var=array(10,15,17,23,9);
echo $var[0]; // 10
echo $var[3]; // 23
$tab=array("a"=>12,"nom"=>"toto","pipo",17,4=>5);

Cours Programmation PHP Page 20/60

echo $tab[0]; // pipo
echo $tab[1]; // 17
echo $tab['a']; // 12
echo $tab['nom']; // toto
L'utilisation de la fonction array n'est pas obligatoire et on peut déclarer
un tableau à la volée.

$tab[0] = 2004;
$tab[1] = 31.14E7;
$tab[2] = "PHP5";
$tab[35] = $tab[2]. "et MySQL";
$tab[] = TRUE;
$ind = 40;
$tab[$ind] = "Dernier élément";
echo "Nombre d'éléments = ", count($tab);
On peut aussi créer des tableaux multidimensionnels à l'aide des deux
méthodes précédentes.

$tab=array("un"=>array("riri",1=>"fifi",2=>'loulou'),2=>array(1,2,3),array('un','deux'
,'trois'));
echo $tab['un'][0]; // riri

echo $tab[2][1]; // 2

echo $tab[3][2]; // trois

$tab2['un']['deux']='test'; // créé un tableau à deux dimensions

Il existe une fonction très pratique pour lister le contenu d'un tableau,
ou pour modifier les éléments : foreach().
$tab=array(1=>'un',2=>'deux',3=>'trois');
foreach($tab as $valeur) {

Cours Programmation PHP Page 21/60

 echo "$valeur \n"; // affiche un deux trois
}
foreach($tab as $cle =>
$valeur) {
echo "$cle => $valeur\n"; // affiche 1 => un, 2 => deux, 3 => trois
}

III.5.6 La variable objet

Les objets se créent avec l'instruction class. Pour créer une instance de
l'objet il faut utiliser le mot clé new.

class Test {
function affiche_hello() {
echo "Hello !";
}
}
$obj=new test();
$obj->affiche_hello();

III.6 Les constantes

Les constantes est un nom qui prend une valeur ne pouvant pas être
modifiée une fois fixée. Une constante n'est accessible qu'en lecture
seule. Elles sont sensibles à la casse et doivent par convention être
écrites en majuscules.

On définit une constante avec la fonction define() et doit respecter

certaines règles :

• une constante ne commence pas par un $

• une constante est accessible depuis n'importe quel endroit du code

Cours Programmation PHP Page 22/60

• une constante ne peut pas être redéfinie
• une constante ne peut contenir un scalaire (entier, booléen, chaîne,
double).

define(CONSTANTE,"valeur");
echo CONSTANTE; // affiche "valeur"
Exemple : define( ‘’PI’’, 3.1415926535 ) ;
echo PI ;
Quelques constantes prédéfinies :

Constantes Significations
PHP_VERSION Version de PHP installée sur le serveur
PHP_OS Nom du système d’exploitation du serveur
DEFAULT_INCLUDE_PATH Chemin d’accès aux fichiers par défaut
__FILE__ Nom du fichier en cours d’exécution
__LINE__ Numéro de la ligne en cours d’exécution

III.7 Obtenir le type d'une variable

Pour obtenir le type d'une variable, on utilise la fonction « gettype » qui
retourne une chaîne de texte indiquant le type. Mais attention rien
ne garantit que le résultat soit le même d'une version PHP à une
autre.

Les types retournés sont "boolean", "integer", "double" (pour des raisons
historiques, "double" est retournée lorsqu'une valeur de type float est
fournie, au lieu de la chaîne "float"), "string", "array", "object",
"resource" (depuis PHP 4), "NULL" (depuis PHP 4), "unknown type"

Si vous souhaitez réellement tester le type d'une variable, il est

préférable d'utiliser les fonctions de type « is_* » : is_array, is_bool,
is_double, is_float, is_int, is_integer, is_long, is_null, is_numeric,
is_object, is_real, is_resource, is_string, is_callable (est-ce une fonction).

Cours Programmation PHP Page 23/60

III.8 Conversion de type
Malgré la grande souplesse, ou le grand laxisme, selon les opinions, de
PHP à l’égard des types des variables, il peut être indispensable de
convertir explicitement une variable d’un type dans un autre. C’est
particulièrement vrai pour les variables issues d’un formulaire, ce
dernier étant l’outil essentiel de communication du poste client au
serveur. Ces variables sont toujours de type string.
Pour convertir une variable d’un type dans un autre, utilisez la syntaxe
suivante :
$result = (type_désiré) $mavar;

Dans l’exemple suivant, vous transformez une chaîne de caractères

successivement en nombre décimal puis en entier et enfin en booléen
:
<?php
$var="3.52 kilomètres";
$var2 = (double) $var;
echo "\$var2= ",$var2,"<br />";//affiche "$var2=3.52"
$var3 = (integer) $var2;
echo "\$var3= ",$var3,"<br />";//affiche "$var3=3"
$var4 = (boolean) $var3;
echo "\$var4= ",$var4,"<br />";//affiche "$var4=1" soit la valeur true
?>

Vous avez également la possibilité de modifier le type de la variable

elle-même au moyen de la fonction settype(), dont la syntaxe est la
suivante :
boolean settype($var,"type _désiré")
Elle retourne la valeur TRUE si l’opération est réalisée et FALSE dans

Cours Programmation PHP Page 24/60

le cas contraire. Avec cette fonction, le code précédent devient :
<?php
$var="3.52 kilomètres";
settype($var,"double");
echo "\$var= ",$var,"<br />";//affiche "$var=3.52"
settype($var,"integer");
echo "\$var= ",$var,"<br />";//affiche "$var=3"
settype($var,"boolean");
echo "\$var= ",$var,"<br />";//affiche "$var=1" soit la valeur true
?>

III.9 Définir et supprimer une variable

Si vous souhaitez savoir si une variable est définie, c'est à dire si elle
est affectée, on utilise « isset ».

Enfin si vous souhaitez supprimer une variable, il faut utiliser « unset

».

Cours Programmation PHP Page 25/60

IV. Les opérateurs

IV.1 Opérateurs arithmétiques

Exemple :

$nombre = 2 + 4 ; // $nombre prend la valeur 6

$nombre = 3*5+1 ; // $nombre prend la valeur 16

$nombre = 10%3 ; // $nombre prend la valeur 1 car il reste 1

IV.2 Opérateurs d'assignation

Le principal est le = mais on a aussi comme en C des opérateurs
combinés +=, -=, *=, /=, %=, .= ...

Cours Programmation PHP Page 26/60

IV.3 Opérateurs de comparaison

Il y a aussi l'opérateur ternaire « ? : » expr1?expr2:expr3 Si expr1 est

vrai alors expr2 sinon expr3.

IV.4 Opérateur d'erreur

On dispose d'un opérateur spécial @ qui appliqué à une expression
empêche la sortie d'un message d'erreur en cas de problème. On peut
toujours récupérer le message d'erreur éventuel à l'aide de la variable
$php_errormsg mais uniquement si l'option « track_errors » est à « On
» dans le php.ini.

$retour = @$tab['toto']; // ne retourne pas d'erreurs si l'index toto

n'existe pas

IV.5 Opérateurs d'incrémentation/décrémentation

On dispose comme en C des opérateurs ++ et --, à utiliser avant ou
après le nom de variable.

$a++; // retourne $a puis l'incrémente de 1

Cours Programmation PHP Page 27/60

++$a; // incrémente $a de 1 puis retourne $a
$a--; // retourne $a puis décrémente de 1
--$a; // décrémente $a de 1 puis retourne $a

Exemple :

Décrémentation Incrémentation
$var=56; $var=56;
echo $var––; //affiche 56 puis décrémente $var. echo $var++; //affiche 56 puis incrémente $var.
echo $var; //affiche 55. echo $var; //affiche 57.
echo ––$var; //décrémente $var puis affiche 54. echo ++$var; //incrémente $var puis affiche 58.

IV.6 Opérateurs logiques

Les opérateurs logiques sont :

Opérateur Description
OR Teste si l’un au moins des opérandes a la valeur TRUE :
$a = true;
$b = false;
$c = false;
$d = ($a OR $b);//$d vaut TRUE.
$e = ($b OR $c); //$e vaut FALSE.

|| Équivaut à l’opérateur OR mais n’a pas la même priorité.

XOR Teste si un et un seul des opérandes a la valeur TRUE :

$a = true;
$b = true;
$c = false;
$d = ($a XOR $b); //$d vaut FALSE.
$e = ($b XOR $c); //$e vaut TRUE.

AND Teste si les deux opérandes valent TRUE en même temps :

$a = true;
$b = true;
$c = false;
$d = ($a AND $b); //$d vaut TRUE.
$e = ($b AND $c); //$e vaut FALSE.

&& Équivaut à l’opérateur AND mais n’a pas la même priorité.

Cours Programmation PHP Page 28/60

 ! Opérateur unaire de négation, qui inverse la valeur de
l’opérande :
$a = TRUE;
$b = FALSE;
$d = !$a; //$d vaut FALSE.
$e = !$b; //$e vaut TRUE.

IV.7 Opérateurs de chaînes

Il y a deux opérateurs de chaînes : le « . » qui concatène deux chaînes
entre elles et le « .= » déjà vu qui est l'opérateur d'assignation.

$a="Bonjour";
$b=$a." les amis"; // $b contient Bonjour les amis
$b.="! Salut."; // $b contient Bonjour les amis! Salut.

Cours Programmation PHP Page 29/60

V. Les instructions de contrôle

V.1 L’instruction if
if(expression)
{
// bloc de code
}
Exemple :

<?php
$a=6;
if(is_integer($a) && ($a<10 && $a>5) && ($a%2==0) ) {
echo "Conditions satisfaites";
}
?>

L’expression composée : (is_integer($a) && ($a<10 && $a>5) &&

($a%2==0)) est évaluée à TRUE si $a répond simultanément aux trois
conditions suivantes : être un entier, être compris entre 5 et 10 et être
divisible par 2, soit pour $a les valeurs possibles de 6 et 8 uniquement.
Le message ne s’affiche donc que dans ces cas.

V.1.1 L’instruction if...else

L’instruction if...else permet de traiter le cas où l’expression

conditionnelle est vraie et en même temps d’écrire un traitement de
rechange quand elle est évaluée à FALSE, ce que ne permet pas une
instruction if seule. L’instruction ou le bloc qui suit else est alors le
seul à être exécuté. L’exécution continue ensuite normalement après le
bloc else.

Cours Programmation PHP Page 30/60

Exemple :

<?php
$prix=55;
if($prix>100)
{
echo "<b>Pour un montant d'achat de $prix F, la remise est de 10 % </b><br />";
echo "Le prix net est de ",$prix*0.90;
}
else
{
echo "<b>Pour un montant d'achat de $prix F, la remise est de 5 %</b><br />";
echo "<h3>Le prix net est de ",$prix*0.95,"</h3>";
}
?>

Le bloc qui suit les instructions if ou else peut contenir toutes sortes
d’instructions, y compris d’autres instructions if...else. Nous obtenons
dans ce cas une syntaxe plus complexe, de la forme :
if(expression1)
{//Bloc 1}
elseif(expression2)
{//Bloc 2}
else
{//Bloc 3}

Exemple :

Cours Programmation PHP Page 31/60

 <?php
$nombre = -4;
if($nombre == 0)
{
echo "le nombre est égal à zéro";
}
else
{
if($nombre > 0)
{
echo "le nombre est positif";
} else
{
echo "le nombre est négatif";
}
}
?>

V.1.2 L’opérateur ?
L’opérateur ? permet de remplacer avantageusement une instruction
if...else en évaluant une expression et en attribuant à une variable une
première valeur si la condition est vraie ou une autre valeur si elle est
fausse.
Sa syntaxe est la suivante :
$var = expression ? valeur1 : valeur2
Elle est équivalente à :
if(expression) {
$var=valeur1;
}
else {
$var=valeur2;
}

Cours Programmation PHP Page 32/60

Exemple :
$var = ($prix>100)? "la remise est de 10 %":"la remise est de 5 %";
echo "<b>Pour un montant d'achat de $prix €: $var </b><br />";

V.1.3 L’instruction switch…case

Supposez que vous vouliez associer un code de département avec son
nom réel. Avec une suite d’instructions if, vous écririez le script
suivant :
<?php
$dept=75;
if($dept==75) echo "Paris";
if($dept==78) echo "Hauts de Seine";
if($dept==91) echo "Yvelines";
if($dept==93) echo "Seine Saint Denis";
?>
Ce code peut être simplifié sans multiplier les instructions if grâce à
l’instruction switch...case. Cette dernière permet de comparer la
valeur d’une expression avec une liste de valeurs prédéterminées par
le programmeur et d’orienter le script en fonction de la valeur de cette
expression. La syntaxe de cette instruction est la suivante :
switch(expression)
{
case valeur1:
//bloc d'instructions 1;
break;
case valeur2:
//bloc d'instructions 2;
break;
........................
case valeurN:
//bloc d'instructions N;
break;
default:
//bloc d'instructions par défaut;

Cours Programmation PHP Page 33/60

break;
}

Si l’expression qui suit le mot-clé switch vaut valeur1, les instructions

qui suivent la première instruction case sont exécutées, après quoi
l’exécution passe à la fin du bloc switch. Il en va de même pour les
valeurs suivantes. Si aucune concordance n’est trouvée, ce sont les
instructions qui suivent l’instruction default qui sont exécutées.
La présence de cette instruction n’est pas obligatoire, mais elle est
conseillée pour faire face à toutes les éventualités, telles les erreurs de
saisie, par exemple. Chaque groupe case doit se terminer par une
instruction break, faute de quoi les autres blocs case sont
aussi exécutés.
Exemple :

<?php
$dept=75;
switch($dept)
{
//Premier cas
case 75:
case "Capitale":
echo "Paris";
break;
//Deuxième cas
case 78:
echo "Hauts de Seine";
break;
//Troisième cas
case 93:
case "Stade de france":
echo "Seine Saint Denis";
break;
//la suite des départements...
//Cas par défaut
default:
echo "Département inconnu en Ile de France";
break;
}
?>

Cours Programmation PHP Page 34/60

V.2 Les instructions de boucles
Les boucles permettent de répéter des opérations élémentaires un
grand nombre de fois sans avoir à réécrire le même code. Selon
l’instruction de boucle utilisée, le nombre d’itérations peut être défini à
l’avance ou être déterminé par une condition particulière.

V.2.1 La boucle for

Présente dans de nombreux langages, la boucle for permet d’exécuter
plusieurs fois la même instruction ou le même bloc sans avoir à réécrire
les mêmes instructions. Sa syntaxe est la suivante :
for(expression1; expression2; expression3)
{
//instruction ou bloc;
}
Exemple :

<?php
for($i=1;$i<7;$i++)
{
echo "<h$i> $i :Titre de niveau $i </h$i>";
}
?>
Les trois expressions utilisées dans la boucle for peuvent contenir
plusieurs parties séparées par des virgules. La boucle peut en ce cas
être réalisée sur plusieurs variables, comme illustré à l’exemple ci-
après :

Cours Programmation PHP Page 35/60

 <?php
for($i=1,$j=9;$i<10,$j>0;$i++,$j––)
//$i varie de 1 à 9 et $j de 9 à 1
{
echo "<span style=\"border-style:double;border-width:3;\"> $i +
$j=10</span>";
}
?>

V.2.2 La boucle while

C'est le moyen le plus simple pour faire une boucle. On traduit la boucle
while par 'tant que'. Tant que la/les conditions est/sont vérifiée/s, on
traite les instructions situées dans la boucle. La particularité de cette
instruction est que la condition est testée à chaque début de boucle.
➢ Syntaxe de while :
<?php
Initialisation;
while(condition)
{
instruction 1;
incrementation;
...
} ?>

Exemple

Cours Programmation PHP Page 36/60

 <?php
$n=1;
while($n%7!=0 )
{
$n = rand(1,100);
echo $n," /";
}
?>

V.2.3 La boucle do ... while

L'instruction do{ ... } while() traduite par: 'répéter / faire ... tant que' est
une alternative à l'instruction while(). Elle permet de tester la condition
après la première itération et exécution du premier bloc d'instructions.
Dans le cas de la boucle while, la condition est examinée avant la
boucle tandis que pour la boucle do-while elle est examinée à la fin.

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

au moins une fois.

<?php
do
{
// bloc d'instructions;
}
while(condition);
?>

Exemple :

<?php
do
{
$n = rand(1,100);
echo $n," / ";
}
while($n%7!=0);
?>

Cours Programmation PHP Page 37/60

V.2.4 foreach
La boucle « foreach » est peut-être l'une des plus intéressantes pour la
manipulation de tableaux ou de résultats de requêtes SQL. Elle permet
de lister les tableaux. Elle dispose de deux syntaxes :

foreach(array_expression as $value) commandes

foreach(array_expression as $key => $value) commandes

La première syntaxe récupère les éléments du tableau un par un,

séquentiellement. La valeur de l'élément courant du tableau est placée
dans $value.

La seconde syntaxe est presque identique, sauf qu'en plus la clé

(l'index) de l'élément actuel est placée dans $key.

<?php
//Création du tableau de 9 éléments
for($i=0;$i<=8;$i++)
{
$tab[$i] = pow(2,$i);
}
$val ="Une valeur";
echo $val,"<br />";
//Lecture des valeurs du tableau
echo"Les puissances de 2 sont :";
foreach($tab as $val)
{echo $val." : ";}
?>

V.3 L’instruction break

Il est possible d’arrêter complètement une boucle for, foreach ou while
avant son terme normal si une condition particulière est vérifiée, à

Cours Programmation PHP Page 38/60

l’aide de l’instruction break. Le script n’est pas arrêté, comme avec
l’instruction exit, et seule la boucle en cours se termine.

<?php
//Création d'un tableau de noms
$tab[1]="Basile";
$tab[2]="Conan";
$tab[3]="Albert";
$tab[4]="Vincent";
//Boucle de lecture du tableau
for($i=1;$i<count($tab);$i++)
{
if ($tab[$i][0]=="A")
{
echo "Le premier nom commençant par A est le n˚ $i: ",$tab[$i];
break;
}
}
?>

V.4 L’instruction continue

À la différence de l’instruction break, l’instruction continue n’arrête pas
la boucle en cours mais seulement l’itération en cours. La variable
compteur est incrémentée immédiatement, et toutes les instructions
qui suivent le mot-clé continue ne sont pas exécutées lors de l’itération
en cours.

Exemple :

Cours Programmation PHP Page 39/60

 <?php
//Interruption d'une boucle for
for($i=0;$i<20;$i++)
{
if($i%5==0) { continue;} ←
echo $i,"<br />";
}
//********************
//Interruption d'une boucle foreach
$tab[1]="Ain";
$tab[2]="Allier";
$tab[27]="Eure";
$tab[28]="Eure et Loir";
$tab[29]="Finistère";
$tab[33]="Gironde";
foreach($tab as $cle=>$valeur)
{
if($tab[$cle][0]!="E") { continue;} ←
echo "code $cle : département ",$tab[$cle],"<br />";
}
?>

V.5 require et include (_once)

« require » et « include » incluent à l'endroit actuel et exécutent le fichier
PHP. Ils sont identiques dans leur fonctionnement à une exception : le
traitement des erreurs. Un include produit un « warning » (le code
continue en principe à s'exécuter) tandis qu'un require produit une «
erreur fatale » (l'exécution s'arrête).

Comme require et include sont des éléments du langage et pas des

fonctions il n’y a pas besoin d'utiliser les parenthèses.

« require_once » et « include_once » ressemblent à leurs homologues

avec cependant une différence. Quoi qu'il arrive, le fichier est inclus
une seule fois. Si un second « require_once » apparaît avec le même
fichier, l'instruction ne sera pas exécutée.

Cours Programmation PHP Page 40/60

VI. Gestion des formulaires
Les formulaires sont les éléments les plus importants dans la
réalisation d'un site web dynamique. C'est un moyen très adapté pour
réaliser les échanges de données avec les utilisateurs.
De la saisie jusqu'à la récupération des données, nous allons voir
toutes les notions de base qu'il faut connaitre lorsque l'on manipule les
formulaires.
En effet, les deux valeurs possibles de l'attribut méthode nous
permettent d'avoir deux méthodes possibles pour envoyer les données
dans un formulaire : soit par la méthode GET soit par la méthode POST.
Les deux méthodes sont à peu près les mêmes puisque toutes les deux
permettent d'envoyer des données. Toutefois, chacune a sa façon de
gérer les choses et le choix des méthodes utilisées nécessite la vigilance
du développeur.

VI.1 Formulaire avec la méthode GET

La méthode GET consiste à transmettre les données via l'URL. Il est
intéressant de l'utiliser dans le cas où on veut faire transiter des
données de pages en pages. Cependant, il faut avoir
conscience que les données seront transmises par http et donc visibles
dans la barre d'adresse. Cet aspect mérite une attention
particulière parce que de la sécurité des données est menacée.
Dans le cas où les données sont confidentielles, mieux vaut chercher à
ne pas utiliser cette méthode.

Cours Programmation PHP Page 41/60

VI.2 Formulaire avec la méthode POST
Une autre méthode pour l'envoi des formulaires est la méthode POST.
Il est obligatoire de l'utiliser dans certains cas comme l'envoi de
fichiers, envoi de données lourdes, envoi de données confidentielles. La
méthode POST est également recommandée si le formulaire
déclenche une action spécifique qui doit être renouvelée à chaque
fois. Avec la méthode POST, il est possible de revenir en arrière et de
resoumettre le formulaire.

VI.3 Les éléments d’un tableau

➢ Zone de texte

➢ L’élément TEXTAREA
<Textarea name= "commentaire " rows=10 cols=40 >
//Taper vos commentaires ici
</Textarea>

➢ Bouton option
<input type="radio" name="sexe" value="F" checked>Feminin <BR>
<input type="radio" name="sexe" value="M">Masculin

Cours Programmation PHP Page 42/60

 ➢ Case à cocher
<input type="checkbox" name="check" value="Word" checked>Feminin
<BR>
<input type=" checkbox" name="check" value="Excel">Excel <BR>
<input type=" checkbox" name="check" value="Access">Access

➢ L’élément Select—option
Cet élément sert à définir des listes (menus déroulant ou ascenseurs).
Elle s’utilise avec l’élément OPTION
<select name="liste">
<option> Taro
<option> Patate
<option> Igname
<option selected> Pomme de Terre
<option> Oignon
<option> Ail
</select >

➢ Boutons
<input type="submit" value="Envoyer">
<input type="reset" value="Annuler">

VI.4 Récupération des données

Dans l'attribut action d'un formulaire, on spécifie l'adresse du fichier
dans lequel les données sont renvoyées et traitées.

Cours Programmation PHP Page 43/60

 ➢ Utilisation des super globales
Les données transmises se trouvent souvent sous forme de tableau
dans des variables qu'on appelle des superglobales :
Le tableau $_GET permet de récupérer toutes les données envoyées
par la méthode GET. Il contient toutes les données transmises via
l'URL.

Le tableau $_POST contient les données envoyées par la méthode

POST.
Le tableau $_FILES est spécifique à l'envoi de fichiers. Il contient les
informations du fichier quand l'utilisateur télécharge un fichier via un
formulaire.
Pour récupérer une donnée, on utilise généralement le nom du champ
comme index du tableau $_POST. La fonction isset() permet de savoir
si une variable a été affectée ou non. Si vous ne cochez pas la case
musique, la variable $_POST['musique'] ne contient pas de valeur. Et
puisqu'on en parle, profitons pour voir ce qu'est la fonction
empty().
La fonction 'empty()' a le même rôle que la fonction isset() sauf qu'elle
renvoie true lorsque la variable vaut 0 ou non définie.

Cours Programmation PHP Page 44/60

VII. Les fonctions
Une fonction est un bloc de code qui n’est pas exécuté de manière
linéaire dans un script. Ce code ne le sera que lors de l’appel explicite
de la fonction. Écrit une seule fois, ce code peut être exécuté aussi
souvent que nécessaire. Cela allège d’autant l’ensemble du code.

VII.1 Syntaxe et portée

Voici la syntaxe d'une fonction.

function fonc($arg1, $arg2, $arg3, ..., $argn)

{
//bloc de commandes

return $valeur

Une fonction n'a pas besoin d'être déclarée avant d'être utilisée (sauf si
vous voulez rester compatible avec PHP3), du moment qu'elle apparaît
dans le script.

VII.2 Arguments
On peut passer autant d'arguments que souhaité à une fonction PHP,
de tous types. Les arguments sont séparés par des virgules. Par défaut
ils sont passés par copie.

Function affiche($msg) {
echo $msg;
}
Il est possible de passer des arguments par référence, on peut donc en
changer la valeur à l'intérieur de la fonction. Pour cela on rajoute un «

Cours Programmation PHP Page 45/60

& » devant l'argument. On peut passer ponctuellement une variable par
référence en plaçant un « & » devant son nom lors de l'appel de la
fonction.

function modif(&$msg) {
echo $msg;
}
$msg="salut";
modif($msg);
On peut aussi définir des valeurs par défaut mais ATTENTION, dans la
liste des paramètres les valeurs par défaut doivent être en dernier.

function affiche($nom, $prenom="toto") {

echo "$nom. " ".$prenom"
;}

VII.3 Valeur de retour

On retourne une valeur avec l'instruction « return ». On peut retourner
tout type de valeurs, mais pas plusieurs en même temps. Cependant
rien n'empêche dans ce cas de retourner un tableau. Une fonction peut
aussi retourner une référence. Dans ce cas elle doit être déclarée avec
un « & » devant son nom.

function carre ($num) {

return $num * $num;
}

echo carre (4); // affiche '16'

Cours Programmation PHP Page 46/60

VII.4 Fonction retournant plusieurs valeurs
PHP n’offre pas la possibilité de retourner explicitement plusieurs
variables à l’aide d’une syntaxe du type :
return $a,$b,$c,...
Pour pallier cet inconvénient, il suffit de retourner une variable de
type array contenant autant de valeurs que désiré.

Exemple : Ecrire une fonction qui calcule le module et l’argument

d’un nombre complexe donné.

VII.5 Fonction à paramètre de type array

En passant un tableau comme paramètre à une fonction, cette dernière
n’a en apparence qu’un seul paramètre. Ce sont en fait les éléments du
tableau qui sont utilisés et traités par la fonction, chacun devenant
comme un paramètre particulier. C’est donc dans le corps de la
fonction que vous pourrez déterminer le nombre d’éléments du tableau
et utiliser cet ensemble de valeurs, qui seront lues à l’aide d’une boucle.

Exemple : Créer une fonction qui réalise le produit de N nombres qui

lui sont passés en tant qu’éléments du tableau, affiche le nombre de
paramètre et retourne leur produit.

VII.6 Fonctions de lecture de tableau

Exemple :

Cours Programmation PHP Page 47/60

//Définition de la fonction
function lectab($tab,$bord,$lib1,$lib2)
{
echo "<table border=\"$bord\" width=\"100%\"><tbody><tr><th>$lib1</th>
<th>$lib2 </th></tr>";
foreach($tab as $cle=>$valeur)
{
echo "<tr><td>$cle</td> <td>$valeur </td></tr>";
}
echo "</tbody> </table><br />";
}
//Définition des tableaux
$tab1 = array("France"=>"Paris","Allemagne"=>"Berlin","Espagne"=>"Madrid");
$tab2 = array("Poisson"=>"Requin","Cétacé"=>"Dauphin","Oiseau"=>"Aigle");
//Appels de la fonction
lectab ($tab1,1,"Pays","Capitale");
lectab ($tab2,6,"Genre","Espèce");

VII.7 Les variables statiques

Lors de l’appel d’une fonction, les variables locales utilisées dans le
corps de la fonction ne conservent pas la valeur qui leur est affectée
par la fonction. La variable redevient en quelque sorte vierge après
chaque appel.
Pour conserver la valeur précédemment affectée entre deux appels
d’une même fonction, il faut déclarer la variable comme statique en la
faisant précéder du mot-clé static, et ce avant de l’utiliser dans le corps
de la fonction. Le deuxième appel de la fonction peut réutiliser la valeur
qu’avait la variable après le premier appel de la fonction, et ainsi de
suite à chaque nouvel appel.
L’utilisation typique des variables statiques concerne les fonctions qui
effectuent des opérations de cumul. Une variable déclarée comme static
ne conserve toutefois une valeur que pendant la durée du script. Lors
d’une nouvelle exécution de la page, elle reprend sa valeur initiale. Il

Cours Programmation PHP Page 48/60

ne faut donc pas compter sur cette méthode pour transmettre
des valeurs d’une page à une autre, même si ces dernières appellent la
même fonction contenant des variables statiques.
Exemple :

function acquis($capital,$taux)
{
static $acquis=1;
//corps de la fonction
}

Cours Programmation PHP Page 49/60

VIII. Les bases de données MySQL

VIII.1 Présentation
MySQL est un SGBDR : « Système de Gestion de base de Données
Relationnel » qui se définit luimême comme étant « La base de données
Open Source la plus populaire au monde ». Rien que ça. Et c'est vrai !
Edité par la société MySQL AB, MySQL est un produit Open Source
libre d'utilisation sous licence GPL pour les projets libres. Cependant
une licence commerciale est nécessaire dans les autres cas, notamment
si on souhaite redistribuer MySQL avec un produit non libre ou si on
souhaite un support technique.

La version de production actuelle de MySQL est la version 4 (4.0.17 à

l'écriture de ce support), mais la grande majorité des serveurs des
hébergeurs sont encore dans les dernières versions de MySQL 3.23
(3.23.58). La future version actuellement en développement est la 5.0.0
et n'est surtout pas à utiliser en production.

Les principales qualités de MySQL sont sa simplicité et sa rapidité. Son

principale défaut est le manque de fonctionnalités dites avancées (dans
les versions précédentes) : clé étrangères, procédures stockées, triggers
et selects imbriqués notamment. Mais cela ne doit pas occulter sa
puissance avec l'ajout de fonctionnalités avancées comme une syntaxe
SQL étendue (replace, limit, delete), les index de recherche « fulltext »
permettant de créer des moteurs de recherche, ...

La prochaine version stable (5.0) comblera les lacunes des précédentes

versions avec le support complet de la syntaxe SQL ANSI-99.

Cours Programmation PHP Page 50/60

VIII.2 Outils

➢ PhpMyAdmin
S'il reste bien entendu possible d'utiliser MySQL en ligne de commande,
un peu comme « sqlplus » de Oracle, on est bien plus à l'aise avec un
environnement plus intuitif. Ainsi, l'outil phpMyAdmin est une
interface web à MySQL permettant d'effectuer la plupart des tâches de
maintenance et d'utilisation. Cette solution fonctionne depuis
n'importe quel navigateur et est indépendante de la machine. On
accède à phpMyAdmin généralement par l'URL
http://server_name/mysql.

VIII.3 Créer une base

A partir de l'écran d'accueil de phpMyAdmin, on saisit le nom de la base
dans « Créer une base de données ». Il faut de préférence choisir un

Cours Programmation PHP Page 51/60

nom simple et intuitif. Puis on clique sur « Créer ». Après la création
une nouvelle page s'affiche : c'est la page principale d'administration
de la base. En haut seront toujours présents après l'exécution d'une
commande les résultats de celle-ci. Cet écran permet notamment
l'exécution de commandes SQL, et le travail sur les tables.

VIII.4 MySQL et PHP

VIII.4.1 Connexion à une base de données

Pour que la base de données MySQL soit accessible à partir des pages
d’un site, il faut pouvoir l’utiliser par l’intermédiaire d’un script. MySQL
est utilisable par d’autres langages que PHP, Java par exemple. Le
couple PHP-MySQL est cependant le plus répandu sur le Web.
L’accès à une base MySQL et son utilisation, qu’il s’agisse d’insérer, de
modifier ou de lire des données, suit les étapes ci-dessous :

1. Connexion au serveur MySQL.

2. Envoi de diverses requêtes SQL au serveur (insertion, lecture,
suppression ou mise à
jour des données).
3. Récupération du résultat d’une requête.
4. Fermeture de la connexion au serveur.

VIII.4.1.1 Connexion au serveur MySQL

On utilise la fonction mysql_connect(). Cette fonction prend (au
minimum) trois paramètres : le serveur (hostname), l'utilisateur et son
mot de passe.

$host="hostname"
$user="username";

Cours Programmation PHP Page 52/60

$pass="password";
$cnx=mysql_connect($host, $user, $pass);
if(!$cnx) die ("erreur de connexion à MySQL");

VIII.4.1.2 Choix d'une base

On choisit une base de données par défaut avec la fonction
mysql_select_db(). Elle prend au minimum un paramètre, le nom de
la base. Le second paramètre optionnel est une ressource retournée par
mysql_connect, en cas de connexion sur plusieurs serveurs MySQL.
Par défaut, la fonction prend la dernière connexion ouverte (celle du
dernier mysql_connect exécuté).

$b_base="db_l2";
$db=msql_select_db($b_base);
if(!$db) die("Erreur de connexion à la base $b_base");

VIII.4.1.3 Fermeture d'une connexion

On ferme une connexion à MySQL avec la fonction mysql_close().
Cependant dans le cas de connexion non persistante (voir à ce point)
cette fonction n'est pas obligatoire car PHP ferme automatiquement les
connexions à la fin d'un script : mysql_close($cnx);

VIII.4.1.4 Séquence complète pour une base

$host="localhost"
$user="root";
$pass="";
$b_base=" db_l2";

mysql_connect($host, $user, $pass) or die("erreur de connexion à

MySQL");

Cours Programmation PHP Page 53/60

mysql_select_db($b_base) or die("erreur à la selection de $b_base);
mysql_close();

VIII.4.2 Les requêtes

VIII.4.2.1 Exécuter une requête

On exécute une requête SQL avec la fonction mysql_query(). Cette
fonction prend au moins un paramètre : une requête SQL sous forme
de chaîne. La fonction retourne FALSE en cas d'échec (colonne ou table
invalide, droits insuffisants, pas de connexion, etc).

ATTENTION : Ce n'est pas parce que l'appel à mysql_query() n'a pas

retourné d'erreur que la fonction retourne des lignes de résultats dans
le cas d'un SELECT par exemple. Enfin, la requête SQL ne doit pas finir
par un point-virgule.

La requête peut être de n'importe quel type (selection, mise à jour,

destruction, etc). Dans le cas d'un SELECT, SHOW, EXPLAIN ou
DESCRIBE, mysql_query() retourne une ressource qui sera ensuite
utilisée pour lire le résultat.

$result=mysql_query("select id_message, sujet from f_message");

VIII.4.2.2 Nombre de lignes affectées

Dans le cas d'un DELETE, INSERT, REPLACE ou UPDATE, on peut
connaître le nombre de lignes affectées (modifiées) par la requête à
l'aide de la fonction mysql_affected_rows().

$result = mysql_query("delete from f_message where login='toto'");

if($result) echo mysql_affected_rows()." Enregistrements supprimés";

Cours Programmation PHP Page 54/60

VIII.4.2.3 Nombre de lignes retournées
Dans le cas d'un SELECT, le nombre d'enregistrements (lignes)
retourné est obtenu avec la fonction mysql_num_rows().
$result = mysql_query("select * from f_message where id_message >
10");
if($result) echo mysql_num_rows()." enregistrements retournés”);

VIII.4.2.4 Récupérer les résultats

La fonction la plus sympathique pour récupérer les enregistrements
après l'exécution d'une sélection est mysql_fetch_array(). Elle prend
au minimum un paramètre : une ressource résultat (résultat de
mysql_query). Elle retourne une ligne de résultat sous forme d'un
tableau associatif, d'un tableau indexé ou les deux. Par défaut, le
tableau retourné est à la fois associatif et indexé.

Dans un tableau associatif, l'index du tableau est le nom du champ

correspondant à la colonne. Dans un tableau indexé, les colonnes sont
numérotées à partir de zéro.

Notez que mysql_fetch_array() ne retourne qu'une seule ligne de

résultat. Pour passer à la suivante, il faut exécuter la fonction à
nouveau. Elle retournera FALSE quand il n'y aura plus de lignes à lire.

$result=mysql_query("select sujet,texte from f_message where

login='toto'");
$tab=mysql_fetch_array($result); // Première ligne du résultat
echo $tab['sujet'].', '.$tab['texte']; // affiche les champs sujet et
texte

echo $tab[0].', '.$tab[1]; // idem

Cours Programmation PHP Page 55/60

Si plusieurs colonnes portent le même nom, la dernière colonne sera
prioritaire. Dans une requête affichant des noms de colonnes
identiques, le mieux est de les renommer :

SELECT t1.nom as col1, t2_nom as col2 FROM t1, t2 ...

Le second paramètre de mysql_fetch_array() peut être :

• MYSQL_ASSOC : le résultat est uniquement un tableau associatif

(index=nom de colonne)

• MYSQL_NUM : le résultat est uniquement un tableau indexé

numériquement.

• MYSQL_BOTH (par défaut) : les deux

Voici comment récupérer tous les résultats :

$result=mysql_query("select sujet,texte from f_message where

login='toto'");
while ($result && $tab=mysql_fetch_array($result)) {
echo $tab['sujet'].', '.$tab['texte']; // affiche les champs sujet et texte
}

Notez l'expression du while. Pour y rentrer, il faut que le résultat de la

requête ($result) ne soit pas FALSE (donc que la requête ait fonctionné)
et qu'il reste des lignes à lire. Autrement dit si la requête ne retourne
rien, on ne rentre pas dans la boucle.

Notez enfin qu'il existe deux autres fonctions possibles :

Cours Programmation PHP Page 56/60

mysql_fetch_row() : équivaut à mysql_fetch_array($var,MYSQL_NUM)
mysql_fetch_assoc() : équivaut à mysql_fetch_array($var,
MYSQL_ASSOC)

VIII.4.2.5 Insertion avec auto-incrément

L'identifiant unique d'une table est souvent un entier auto-incrémenté.
L'avantage est qu'il n'y a pas besoin de gérer cet identifiant, c'est
MySQL qui le détermine tout seul. Mais dans certains cas, il peut être
nécessaire de récupérer la valeur de ce champ auto-incrémenté après
une insertion pour, par exemple, mettre à jour un autre enregistrement
(liste chaînée, jointure, etc). On utilise pour ça la fonction
mysql_insert_id().

$result=mysql_query("insert into f_message (sujet, texte) values

('test','test')");

$id=mysql_insert_id();
$result=mysql_query("select sujet, texte from f_message where
id_message=$id");
$tab=mysql_fetch_array($result);

echo $tab['sujet'].', '.$tab['texte']; // test, test

VIII.4.3 Récupération des erreurs

En cas d'erreur lors d'une manipulation sur MySQL, on peut récupérer
le numéro de l'erreur MySQL par la fonction mysql_errno(). De même
on peut récupérer le message d'erreur par la fonction mysql_error().

Cours Programmation PHP Page 57/60

IX. Sessions PHP

IX.1 Principe
Les sessions permettent de préserver des données lors de la visite d'un
site. Chaque personne se voit attribué un identifiant unique appelé
identifiant de session, ou SID. Ce SID est soit stocké dans un cookie,
soit passé par URL. On peut ainsi définir un nombre infini de variables
qui seront accessibles durant toute la durée de la session.

Notez que si vous fermez et relancez votre navigateur, vous changez

d'identifiant, et donc la précédente session est perdue, même si elle
était nommée.

On peut connaître son SID grâce à la constante de même nom, ou par

la fonction session_id().

IX.2 Utilisation

IX.2.1 Ouverture
Si dans PHP.INI la valeur « session.auto_start » est activée, les sessions
sont démarrées de manière automatique lors de l'accès à une page.
Sinon il faut utiliser explicitement la fonction session_start(). Son
appel créé une session ou restaure une session précédemment stockée
sur le serveur.

ATTENTION : L'ouverture d'une session doit obligatoirement

apparaître avant toute sortie/affichage du script PHP ou de
balises HTML, même une ligne vide !

Cours Programmation PHP Page 58/60

IX.2.2 Variables de session
Il y a deux moyens de créer des variables de session, qui seront
accessibles depuis n'importe quelle page visitée à partir du moment ou
session_start() a été appelée. Le premier moyen ne fonctionne pas si
register_globals est à off dans PHP.INI :

Méthode 1 (déconseillée) :

La fonction session_register() prend comme paramètre un nom de

variable et la définit comme variable de session. Cette variable peut
ensuite être accédée par son nom.

$txt='Bonjour les amis';

session_register('txt'); // txt devient une variable de session.
Pour savoir si une variable est enregistrée dans la session courante, on
utilise session_is_registered(). if(session_is_registered('txt')) echo $txt;
Pour supprimer une variable de session, il faut utiliser
session_unregister(). Par contre il ne faut pas oublier d'utiliser unset()
pour supprimer la variable globale, car la précédente fonction ne la
supprime pas, elle empêche seulement sa sauvegarde à la fin du script.

if(session_is_registered('txt')) {
session_unregister('txt');
unset($txt); }

Méthode 2 (La meilleure à utiliser) :

On utilise tout simplement le tableau global $_SESSION. Ainsi :
$_SESSION['txt']="Bonjour les amis"; crée la variable de session txt,
echo $_SESSION['txt'] ;
l'affiche et unset($_SESSION['txt']); l’efface.

Cours Programmation PHP Page 59/60

IX.2.3 Expiration de la session
La durée de vie d'une session PHP dépend de trois paramètres de
configuration du fichier PHP.INI : session.gc_maxlifetime,
session.cookie_lifetime et session.cache_expire. Le premier
concerne la durée de vie des données sur le serveur, en nombre de
secondes. Il est par défaut de 1440 secondes, soit 24 minutes. Au-delà,
les données sont supprimées et elles seront rechargées via le cookie de
session lors du prochain appel.

Le second est la durée de vie du cookie de session, exprimé en

secondes. Par défaut la valeur est zéro (0) ce qui signifie : jusqu'à ce
que le navigateur soit éteint.

Le troisième est la durée de vie des données de session, en minutes. Sa

valeur par défaut est de 180 minutes, soit trois heures. Ce qui veut dire
que dans une même session, on peut rester trois heures sur la même
page, les valeurs ne sont pas perdues. Au-delà, il faut rouvrir une
nouvelle session et restaurer de nouvelles valeurs. A chaque
chargement de page (ouverture de session), on recommence le
décompte.

On peut modifier le délai d'expiration de la session grâce à la fonction

session_cache_expire() qui prend comme valeur la nouvelle durée en
minutes. Sans paramètre elle retourne la valeur actuelle.

Cours Programmation PHP Page 60/60