Langage de Programmation 3 (PHP) Edition 2022

Page 1 sur 130
BIMA LEMINDE ALI-NGAKONG Glody

Chef de travaux | ISC-BANDUNDU
COURS DE LANGAGE
DE
PROGRAMMATION 3 (PHP)
A l’usage des étudiants de troisième année graduat en
informatique de gestion et des passionnés de la programmation.
Edition
entièrement revue
Avril 2022
COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

Page 2 sur 130
« La science n’est pas assise autour d’un

roc de savoir ; mais plutôt sur une remise
en question permanente. »
Une pensée pieuse au Professeur Emérite :

KANGA MATONDO Emmanuel
BIBLIOGRAPHIE

Page 3 sur 130
a) Ouvrages
[1] David Bosman, créez votre site web : Apprenez HTML et CSS, Ed.
Compétence micro, 2006.
[2] Eric D. et Cyril P., PHP 5 avancé, 4è édition, Ed. Eyrolles, Paris, 2007.
[3] Johann-Christian Hanke, Les mystères de PHP & MySQL, Ed.
Compétence Micro, 2006.
[4] Philippe Rigaux, pratique de MySQL et PHP 4ème édition, Ed. Dunod,
2008.
[5] Saint-Jean Djungu., outils et langages du web n.0, Ed. Médiaspaul,

Kinshasa, 2013.
[6] Thiery Templier et Arnaud Gougeon, Javascript pour le web 2.0, Ed.
Eyrolles, 2010.
b) Notes de cours
[1] IVINZA LEPAPA A.C & BIMA LEMINDE G., Support de Cours de
Projet de programmation 3, G3-INFO, USK-Kin, 2020-2021.
[2] BIMA LEMINDE G., Technique des bases de données, UNIC-Kin, G3

INFO, 2019-2020.
[3] MUKENGE MBUMBA J., Cours de langage xml, l1 info – ISC-KIN,

2013-2014.
[5] MVIBUDULU, J.A, Algorithmique 1, G1 INFO, ISC-KIN, 2019-2020.
c) Sites web visités

[1] http://www.perso.wanadoo.fr
[2] http://www.siteduzero.com/tutoriel
[3] http://www.developpez.com
[4] http://www.creation-de-site.net/tutoriaux
[5] http://www.nephi.unice.fr
[6] http://www.phpfrance.com
[7] http://www.easyphp.org/
[8] http://www.php.net/
[9] http://www.commentcamarche.net
[10]http://www.developpez.com

Page 4 sur 130
TABLE DES MATIERES
BIBLIOGRAPHIE...........................................................................................................3
TABLE DES MATIERES...............................................................................................4
AVERTISSEMENTS......................................................................................................8
INTRODUCTION...........................................................................................................9
2. METHODES EXPLOITEES............................................................................11
3. STRATEGIES D’EVALUATION...................................................................11
PREMIER CHAPITRE : GENREALITES SUR LE LANGAGE PHP........................12
I.1 Présentation du langage PHP................................................................................12
I.2 Historique du langage PHP..................................................................................13
I.3 Principes du langage PHP....................................................................................14
I.4. Positionnement face aux autres langages............................................................14
DEUXIEME CHAPITRE : ELEMENTS DE LA SYNTAXE DU LANGAGE PHP. .18
II.1 Commentaires et séparateur d’instructions.........................................................18
II.1.1 Commentaires..............................................................................................18
II.1.2 Séparateur d’instructions..............................................................................19
II.2 Variables.............................................................................................................19
II.2.1 Booléen, entier, réel et null..........................................................................20
Booléen (bool)...........................................................................................................20
Entiers (int)................................................................................................................20
Nombre en virgule flottante (float)...........................................................................20
Execution.......................................................................................................................21
II.2.2 Chaîne de caractères (string)........................................................................21
Entre quotes simple...................................................................................................21
Entre guillemets doubles...........................................................................................22
Exécution...................................................................................................................24
Différentes opérations sur les chaînes.......................................................................24
II.2.4 Portée des variables......................................................................................26
Exécution...................................................................................................................26
Exécution...................................................................................................................27

Page 5 sur 130
Exemple.....................................................................................................................27
2. Variable globale.....................................................................................................28
II.3 Constantes...........................................................................................................28
Exécution...................................................................................................................29
II.4 Tableaux..............................................................................................................29
Exemple.....................................................................................................................30
Exécution...................................................................................................................30
Exemple.....................................................................................................................30
Exécution...................................................................................................................31
Exemple.....................................................................................................................31
Exécution...................................................................................................................32
Tableau associatif......................................................................................................32
Exemple.....................................................................................................................32
Exécution...................................................................................................................33
Exemple de fonctions sur tableaux............................................................................33
II.5 Inclusion des bibliothèques ou des fichiers.........................................................33
II.6 Opérateurs...........................................................................................................34
II.6.1 Opérateur d’affectation................................................................................35
II.6.2 Opérateurs arithmétiques.............................................................................35
1) Expressions arithmétiques.....................................................................................36
II.6.3 Opérateurs logiques......................................................................................36
II.6.4 Opérateurs de comparaison..........................................................................36
II.6.5 Opérateurs d’incrémentation et de décrémentation......................................37
II.6.6 Opérateurs de Concaténation de string........................................................39
Exemple14.................................................................................................................39
Exécution...................................................................................................................40
II.6.7 Opérateurs combinés....................................................................................41
II.6.8 Opérateurs sur les bits..................................................................................42
II.6.9 Priorités entre opérateurs..............................................................................43
II.7 Fonctions.............................................................................................................43

Page 6 sur 130
II.7.1 Fonctions pour déterminer le type d’une variable........................................44

Exemple.....................................................................................................................44
Exécution...................................................................................................................45
II.7.2 Fonction isset (), unset () et var_dump()......................................................45
II.7.3 Fonction gettypel ()......................................................................................45
Exécution...................................................................................................................46
TROISIEME CHAPITRE : STRUCTURES DU LANGAGE PHP.............................47
III.1 Structure de contrôle..........................................................................................47
III.1.1 Structure de contrôle conditionnelle...........................................................47
III.1.2 Structure de contrôle répétitive...................................................................52
Exemple.....................................................................................................................53
III.1.3 Instructions de contrôle des boucles...........................................................56
III.2 Récupération de données du formulaire............................................................57
III.2.1 Passage des variables dans l’url avec la méthode GET..............................57
Résultat après exécution............................................................................................59
Le fichier php (saisie.php).........................................................................................59
Résultat après execution............................................................................................60
III.2.3 Passage des paramètres à un script avec la méthode POST.......................60
Résultat après exécution du fichier (pass.html).........................................................61
III.3 Fichier texte.......................................................................................................62
Résultat après exécution............................................................................................65
III.4 Gestion des exceptions.......................................................................................66
III.4.1 La classe Exception....................................................................................66
QUATRIEME CHAPITRE : NOTIONS DE LA PROGRAMMATION OBJET........69
IV.1 Introduction à la POO........................................................................................69
IV.2 Avantages de la POO.........................................................................................69
IV.3 Objets.................................................................................................................70
IV.4 Attributs et méthodes.........................................................................................70
V.5 CLASSE..............................................................................................................70
IV.5.1 INTANCE DE CLASSE............................................................................71

Page 7 sur 130
CINQUIEME CHAPITRE : ACCES AUX BASES DE DONNEES MySQL.............88

V.1 Interface phpMyAdmin.......................................................................................88
V.2 Création de la base de données...........................................................................88
V.2.1 Lancement d’EasyPHP................................................................................89
V.2.2 Création de tables.........................................................................................92
V.3 Etudes de cas.......................................................................................................95
V.3.2 Insertion de données....................................................................................98
a. Introduction............................................................................................................98
V.3.3 Connexion à MySQL.................................................................................101
V.3.4 Affichage du contenu de la base de données.............................................102
V.3.5 Insertion de données dans des tables.........................................................104
V.3.6 Mise à jour d’une table..............................................................................106
IV.3.7 Recherche dans la base de données..........................................................110
IV.3.7 INDEX......................................................................................................113
1. Code formulaire d’index (index.php)..................................................................113
2. Code d’affichage du titre (titre.php)....................................................................114
3. Code d’affichage du menu (menu.php)...............................................................115
IV.4 Deuxième étude de cas : Gestion des sections (ISC-Bandundu).....................116
SIXIEME CHAPITRE : EDITEUR WYSIWYG DREAMWEAVER.......................117
VI.1 Organisation et planification...........................................................................117
VI.2 Mettre en ligne.................................................................................................118
VI.3 Présentation de Dreamweaver.........................................................................120
CONCLUSION............................................................................................................127

Page 8 sur 130
AVERTISSEMENTS
Ce support de « LANGAGE DE PROGRAMMATION PHP » du Chef de

travaux Glody BIMA LEMINDE ALI-NGAKONG », demande avant tout, un
certain entendement de l’informatique et des connaissances de base en
algorithme et principalement une prédisposition d’analyse inéluctable et
cartésienne ; Vu que l’apport de ce cours, met un accent tout à fait particulier
sur le développement web reposant sur une panoplie des technologies et une
compréhension technique approfondie de la création des applications web
dynamiques et attractives. Le cours de programmation 3 avec le langage PHP
se veut pour objectif primordial de donner aux étudiants ayant participés des
techniques de développement moderne et professionnelle, afin que ces
derniers puissent assimiler et comprendre les arcanes du web.
Ce support de cours est soumis aux droits d’auteur et n’appartient donc pas au
domaine public. Sa reproduction est cependant autorisée à condition de
respecter les conditions suivantes :
▪ Si ce document est reproduit pour les besoins personnels du

reproducteur, toute forme de reproduction (totale ou partielle) est
autorisée à la condition de citer l’auteur.
▪ Si ce document est reproduit dans le but d’être distribué à des tierces

personnes, il devra être reproduit dans son intégralité sans aucune
modification. Cette notice de copyright devra donc être présentée ; De
plus, il ne devra pas être vendu.
Cependant, dans le seul cas d’un enseignement gratuit, une participation aux
frais de reproduction pourra être demandée, mais elle ne pourra être
supérieure au prix du papier et de l’encre composant le document.
Copyright © 2022 CT. BIMA LEMINDE ALI-NGAKONG Glody; all

rights reserved. Toute reproduction sortant du cadre précisé est
prohibée.

Page 9 sur 130
INTRODUCTION
De nos jours, le monde connait des avancées très significatives dans le

domaine informatique ; cette science pluridisciplinaire est au cœur de toutes
les grandes entreprises. Les besoins des entreprises étant dictés à la fois par la
concurrence, les besoins sans cesse croissants des utilisateurs et
l’environnement en perpétuel évolution, il est tout à fait logique pour les
organisations de se doter des applications informatiques dignes de leur
permettre l’atteinte des objectifs en temps opportun et au moindre coût.
L’informatisation est le phénomène le plus important de notre époque. Elle

intervient maintenant dans tous les secteurs de l’entreprise et est devenue une
nécessité que personne ne peut s’en passer. Notre époque est aussi
caractérisée par la mondialisation, qui peut se traduire en des termes simples
comme la concurrence à l’échelle planétaire. Deux grands phénomènes ont vu
le jour à la suite de cette concurrence qui ne tient pas compte de limites
frontalières des pays. Il s’agit de la délocalisation des services et la
dématérialisation des documents.
Le phénomène de délocalisation des services a le plus touché les grandes

firmes multinationales, qui, pour diminuer davantage les dépenses et
maximiser les recettes, tout en restant compétitives sur le marché, se sont
vues obligées de déplacer une partie de leurs activités vers les pays du tiers
monde (Asie et Afrique) où la main d’œuvre est bon marché.
Le personnel qui doit prester dans les services délocalisés tout comme dans
les directions mères de ces firmes est obligé d’échanger des informations en
temps réel, question de gagner du temps et ainsi favoriser l’atteinte des
objectifs de ces firmes dans des conditions adéquates.
L’internet étant le seul canal par lequel il faut transiter pour échanger en
temps réel les informations, les informaticiens de ce jour sont obligés de
maitriser les langages de programmation orientés client-serveur afin de rester
utiles à la société en dépit du développement rapide des technologies de
l’information et de la communication.
Il existe une ribambelle de langages de programmation orientés client-serveur

(ASP, JSP, PHP, PYTHON, RUBY ON RAIL ... pour ne citer que ceux-ci).
Dans le cadre de ce cours, notre dévolu a été jeté sur le langage PHP (Pré
HyperText Processor) qui est un langage de scripts orienté serveur. Ce

Page 10 sur 130
langage est associé au HTML (HyperText markup language) qui va tourner

du côté client, question de rendre le fonctionnement client-serveur effectif.
Les différentes démonstrations utilisées dans ce support sont réalisées grâce

au logiciel gratuit EasyPHP qui comporte deux serveurs (MySQL pour faire
tourner les bases de données web et APCHE serveur web pour l’exécution des
applications PHP).
Ainsi, ce support de six (6) chapitres présente d’une façon succincte et

magistrale quelques outils et technologies du web et passe en revue le
développement des applications web dynamique.
• Le premier chapitre présente le langage PHP dans sa généralité ;

• Le deuxième chapitre fait un tour d’horizon des éléments de la syntaxe
du langage PHP ;
• Le troisième chapitre pour sa part aborde la structure de contrôle du
langage PHP ;
• Le quatrième chapitre fait une introduction à la programmation orienté-
objet en PHP ;
• Quant au cinquième chapitre, ce dernier explique les différentes
procédures à suivre pour accéder à une base de données MySQL sur un
serveur web ;
• Le sixième et dernier chapitre de ce support indique un certain nombre
des conseils à suivre pour réaliser un site web professionnel et présente
par la même occasion le Dreamweaver, un logiciel qui permet de créer
un site web dynamique sans pour autant écrire le moindre code.
1. OBJECTIFS DU COURS
a) Objectif général
Ce cours a pour objectif principal, d’initier les étudiants informaticiens à la
programmation client-serveur avec le langage PHP.
b) Objectifs spécifiques
L’étudiant qui aura suivi et maitrisé ce cours sera en mesure :
 D’avoir des notions générales sur le fonctionnement de

l’environnement client-serveur ;

Page 11 sur 130
 De développer des bases de données Web et des applications

orientées client-serveur ;
 D’assurer le mastering des sites web dynamiques ;
 De bénéficier des avantages de la délocalisation des services
dans les pays d’Afrique en tant qu’Informaticiens.
Bref, ce cours permet aux étudiants informaticiens de rester à jour dans leur
domaine en dépit de l’évolution sans cesse croissante des Technologies de
l’information et de la Communication. Il prend appui sur l’enseignement des
cours ci-après : algorithme, langage HTML & CSS, langage C et en
constituent une base.
2. METHODES EXPLOITEES
Le cours sera dispensé en appliquant la méthode interro-active ; donc

l’étudiant sera lui-même au centre de sa formation et aura deux (2) volets : la
théorie : 45 heures et la pratique : 15 heures. Après l’exposé magistral de
chaque partie du cours par le Chef de travaux, les étudiants réaliseront un
projet pour consolider leurs savoirs.
3. STRATEGIES D’EVALUATION
L’évaluation se fera en trois temps :
1. Une partie des points (25%) sera attribuée aux projets que les étudiants
réaliseront sur base des thèmes qui seront proposés. Ces projets seront
hébergés dans un serveur web distant et défendu à la fin du cours.
2. La deuxième partie des points (25%) sera attribuée à une interrogation
écrite.
3. La troisième partie des points (50%) sera attribuée à un examen oral.
Chaque étudiant reçoit deux grandes questions recouvrant les six parties du
cours. Les questions de précision permettent à l’étudiant d’augmenter sa
côte.
BIMA LEMINDE ALI-NGAKONG Glody.

Chef de travaux

Page 12 sur 130
PREMIER CHAPITRE : GENREALITES SUR LE LANGAGE PHP
Le présent chapitre tient à clarifier les concepts de base relatifs à la

programmation client-serveur. Nous retiendrons, en effet, que la maitrise de
ces concepts permettrait à l’étudiant de mieux comprendre les notions
fondamentales abordées plus loin, tout en spécifiant des exemples d’usages de
ces concepts à travers le langage de programmation client-serveur PHP pour
une formation assidue. Sur ce, les points ci-après seront traités :
 Présentation du langage PHP ;

 Historique du langage PHP ;
 Principe du langage PHP ;
 Positionnement face aux autres langages ;
 Installation et utilisation d’EasyPHP.
I.1 Présentation du langage PHP
Le langage PHP (historiquement Personal home page, officiellement

acronyme récursif de PHP : HyperText Preprocessor, est utilisé
principalement en tant que langage de script côte serveur, ce qui veut dire que
c’est le serveur (la machine qui héberge la page web en question) qui va
interpréter le code PHP et générer du code (constitué généralement
d’XHTML ou d’HTML, de CSS, et parfois de JavaScript) qui pourra être
interprété par un navigateur.
Il a été conçu pour permettre la création d’applications dynamiques, le plus

souvent développées pour le Web. PHP est très majoritairement installé sur
un serveur Apache, mais peut être installé sur les autres principaux serveurs
http du marché. Ce couplage permet de récupérer des informations issues
d’une base de données, d’un système de fichiers (contenu de fichier et de
l’arborescence) ou plus simplement des données envoyées par le navigateur
afin d’être interprétées ou stockées pour une utilisation ultérieure.
C’est un langage peu typé et souple et donc facile à apprendre par un débutant
mais, de ce fait, des failles de sécurité peuvent rapidement apparaitre dans les
applications.

Page 13 sur 130
Son utilisation commence avec le traitement des formulaires puis par l’accès
aux bases de données. L’accès aux bases de données est aisé une fois
l’installation des modules correspondant effectuée sur le serveur.

Page 14 sur 130
La force la plus évidente de ce langage est qu’il a permis au fil du temps la

résolution aisée de problèmes autrefois compliqués et est devenu par
conséquent un composant incontournable des offres d’hébergements.
Il est multiplateforme : autant sur Linux qu’avec Windows il permet

aisément de reconduire le même code sur un environnement à peu près
semblable (prendre en compte les règles d’arborescences de répertoires qui
peuvent changer).
I.2 Historique du langage PHP
Contrairement à d’autres langages comme : le C, le C++, le Java et le

Python, PHP est un langage assez jeune. Son évolution sur quelques années
en a fait l’un des langages les plus importants du Web.
 En 1994, Rasmus Lerdorf a conçu un langage de script interfaçant le

HTML et une base de données par l’intermédiaire de requêtes SQL
pour ses propres besoins. Cette version n’a pas été mise à la
disposition du public.
 En 1995, c’est la création du langage Personal Home Ppage v1, puis
PHP v2 qui intègre :
• Boucles et autres structures de contrôle ;
• Interface avec les formulaires HTML et l’interface avec
MySQL;
C’est un langage de script exécuté par le serveur Web (comme les CGI, ASP,
JSP, PYTHON...) contrairement au JavaScript ou aux applets Java qui
s’exécutent directement sur le navigateur client. La syntaxe et l’esprit du
langage PHP s’inscrivent dans la lignée du langage C.
 En 1998, Zeev Suraski et Andi Gutsman s’associent à Rasmus Lerdorf

pour développer la version 3.0 de PHP, désormais Pré HyperText
Processor ;
 En 2000, PHP4 introduit la programmation objet, les sessions, ....
 Le développement de PHP 5 a été entamé en 2002, mais c’est l’année
2003 qui a été la plus active. L’objectif était double : d’une part,
rendre PHP plus professionnel, mais également le simplifier d’autre
part.

Page 15 sur 130
 En 2004, sera publiée la première version stable de PHP 5 ; Une année

plus tard, sera lancée les versions 5.1 (en 2005) et 5.2 (en 2006) avec
comme principales nouveautés :
• L’intégration du Zend Engine 2, qui amène une prise en charge
complète de la programmation orientée objet ;
• La refonte de la prise en charge de XML ;
• L’intégration de la base de données SQLite ;
• La simplification des principales tâches courantes ;
• L’apparition d’un socle commun pour la gestion des appels aux
bases de données : PHP Data Object (PDO).
▪ Actuellement, le langage PHP est en sa version 8.0.0 publiée le 26

Novembre 2020.
I.3 Principes du langage PHP
La consultation d’une adresse de site (URL) depuis un navigateur (client),

permet au serveur de renvoyer une page. Lorsqu’il s’agit d’une page HTML,
elle est renvoyée telle qu’elle a été écrite, mais l’appel d’une page PHP se
passe différemment, car les scripts PHP sont exécutés directement sur le
serveur, et la page renvoyée est en code HTML comme l’illustre la figure ci-
dessous :
HTML, PHP PHP
Serveur
WEB
Browser utilisateur
+
(lE ou Netscape) PHP
Interpréteur
HTML PHP HTML
Les requêtes clients se font à partir de fichier HTML ou PHP (extension.

php, .php3, .php4, .php5), et le serveur renvoie des pages HTML. Le langage
est avant tout un langage de script (Scripting). Le code inséré dans les pages
HTML est alors expédié par le serveur. Son fonctionnement est différent de
celui de JavaScript, où les scripts sont exécutés par le navigateur (donc côte
client).
I.4. Positionnement face aux autres langages
Le langage PHP utilise une syntaxe très simple car elle reste très proche du
C, langage maitrisé par la plupart des développeurs. A l’heure actuelle les «
concurrents » de PHP sont :

Page 16 sur 130
ASP : Technologie de Microsoft très similaire, utilisant un

langage de script, généralement VB Script (version allégée de
Visual Basic) ;
JSP : de SUN écriture en JAVA, grande modularité.
I.5 Installation et utilisation d’EasyPHP

Il existe plusieurs façons d’installer Apache (serveur Web), PHP et MySQL
(base de données) :
o Manuellement : en installant un par un, PHP, Apache, et MySQL.

Même si cette solution est plus compliquée, elle permet de
comprendre le mécanisme des fichiers de configuration, du serveur
Apache.,
o Automatiquement : avec un utilitaire de type EasyPHP qui automatise
toute la procédure d’installation.
EasyPHP est un package téléchargeable sur le site

http/www.easyphp.org/ qui comprend :
• Un serveur web Apache ;

• Un moteur de script PHP ;
• Un système de gestion de base de données MySQL ;
• Et son interface phpMyAdmin qui gère le SGBD facilement
(Interface écrite elle-même en PHP !!).
Pour l’installer, il suffit d’exécuter le fichier d’installation. Et le démarrage

se fait via le menu démarrer de Windows. Sa gestion se fait de la manière
suivante :
 Dans la barre des tâches, cliquer avec le bouton droit de la souris sur
l’icône de gestion EasyPHP, cliquer ensuite sur administration ;
 Le menu administration s’affiche en proposant.
• L’ajout de répertoire de pages web proposées par le
serveur Apache ;
• La gestion du SGBD MySQL ;
• Ect.
 Enregistrer les scripts sur un répertoire racine de site web :
• Par défaut, ils sont à mettre dans : C:\Program files\
EasyPHP1-7\www ;
• Cree un répertoire mon site puis y déposer les scripts ;

Page 17 sur 130
• Entrer le nom et indiquer le chemin du site en local ;

• Exécuter un script PHP ou une page HTML en cliquant
sur le menu Web local puis sur les répertoires et fichiers
à visualiser dans le navigateur.
Avant d’utiliser du PHP, il faut dans un premier temps s’assurer que votre
hébergeur supporte celui-ci et renommer l’extension du document HTML
en .php ou .php3 ou .php4. Il existe plusieurs façons d’intégrer du code PHP
à l’intérieur d’un document HTML :
1) à l’aide de tags < ? et ?>

<? echo " premier exemple PHP" ; ?>
2) à l’aide des tags < ?php et ?>
<?php echo "premier exemple PHP"; ?>
3) à l’aide de délimiteur de type ASP (<% et
%>)
<% echo "premier exemple PHP" ; % >
4) à l’aide de la balise <script

langage="..." >
<script langage="PHP">
<!-
echo ("premier exemple PHP") ;
//-->
</Script>
Exemple (Exemple1.php)
<!DOCTYPE html>
<html >
<head >
<title>Exemple1</title>
<meta charset=”utf-8”/>
</head >
<body>
<p>
<?php
echo" Hello word ! <br/> Bonjour monde !";
?>

Page 18 sur 130
</p>
</body>
</html >
À l’exécution, on a:
Nota : Le code PHP est exécuté sur le serveur ; En visualisant le code source
du fichier dans le navigateur, on n’obtient que du HTML :
<!DOCTYPE html>
<html >
<head >
<title>Exemple1</title>
<meta charset=”utf-8”/>
</head >
<body>
<p>
Hello word ! <br> bonjour monde!
</p>
</body>
</html>

Page 19 sur 130
DEUXIEME CHAPITRE : ELEMENTS DE LA SYNTAXE DU

LANGAGE PHP
Dans ce chapitre, seuls les éléments importants de la syntaxe du langage

seront traités. Il s’agit de :
 Commentaires et séparateur d’instructions ;

 Variables ;
 Constantes ;
 Opérateurs ;
 Fonctions ;
 Structure de contrôle PHP ;
 Tableaux ;
 Formulaires.
II.1 Commentaires et séparateur d’instructions
II.1.1 Commentaires
Commenter le code source est une excellente habitude de programmation.

De bons commentaires peuvent aider à analyser plus rapidement le code, à
garder la trace de ce qui est fait au fur et à mesure de la construction d’un
programme complexe et à se souvenir de ce qu’il faudra ajouter ou modifier.
Les commentaires peuvent être utilisés pour cacher des parties du code à
utiliser uniquement pour certaines situations ou que l’on met de côté pendant
qu’on travaille sur quelque chose qui pourrait provoquer un conflit. Ils
peuvent aussi aider à rappeler ce qu’on était en train de faire lorsqu’on
reprend un projet après avoir travaillé sur un autre ou quand on revient de
congé.
Dans un environnement de développement en équipe ou chaque fois que le

code passe d’un programmeur à un autre, les commentaires aident les autres
à comprendre le but et les associations de tout ce qu’on avait commenté, sans
qu’il soit nécessaire d’analyser chaque ligne pour être sûr d’avoir compris.
Le langage PHP utilise trois sortes de commentaires, à savoir :
// Commentaire de fin de ligne

Page 20 sur 130
/* Commentaire sur plusieurs lignes */

# Autre commentaire style Shell Unix
II.1.2 Séparateur d’instructions
En langage PHP, les instructions sont séparées par des points-virgules, tout
en sachant que tout script commence par la balise <?php pour se terminer
avec la balise ?>
II.2 Variables
Une variable est le conteneur d’une valeur d’un des types utilisés par PHP
(entiers, flottants, chaînes de caractères, tableaux, booléens, objets, ressource
ou NULL). Chaque variable possède un identifiant particulier, qui commence
toujours par le caractère dollar ($) suivi du nom de la variable.
PHP n’est pas un langage fortement typé ; dans la mesure où il décide à

l’exécution, en fonction de son contenu, quel type sera indiqué pour la
variable. Il est inutile de déclarer les variables au préalable. Le nom d’une
variable :
▪ Doit être précédé du symbole $ ; o Doit commencer par une lettre ;

▪ Peut comporter des lettres, des chiffres et le caractère_ ;
▪ Les noms de variables son sensibles à la casse (minuscules,
majuscules);
Une variable n’ayant jamais été déclarée possède pour valeur la chaîne vide :
" ". Le langage PHP supporte 7 types de base suivants :
• Booléen ;
• Entier
• Réel ;
• Chaîne de caractères ;
• Tableau ;
• Object ;
• Resource ou nul.
Remarque : l’utilisateur peut forcer une variable à prendre un certain type, il
doit alors transtyper (cast) ou utiliser la fonction settype().

Page 21 sur 130
II.2.1 Booléen, entier, réel et null
Booléen (bool)
Constantes TRUE et FALSE. Ils sont créés à l’aide d’opérateurs qui

retournent une valeur booléenne. C’est un type très important qui permet de
stocker soit vrai soit faux. Cela permet de retenir si une information est vraie
ou fausse. On les utilise très fréquemment ; On écrit true pour vrai, et false
pour faux.
Entiers (int)
Les entiers sont les nombres du type 1, 2, 3, 4, etc. On compte aussi parmi
eux les nombres relatifs : -1,-2, -3...
$a= 123 ; // nombre entier 123 en base 10

$a= -123 ; // nombre entier négatif - 123 en base 10
$a= 045 ; // nombre entier 37 en base 8
$a= 0x12 ; // nombre entier 18 en base 16
Nombre en virgule flottante (float)
Ce sont les nombres à virgule, comme 14,738. On peut stocker de nombreux

chiffres après la virgule, ce qui devrait convenir pour la plupart des usages
que vous en ferez. Il importe de signaler que les nombres doivent être écrits
avec un point au lieu de la virgule (c'est la notation anglaise). Exemple :
$a= 1.23;
$a= 1.23 e3 ;
Null : représente l’absence de valeur.
<html>
<head>
</head>

Page 22 sur 130
<body>
<p>
<?php
$a=3; echo"\$a=$a<br/>";
$a=3.3; echo"\$a=$a<br/>"; $a="3a";
echo"\$a=$a<br/>"; echo"\$b=<br/>";
?>
</p>
</body>
</html >
Execution
II.2.2 Chaîne de caractères (string)
Les chaînes de caractères sont des noms informatiques qu'on donne au texte.
Tout texte est appelé chaîne de caractères. En PHP, ce type de données a un
nom : string. On peut stocker des textes courts comme très longs au besoin.
Exemple : "Je suis un texte". Une chaîne de caractères est habituellement

écrite entre guillemets ou entre apostrophes (on parle de guillemets simples) :

Page 23 sur 130
'Je suis un texte'. Les deux fonctionnent mais il y a une petite différence que
l'on va découvrir plus loin.
Entre quotes simple
Pour insérer il faut le faire précéder de / ainsi les variables présentes dans ces
chaînes ne seront pas remplacées par leurs valeurs.
Exemple
‘ je vous dis : "c/’ est un exemple de chaine"’
Entre guillemets doubles
Les variables qui s’y trouvent seront remplacées par leurs valeurs : $va,
{$var}, et ${var}, les séquences suivantes vont être comprises par PHP :
• /n Nouvelle ligne
• /r Retour à la ligne
• /t Tabulation horizontal
• // Anti slash
• /$ Caractère
• /" Guillemets doubles
<html>
<head>
</head>
<body>
<script language="php">
$texte="Bonjour les informaticiens de l'ISC";
$a=3; print"Un texte:
$texte<br/>"; print"Un
chiffre: $a";
</script>
</body>
</html>

Page 24 sur 130
Exécution
Exemple (Exemple4.p hp)
<!DOCTYPE html>
<html>
<head>
</head>
<body>
<?php $a="abc"; echo"entre guillemets: $a<br/>";
echo'entre quotes: $a<br/>'; echo"combinaison de
'quotes' guillemets<br/>" ; echo'combinaison de
"quotes" guillemets<br/>'; echo'j\'ai dit<br/>';
echo"j\"ai dit<br/>";

Page 25 sur 130
echo"le passage \n a la ligne (idiot en HTML!)<br/>";

echo"le backslash \\ lui-même<br/>" ; echo"et le dollar\
$";
?>
</body>
</html>
Exécution
Différentes opérations sur les chaînes
 Chr (num) : retourne une chaine d’un seul caractère, dont le code
ASCII est égal à l’entier num ;
 Trim (chaine) : supprime les caractères invisibles dans une chaine de
caractères ;
 Nl2br (chaine) : insère <br> devant tous les caractères de fin de ligne
de la chaine en PHP 4 ;
 html_entity_décode (chaîne) : PHP4! Convertit toutes les entités
HTML de la chaine en caractère normaux ;

Page 26 sur 130
 htmlentities (chaîne) : convertit tous les caractères possibles en entités

HTML PHP 3 et 4 ;
 Substr (Chaîne, position, longue) : retourne la sous-chaîne de chaîne
qui commence à la position et de longueur indiquée. L’indice de début
d’une chaîne est 0 ;
 str_replace (ancien, nouveau, chaîne_a_modifier) : remplace toutes les
occurrences de la chaîne ancienne par la chaîne nouvelle dans la
chaîne_a_ modifier ;
 strlen (chaine) : Cette fonction retourne la longueur d'une chaîne de
caractères, c'est-à-dire le nombre de lettres et chiffres qu'il y a (espaces
compris) ;
 strtolower (chaine) : met tous les caractères d'une chaîne en
minuscule ;
 strtoupper (chaine) : met tous les caractères d’une chaine en majuscule
;
 addslashes (chaîne) : ajoute des backslashes aux caractères ‘ "/ et le
caractère nul pour les requêtes le nécessitant en requête de bases de
données
 sprintf(format, expression1, expression2, ...) : formate comme printf
de 0.
%d int
%2d int dans un champ de 2 caractères au moins
%e réel en format scientifique
%f réel
%2.1f réel dans un champ de 2 caractères avant le
point et 1 décimal
%o int en octal
%s chaîne de caractères
%x int en hexa Ect.
 Explode (séparateur, chaîne) : découpe la chaîne en sous-chaînes en

utilisant le séparateur (chaîne) le résultat est le tableau de sous-chaines
obtenues.
 Implode (séparateur, array) : retourne une chaîne contenant tous les
éléments du tableau séparés par le séparateur (chaîne).

Page 27 sur 130
 Ect.
II.2.4 Portée des variables
La portée d’une variable dépend du contexte dans lequel la variable est

définie. En PHP, toute variable intervenant dans une fonction, et qui n’est
pas un paramètre de cette dernière, est considérée comme locale même si elle
a été déjà affectée à une valeur dans le programme principal.
function test()
{ print
"$a";
}
$a = 3 ;
test()
</script>

Page 28 sur 130
Exécution
Nota : Le code ci-dessus ne produit aucun résultat et affiche même un

message d’erreur car la variable $a est local à la fonction test (="") et n’a
aucun lien avec la variable globale déclarée dans le programme principal.
Pour pouvoir utiliser une variable globale dans une fonction il faut la
déclarer en utilisant le mot clé global.
function test()
{
global $a; print"$a";
}
$a =3;
Test()
</script>

Page 29 sur 130
Exécution
1. Variables statiques
Dans une fonction, une variable peut être déclarée statique
Exemple
< ?php
function test() {
Static $Nb_appel = 0;
echo $Nb_appel++;
} ?>
2. Variable globale
Les variables globales peuvent être utilisées dans une fonction à l’aide :
 D’une déclaration avec le mot clé global global $varglo

 Du tableau associatif prédéfini $globals
$globals ["varglo"] Sans $ et placée entre " "
II.3 Constantes
Le langage PHP définit les constantes à l’aide de la fonction define(). Elles

ne peuvent plus par la suite recevoir d’autres valeurs. Par convention, on
écrit les constantes en majuscules pour faciliter la relecture du code. Elles
acceptent uniquement les valeurs de type :
 Chaîne de caractère ;
 Entier ;
 Double ;
 Booléen.

Page 30 sur 130
Pour créer une constante, il suffit de taper : Define(NOM_CONS,
Valeur_cste);
Et pour l’affichage :
Echo NOM_CONS ; // sans $ et avec casse correcte
<?php
Define("PI",
3.1416); Define
("BR","<BR>");
echo PI; echo BR;
$a = PI *2; echo $a;
echo BR;
?>
Exécution
II.4 Tableaux
Les tableaux représentent un type composé car ils permettent de stocker sous
un même nom de variable plusieurs valeurs indépendantes d’un des types de

Page 31 sur 130
base que vous venez de voir. C’est comme un tiroir divisé en compartiments.
Chaque compartiment, que nous nommerons un élément du tableau, est
repéré par un indice numérique (le premier ayant par défaut la valeur 0 et non
1). D’où l’expression de tableau indicé ; chaque élément peut aussi être
identifié par une étiquette, qui est une chaîne de caractères ou une variable de
type string, nommée clé, associée à l’élément du tableau. Ce type de tableau
est appelé tableau associatif. Les éléments de ces tableaux peuvent être de
type integer, double, boolean, string ou même array, ce qui permet de créer
des tableaux de tableaux, c’est-àdire des tableaux multidimensionnels, ce que
PHP ne permet pas explicitement, contrairement à d’autres langages.
Dans un tableau simple $tab, l’élément n’est $tab[n]. Le premier élément a

l’indice 0. Pour définir un tableau on peut utiliser l’une des deux méthodes
suivantes :
Affecter des valeurs une à une
• $tab [2]= 12 ;
• $tab [0]="Bonjour"
Utiliser la fonction array()

1. Fonction array
Exemple
<?Php
//creation d’un tableau simple
$tab=array(12, 15, 2, 1, 8, 24, 35, 5,2) ;
//Accéder à un élément
echo $tab[0]."<BR >";
echo $tab[1]."<BR >";
?>

Page 32 sur 130
Exécution
Fonction print_r
Elle permet d’afficher une variable, quel que soit son type.
Exemple
<?php
//création d’un tableau simple
$tab=array(12,15,2,1,8,24,35,5,2) ; //
Accéder à un élément
print_r($tab); ?>

Page 33 sur 130
Exécution
Ajout d’un nouvel élément
Exemple
<?php
$tab=array (12,15,2,1,8,24,35,5,2) ;
$tab[]="99" ;
//Accéder à un élément
print_r($tab);
?>

Page 34 sur 130
Exécution
Tableau associatif
On peut nommer les éléments d’un tableau associatif :
Pour un élément : $tab ["Nom"]="ABC"

Pour la fonction array(): "indexe"=> valeur
Exemple
<?php
$tab1=array ("a"=>12,"b"=>15,"c"=> 2,"d"=>1);
$tab2=array (0=>1,1
=>45,2=>4); //Accéder à un
élément
echo $tab1["a"]."<BR >";
echo $tab1["c"]."<BR >";
echo $tab2[1]."<BR >";
?>

Page 35 sur 130
Exécution
Exemple de fonctions sur tableaux
reset($tab) : permet de placer le pointeur interne sur le

premier élément du tableau.
key ($tab): renvoie l’index de l’élément courant next ($tab):
déplace le pointeur sur le prochain élément count ($tab):
donne le nombre d’éléments du tableau.
II.5 Inclusion des bibliothèques ou des fichiers
Comme le C et le C++, le langage PHP permet l’utilisation de deux fonctions

très simples et cependant très utiles qui permettent la réutilisation de code.
En utilisant les fonctions require() ou include(), il est possible de charger des
fichiers dans un script PHP.
Il convient de considérer qu’à l’endroit où on inclue une bibliothèque, PHP

recopiera celle-ci ; Cela permet de gagner du temps et de centraliser les
opérations récurrentes.
Par exemple, voici un fichier a_inclure.php :

<?php
echo 'Quelle est la plus belle fille de l’ISC-Bandundu ?<br>';
?>
Et voici un fichier principal utilisant le précédent (include.php) :
<?php echo 'La question que nous nous posons
tous :<br>'; include ('a_inclure.php');

Page 36 sur 130
echo 'Avez-vous la réponse ?<br>';
?>
A l’exécution, on a :
II.6 Opérateurs
Les opérateurs sont des symboles ou signes utilisés entre deux termes
(nombres, variables, constantes) pour effectuer une opération. Ils ont des
priorités de priorité et d’associativité. Quand plusieurs opérateurs agissent
sur le même élément (ou opérande), la priorité des opérateurs détermine
lequel agit en premier. Quand plusieurs opérateurs ont la même priorité, les
règles d’associativité s’appliquent.
Ces règles sont généralement mathématiques ; par exemple, les opérateurs

sont habituellement utilisés de gauche à droite, et les expressions
d’opérateurs qui sont à l’intérieur de parenthèses sont évaluées avant celles
qui sont à l’extérieur des parenthèses. Le langage PHP reconnait les
opérateurs ci-dessous :

Page 37 sur 130
II.6.1 Opérateur d’affectation
L’opérateur d’affectation utilisé par le langage PHP est le signe égal, nous
l’avons aperçu dans les exemples précédents. La variable se place avant le
symbole égal (=) et la valeur est spécifiée après.
<?php
// Assignement de valeurs à des variables
$nom = 'SOLE';
// Ici $nom prend la valeur SOLE
$age = 20 ;
?>
II.6.2 Opérateurs arithmétiques
Les opérateurs arithmétiques en PHP ne nécessitent pas de présentation

particulière, car ils sont les opérateurs mathématiques traditionnels. Le
tableau ci-dessous nous en donne un rapide aperçu.
$a=9 ; et $b=4 ;
Operateur Operation Exemple Description Résultat
+ Addition echo $a+$b; Calcule la somme 13
- Soustraction echo $a-$b; Calcule la 5
difference
* Multiplication echo $a*$b; Calcule le produit 36
/ Division echo $a/$b; Calcule le quotient 2.25
% Modulo echo Calcule le modulo 1
$a%$b;
Dans nos exemples, nous affichons à l’écran le résultat renvoyé par les
opérations. Notons qu’il serait également possible de renvoyer le résultat
dans une variable, comme ceci :
<?php
$a = 9 ;
$b = 4 ;
$resultat = $a + $b;
echo $resultat; // Affiche 13
?>

Page 38 sur 130
Nota : la valeur stockée dans la variable $resultat est le résultat obtenu par
l’addition des valeurs des variables $a et $b.
1) Expressions arithmétiques
<?php
$i=2;
$j=6;
$x=5.2;
echo'Expression($x+$i)%$j:';
echo ($x+$i)%$j;
echo"<br>";
?>
II.6.3 Opérateurs logiques
Les opérateurs logiques servent énormément dans les structures de contrôle.

Le tableau ci-dessous présente les plus courants.
Opérateur Exemple Evalué à vrai (True) quand :
! ! $b ; $b ne renvoie pas TRUE.
&& $a && $b ; $a et $b renvoient TRUE.
|| $a || $b ; Au moins l’un des deux renvoie TRUE.
AND $a AND $b ; $a et $b renvoient TRUE.
OR $a OR $b ; Au moins l’un des deux renvoie TRUE.
XOR $a XOR $b ; L’un des deux, et uniquement l’un des deux,
renvoie TRUE.
Nota : Les opérateurs || et OR, ainsi que && et AND donnent exactement le
même résultat. La seule différence réside dans les priorités d’applications ;
les opérateurs logiques OR et AND ont une priorité faible alors que || et &&
ont une priorité forte.
II.6.4 Opérateurs de comparaison
Les opérateurs de comparaison sont principalement utilisés en combinaison

avec les structures conditionnelles (if, for, while, etc.) que nous verrons peu
après. Une liste des opérateurs de comparaison est donnée au tableau ci-

Page 39 sur 130
dessous. Ces opérateurs permettent de comparer deux termes et de renvoyer

un booléen vrai ou faux (TRUE ou FALSE) selon la véracité de la
comparaison.
Opérateur Signification Exemple Description

== Egal à $a == $b ;
Renvoie TRUE si $a est égal à
$b.
< Inférieur à $a < $b ; Renvoie TRUE si $a est plus
petit que $b.
> Supérieur à $a > $b ; Renvoie TRUE si $a estplus
grand que $b.
<= Inférieur ou égal à $a <= $b ; Renvoie TRUE si $a est
inférieur ou égal à $b.
>= Supérieur ou égal à $a >= $b ; Renvoie TRUE si $a est
supérieur ou égal à $b.
!= Différent de $a != $b ; Renvoie TRUE si $a est
différent de $b.
=== Egal à, en type et en $a === Renvoie TRUE si $a est égal à
valeur $b ; $b et si les deux variables ont
le même type.
!=== Différent en valeur ou $a !=== Renvoie TRUE si $a a une
en type $b ; valeur différente de celle de $b
ou si $a n’a pas le même type
que $b.
Exemple :
<?php
$a = 9;
$b = 5;
// $a == $b renverra 0 (faux)
// $a != $b renverra 1 (vrai)
// $a < $b renverra 0 (faux)
?>
II.6.5 Opérateurs d’incrémentation et de décrémentation
S’inspirant de la logique du C et PERL, le langage PHP possède quelques

raccourcis qui évite l’écriture d’instructions d’incrémentation ou de
décrémentation telles que : $i = $i+1; ou $i=$i-1; Utilisez ++ ou - -

Page 40 sur 130
respectivement pour incrémenter ou décrémenter une variable d’une seule

unité, comme l’illustre l’exemple ci-dessous :
Exemple :
<?php
$i = 1 ;
$i = $i+1; // Est équivalent à :
$i++;
$i = $i–1; // Est équivalent à :
$i- -;
?>
Nota : Ces opérateurs peuvent figurer devant ou derrière la variable :
• ++$a : la variable est incrémentée puis évaluée
(pré incrémentation),
• $a++ : la variable est évaluée puis incrémentée (post incrémentation).
Exemple12 : Post incrémentation et décrémentation

<?php
$a=3;
$b=$a++; echo"$b";
?>
Exécution
Exemple13 : Pré incrémentation et décrémentation

<?php
$a=3;
$b=++$a;
echo"$b";

Page 41 sur 130
?>
Exécution
II.6.6 Opérateurs de Concaténation de string
L’opération de concaténation est très importante en programmation car elle

permet par exemple d’empiler des informations dans une variable. En
langage PHP, les symboles virgule (,) et point (.) sont utilisés pour
concaténer les chaines de caractères. En voici un exemple concret :
Concaténation: (point) et (virgule)
Exemple14
<?php
$ident="Monsieur";
echo"Bonjour"," ",$ident,"<br>";
echo"Bonjour"."".$ident."<br>";
?>

Page 42 sur 130
Exécution
Exemple 15
<?php $c="abc";
$a=1; echo $c.
$c."<br>";
echo($a+2).
$c."<br>";
echo'$a'."abc".'<br>';
?>

Page 43 sur 130
Exécution
II.6.7 Opérateurs combinés
Il est possible de cumuler l’opérateur d’affectation avec un opérateur

arithmétique (comme illustrer au tableau suivant).
Opérateur Opération
+= Ajoute la valeur de droite à la valeur de gauche. Met le
résultat dans la variable de gauche.
-= Soustrait la valeur de droite à la valeur de gauche. Met le
*= Multiplie la valeur de droite par la valeur de gauche. Met le
/= Divise la valeur de droite par la valeur de gauche. Met le
Exemple :
<?php
$a = 10;
$b = 7;
$a *= 5;
Echo $a ; // $a est égal à 50
$b += $a;

Page 44 sur 130
Echo $b ; // $b est égal à 57

?>
II.6.8 Opérateurs sur les bits
Les opérateurs suivants permettent d’agir directement sur la représentation

binaire d’un nombre (0 ou 1), et donc sur les bits le composant. La liste des
opérateurs bit à bit gérés par PHP est donnée dans le tableau ci-après :
Opérateur Signification Exemple Description
& ET $a & Pour tout x, met à 1 le bit de la position x
$b ; si les bits correspondants de $a et de $b
sont à 1.
| OU $a | $b ; Pour tout x, met à 1 le bit de la position x
si le bit correspondant de $a ou de $b est à
1.
<< Décalage gauche à $a << Pour tout x, met le bit à 1 si le bit (x-$b) de
$b ; $a est à 1.
>> Décalage droite à $a >> Pour tout x, met le bit à 1 si le bit (x+$b) de
$b ; $a est à 1.
^ XOR $a ^ $b ; Pour tout x, met à 1 le bit de la position x si
le bit correspondant de $a est à 1 ou le bit de
$b est à 1, mais pas les deux.
~ Négation ~ $a ; Pour tout x, met à 1 le bit de la position x

si le bit correspondant de $a est à 0.
Nota : Les opérateurs bit à bit permettent de traiter les nombres entiers sous
la forme de séries de bits. Ces séries de bits représentent le nombre en
question.
Exemple :
<?php
$un = 1 ; // S’écrit 1 en binaire
$deux = 2 ; // S’écrit 10 en binaire
$trois = $un | $deux ; // S’écrit 11 en binaire
$quatre = $deux << $un ; // S’écrit 100 en binaire
?>

Page 45 sur 130
II.6.9 Priorités entre opérateurs
Il nous est de fois impérieux d’imbriquer plusieurs opérateurs. Dans ce

contexte, il est conseillé de tenir compte des priorités pour que l’interpréteur
PHP puisse les traiter dans le bon ordre. Le tableau ci-dessous récapitule les
priorités des différents opérateurs (sachant que le premier est le plus
prioritaire).
Priorité Opérateurs
1 () []
2 -.- + + !
3 */ %
4 + -
5 < <= > >=
6 == != ===
7 &
8 |
9 &&
10 ||
11 Affectation, opérateurs combinés (= += -=,…)
12 XOR
II.7 Fonctions
Une fonction est un sous-programme qui retourne une valeur à partir de

données qu’on lui apporte (les paramètres d’entrée). Elle peut être aussi
définie comme étant une partie autonome d’un programme, réalisant une
tâche précise, à laquelle on transmet des valeurs lors de son appel et qui
retourne une valeur à la fin de son action.
Elle se déclare comme suit en PHP :
function nom_fonction (liste de paramètres)
Instructions ;

Page 46 sur 130
Exemple function
somme ($a,$b)
Print"$a+$b";
II.7.1 Fonctions pour déterminer le type d’une variable
Exemple
<?php
echo"variable non declare isset :";
echo isset($b); echo'<br>';
$b=NULL;
echo"variable NULL isset:";
echo isset($b); echo"<br>"; $b=13;
echo"variable a la valeur $b isset:";
echo isset($b);
echo"<br>"; Unset($b);
echo"apres unset(\$b) isset:";
echo isset($b);
echo"<br>";
?>

Page 47 sur 130
Exécution
II.7.2 Fonction isset (), unset () et var_dump()
isset (variable) : détermine si une variable est affectée/définie renvoie

TRUE, sinon FALSE.
unset (variable) : détruit une variable unset() à l’intérieur d’une fonction
n’a pas la même portée de destruction suivant le type de variable
var_dump (variable) : affiche toutes les informations d’une variable
utile pour debuger.
II.7.3 Fonction gettypel ()
Exemple
<?php
$a=3; echo"valeur $a type : ";
echo gettype($a);

Page 48 sur 130
echo"<br>"; $a=3.3;
echo"valeur $a type : ";
echo gettype($a);
echo"<br>"; $a="3a";
echo"valeur $a type : ";
echo gettype($a);
echo"<br>"; $a=TRUE ;
echo"valeur TRUE type : ";
echo gettype($a);
echo"<br>"; $b=NULL ;
echo"sans valeur type : ";
echo gettype($b);
echo"<br>";
?>
Exécution

Page 49 sur 130
TROISIEME CHAPITRE : STRUCTURES DU LANGAGE PHP
III.1 Structure de contrôle
Les structures de contrôle permettent de répéter certaines actions ou de

soumettre certaines exécutions à des conditions. En PHP, leur syntaxe est
similaire à celle du langage C. Ces structures fonctionnent pour la plupart à
partir d’un test ; ce test est une expression qui doit renvoyer une valeur
comprise comme un booléen.
A cet effet, les structures de contrôle peuvent se présenter sous deux aspects,
à savoir :
▪ La structure de contrôle conditionnelle ;

▪ La structure de contrôle répétitive.
III.1.1 Structure de contrôle conditionnelle
On parle de la structure de contrôle conditionnelle lorsque pour l’exécution

d’un bloc d’actions, une condition est posée pour permettre la prise de
décision. Pour cela, il existe :
 La structure de contrôle simple ;

 La structure de contrôle alternative ;
 La structure imbriquée.
1. La structure de contrôle simple : if ( ) { }
Il s’agit à ce niveau de tester si la condition est remplie et d’exécuter le bloc

d’instructions sans qu’il y ait un autre bloc d’instructions en alternance. La
condition entre parenthèses est évaluée et les instructions situées entre les
accolades sont exécutées seulement si l’évaluation aboutit à TRUE (vrai)
comme l’illustre la figure ci-dessous :

Page 50 sur 130
En PHP, cela s’écrit de la façon suivante :
if (condition)
{
instructions
}
Exemple : Accorder une prime de 500$ à tous les agents de sexe masculin.
<?php
$sexe = "M";
if($sexe =="M")
{
echo 'Vous avez droit à une prime de 500$';
exit();
// La fonction exit() arrête l’exécution du script
}
?>
2. La structure de contrôle alternative : if( ) { } - else{ }

Page 51 sur 130
Ici, au lieu d’une action, on en a deux ; Il y a alternance. D’où, nous avons le

formalisme suivant :
La notation en PHP se fait comme ceci :

if (condition){
Instructions si la condition est
vérifiée.
}else{
Instructions si la condition n’est pas
vérifiée.
}

Page 52 sur 130
Exemple : Accorder une prime de 500$ aux agents de sexe masculin et 250$
aux agents de sexe féminin.
<?php
$sexe = 'M'; if($sexe == 'M')
{ echo 'Votre prime est de 500$';
}else{
echo 'Votre prime est de 250$';
}
?>
3. La structure imbriquée
On parle de l’imbrication lorsqu’il y a plus de deux alternatives c.à.d. on a

dans la structure plus de deux possibilités dont chacune représente une
condition. Ainsi, deux possibilités s’offre pour imbriquer une structure
conditionnelle, à savoir : soit avec l’instruction elseif ou encore avec
l’instruction switch.
▪ Instruction : if( ) { } – elseif( ) { } – else( ) { }

A ce stade, l’alternance n’est plus limitée à deux blocs. Elle est généralement
constituée de plusieurs blocs et peut contenir autant de blocs elseif que
nécessaire (voir la figure suivante).
En PHP, la figure ci-dessus peut être représentée de la manière suivante :

Page 53 sur 130
if (condition1)
{
Instructions si la condition1 est
vérifiée.
}elseif (condition2){
vérifiée.
}elseif(condition3){
vérifiée.
}else{
Instructions si les conditions ne sont pas
vérifiées.
}
Exemple :
<?php
$nombre = 2 ;
if($nombre>1){
echo "$nombre est supérieur à 1";
} elseif ($nombre < 1) {
echo "$nombre est inférieur à 1";
} else {
echo "$nombre est égal à 1";
// Ici on sait que $nombre est égal à 1 car s’il n’est ni
supérieur, ni inférieur à 1 c’est qu’il est égal à 1.
}
?>
▪ Instruction switch
Cette instruction permet de faire plusieurs tests sur la valeur d’une variable,
ce qui évite de faire plusieurs if imbriqués et simplifie ainsi la lecture du
code.
Exemple :
<?php
$nombre = mt_rand(0,4);
switch ($nombre)
{
case4:
echo "$nombre est supérieur à 3 <br>";

Page 54 sur 130
case 3:
case 2:
case 1: echo "$nombre est supérieur à 0
<br>"; break ;
default:
echo "$nombre est 0 <br>";
}
?>
Nota : Les parenthèses qui suivent le mot-clé switch() indiquent une
expression dont la valeur est testée successivement par chacun des « case ».
Lorsque la valeur correspond à un « case », la suite d’instructions est
exécutée jusqu’à la fin du switch ou l’apparition d’un break. Si aucune
correspondance n’est trouvée, alors le code est exécuté à partir du mot-clé
default.
III.1.2 Structure de contrôle répétitive
Dans un programme, chaque instruction est exécutée une fois. Cependant, il

est quelquefois nécessaire d’exécuter des instructions plusieurs fois jusqu’à
ce qu’une condition soit satisfaite. A cet effet, les boucles sont des structures
qui permettent d’exécuter plusieurs fois une même série d’instructions en
fonction d’une (ou plusieurs) condition(s).
1. Boucle while
La boucle while(){} correspond à « tant que ». Donc, on pourra exécuter des

instructions tant qu’une condition sera remplie. Voici la syntaxe générale :
while(<instruction de condition booléenne>){
<code à exécuter tant que la condition est vraie>

Page 55 sur 130
La boucle commence par tester la condition. Si la condition a la valeur true,

la boucle exécute la totalité du bloc d’instructions. Ensuite, elle teste la
condition une nouvelle fois et répète ce processus jusqu’à ce que la condition
prenne la valeur « false ». A ce moment, la boucle arrête de s’exécuter.
Exemple
Soit à imprimer 10 fois la chaine de caractères "Graduat informatique":

<?php
$cpt=0;
while ($cpt<10)
{
Echo "Graduat informatique" ;
$cpt++ ;
}
?>
Nota : Quand la boucle commence à s’exécuter, elle vérifie si la valeur de $cpt est
inférieur à 10. Comme c’est le cas, le corps de la boucle est exécuté et le mot
Graduat informatique est affiché à l’écran, puis la valeur de $cpt est incrémentée.
Cette boucle continue jusqu’à ce que la valeur de $cpt soit égale à 10, auquel cas
la boucle arête de s’exécuter.
2. Boucle do – while
La boucle do – while ressemble à la boucle while, à la seule différence

qu’elle évalue la condition après les instructions et non avant. Voici la
syntaxe:
Do{
<code à exécuter>
while(<instruction de condition booléenne>) ;
Le code ci-dessous illustre la boucle while précédente convertie en boucle

do– while:
<?php

Page 56 sur 130
$cpt =0;
do {
echo "Graduat informatique";
$cpt++;
}
while ($cpt <= 10);
?>
Nota: La différence principale entre les deux boucles est que la boucle do– while
s’exécute toujours au moins une fois, alors que la boucle while ne s’exécute pas si
la condition initiale n’est pas remplie.
3. Boucle for
La boucle for est la plus puissante des constructions de boucles. Voici la
syntaxe :
for(<initialisation> ;<condition booléenne> ;<itération>){
<code à exécuter>
La boucle for est constituée de trois parties : une expression d’initialisation, une
expression conditionnelle booléenne et une expression d’itération. La troisième
expression met généralement à jour la variable de la boucle initialisée par la
première expression. Voici la boucle for équivalente à la boucle while
précédente :
Exemple:
<?php
for ($cpt=0;$cpt<10; $cpt++)
{
echo "Graduat informatique";
}
?>
4. Boucle foreach

Page 57 sur 130
La boucle foreach permet de parcourir un à un les éléments d’un tableau. Il y

a deux syntaxes possibles, à savoir :
• foreach ($array as $element) instruction;

• foreach ($array as $key=>$element) instruction;
La première syntaxe passe en revue le tableau $array. À chaque itération, la
valeur de l’élément courant est assignée à $element et le pointeur interne de
tableau est avancé d’un élément (ce qui fait qu’à la prochaine itération, on
accédera à l’élément suivant).
La deuxième forme fait exactement la même chose, mais c’est la clé de

l’élément courant qui est assignée à la variable $key.
Exemple :
<?php
$tab=array(
'prenom' => 'Christella' ,
'ville' => 'Bandundu',
'travail' => 'informatique'
);
foreach ($tab as $element) {
echo "Valeur: $element<br>\n";
}
foreach ($tab as $cle => $valeur) {
echo "$cle : $valeur<br>\n";
}
?>
Exécution :

Page 58 sur 130
III.1.3 Instructions de contrôle des boucles
1. Instruction break
L’instruction break permet de sortir d’une structure de boucle avant que la

condition du test soit remplie. Quand la boucle rencontre une instruction
break, elle se termine immédiatement en ignorant le code restant.
Exemple :
<?php
$x=0 ; while($x<10){
echo "Graduat informatique" ;
$x++ ;
If($x==5)
break ;
else
//faire autre chose
}
?>
Nota : Dans cet exemple, la boucle s’arrête quand $x est égal à 5.

Page 59 sur 130
2. Instruction continue
L’instruction continue permet d’ignorer le reste de la boucle et de reprendre
l’exécution à l’itération suivante de la boucle.
Exemple :
<?php
for($x=0 ; $x<10 ; $x++){
if($x==5)
continue ; // revient au début de la boucle avec $x=6
echo "Graduat informatique" ;
}
?>
Nota : cet exemple n’imprime pas « Graduat informatique » si $x=5, mais

continue à l’imprimer pour 6, 7,8 et 9.
III.2 Récupération de données du formulaire
Les formulaires constituent un moyen de récupération de l’information

provenant de l’utilisateur. La balise form délimite/définit le formulaire.
L’attribut method permet de choisir la méthode d’envoi http entre :
• POST ;
• GET (envoie de paramètres visibles)
L’attribut action précise l’URL demandée par la requête http.
III.2.1 Passage des variables dans l’url avec la méthode GET
Lorsque vous envoyez un formulaire, l’URL de votre formulaire s’affiche sur

la barre d’adresse. L’usage de la méthode GET affiche les variables
envoyées en clair dans l’URL.
Exemple : http://html.net/page.php?id=1254
Le point d’interrogation forme une chaîne de requête http. Une chaîne de

requête http peut contenir à la fois des variables et leurs valeurs. Dans
l’exemple ci-dessus la chaîne de requête contient la valeur "id" avec la valeur
"1254" on peut en passer plusieurs en les séparant par l’esperluette (&).
III.2.2 Récupération des variables avec PHP

Page 60 sur 130
Le nom page.php qui précède le point d’interrogation dans l’URL représente

le fichier PHP qui va traiter la requête. Ainsi, la variable id contenu dans
l’URL est récupéré de cette façon : $_GET [‘Name]
Exemple: Ecrire un script PHP qui invite l’utilisateur à saisir les informations
suivantes: son nom, son prénom, sa classe respective et son sexe. En sortie
que, le script soit à même de renvoyer toutes les informations renseignées au
formulaire, précédé d’un message de bienveillance.
<html>
<head>
<title>menu principal</title>
<meta charset="iso-8859-1">
</head>
<body bgcolor="#01247F" bordercolor="">
<form method="get" action="saisie.php">
<h2 align="center"><font color="red" face="time new
roman"><u>Menu saisie</u><br/></font></h2>
<hr/>
<table>
<tr>
<td align="left"><b>votre nom</b></td>
<td><input name="nom"></td>
</tr>
<tr>
<td align="left"><b>votre prénom</b></td>
<td><input name="prenom"></td>
</tr>
<tr>
<td align="left" ><b>votre classe</b></td>
<td><input name="classe"></td>

Page 61 sur 130
</tr>
<tr>
<td name="left"><b>sexe</b></td>
<td>
<input name="sexe" type="radio" value="Monsieur" checked>Monsieur
<input name="sexe" type="radio" value="Madame">Madame
</td >
</tr>
<tr>
<td align="center" colspan="2"><input type="submit" value="
envoyer"></td>
</tr>
</table>
</form>
</body>
</html>
Résultat après exécution
Le fichier php (saisie.php)
<?php

Page 62 sur 130
$nom=$_GET['nom'];
$prenom=$_GET['prenom'];
$classe=$_GET['classe']; $sexe=$_GET['sexe'];
echo"Bonjour $sexe $nom $prenom, vous êtes en $classe ème année";
?>
Résultat après execution
III.2.3 Passage des paramètres à un script avec la méthode POST
La méthode POST permet de passer des variables saisies par l’utilisateur

d’un script php à l’autre. Toutes les variables passées en paramètres par cette
méthode seront considérée comme des chaines des caractères. Les données
saisies n’apparaîtront pas dans l’URL et ne seront pas stockées dans les
fichiers de log du serveur.
La variable envoyée avec la méthode POST est récupérée de cette façon :

$_POST[‘name’];

Page 63 sur 130
Exemple :
<html>
<head>
<title>Méthode post</title></head>
<body>
<form method="post" action="pass.php">
Login:<input type="text" name="login"><br/>
Password:<input type="Password" name="pass"><br/>
<input type="submit" value="Identifier"/></form>
</body>
</htm>
Résultat après exécution du fichier (pass.html)
Fichier php (pass.php)
Résultat après envoi de la requête (avec mot de passe incorrecte)
<?php
$login=$_POST['login'];
$pass=$_POST['pass'];
if($pass=="Bims2022")
echo"Bonjour $login !";
else
echo"Accès non autorisé";

Page 64 sur 130
?>
Résultat après envoi de la requête (avec mot de passe correcte)
III.3 Fichier texte
Vous ouvrez le fichier par l’intermédiaire de la fonction fopen. Le résultat est

stocké dans la variable $fichier.
$fichier=fopen("fichier","paramètre");
r Lecture uniquement, on commence au début du fichier
r+ Lecture et écriture, on commence au début du fichier
w Ecriture uniquement. Si le fichier existe déjà, le contenu actuel sera
alors supprimé. S’il n’existe pas, on essaiera de le créer
w+ Lecture et écriture, sinon comme w
a Ecriture uniquement. On commence à la fin du fichier (a pour append,
ajouter). S’il n’existe pas, on essaiera de le créer
a+ Lecture et écriture, sinon comme a
Tableau n° II.9.4.1: Paramètres utilisés dans fopen()
Le contenu des données est à présent lu, ligne après ligne, jusqu’à ce que la
fin du fichier soit atteinte :
while(!feof($fichier)){
$ligne=fgets($fichier,1000);
echo $lignes ;}
feof($fichier) Est vrai dès que la fin du fichier a été atteinte

Page 65 sur 130
$ligne=fgets($fichier,1000); Lit au max les 1000 caractères suivants, mais

s’arrête au niveau de chaque nouvelle ligne
ou bien lorsque la fin du fichier est atteinte
echo $ligne; Affiche ce qui a été lu.

Tableau n°II.9.4.2 : Instruction de l’exemple
• Avec fwrite($fichier, "texte")(ou fputs()); la chaine de caractères texte

peut être écrite dans le fichier;
• reafile(nomfichier)(fread(), fgets()) pour lire;
• le fichier doit être refermé à la fin fclose($fichier);
Exemple : Citation du jour
L’application affiche une citation différente à chaque chargement de la page.

Les citations sont séparées par un même signe, nous avons choisi ici le signe
deux-points (:).
Une fois que le fichier texte a été lu en mémoire avec les intructions PHP
fopen et fread, une fonction permet de convertir son contenu en tableau,
explode. Chaque fois qu’elle rencontre, cette fonction crée un nouvel
élément de tableau. Une fonction rand() génère alors un nombre aléatoire
afin de choisir un élément de ce tableau.

Page 66 sur 130
Figure n° 3.7.4.1: citations.txt
Pour que cette application fonctionne, il vous faut introduire une série de
citations dans un fichier appelé citations.txt et situé dans le même répertoire
que la page.php. Le code de cette page, appelée citations.php, est le suivant :
<!DOCTYPE html>
<html>
<head>
<title>Citation du jour</title>
<meta charset="iso-8859-1"/>
<style>
body

Page 67 sur 130
{
background-color:#ccffff;
font-family:Arial;
}
h1
{
background-color:#666666;
color:yellow;
text-align:center;
}
</style>
</head>
<body>
<h1>Citation du jour</h1>
<?php
$lecture=fopen("citations.txt","r");
$citations=fread($lecture, filesize("citations.txt"));
$tableau=explode(":",$citations);
$nb_citations=count($tableau)-1;
$index=rand(0,$nb_citations);
$texte=$tableau[$index];
fclose($lecture);
?>
<table border="6" cellpadding="20" align="center"

style="border-color:yellow;" width="80%">
<tr><td align="center"><b><marquee
behavior="alternate"><?php echo $texte ?></marquee></b></td>

Page 68 sur 130
</tr>
</table>
</body>
</html>
Résultat après exécution
Figure n°4.3.7.4.2: citations.php
III.4 Gestion des exceptions
Pour être complet, le PHP 5 propose un dispositif de prise en compte

d’erreurs, basé sur la notion d’exception. Une exception est un mécanisme
qui permet d’intercepter une erreur générée par un script et de déclencher
une action en réponse à cette erreur. Si PHP 4 ne permettait pas d’effectuer
une gestion des exceptions, la version 5 fournit un mécanisme qui permet de
gérer les conséquences d’une erreur.

Page 69 sur 130
III.4.1 La classe Exception
Le langage PHP dans sa version 5 introduit la classe prédéfinie « Exception »

qui offre une gestion évoluée des exceptions.
Gérer une exception consiste à délimiter un ou des blocs de code et à prévoir

une action particulière qui doit être réalisée dans le cas où l’erreur prévue se
produit. Ces blocs constituent les gestionnaires d’exception. Pour les créer,
procédez de l’une des façons suivantes :
Créez un bloc à l’aide de l’instruction try qui délimite le code dans
lequel peut survenir une erreur. Il peut s’agir, par exemple, du code
qui gère les saisies faites par des utilisateurs dans un formulaire. Ce
bloc contient une instruction throw pour déclencher l’exception en
créant un objet de type Exception à l’aide du motclé « new ».
Créez un bloc à l’aide de l’instruction catch associée au bloc try

précédent. Il comporte le code qui va gérer l’erreur si elle se produit.
C’est ce bloc qui utilise l’objet Exception créé par l’instruction throw.
Si aucune erreur ne se produit dans le bloc try, l’objet Exception n’est
pas créé, et le code du bloc catch est ignoré. L’exécution se poursuit
dans tous les cas après le bloc catch.
Un gestionnaire d’exception a donc la structure suivante :
try
{
//Code à surveiller
if(erreur prévue){throw new Exception();}
else{// Résultat;}
}
catch(Exception $except)
{
//Gestion de l'erreur
}
Le nom de l’objet utilisé dans l’instruction catch est sans importance. Un
même script peut comporter autant de bloc try…catch que possible. Il est

Page 70 sur 130
également possible d’imbriquer des blocs try les uns dans les autres, à
condition que chacun ait un bloc catch associé.
Le constructeur de l’objet Exception créé dans l’instruction throw reçoit deux

paramètres, correspondant aux propriétés message et code de l’objet. Le
premier est une chaîne contenant le message d’erreur et le second un entier
qui définit un code d’erreur facultatif. Cet objet est utilisé dans le bloc catch
en appelant ses méthodes pour afficher des informations sur l’exception.
L’image ci-dessous donne la liste et le rôle des méthodes de l’objet
Exception.
Exemple : Création d’un gestionnaire d’exception
<?php
$a=100;
$b=0;
try
{

Page 71 sur 130
if($b==0){throw new Exception("Division par 0",7);} else{echo

"Résultat de : $a / $b = ",$a/$b;}
}
catch(Exception $except)
{
echo "Message d'erreur :",$except–>getMessage(),"<hr>";
echo "Nom du fichier :",$except–>getFile(),"<hr>"; echo
"Numéro de ligne :",$except–>getLine(),"<hr>"; echo
"Code d'erreur :",$except–>getCode(),"<hr>"; echo
"__toString :",$except–>__toString(),"<hr>";
}
echo "FIN";
?>
A l’exécution on a :
QUATRIEME CHAPITRE : NOTIONS DE LA PROGRAMMATION

OBJET
IV.1 Introduction à la POO
Avant la version 5, PHP était loin d’être un langage de programmation

orientée objet (POO), en comparaison de Java ou de C++, dont, il est vrai, la

Page 72 sur 130
destination n’est pas la même. Dans ASP.Net, destiné typiquement au Web,

toute action de programmation entraîne la création et la manipulation
d’objets préexistants. Du fait de cette lacune de PHP 4, les projets de grande
envergure le délaissaient au profit d’ASP.Net ou de JSP.
Les concepteurs de PHP 5 ont dû effectuer une refonte totale du modèle objet
très sommaire de PHP 4 pour le rendre plus proche de celui de Java. Sans
devenir un langage de POO à part entière, PHP 5 fournit néanmoins
désormais les outils nécessaires à ceux qui souhaitent choisir cette
orientation. La manipulation d’objets n’est pas une obligation dans la plupart
des cas mais pourrait devenir une nécessité pour de gros projets.
La POO permet de modulariser le code des scripts en décomposant les

données à traiter en différentes entités, chacune étant représentée par un type
d’objet. Elle offre de surcroît la possibilité de réutiliser des classes déjà
créées grâce au mécanisme de l’héritage, qui permet de créer de nouvelles
classes à partir des classes existantes en leur ajoutant de nouvelles
fonctionnalités.
IV.2 Avantages de la POO
La programmation orientée objet comporte toutefois les avantages suivants :
• un code réutilisable – les types d’objets peuvent servir de bases pour

d’autres types d’objets, en ne réimplémentant que ce qui change entre
les deux.
• un code naturel – l’homme voit naturellement les choses sous forme
d’objets avec des actions à y appliquer et des caractéristiques propres.
Réutiliser ces éléments permet d’avoir une bonne conceptualisation.
• un code modulaire – chaque type contient son propre contexte et
n’interfère avec les autres types que via des interfaces bien définies. Il
est facile d’isoler un module ou de développer des modules
séparément.
• un code compréhensible – chaque objet regroupe ses propriétés et ses
méthodes. On comprend tout de suite à quoi s’applique une fonction et
à quoi correspond une variable.
Ces avantages ne sont pas exclusifs à la programmation objet. Il est possible

d’avoir un code compréhensible, réutilisable, naturel et modulaire sans
objets, comme il est possible d’avoir un code incompréhensible, non

Page 73 sur 130
réutilisable, non naturel et monolithique avec des objets. Il s’agit juste

d’avoir une solution simple qui favorise ces avantages et dirige le
développeur vers une bonne conception.
IV.3 Objets
Le concept d’objet en programmation est fait pour être naturel et ressembler

à ce que manipule un non-informaticien. Un objet est une chose quelconque.
La voiture de mon voisin est un objet, l’utilisateur de mon application est un
objet, mon compte en banque peut être vu comme un objet, une écriture de
mon compte en banque est aussi un objet. Toute donnée manipulée peut en
fait être représentée comme un objet.
IV.4 Attributs et méthodes
Chaque objet a des attributs qui lui sont propres. Mon compte en banque a un
attribut qui définit le numéro de compte, un autre qui définit le solde actuel,
un troisième qui est une liste des différentes opérations, et ainsi de suite. Les
attributs peuvent être vus comme les caractéristiques propres de l’objet.
Les objets peuvent avoir des méthodes. Il s’agit des actions qu’on peut
appliquer à un objet. Toujours en prenant mon objet de compte en banque, il
existe une méthode pour le solder, une pour ajouter une écriture, une pour le
déplacer dans une autre banque, etc.
V.5 CLASSE
Une classe est un modèle de données. On peut la voir comme une famille
d’objets. Tous les objets d’une même classe sont similaires. Ils partagent les
mêmes attributs et méthodes.
On peut ainsi imaginer une classe représentant les voitures. Toutes les
voitures (tous les objets de la classe voiture) ont des plaques
d’immatriculation, un moteur avec une certaine puissance et un nombre de
portières identifiables (ils ont des attributs communs).
Tous les objets de cette classe ont aussi des méthodes pour démarrer, freiner,
accélérer, tourner, etc.

Page 74 sur 130
IV.5.1 INTANCE DE CLASSE
Nous venons de voir qu’une classe était un type d’objet. Une instance est une
représentation particulière d’une classe.
Pour donner un exemple, Mégane est une classe et une instance de cette
classe pourrait être la voiture que vous venez d’acheter, qui est bleue et sans
options. Une autre instance de la classe Mégane pourrait être la voiture rouge
garée en bas de chez vous. En revanche, il faut faire attention au fait qu’il
peut y avoir plusieurs instances ayant les mêmes propriétés sans qu’elles
soient identiques. Par exemple, si quelqu’un d’autre achète la même voiture
que vous, une Mégane bleue sans options, il s’agira d’une autre instance de
la même classe.
IV.5.1.1. Déclarer une classe
Le mot-clé class permet de définir une nouvelle classe. Il doit être suivi du
nom de la classe et d’un bloc entre accolades. Entre ces accolades pourront
être insérés les attributs de la classe et les définitions des méthodes, ou
encore des commentaires. L’exemple suivant définit une classe voiture :
class voiture {
// Contenu de la classe
 Attributs
Le contenu de la classe est structuré en deux parties. La première partie

permet la déclaration de tous les attributs de la classe. Ces attributs sont
déclarés en utilisant la syntaxe des variables et un des mots-clés suivants :
public, private ou protected.
L’exemple suivant définit un attribut marque :

class voiture { public $marque ;
Dans un premier temps, nous utiliserons le mot-clé public pour déclarer les
attributs de la classe. La description et la signification des différents mots-
clés sont données plus loin, à la section « Sûreté de programmation ».

Page 75 sur 130
Il est possible de définir une valeur par défaut avec la même syntaxe qu’une
affectation.
<?php
class voiture {
public $marque = 'ferrari';
?>
 Méthodes
La deuxième partie du contenu d’une classe permet la déclaration des

méthodes. Ces méthodes se déclarent exactement comme des fonctions.
Deux classes différentes peuvent utiliser des méthodes avec le même nom
sans provoquer de conflit. L’exemple suivant définit une méthode freiner : <?
php
class voiture {
public $marque ; f
unction freiner( $force_de_freinage ) {
// Instructions pour faire freiner
?>
 Constantes
La version 5 de PHP permet de définir des constantes locales à une classe.

De telles constantes vous permettent de ne pas polluer l’espace global avec
des constantes que vous n’utilisez que dans le cadre d’un certain type
d’objet. Pour déclarer une constante dans une classe, il vous suffit de
procéder comme pour une variable avec une valeur par défaut, mais en
utilisant le mot-clé const et sans mettre le symbole $. Une convention
classique est de spécifier les constantes en majuscules dans le code pour
mieux les identifier et les isoler.

Page 76 sur 130
L’exemple ci-dessous permet de définir trois types de tondeuses à gazon :

poussée, tractée ou autoportée.
<?php
class TondeuseGazon
{ const TRACTEE = 1 ;
const AUTOPORTEE = 2
; const POUSSEE = 4 ;
public $type ;
?>
 Instanciation des objets
Pour pouvoir utiliser un objet, il faut d’abord le créer à partir d’un modèle (la
classe). On utilise la syntaxe d’affectation avec le mot-clé new. L’exemple
suivant crée un objet de la
classe voiture :
<?php
// Déclaration de la classe class voiture
{ public $marque ;
function freiner( $force_de_freinage ) {
// Instructions pour faire freiner
}
}
// Instanciation d’un objet
$mavoiture = new voiture() ;
?>
Les parenthèses lors de l’instanciation sont ici optionnelles. Elles ne seront

nécessaires que quand nous utiliserons des paramètres à passer au
constructeur lors de l’instanciation. Nous les utilisons pour avoir un code
plus homogène.

Page 77 sur 130
 Utilisation d’un attribut
Une fois qu’un objet a été instancié, on peut commencer à utiliser ses
attributs et ses méthodes. Les attributs s’utilisent comme des variables
classiques. On accède à un attribut grâce à l’opérateur flèche (->). L’exemple
suivant accède à l’attribut $solde d’un objet de type
CompteEnBanque ;
<?php
class CompteEnBanque
{ public $solde = 0;
}
$mon_compte = new CompteEnBanque() ;
echo 'Le solde de mon compte est : ';
echo $mon_compte->solde, '<br>' ; // Affiche 0
$mon_compte->solde = 6000 ;
echo 'Maintenant le solde de mon compte est : ';
echo $mon_compte->solde, '<br>' ; // Affiche 6000
?>
Nota : L’attribut s’appelle sans mettre de $ après l’opérateur ->.
 Utilisation des méthodes
L’appel d’une méthode se fait de façon similaire à celui d’une fonction.

Comme pour les attributs, il suffit de séparer l’objet et la méthode par
l’opérateur ->. L’exemple suivant appelle la méthode klaxonne() d’un objet
de type voiture :

Page 78 sur 130
<?php
class voiture {
function klaxonne() {
echo "Vous klaxonnez fort !" ;
$ma_voiture = new voiture() ;
$ma_voiture->klaxonne () ; // Affiche Vous klaxonnez fort !
?>
 Référence à l’objet en cours
Il est souvent utile de pouvoir faire référence à l’objet en cours dans une
méthode. C’est par exemple le cas pour accéder à un attribut ou lancer une
autre méthode. La méta variable $this est une référence permanente vers
l’objet courant. On parle de méta variable car ce n’est pas à vous de la
définir, ce sera fait automatiquement par PHP à l’exécution de chaque
méthode.
<?php
class voiture {
public $vitesse = 0;
function avance( $temps ) {
$distance = $temps * $this->vitesse ;
echo "Pendant ces $temps heures on a avancé de $distance km" ;
}
}

Page 79 sur 130
$ma_voiture->vitesse = 100 ; // On avance à 100 km/h
echo 'Actuellement notre vitesse est de ' ;
echo $ma_voiture->vitesse, 'km/h<br>';
$ma_voiture->avance( 2 ) ; // On avance 2h ?>
 Constantes d’aide au débogage
À tout moment, dans une méthode, vous pouvez faire appel aux
métaconstantes __CLASS__ et __METHOD__. Elles vous retourneront les
noms de la classe et de la méthode en cours d’exécution.
<?php
class voiture {
public $vitesse ;
echo 'classe : ', __CLASS__, ' - ' , __METHOD__,
'<br>' ;

$ma_voiture->vitesse = 100 ; // On avance à 100 km/h

Page 80 sur 130
$ma_voiture->avance( 2 );
?>
 Constructeurs et destructeurs
1. Constructeur
PHP prévoit un moyen d’initialiser un objet à sa création. Il s’agit d’exécuter

une méthode spécifique lors de la création de l’objet. On parle de
constructeur.
Si une méthode porte le nom __construct() (n’oubliez pas les deux traits de
soulignements avant le nom), elle servira de constructeur. Il est possible de
fournir des paramètres au constructeur en les ajoutant entre parenthèses dans
l’instanciation. L’exemple suivant nous montre comment on peut initialiser
un objet en donnant des paramètres à son constructeur.
<?php
class voiture {
public $vitesse = 0;
public $marque;
public $annee;
public $modele;
// Définition du constructeur
function __construct($marque,$modele,$annee) {
$this->marque = $marque;
$this->annee = $annee;

Page 81 sur 130
$this->modele = $modele;
// Définition de la fonction avance
$distance = $temps * $this->vitesse ;
echo "Pendant ces $temps heures on a avancé de $distance km" ;
// Définition de la fonction afficher
function affiche( ) {
echo 'Il s\'agit d\'une voiture de marque ' ;
echo $this->marque, '<br>';
echo 'Le modèle est ', $this->modele, '<br>';
echo 'L\'année d\'achat est ', $this->annee, '<br>';
$ma_voiture = new voiture('Renault','clio',2004) ;
$ma_voiture->affiche();
?>

Page 82 sur 130
Si votre classe est une classe dérivée et si le constructeur y est redéfini, seul
le constructeur de la classe fille sera appelé. PHP n’appelle pas implicitement
le constructeur parent, c’est à vous de le faire. Vous pouvez vous reporter à
la section sur l’héritage pour plus de détails sur la redéfinition de méthodes et
l’appel de la méthode de la classe parente.
2. Destructeur
De la même manière qu’il existe un constructeur, on peut définir un

destructeur. Il s’agit d’une méthode nommée __destruct(). Elle est
automatiquement appelée quand l’objet est détruit, soit par delete() ou
unset(), soit à la fin du script.
Un destructeur est pratique pour fermer les ressources ouvertes : fichiers,

connexions vers des serveurs de bases de données, etc.
De même que pour le constructeur, si votre classe est une classe dérivée et si
le destructeur y est redéfini, le destructeur de la classe parente ne sera pas
appelé implicitement par PHP. C’est à vous de le faire explicitement.
<?php class mere {
function __destruct() {
echo "appel au destructeur de la classe mère <br>" ;
class fille extends mere{
function __destruct() {
echo "appel au destructeur de la classe fille <br>" ;
parent::__destruct() ;
$objet = new fille() ;

unset($fille) ;

Page 83 sur 130
// Affiche
// appel au destructeur de la classe fille
// appel au destructeur de la classe mère
?>
 La notion d’héritage
La catégorisation par classes d’objets est assez limitée. Assez souvent,

plusieurs classes partagent elles-mêmes certains de leurs attributs et
méthodes. On peut parler de catégories d’objets et de sous-catégories.
Il est possible d’expliquer cette relation avec la notion d’héritage. Ainsi,

l’objet qui définit ma voiture appartient à la classe des voitures, qui elle-
même dérive de la classe des véhicules à moteur. On dit alors que la classe
des voitures hérite de la classe des véhicules à moteur : elle peut en utiliser
les méthodes et les attributs.
Pour le langage PHP, une classe ne peut hériter que d’une seule classe.
L’héritage multiple est interdit et il est impossible de dire par exemple que la
classe des écharpes en laine hérite de la classe des écharpes et de la classe
des vêtements en laine, simultanément.
Pour définir un héritage, on utilise le mot-clé extends après le nom de la

classe dans la déclaration. Dans l’exemple suivant, la classe des voitures
hérite de la classe des véhicules à moteur.
<?php class
vehicule_a_moteur{
public function freine(){
// Code pour vehicule_a_moteur.freine ...
public function avance(){
// Code pour vehicule_a_moteur.avance ...
}
}

Page 84 sur 130
class voiture extends
vehicule_a_moteur{ public $marque;
public $modele; public $annee;
public function klaxonne(){
// Code pour voiture.klaxonne ...
public function avance($temps=NULL){
// Code pour voiture.avance ...
public function freine($temps=NULL){
// Code pour voiture.freine ...
public function demarre(){
// Code pour voiture.demarre ...
?>
1. Redéfinition d’attribut ou de méthode
Si un attribut est redéfini, c’est sa dernière définition qui est utilisée pour
déterminer la valeur par défaut de l’objet de la classe fille :
<?php class
vehicule_a_moteur {
public $nombre_roues = 2 ;
}
class voiture extends vehicule_a_moteur {

Page 85 sur 130
public $nombre_roues = 4 ;
$berline = new voiture() ;
echo $berline->nombre_roues ;
// Affiche 4
?>
Si une méthode est redéfinie, c’est sa dernière définition qui est utilisée:
<?php class vehicule_a_moteur
function nombre_de_roues()
{ echo 2 ;
class voiture extends vehicule_a_moteur
{ function nombre_de_roues() {
echo 4 ;
$berline = new voiture() ;
$berline->nombre_de_roues() ;
// Affiche 4
?>
2. Héritage strict
Les développeurs du moteur PHP adhèrent au concept d’héritage strict. Il

s’agit dans notre exemple sur les voitures de considérer que si la classe

Page 86 sur 130
voiture hérite de la classe véhicule, toute instance de voiture doit pouvoir être
manipulée comme un véhicule générique, en ignorant les particularités de la
classe fille. Toute méthode redéfinie doit être compatible avec la méthode
précédente. Pour revenir sur notre exemple de voiture, bien qu’elle accepte
une vitesse dans sa méthode avance(), elle doit aussi accepter cette même
instruction sans paramètre, comme n’importe quel véhicule.
On dit que les méthodes de la classe fille doivent avoir des prototypes
compatibles avec ceux de la classe mère. Il est possible d’ajouter des
paramètres supplémentaires, à condition qu’ils soient facultatifs. Il est aussi
possible de rendre facultatifs des paramètres en leur donnant une valeur par
défaut.
Pour résumer, le nombre de paramètres obligatoires de la méthode fille doit

être inférieur ou égal au nombre de paramètres possibles de la méthode
mère ; le nombre de paramètres possibles de la méthode fille doit quant à lui
être supérieur ou égal au nombre de paramètres possibles de la méthode
mère. Par exemple, une méthode qui a trois paramètres obligatoires sur cinq
peut être remplacée par une méthode qui a un paramètre obligatoire (nombre
inférieur) et cinq facultatifs (donc six au total, ce qui est supérieur aux cinq
initiaux.
Seuls les constructeurs ne sont pas soumis à cette règle car la notion de
constructeur générique n’a pas vraiment de sens.
Cet héritage strict est une contrainte importante qui n’existait pas en PHP 4.
Un message d’erreur de niveau E_STRICT sera envoyé pour chaque
infraction. Si vous ne souhaitez pas vous confiner dans un héritage strict, il
vous suffira de les ignorer (ce qui est probablement le cas par défaut). Vous
pourrez trouver plus de renseignements sur ce que sont les messages
E_STRICT dans le chapitre 19 sur la gestion des erreurs.
3. Accès aux méthodes parentes
Si une méthode est redéfinie dans la classe fille, il peut être utile de
volontairement appeler la méthode de la classe parente. Il suffit alors
d’utiliser une notation statique (voir plus loin pour plus de détails sur ce
qu’est un appel statique et comment l’utiliser) avec le mot-clé parent. La
syntaxe parent::xxx() permet d’accéder à la méthode xxx de la classe mère.

Page 87 sur 130
C’est par exemple le cas si on ne veut que faire un ajout. Il suffit alors dans
notre méthode de faire notre ajout puis appeler la méthode parente qui fera le
gros du travail.
<?php class
vehicule_a_moteur
{ function avancer() {
echo "J'avance \n" ;
}
{ function passer_la_vitesse( $vitesse ) {
echo "Je passe la vitesse $vitesse \n" ;
function avancer() { $this->passer_la_vitesse(1)
; parent::avancer() ;
}
}
$maVoiture = new voiture() ;
$maVoiture->avancer() ;
// Affiche "Je passe la vitesse 1" puis "J’avance"
?>
4. Sûreté de programmation
Un des défauts mis en avant concernant le modèle objet de la version 4 est le

manque de sûreté de programmation ; il a été comblé avec PHP 5. Vous

Page 88 sur 130
retrouverez la plupart de ces principes dans d’autres langages objets comme

C++ ou Java, ils ne sont guère différents dans PHP 5.
Il est important toutefois de noter que ces nouvelles fonctionnalités sont tout
à fait optionnelles. Vous pouvez, si vous le souhaitez, utiliser les objets PHP
5 de la même façon que les objets PHP 4 (si ce n’est le fait qu’ils sont
désormais passés par référence).
5. Contrôle d’accès
Le contrôle d’accès est une fonctionnalité qui permet de filtrer les accès aux
attributs et aux méthodes.
 Accès public
Une méthode (ou attribut) publique est accessible depuis toute votre
application. C’est le cas par défaut, et le comportement dans PHP 4. Vous
pouvez toutefois le préciser explicitement en utilisant le mot-clé public
devant les attributs et méthodes dans la déclaration de la classe.
Les deux déclarations suivantes sont équivalentes :
class vehicule_a_moteur {
var $marque ; // Affichage PHP4
function avancer() {
}
}
e
t
<?php class vehicule_a_moteur
{ public $vitesse ; // Affichage
PHP5 public function avancer() {
}
}
?>
 Accès privé

Page 89 sur 130
Une méthode (ou attribut) en accès privé n’est utilisable qu’à l’intérieur
même de la classe. Il est interdit d’y faire appel à partir de l’extérieur. Le
mot-clé à utiliser est private.
<?php
class vehicule_a_moteur {
private $vitesse = 30 ;
public function avancer() {
echo "J'avance à la vitesse de " ;
echo $this->vitesse , " km/h \n" ;
// Appel autorisé car on est à l’intérieur de la classe
$maVoiture = new vehicule_a_moteur() ;
// Affiche "J’avance à la vitesse de 30km/h"
?>
Si le développeur accède tout de même par erreur à un attribut (ou à une

méthode) privé depuis l’extérieur de la classe, PHP retourne une erreur
fatale.
echo $maVoiture->vitesse ;
// On est à l’extérieur de la classe, l’appel est interdit
// PHP génère une erreur fatale
 Accès protégé
Un accès protégé est une solution intermédiaire entre un accès privé et un
accès public. Il est toujours interdit de faire appel à une méthode ou à un
attribut protégé depuis l’extérieur de l’objet, mais la méthode (ou l’attribut)
est utilisable par les classes dérivées.

Page 90 sur 130
Le mot-clé pour un accès protégé est protected.
class vehicule_a_moteur
{ protected $vitesse = 30 ;
private $roues = 4 ;
{ public function avancer() {
echo "J'avance à la vitesse de " ;
echo $this->vitesse , " km/h \n" ;
// Appel autorisé car on est à l’intérieur d’une classe dérivée
public function nombreRoues() {
echo "il y a ", $this->roues, "\n" ;
// Appel interdit, le nombre de roues est privé
$maVoiture = new voiture() ;
// Affiche "J’avance à la vitesse de 30km/h"
$maVoiture->nombreRoues() ;
// Génère une erreur fatale car la méthode essaie
// d’accéder à un attribut privé

Page 91 sur 130
CINQUIEME CHAPITRE : ACCES AUX BASES DE DONNEES

MySQL
V.1 Interface phpMyAdmin
Même si le couple PHP - MySQL est le plus rependu actuellement sur le

web, MySQL est accessible à d’autres langages, notamment Java. La totalité
des hébergements PHP-MySQL offrent une interface nommée
phpMyAdmin, à partir de laquelle il est possible, pour l’administrateur
seulement, d’effectuer toutes les opérations de création de base et de tables,
d’insertion ainsi que de sélection de données. L’interface phpMyAdmin
installée sur vos serveurs local et distant est en réalité est un formulaire écrit
en PHP permettant d’agir sur la base de données.
L’interface phpMyAdmin vous permet d’envoyer au serveur des requêtes

SQL (Structured Query Language) de création et d’administration
de base sans avoir à les écrire. L’interface affiche de surcroît le code SQL de
la requête qui vient d’être exécutée.
Pour y accéder à partir d’un navigateur, il vous suffit de saisir les adresses
suivantes :
 En local : http://localhost/mysql
(http://localhost/phpmyadmin)
ou
http://127.0.0.1/mysql (http://127.0.0.1/phpmyadmin)
 Pour des serveurs distants :

http://www.votresite.com/phpmyadmin
ou encore parfois :
http://www.votresite.com/mysql

Page 92 sur 130
V.2 Création de la base de données
De nombreux hébergeurs, qu’ils soient gratuits ou payants, n’offrent la

possibilité de créer qu’une seule base de données sur leur serveur. Vous
verrez cependant qu’il est possible de créer en local plusieurs bases de
données différentes.
Pour attribuer un nom à une base de données, il faut respecter les

conventions suivantes, index et alias utilisés :
• Les caractères autorisés sont les caractères
alphanumériques et de soulignement(_) ainsi que le signe
dollar($).
• Le nombre de caractères est limité à 64, extensible à 255
pour les noms d’alias. Plus le nom est long, plus il y a de
risque d’erreur en le recopiant.
• Un nom peut commencer par un chiffre mais ne doit pas
contenir que des chiffres.
• La sensibilité à la casse dépend du système d’exploitation.
Autant considérer que MySQL est sensible à la casse et
surtout éviter de changer de casse dans une même requête,
notamment pour les noms d’alias de table.
V.2.1 Lancement d’EasyPHP
Pour lancer le serveur EasyPHP, il suffit de l’exécuté à partir de bureau

Windows, ou encore appuyer sur le menu démarrer, ensuite cliquez sur
tous les programmes et enfin faite un clic sur EasyPHP.

Page 93 sur 130
Clique r sur l’icône EasyPHP et choisissez le menu

«Administration» :
La page d’administration s’affiche et cliquer sur «GESTION

BDD» :

Page 94 sur 130
Pour créer la base de données, il suffit de saisir le nom de la base de

données désirée (ici magasin), dans la zone de saisie da la page
d’accueil phpMyAdmin et de cliquer sur le bouton créer. Une fois la
base créée, son nom apparaîtra dans la partie gauche de l’interface.
Pour détruire la base, il suffit de la sélectionner puis de cliquer sur le
bouton «Supprimer».
V.2.2 Création de tables
a. Introduction
Une table est composée de colonnes, ou champs. Chacune de ces colonnes
est dotée d’un type particulier, censé correspondre le mieux possible à
l’information qu’elle contient. Avant de créer une table, il importe de
connaître les différents types de données proposées par MySQL. Le choix
judicieux de ce type réduit l’espace disque utilisé. Cette partie du cours
présente les différents types de données reconnus par MySQL ainsi que les
commandes SQL utilisables pour créer les tables.
b. Types de données MySQL

MySQL permet de stocker des informations selon de nombreux types de
données. Cela donne la possibilité d’adapter le plus précisément possible le
type de données à l’information qui est enregistrée dans une table. Le choix

Page 95 sur 130
du type doit se faire de telle sorte que l’information occupe le moins

d’octects possible.
b.1 Types numériques

Les types numériques permettent de stocker toutes sortes de valeurs
numériques entières ou décimales avec des intervalles de valeurs très
étendus. Comme expliqué précédemment, il est important d’adapter le type
choisi au format de l’information stockée afin de ne pas occuper plus
d’espace serveur que nécessaire et, par voie de conséquence, de ne pas
allonger inutilement les temps de réponse des recherches effectuées.
Le tableau 4.2.2 présente les différents types de données numériques

Champs numériques Taille mémoire en Description
octects
TINYINT [(longueur)] 1 Nombre entier, intervalle : de 128 à
127 ou de 0 à 255
SMALLINT [(longueur)] 2 Nombre entier, intervalle : de 32
768 à 32 768 ou de 0 à 65 535
MEDIUMINT 3 Nombre entier, intervalle : de 8 388

[(longueur)] 608 à 8 388 607 ou de 0 à
4 294 967 295
INT [(longueur)] / Nombre entier, intervalle : de 9 223
INTEGER [(longueur)] 4 372 036 854 775 808 à 9 223 372
036 854 775 807 ou de 0 à 18 446
744 073 709 551 615
REAL [(longueur, place

de la décimale)] /
DOUBLE [(longueur, 8 Nombre à virgule flottante
place de la décimale)]
FLOAT [(longueur, place
de la décimale)] 4 Nombre à virgule flottante
DECIMAL [(longueur, Nombre à virgule flottante non
place de la décimale)] compacté avec un signe, les
NUMERIC [(longueur, nombres sont enregistrés sous la
place de la décimale)] forme d’une chaîne de caractères.
Tableau n°4.2.2 : Types de données numériques

Page 96 sur 130
Nota : Tous les types de données des champs peuvent être complétés par les
paramètres suivants :
• [UNSIGNED] : le signe n’est pas pris en compte

• [ZEROFILL]: les valeurs manquantes sont remplies avec la
valeur
NULL
b.2 Types chaînes de caractères

Ces types permettent de stocker des chaînes de caractères de longueurs très
diverses, allant du simple caractère au discours fleuve d’un visiteur prolixe
dans un livre d’or. A nouveau, il vous faut penser à adapter le type de
données à ce que vous désirez stocker afin d’utiliser le moins d’octect
possible.
Le tableau 4.2.3 présente les différents types de données chaînes de
caractères
Champs numériques Taille mémoire en Description
octects
CHAR (longueur) De 1 à 255 Longueur de la chaîne de
[Binary] caractères : de 1 à 255
VARCHAR (longueur) variable Longueur variable de la chaîne de
[Binary] caractères
TINYBLOB / TINYTEXT BLOB ou TEXT avec un max de
255 caractères
BLOB / TEXT BLOB ou TEXT avec un max de
650535 caractères
MEDIUMBLOB / BLOB ou TEXT avec un max de
MEDIUMTEXT 16 777 215 caractères
LONGBLOB / BLOB ou TEXT avec un max de 4
LONGTEXT 294 967 295 caractères
ENUM (valeur1, valeur2, Enumération. Max 65 535
valeur3) valeurs individuelles
SET (valeur1, valeur2, Comme ci-dessus, mais avec des
valeur3) groupes de max 64 valeurs
Tableau n° 4.2.3: Types chaînes de caractères
b.3 Types de dates et d’heures

Page 97 sur 130
Les types de dates et d’heures permettent de stocker des dates dans des
formats différents, allant de la simple année seule à l’ensemble date complète
plus heure complète à la seconde près. Pour stocker un timestamp UNIS, il
est préférable d’utiliser une colonne de type entier INT (10), qui facilite les
opérations.
Le tableau 4.2.4 présente les différents types de données de dates et d’heures

Champs numériques Taille mémoire Description
en octects
DATE 4 Date du type YYYY-MM-DD
DATETIME 8 Date du type YYYY-MM-DD
HHMM-SS
TIME 3 Heure du type HH-MM-SS
TIMESTAMP 4 Temps standard Unix
YEAR 1 Année du type YYYY
Tableau n°4.2.4 : Types de dates et d’heures
b.4 Opérations des attributs

Chaque attribut d’une table peut être précisé à l’aide des options suivantes :
• NOT NULL : pour que chaque enregistrement de l’attribut ait
obligatoirement une valeur ou NULL pour autoriser l’absence
de valeur (cette dernière option est interdite pour une clé
primaire).
• DEFAULT : permet de définir une valeur par défaut pour
l’attribut si aucune valeur n’y est enregistrée. Cette option est
impossible pour les types BLOB et TEXT. Les valeurs par
défaut doivent être des constantes, et il n’est pas possible
d’utiliser de fonction pour les définir.
• AUTO_INCREMENT : pour qu’un attribut numérique entier
soit automatiquement incrémenté d’une unité à chaque insertion
d’un enregistrement, o, utilise pour ce faire
AUTO_INCREMENT. Pour que cette contrainte soit valable, il
faut que l’attribut soit indexé ou qu’il soit la clé primaire.

Page 98 sur 130
• PRIMARY KEY : crée une clé primaire.

V.3 Etudes de cas
Nous allons dans cette section, réaliser l’interfaçage entre le PHP et le

MySQL qui a l’avantage d’être disponible gratuitement et de ce fait,
extrêmement rependu sur le web en combinaison avec le serveur Apache.
Pour ce faire, il existe plusieurs possibilités pour utiliser une base de données
avec PHP, notamment :
L’approche classique : qui consiste à utiliser une extension native
dédiée (mysql et mysqli pour MySQL, oci8 pour Oracle…). Bien que
ces extensions aient des similitudes entre elles, vous aurez alors à
manipuler des fonctions spécifiques différentes selon votre SGBD.
L’approche orienté objet (PDO) proposé avec PHP 5 : il s’agit d’une
extension qui permet de travailler de manière unifiée quel que soit le
SGBD utilisé.
V.3.1 Première étude : Gestion d’un magasin (Ets JohannaBims)

La première étape consiste à créer les tables destinées à contenir les données
de la base de données magasin, avec les tables client, commande, article et
ligne. La figure ci-dessous illustre le MLD de ladite base de données qui va
nous permettre de créer les différentes tables qui la composent.
Figure n°4.2.5 : MLD de la base magasin
En résumé : Pour créer une table, par exemple la table client, procédez de la
manière suivante :
 Sélectionner la base de données dans la page d’accueil de

phpMyAdmin.

Page 99 sur 130
 Sélectionnez un nom pour la table et le nombre de champs

qui la composent dans les zones de saisie.
 Cliquez sur le bouton Exécuter.
 Dans la page qui s’affiche, saisissez les caractéristiques des
colonnes, ou champs, de la table dans un formulaire
comptant autant de lignes qu’il y a de champs définis (voir
la figure 4.3.1).
Figure n°4.3.1 : Création de la table client

Le code généré par phpMyAdmin est le suivant :

Page 100 sur 130
Vous pouvez créer de la même façon les autres tables de la base magasin en
prenant soin de respecter les définitions données précédemment.
V.3.2 Insertion de données
a. Introduction
Une fois les tables créées, différents moyens permettent d’y enregistrer les
données nécessaires au fonctionnement d’un site de web dynamique. Il existe
deux grandes catégories de données, les données statiques, qui ne dépendent
que de l’administrateur du site, comme celles de la table article, qui
constituent le contenu du magasin, et les données en provenance des
internautes clients du site, qui rempliront les autres tables. Ces dernières
informations sont obtenues à partir d’un formulaire de saisie alors que les
données statiques peuvent être enregistrées aussi bien à partir d’un
formulaire en ligne qu’à l’aide de phpMyAdmin.
b. Insertion ligne par ligne

Vous allez commencer par insérer les données dans la table article. Il suffit
pour cela de cliquer sur la base magasin dans la page d’accueil phpMyAdmin
puis, dans l’ensemble des tables de la base qui s’affichent, de sélectionner la
table voulue et de cliquer sur le bouton insérer. Un formulaire de saisie
s’affiche alors comme illustré à la figure n°4.3.2.1.
En cliquant sur le bouton « Insérer », vous générez l’affichage du code

Page 101 sur 130
SQL de la requête, par exemple : INSERT INTO

‘article’(‘id_article’,’designation’,’prix’,’categorie’)
VALUES(‘CS110’,’Caméscope Sony
110’,’1250.00’,’vidéo’,’informatique’);
Figure n°4.3.2.1: Insertion de données ligne par ligne
c. Importation à partir d’un fichier texte
L’insertion ligne par ligne devient rapidement rébarbative lorsqu’il s’agit de

saisir un grand nombre de données. Si ces données sont récupérables à partir
d’un catalogue, il est possible de les inclure en une seule opération à
condition qu’elles soient formatées selon les mêmes critères que ceux que
vous avez utilisés pour les fichiers texte.
Chaque donnée doit être délimitée par un caractère particulier (par défaut des
guillemets) et séparée des autres par un autre caractère (par défaut le point-
virgule).
Pour importer une liste de données dans la table, vous devriez, par exemple,
créer le fichier article.txt dont le contenu est visualisé dans le Notepad++ de
Windows est illustré à la figure 4.3.2.2.

Page 102 sur 130
Figure n°4.3.2.2 : Fichier texte visualisé dans le notepad++
Pour réaliser ce type d’importation, vous devez sélectionner la base, puis la

table et ensuite cliquer sur l’onglet insérer des données provenant d’un
fichier texte dans la table. Vous obtenez alors une page identique à celle de la
figure 4.3.2.3.
Si le fichier est situé sur le post client, vous pouvez utiliser le bouton
parcourir pour le localiser et conserver le choix par défaut DATA LOCAL.
En cliquant sur le bouton Afficher, vous pouvez vérifier que l’insertion des
données s’est effectuée correctement et en conformité avec le fichier texte.

Page 103 sur 130
Figure n°4.3.2.3 : Formulaire d’insertion à partir d’un fichier texte
d. Importation à partir d’un fichier Excel
La figure 4.3.2.4 représente une feuille de tableur Excel contenant un

ensemble de données présentées selon l’ordre des colonnes de la table, dans
notre cas la table article. Pour les enregistrer dans la table, vous devez
enregistrer la feuille au format CSV puis choisir «CSV (séparateur : point-
virgule) » comme type de fichier. Vous obtenez un fichier avec
l’extension .csv, dont la structure est similaire à celle d’un fichier texte, le
séparateur choisi entre chaque champ étant ; La procédure d’insertion est la
même que pour un fichier texte ordinaire.

Page 104 sur 130
Figure n° 4.3.2.4 : La table article après insertion de données
V.3.3 Connexion à MySQL
Pour pouvoir traiter une base de données MySQL, depuis un script

PHP, il faut :
 Ouvrir une connexion vers le serveur MySQL, à l’aide de
mysql_connect() ;
 Sélectionner l’une des bases de données générées par
MySQL, avec mysql_select_db() ;
 Lancer des requêtes SQL vers une table à l’aide
mysql_query() ;
La gestion de mysql_connect() nécessite de bien organiser son travail. Cette

commande nécessite trois paramètres :
• Le nom de l’ordinateur hôte,
• Le nom de l’utilisateur, et  Son mot de
passe.
Si vous voulez accéder à une base de données en PHP, vous devez utiliser la
commande :
<?
$link=mysqlconnect("nom hôte :port", "nom utilisateur","mot de
passe") ;
?>
Nota :

Page 105 sur 130
 Aussi longtemps que vous testez vos bases de données en local,

ces paramètres sont les suivants : "localhost », "root" et
""
 Par la suite, il faut tenir compte des informations fournies par le
fournisseur d’accès
 Pour ne pas avoir à modifier des dizaines de pages au moment
où vous téléchargerez votre site PHP chez votre fournisseur, il
est conseillé de créer un fichier de connexion.
 A l’intérieur de ce fichier que vous pouvez baptiser
connexion.php, placez les instructions suivantes :
<?
$nom_hote="localhost";
$nom_utilisateur="root";
$password="" ;
$base="magasin";
$connexion=mysql_connect($nom_hote,$nom_utilisateur,$pass
word) or die ('impossible de se connecter a mysql'); $db =
mysql_select_db($base, $connexion);
?>
Vous pouvez ainsi, à l’intérieur de toutes vos pages exploitant MySQL,

placez la séquence suivante : include("connexion.php");
V.3.4 Affichage du contenu de la base de données
Le script suivant, affiche tous les enregistrements de la table client.
<!DOCTYPE html>
<html>
<head><title>Base de données</title></head>
<body> <?
php
include"connexion.php";
$table=mysql_query("SELECT * FROM
client"); echo"<table border=1>"; echo"<tr>";
echo"<td>Nom</td>"; echo"<td>Prenom</td>";
echo"<td>Adresse</td>"; echo"</tr>";
while($ligne=mysql_fetch_object($table)){

Page 106 sur 130
echo"<tr>"; echo"<td>$ligne->nom</td>";
echo"<td>$ligne->prenom</td>";
echo"<td>$ligne->adresse</td>";
echo"<tr>";
}
?>
</body>
</html>
L’exécution sur le serveur local donne le résultat suivant :
Figure n°4.3.4: Commande SELECT

Page 107 sur 130
V.3.5 Insertion de données dans des tables
Figure n°4.3.5: Formulaire de saisie
A défaut d’exploiter les possibilités indiquées précédemment pour insérer

des données dans différentes tables d’une base de données, nous allons
explorer ici l’utilisation d’un formulaire comme interface de saisie ; dont le
code pourrait ressembler à ceci :
<!DOCTYPE html>
<html>
<head>
<title>Saisissez vos coordonnées</title>
</head>
<body>
<form action="formulaire.php" method="post">
<fieldset>
<legend><b>Vos coordonnées</b></legend>
<table>
<tr><td>Nom:</td><td><input type="text"
name="nom" size="40" maxlength="30"/></td></tr>
<tr><td>Prenom:</td><td><input type="text"

Page 108 sur 130
name="prenom" size="40"
maxlength="30"/></td></tr>
<tr><td>Age:</td><td><input type="text"
name="age"
size="40" maxlength="2"/></td></tr>
<tr><td>Adresse:</td><td><input type="text"
name="adresse" size="40"
<tr><td>Ville:</td><td><input type="text"
name="ville" size="40"
<tr><td>Mail:</td><td><input type="text" name="mail"
size="40" maxlength="50"/></td></tr>
<tr><td><input type="submit"
value="Envoyer"/></td><td><input type="reset"
value="Effacer"/></td></tr>
</table>
</fieldset>
</form>
<?php
include"connexion.php";
if(!empty($_POST['nom'])&& !empty($_POST['adresse']) &&
!empty($_POST['ville']))
{
$id_client="\N";
$nom=$_POST['nom'];
$prenom=$_POST['prenom'];
$age=$_POST['age'];
$adresse=$_POST['adresse'];
$ville=$_POST['ville'];
$mail=$_POST['mail'];
$result=mysql_query("INSERT INTO client
VALUES('$id_client','$nom','$prenom','$age','$adresse',
'$ville','$mail')");
if(!$result)
{
echo"<script type=\"text/javascript\">
alert('Erreur')</script>";

Page 109 sur 130
}
else
{
echo"<script type=\"text/javascript\"> alert('Vous êtes
enregistré')</script>";
}
mysql_close();
}
else
{
echo"<h3>Formulaire à completer</h3>";
}
?>
</body></html>
V.3.6 Mise à jour d’une table
Un client doit pouvoir modifier ses coordonnées, comme son adresse de livraison
ou son e-mail. L’exemple ci-dessous
(formulaire_modification.html) crée une page contenant un formulaire qui permet
la saisie du code client dans une zone de texte HTML.
<!DOCTYPE html>
<html>
<head>
<title>Modifiez vos coordonnées</title>
</head>
<body>
<form action="modification.php" method="post">
<fieldset>
<legend><b>Saisissez votre code client pour modifier vos
coordonnées</b></legend>
<table><tbody>
<tr><td>Code client:</td>
<td><input type="text" name="id_client"
size="20" maxlength="10"/></td>
</tr>

Page 110 sur 130
<tr>
<td><input type="submit"
value="Modifier"/></td>
</tr></tbody>
</table>
</fieldset>
</form>
</body>
</html>
Figure n°4.3.6.1 : Page de saisie de code client
La mise à jour des données du client est réalisée par le script

modification.php. La première inclusion de code PHP renvoie le client vers la
page de saisie du code s’il a validé le formulaire sans avoir effectué de saisie.
La suite du fichier comporte deux parties distinctes. La première crée
dynamiquement un formulaire permettant la modification des données et la
seconde enregistre ces données dans la base.
<?php
if(empty($_POST['id_client'])){header("location:modification.html"
);}
?>
<!DOCTYPE html>
<html>
<head>
<title>Modifiez vos coordonnées</title>

Page 111 sur 130
</head>
<body>
<?php
include("connexion.php");
import_request_variables("P","_");
$result=mysql_query("SELECT * FROM client WHERE
id_client='$_id_client'");
$coord=mysql_fetch_row($result);
echo"<form action=\"modification.php\"
method=\"post\"
enctype=\"application/x-www-form-urlencoded\">";
echo"<fieldset>";
echo"<legend><b>Modifiez vos
coordonnées</b></legend>";
echo"<table>";
echo"<tr><td>Nom:</td><td><input
type=\"text\" name=\"nom\" size=\"40\"
maxlength=\"30\"
value=\"$coord[1]\"/></td></tr>";
echo"<tr><td>Prenom:</td><td><input
type=\"text\" name=\"prenom\" size=\"40\"
maxlength=\"30\"
echo"<tr><td>Age:</td><td><input type=\"text\"
name=\"age\" size=\"40\" maxlength=\"2\"
echo"<tr><td>Adresse:</td><td><input
type=\"text\" name=\"adresse\" size=\"40\"
maxlength=\"60\"
echo"<tr><td>Ville:</td><td><input type=\"text\"
name=\"ville\" size=\"40\" maxlength=\"40\"
echo"<tr><td>Mail:</td><td><input type=\"text\"
name=\"mail\" size=\"40\" maxlength=\"50\"
echo"<tr><td><input type=\"submit\"

Page 112 sur 130
value=\"Enregistrer\"
name=\"modif\"/></td><td><input type=\"reset\"
value=\"Effacer\"/></td></tr></table>";
echo"</fieldset>";
echo"<input type=\"hidden\" name=\"id_client\"
value=\"$_id_client\"/>";
echo"</form>";
if(isset($_POST['nom'])&&isset($_POST['adresse'])&&isset
($_POST['ville']))
{
$nom=$_POST['nom'];
$adresse=$_POST['adresse'];
$ville=$_POST['ville'];
$mail=$_POST['mail'];
$age=$_POST['age'];
$code=$_POST['id_client'];
$requete=mysql_query("UPDATE client SET
nom='$nom',adresse='$adresse',ville='$ville',
mail='$ail’,age='$age' WHERE id_client='$code'");
if(!$requete)
{
echo"<script type=\"text/javascript\">
alert('Erreur')</script>";
}
else
{
echo"<script type=\"text/javascript\"> alert('Vos
modification sont enregistrés');</script>";
}
}
else
{
echo"Modifier vos coordonnées !";
}
mysql_close();
?>
</body> </html>

Page 113 sur 130
Figure n° :4.3.6.2 : Formulaire de modification des coordonnées

IV.3.7 Recherche dans la base de données
L’exemple ci-dessous crée un formulaire classique permettant de saisir un

mot-clé et d’opérer des choix de tri des résultats. Les critères de tri selon le
prix, la catégorie ou l’identifiant d’article sont affichés sous formes de liste
déroulante. Le choix de l’ordre croissant ou décroissant s’effectue au moyen
de deux boutons radio ayant le même attribut name, ce qui les rend exclusifs
l’un de l’autre.
Le script contrôle d’abord que le visiteur a saisi un mot-clé dans le formulaire

en vérifiant que la variable $_POST[‘motcle’] n’est pas vide. Il récupère
ensuite le mot-clé, la catégorie, le critère de tri et l’ordre d’affichage,
respectivement dans les variables $mocle, $categorie, $ordre et $tri. Si la
catégorie choisie est "tous", la partie de la commande WHERE concernant
cette catégorie est vide. Pour les autres choix, elle est égale à "AND
categorie=$categorie".

Page 114 sur 130
<!DOCTYPE html>
<html>
<head>
<title>Rechercher un article dans le magasin</title>
</head>
<body>
<form action="recherche.php" method="post">
<fieldset>
<legend><b>Rechercher un article en
magasin</b></legend>
<table>
<tr><td>Mot clé:</td>
<td><input type="text" name="motcle" size="40"
maxlength="40"/></td>
</tr>
<tr><td>Dans la catégorie:</td>
<td><select name="categorie">
<option value="tous">Tous</option>
<option value="video">Vidéo</option>
<option
value="informatique">Informatique
</option>
<option value="photo">Photo</option>
<option value="divers">Divers</option>
</select></td></tr>
<tr><td>Trier par:</td>
<td><select name="tri">
<option value="prix">Prix</option>
<option
value="categorie">Categorie</option>
<option value="id_article">Code</option>
</select></td></tr>
<tr><td>En ordre:</td>
<td>Croissant<input type="radio" name="ordre"
value="ASC" checked="checked"/>
Décroissant<input type="radio" name="ordre"
value="DESC"/></td>

Page 115 sur 130
</tr>
<tr>
<td>Envoyer</td><td><input type="submit"
value="OK"/></td>
</tr>
</table>
</fieldset>
</form>
<?php
if(!empty($_POST['motcle']))
{
include("connexion.php");
$motcle=$_POST['motcle'];
$categorie=$_POST['categorie'];
$ordre=$_POST['ordre'];
$tri=$_POST['tri'];
$reqcategorie=($_POST['categorie']=="tous")?"":"AND
categorie='$categorie'";
$requete=mysql_query("SELECT id_article,designation,
prix,categorie FROM article WHERE
lower(designation)LIKE'%$motcle%'".$reqcategorie."
ORDER BY $tri $ordre");
echo"Les articles correspondant au motclé $motcle sont:";
echo"<table border=1 cellspacing=2>";
while($ligne=mysql_fetch_object($requete))
{
echo"<tr>";
echo"<th>$ligne->id_article</th>";
echo"<td>$ligne->designation</td>";
echo"<td>$ligne->prix</td>"; echo"<td>$ligne-
>categorie</td>"; echo"</tr>";
}
echo"</table>";
}
?>
</body>
</html>

Page 116 sur 130
Figure n° 4.3.7 : Formulaire de recherche et résultats obtenus
IV.3.7 INDEX
1. Code formulaire d’index (index.php)
<!DOCTYPE html>
<html>
<head>
<title>GESTION MAGASIN</title>
</title>
</head>
<body>
<frameset rows="16%, 84%" >
<frame name="Titre" src="titre.php" border="2" >
<frameset rows ="19%, 81%" >

Page 117 sur 130
<frame name="menu" src="menu.php" border="2" bgcolor="PINK" >
<frame name="Affichage" src="affichage.php" border="2" >
</frameset>
</frameset><noframes></noframes>
</html>
2. Code d’affichage du titre (titre.php)
<!DOCTYPE html>
<html>
<head>
<title>GESTION MAGASIN</title>
</head>
<body bgcolor="#0066CC">
<table boder="0" >
<tr>
<td with="2000" height="40" colspan="2"

bgcolor="#0066CC" bordercolor="#0066CC"
valign="middle"><marquee width="100%" bgcolor=" "
scrollamount="4%" behavior="alternate"><font size="6’" color="#FFBB99"
face="comic sans ms"><b>BIENVENUE A LA GESTION DE MAGASIN
</b></font></marquee></td>
</tr>
</table>
</body >
</html>
3. Code d’affichage du menu (menu.php)
<!DOCTYPE html>
<html>

Page 118 sur 130
<head>
<style>
A: visited {color: "black;"}
A: hover {color: "yellow;"}
</style>
<titre>menu principal</title>
</head>
<body bgcolor="#99CCDD" bordecolor=" ">
<h3 align="center"><font color="#BBGGBB" face="arial black"><u>menu

principal</u></font></h3>
<a href="saisie.php" target="Affichage">saisie des sections</a><br>
<a href="modification.php" target="Affichage">modification des

articles</a><br>
<a href="recherche.php" target="Affichage">recherche d’articles</a><br>
<a href="suppression.php" target="Affichage">suppression des

d’articles</a><br>
<a href="affichage.php" target="Affichage">liste de tous les

clients</a><br>
</body >
</html>
IV.4 Deuxième étude de cas : Gestion des sections (ISC-Bandundu)
Dans le souci de moderniser et redorer l’image de l’Institut Supérieur de

Commerce de Bandundu, le Secrétaire Général Académique, demande aux
étudiants finalistes du premier cycle de graduat en informatique de gestion, de

Page 119 sur 130
développer une application web dynamique capable d’assurer la gestion des

informations relatives aux différentes sections opérationnelles au sein dudit
Institut, afin de répondre présent aux phénomènes de délocalisation des
services et de dématérialisation des documents qui caractérisent l’humanité
tout entière.
Les informations élémentaires par section sont les suivantes :
 Code de la section (codesection, text 2) ;

 Intitulé de la section (intule, text 25) ;
 Vacation de la section (vacation, text 25) ;
 Spécialité de la section (specialite, text 25) ;
 Nom du chef de section (chef, text 25) ;
 Nombre d’années de formation (bombrannee, int 2) ;
 Nombre de classes (nombreclasse, int 2) ;  Remarques ou
observations (remarque, text 50).
Il importe de signaler que cette application doit permettre à l’aide d’un menu
principal, la réalisation des opérations ci-après : (saisie, modification,
suppression, édition et recherche) et doit être réalisée en PHP avec
l’utilisation de PDO (PHP Data Object) pour se connecter à la base de
données.

Page 120 sur 130
SIXIEME CHAPITRE : EDITEUR WYSIWYG DREAMWEAVER
Un site web représente un tout pour une entreprise, une organisation ou un

individu. C’est un moyen moderne pour se faire connaître ou faire son
marketing à l’échelle mondiale. Pour créer un site web, le webmaster dispose
de trois choix possibles :
 Ecrire ses propres codes HTML ;

 Utiliser un éditeur WYSIWYG (What You See Is What
You Get), comme le Dreamwearver;
 Utiliser un CMS (Contenu Management System), comme
le Joomla.
 Utiliser un framwork comme symphony.
Au terme du troisième chapitre de ce support, l’étudiant dispose déjà de pas

mal d’outils en main pour créer son propre site web dynamique. Ce chapitre
donne quelques conseils pratiques et indique comment créer une application
web sans toutefois écrire un seul code.
VI.1 Organisation et planification
Créer un site demande du temps et de l’énergie. Il vaut mieux bien réfléchir

avant de se jeter à l’eau pour s’apercevoir des jours plus tard, que vous
pouvez tout refaire à cause d’une erreur ou d’un oubli à la base.
A. Contenu et structure
Dressez la liste de ce dont vous souhaitez parlez. Le type et la quantité de
sujets à présenter auront un impact sur la structure et aussi sur l’apparence du
site. Vous n’utiliserez pas les mêmes couleurs, ni les mêmes images, etc. On
parle de « l’architecture » d’un site web pour une bonne raison : un site est
construit comme un bâtiment, avec des pièces plus ou moins bien situées, plus
ou moins faciles d’accès et plus ou moins belles.
Comme un architecte, le webmaster construit le site en fonction de l’usage

auquel il est destiné. Il faut rendre le site accessible, en faisant preuve de bon
sens. Voici en vrac, quelques pistes à méditer une fois que vous savez ce que
vous voulez mettre dans votre site :
• Qu’est ce qui est plus important ? Est-ce visible, facile d’accès ?

• Comment le rendre encore plus facile d’accès ?

Page 121 sur 130
• La navigation est-elle intuitive ? Les noms des liens sont-ils

explicitent ? Faciles à trouver ?
• Quelle taille de texte utiliser ? Quelle couleur ? Pour que cela soit
facile à lire. On tombe encore souvent sur des sites dont les couleurs
d’arrière et de premier plan rendent le texte absolument illisible.
Utilisez des couleurs assez contrastées entre le texte et le fond.
• Quelle taille donner aux images ?
B. Look
Imaginez le look, l’apparence de votre site. Vous aurez beaucoup de mal à
créer quelque chose si vous ne savez pas un peu ce à quoi il doit ressembler.
Rien ne vous oblige à faire un site très graphique, d’ailleurs, mais il vaut
mieux être certain de savoir ce que vous voulez. Encore une fois, pour éviter
de tout recommencer à mi-chemin.
C. Charte graphique
Derrière cette expression sérieuse se cache une idée toute simple : pour vos
visiteurs, le site est un tout. Si sur votre page d’accueil, le menu est sur une
colonne à gauche, le visiteur est en droit de s’attendre à le trouver au même
endroit sur toutes les pages du site, et de trouver les liens affichés dans le
même ordre, de la même façon. La remarque vaut aussi pour l’apparence
graphique du site, les couleurs utilisées, le logo.
D. Dossier du travail
Un site se comporte rarement d’une seule page web. Il y a plusieurs pages,

des fichiers à télécharger, des photos, etc. si vous n’organisez pas au
minimum les documents, ça sera vite ingérable. Il n’y a pas une bonne façon
de faire, nous conseillons de placer les pages HTML à la racine du site. Les
photos et toutes les images sont rangées dans un dossier nommé (images). Les
téléchargements dans un dossier téléchargements, etc. si vous affichez de
nombreuses galeries de photos, vous pouvez envisager de les organiser en
sous-dossiers.
VI.2 Mettre en ligne
Pour que vos pages web soient visibles sur internet, vous devez les télécharger
sur votre serveur. Le FTP (File Transfert Protocole), ou protocole de transfert
de fichier, comme son nom l’indique, il suffira justement de faire çà. En

Page 122 sur 130
anglais, copier sur le serveur ça s’appelle upload, en opposition à download

qui consiste à présent à prendre du serveur pour copier sur votre ordinateur.
A. Quoi télécharger ?
Tout ce qui est utilisé dans votre site web :
• Les pages HTML ;
• Les pages PHP ;
• Les pages Javascript ;
• Les feuilles de styles CSS ;
• Les images ;
• Les sons ;
• Les vidéos ;
• Etc.
Si vous ne copiez pas les photos sur le serveur, elles ne s’afficheront pas. En
plus des fichiers, vous devez aussi télécharger les dossiers que vous avez pu
utiliser pour les organiser. Si non vos chemins d’accès ne fonctionneront plus.
B. Utilisation du FTP
Voici comment faire avec Internet Explorer.

• Tapez l’adresse FTP de votre serveur dans la barre d’adresse de
n’importe quelle fenêtre de l’Explorateur de Windows et appuyez
sur la touche Enter.
• Vous recevrez soit un message d’erreur.
• Dans ce cas, validez et allez dans Fichier |Se connecter entant que
• Sur la fenêtre à présent ouverte, tapez votre login et votre mot de
passe et appuyez sur Ouvrir une session. Après quelques instants,
vous affichez le contenu de votre serveur. Si nécessaire ouvrez le
dossier racine de votre site (consultez le doc de votre hébergeur)
• A présent vous pouvez copier vos fichiers et dossiers locaux vers le
serveur, ou l’inverse par simple glissée-déplacer.

Page 123 sur 130
VI.3 Présentation de Dreamweaver
A. Lancement de Dreamweaver
Pour lancer Dreamweaver, la procédure est la suivante :
• Cliquez sur Démarrer + Tous les programmes ;

• Cliquez sur Macromedia + Macromedia Dreamweaver8
Figure n°5.3.1: Fenêtre de lancement de Dreamweaver

Page 124 sur 130
La figure 4.3.1 montre que vous avez la possibilité de créer un document

HTML. En cliquant sur l’onglet HTML, la fenêtre suivante apparaît :
Figure n°5.3.2: Fenêtre de création de Dreamweaver
La fenêtre de Dreamweaver est constituée, entre autre de :
 La barre de titre ;
 La barre de menu (Fichier, Edition, Affichage, Insertion, Modifier,
Texte, Commandes, Site, Fenêtre, Aide) ;
 La barre des onglets (Insertion, Commun, M. en forme, Texte,
Tableaux, Cadres, Formulaires, Modèles, Caractères, Médias, Entête,
Scripts, Application) ;
 La fenêtre du document (page XHTML) ;
 La barre de mise en forme ;
 Espace d’organisation des pages en site.
Nota : remarquons que la fenêtre du document est fractionnée en deux parties :
• Code et
• Création

Page 125 sur 130
B. Création d’un document
La création d’un document XHTML se fait la plus simplement possible. Il

suffit de saisir le texte dans la fenêtre du document (partie blanche). La mise
en forme du document se fait comme on a l’habitude de le faire en Word.
Figure n°4.3.3 : Exemple d’un document en Dreamweaver
C. Aperçu d’un document Dreamweaver sur le navigateur
Pour voir la présentation d’un document Dreamweaver sur Internet Explorer,

par exemple, il suffit d’appuyer sur la touche de fonction F12 du clavier ou
cliquez sur Aperçu dans le navigateur ou encore cliquez sur Fichier + Aperçu
dans le navigateur.

Page 126 sur 130
D. Propriétés de la page
Pour définir les différentes propriétés d’une page XHTML (Titre, Image
d’arrière-plan, couleurs, …..), cliquez sur Modifier + Propriétés de la page ou
Ctrl+J.
VI.4 Création d’un site
A. Définir localement l’emplacement d’un site
Pour que Dreamweaver puisse stocker les différents éléments qui composent
le site (fichiers, images, sons, etc.), vous devez créer un dossier sur votre
ordinateur :
1. Cliquez sur Site + Nouveau

2. Tapez le nom du nouveau site, par exemple SiteExemple (cfr figure
5.4.1)
3. Cliquez sur Suivant
4. Si vous désirez utiliser une technologie de serveur particulière,
cliquez sur Oui ….. Sinon, cliquez sur Non
5. Si vous avez coché Oui à l’étape 4, sélectionnez le type de
technologie dans cette liste
7. Sauf pour les cas particuliers d’utilisation d’un réseau local, lisez
l’option Modifier les copies locales sur ma machine … cochée
8. Cliquez sur l’icône du dossier pour choisir le dossier du site
9. Sélectionnez dans cette zone le dossier du site
10. Cliquez sur sélectionner
11. Cliquez sur Suivant dans la boite de dialogue Définition du site
pour…
12. Cliquez sur la liste, puis sélectionnez le type de connexion avec le
serveur distant (généralement FTP)
13. Tapez les renseignements nécessaires à la connexion
15. Sauf si plusieurs personnes modifient les pages du site, laissez
l’option Non …. Sélectionnez
17. Cliquez sur l’onglet Avancé
18. Cliquez sur une catégorie dans cette liste

Page 127 sur 130
19. Modifiez les options correspondantes dans cette zone

20. Cliquez sur OK
Figure n°5.3.4 : Etape 1 de la création d’un site avec Dreamweaver
B. Création d’une page modèle

Pour faciliter la création d’un site et surtout préserver la charte graphique, il
est conseillé de mettre au point un modèle. Tout le reste des pages web partira
de cette page modèle. Pour ce faire, il faut procéder comme suit :
• Cliquez sur le menu Fichier + Nouveau

• Enregistrez le fichier en lui donnant, par exemple le nom modele.dwt (cfr
figure 5.3.5)

Page 128 sur 130
Figure n°5.3.5 : Exemple de modèle
C. Pages du site
Vous pouvez maintenant partir du fichier modele.dwt pour construire toutes
les pages de votre site web. Les figures 5.3.6 et 5.3.7 en sont une bonne
illustration. Les liens entre les pages, la création de formulaires, l’insertion
des images, etc., peuvent se faire le plus facilement possible. Il est aussi
possible de créer un fichier CSS externe.

Page 129 sur 130
Figure n°5.3.6 : Page d’accueil
Figure n°5.3.7 : Page de contact

Page 130 sur 130
CONCLUSION
Nous venons de passer en revue la programmation orientée client/serveur,

avec un accent soutenu sur le langage de script PHP, appuyé par des exemples
et deux études de cas. Cette démarche a consisté à permettre aux étudiants
finalistes du premier cycle en informatique de gestion de migrer leurs
applications desktop vers l’environnement web afin de répondre présents au
phénomène de la délocalisation des services engendré par la mondialisation.
Le deuxième langage clé utilisé dans cet environnement, à savoir le HTML

(HyperText Markup language) a été d’une extrême pertinence dans le cadre
de ce cours, dans la mesure où actuellement, la majeure partie de
l’information disponible sur le web est stockée dans des documents à l’aide de
ce langage, qui se révèle comme un outil par excellence pour faire la
présentation des organisations sur le web.
Quant au troisième langage JAVASCRIPT, les étudiants ont uniquement reçu

des pistes de recherche, étant donne’ le temps imparti pour ce cours.
A travers ce cours, notre souci majeur était celui de permettre aux étudiants de
troisième année graduat en informatique de gestion de rester à jour dans leur
domaine en dépit de l’évolution sans cesse croissante des technologies de
l’information et de la communication. Nous espérons que le
support de ce cours de langage de programmation PHP vous sera utile dans
votre cursus universitaire.
D’autres aspects non abordés dans ce support continueront à faire l’objet de

recherches et pourront être intégrés dans les versions qui suivront.
BIMA LEMINDE ALI-NGAKONG Glody.

Chef de travaux

Langage de Programmation 3 (PHP) Edition 2022

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Langage de Programmation 3 (PHP) Edition 2022

Transféré par

Droits d'auteur :

Formats disponibles

Page 1 sur 130

BIMA LEMINDE ALI-NGAKONG Glody

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

« La science n’est pas assise autour d’un

Une pensée pieuse au Professeur Emérite :

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

[5] Saint-Jean Djungu., outils et langages du web n.0, Ed. Médiaspaul,

[2] BIMA LEMINDE G., Technique des bases de données, UNIC-Kin, G3

[3] MUKENGE MBUMBA J., Cours de langage xml, l1 info – ISC-KIN,

c) Sites web visités

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

TABLE DES MATIERES

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

II.7.1 Fonctions pour déterminer le type d’une variable........................................44

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

CINQUIEME CHAPITRE : ACCES AUX BASES DE DONNEES MySQL.............88

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

Ce support de « LANGAGE DE PROGRAMMATION PHP » du Chef de

▪ Si ce document est reproduit pour les besoins personnels du

▪ Si ce document est reproduit dans le but d’être distribué à des tierces

Copyright © 2022 CT. BIMA LEMINDE ALI-NGAKONG Glody; all

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

De nos jours, le monde connait des avancées très significatives dans le

L’informatisation est le phénomène le plus important de notre époque. Elle

Le phénomène de délocalisation des services a le plus touché les grandes

Il existe une ribambelle de langages de programmation orientés client-serveur

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

langage est associé au HTML (HyperText markup language) qui va tourner

Les différentes démonstrations utilisées dans ce support sont réalisées grâce

Ainsi, ce support de six (6) chapitres présente d’une façon succincte et

• Le premier chapitre présente le langage PHP dans sa généralité ;

L’étudiant qui aura suivi et maitrisé ce cours sera en mesure :

 D’avoir des notions générales sur le fonctionnement de

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

 De développer des bases de données Web et des applications

Le cours sera dispensé en appliquant la méthode interro-active ; donc

L’évaluation se fera en trois temps :

BIMA LEMINDE ALI-NGAKONG Glody.

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

PREMIER CHAPITRE : GENREALITES SUR LE LANGAGE PHP

Le présent chapitre tient à clarifier les concepts de base relatifs à la

 Présentation du langage PHP ;

I.1 Présentation du langage PHP

Le langage PHP (historiquement Personal home page, officiellement

Il a été conçu pour permettre la création d’applications dynamiques, le plus

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

La force la plus évidente de ce langage est qu’il a permis au fil du temps la

Il est multiplateforme : autant sur Linux qu’avec Windows il permet

I.2 Historique du langage PHP

Contrairement à d’autres langages comme : le C, le C++, le Java et le

 En 1994, Rasmus Lerdorf a conçu un langage de script interfaçant le

 En 1998, Zeev Suraski et Andi Gutsman s’associent à Rasmus Lerdorf

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

 En 2004, sera publiée la première version stable de PHP 5 ; Une année

▪ Actuellement, le langage PHP est en sa version 8.0.0 publiée le 26

I.3 Principes du langage PHP

La consultation d’une adresse de site (URL) depuis un navigateur (client),

Les requêtes clients se font à partir de fichier HTML ou PHP (extension.

I.4. Positionnement face aux autres langages

COURS DE LANGAGE DE PROGRAMMATION 3 (PHP) || CT. Glody BIMA LEMINDE

ASP : Technologie de Microsoft très similaire, utilisant un