Vous êtes sur la page 1sur 37

 

COURS DE PHP 
 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                 
PHP/MySQL 

I. Introduction 
I.1. Qu'est ce que PHP? 
Mis  au  point  en  1994  par  Rasmus  Lerdorf  pour  publier  son  CV  en  ligne  mais  surtout 
conserver  la  trace  des  visiteurs  qui  venaient  sur  son  site  consulter  son  CV,  PHP  est  un 
langage  de  script  coté  serveur.  Grace  au  succès  de  son  code  sympathique,  et  suite  aux 
demandes  multiples    des  internautes,  Rasmus  mis  en  ligne  1995  une  première  version  de 
son programme qu’il nomma Personal Sommaire Page Tools puis Personal Home Page v1.0 
(d’où le nom PHP).  
Le  succès  de  PHP  1.0  conduit  à  l’amélioration  et  à  l’intégration  progressive  de  plusieurs 
fonctionnalités à son code ; bref à une aventure passionnante qui ne cesse d’embarquer de 
plus en plus personnes.  
PHP dont la nouvelle définition est l’acronyme récursif : " PHP Hypertext Preprocessor" est 
devenu en quelques années un langage de programmation de référence utilisé sur plusieurs 
millions de sites web à travers le monde.  
PHP est un langage Open Source, spécialement conçu pour le développement d'applications 
web  mais  utilisable  à  d’autres  fins.  C’est  un  langage  interprété  dont  la  syntaxe  provient 
surtout de celle du langage C mais aussi de celles de Perl et de Java. PHP est sensible à la 
casse et s’intègre aussi facilement au HTML que le JavaScript. 
 
Les principaux atouts de PHP sont : 
• La gratuité et la disponibilité de son code source (PHP est distribué sous licence GNU 
GPL) 
• La simplicité d’écriture de scripts. PHP est très simple pour le néophyte mais offre des 
fonctionnalités avancées pour les experts 
• La possibilité d’inclure directement du code PHP dans du code HTML, contrairement 
aux scripts CGI 
• La  simplicité  d’interfaçage  avec  des  bases  de  données  (de  nombreux  SGBD  sont 
supportés, mais le plus utilisé est MySQL, un SGBD gratuit et disponible sur plusieurs 
plateformes. 
• L’intégration au sein de plusieurs serveurs web (Apache, IIS, etc.) 
• Une  grande  communauté  (ouverte)  de  programmeurs  travaille  à  corriger,  à  faire 
évoluer et à sécuriser le code. 
 
I.2. Que peut faire PHP? 
Une réponse à peine osée serait de dire "Tout". En effet, PHP est principalement conçu pour 
servir de langage de script coté serveur, ce qui fait qu'il est capable de réaliser tout ce qu'un 
script  CGI  quelconque  peut  faire,  comme  collecter  des  données  de  formulaire,  générer  du 
contenu dynamique, ou gérer des cookies. Mais PHP peut en faire bien plus. Exemple : 
• Langage  de  programmation  en  ligne  de  commande.  Vous  pouvez  écrire  des  scripts 
PHP  et  les  exécuter  en  ligne  de  commande,  sans  l'aide  d’un  serveur  web  et  d'un 
navigateur. Il vous suffit de disposer de l'exécutable PHP. Cette utilisation est idéale 
pour les scripts qui sont exécutés régulièrement (avec un cron sous  Unix ou Linux), 
ou  un  Task  Scheduler  (sous  Windows).  Ces  scripts  peuvent  aussi  être  utilisés  pour 
réaliser des opérations sur des fichiers texte. 
• Ecrire  des  applications  clientes  graphiques.  PHP  n'est  probablement  pas  le  meilleur 
langage pour écrire des applications clientes graphiques, mais si vous connaissez bien 
PHP  et  que  vous  souhaitez  exploiter  des  fonctionnalités  avancées  dans  vos 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                1 

 
PHP/MySQL 

applications clientes, vous pouvez utiliser PHP−GTK pour écrire de tels programmes. 
Vous avez aussi la possibilité d'écrire des applications très portables avec ce langage. 
PHP−GTK est une extension de PHP, qui n'est pas fournie dans la distribution de base. 
• Génération d’images, d’animations flash, et de fichiers PDF. 
• Support  de  nombreux  protocoles  (LDAP,  IMAP,  SNMP,  MNTP,  POP3,  HTTP,  COM  et 
encore d’autres) 
• Disponibilité  de  fonctionnalités  extrêmement  utiles  pour  le  traitement  de  texte, 
allant  des  expressions  régulières  POSIX  étendue  ou  Perl  aux  traitements  de  fichiers 
XML, avec les standards SAX et DOM. 
• Etc. 
Pour la majorité des serveurs web, PHP fonctionne comme module, mais pour d'autres, il 
fonctionne comme exécutable CGI. 
 
I.3. Implantation / Interprétation 
Un  script  PHP  est  un  simple  fichier  texte  (caractères  ASCII  7  bits).  Le  code  PHP  est 
délimité par des balises spécifiques et est généralement incluse dans du code HTML avec 
lequel  il  se  marie  parfaitement.  Ce  fichier  qui  est  stocké  sur  un  serveur  web  doit  avoir 
une extension ".php" pour être reconnu comme tel et être interprété. 
Lorsqu’un client fait une requête de demande d’une page PHP via un navigateur, la page 
ne lui est transférée. Elle est interprétée coté serveur par un module PHP (interpréteur) 
et  si  nécessaire  un  code  HTML  est  généré  et  transmis  au  navigateur.  C’est  pour  cette 
raison  que  vous  ne  verrez  jamais  le  code  source  d’une  page  PHP  en  demandant 
l’affichage de sa source depuis le navigateur. 
 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                2 

 
PHP/MySQL 

II. Bases du langage 
 

II.1. Balises de PHP  
Le  code  PHP  est  délimité  par  une  paire  de  balises  (une  balise  ouvrante  et  une  balise 
fermante). On parle de balise de début et balise de fin. 
On distingue plusieurs formes de basiles mais une seule de ces formes est recommandé 
pour raisons de compatibilité.  
• <?php   …   ?> 
• <?    …   ?> 
• <script language="php">   …   </script> 
• <%   …   %> 
C’est la première forme qu’il est recommandé d’utiliser. 
 

Exemple : 
< ?php  
  echo "Mon premier code php !" ; 
?> 
 

II.2. Séparateur d’instruction 
Comme  dans  la  plupart  des  langages,  en  PHP  chaque  instruction  se  termine  par  un  point 
virgule.  Toutefois,  la  dernière  instruction  avant  la  balise  de  fin  n’a  pas  besoin  de  point 
virgule. 
 
II.3. Commentaires  
Les commentaires en PHP héritent des commentaires du C++ et du shell Unix. Ainsi on a :  
//     permet de commenter une ligne ou une partie d’une ligne 
#     a le même effet de commentaire que le // 
/* … */   permet de commenter un bloc de code qui peut s’étendre sur plusieurs lignes. 
 
Exemple : 
<?php
echo "Première ligne<br/>"; //un commentaire sur une ligne comme en C++
/* un commentaire sur plusieurs lignes,
comme en C et C++ */
echo "Seconde ligne";
echo "<br/>Enfin, je m’arrête"; #un commentaire comme en Shell Unix
?> 
  
II.4. Types 
PHP supporte les  types basiques suivants : 
Types scalaires  
• booléen 
• entier 
• nombre à virgule flottante 
• chaîne de caractères 
Types composés 
• tableau 
• objet 
Types spéciaux  
• ressource 
• null 
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                3 

 
PHP/MySQL 

Il existe aussi un type appelé mixed qui est un pseudo‐type qui indique le paramètre peut 
indifféremment prendre plusieurs types. 
 

o Un  booléen  a  pour  valeur  vrai  ou  faux  et  est  exprimé  par  l’une  des  deux  valeurs 
constantes  TRUE  ou  FALSE.  Le  chiffre  0,  le  réel  0.0,  la  chaine  vide,  la  chaine  "0",  la 
constante  NULL,  correspondent  aussi  à  FALSE ;  et  toutes  autres  valeurs  correspond  à 
TRUE. 
o Un entier est un nombre de l’ensemble des entiers naturels. Il est possible de spécifier 
les  nombres  entiers  en  décimale  (base  10),  hexadécimale  (base  16),  octale  (base  8) 
éventuellement précédé du signe moins (‐). 
Pour  la  notation  octale,  vous  devez  préfixer  le  nombre  avec  un  zéro;  pour  la  notation 
hexadécimale, vous devez préfixer le nombre avec 0x. 
 

Exemple : 
<?php
$a = 1234; # nombre entier en base 10
$a = -123; # nombre entier négatif
$a = 0123; # nombre entier en base 8, (équivalent à 83 en base 10)
$a = 0x12; # nombre entier en base 16, (équivalent à 18 en base 10)
?> 
 

o Les  nombres  à  virgule  flottante  (nombre  réels)  peuvent  être  spécifiés  en  utilisant 
plusieurs  syntaxes.  
Exemple :
<?php
$a = 1.234;
$a = 1.2e3;
$b = .9 ;
?>
 

o Les  chaînes  de  caractères  sont  des  séquences  de  caractères.  Une  chaîne  peut  être 
spécifiée de trois manières différentes :  
− guillemets simples 
− guillemets doubles 
− syntaxe HereDoc 
Exemples : 
 
<?php
$str1 = ’Ceci est une chaîne simple’;
$str2 = "ceci est une autre chaîne " ;

$str3 = <<<EOD
Exemple de chaîne
s’étalant sur
plusieurs lignes
avec la syntaxe heredoc
EOD;
?>
 

Nota : Lorsqu’une chaîne est spécifiée avec des guillemets doubles, ou en utilisant la syntaxe 
heredoc, les variables qu’elle contient sont remplacées par leur valeur. 
 

Exemple : 
<?php
$outil = "ordinateur";
Echo 'un $outil par table<br/>' ;
echo "Un $outil pour deux étudiants!<br/>";
echo "Tous les ${outil}s sont occupés au cours de PHP !";

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                4 

 
PHP/MySQL 

?>
Les  caractères  d’une  chaîne  sont  accessibles  en  spécifiant  leur  offset  (le  premier  caractère 
est  d’offset  0)  entre  accolade,  après  le  nom  de  la  variable.  Pour  assurer  la  compatibilité 
ascendante, il est toujours possible d’accéder aux caractères avec des crochets. 
Exemple : 
<?php
$str = ’Ceci est un test.’;
$first = $str{0};
$second = $str[1];
?>
 
Pour les autres types, nous allons y revenir plus tard. 
 
II.5. Identificateur 
Un identificateur est un mot qui sert à désigner ou à nommer (telle des étiquettes) certains 
éléments  et  concepts  du  langage  de  programme  (les  variables,  les  constantes,  les 
procédures,  les  fonctions,  et  les  programmes).  En  règle  générale,  c’est  une  chaîne  de 
caractères  alphanumérique  +  le  caractère  sous  tiret.  Il  commence  par  une  lettre  de 
l’alphabet ou par le sous tiret, suivie d’une combinaison quelconque de lettres, de chiffres et 
de sous tiret. Les mots clés réservés  ne peuvent pas être utilisés comme identificateurs. 
 
II.6. Constantes 
Une constante est un identifiant (un nom) qui représente une valeur simple dont la valeur ne 
change plus une fois définie. Les constantes magiques __FILE__ et __LINE__ sont les seules 
exceptions.  
Comme leur nom le suggère, cette valeur ne peut jamais être modifiée durant l’exécution du 
script. Les noms des constantes ne commencent pas par le signe ($) et par convention, les 
constantes sont toujours en majuscules. Les constantes sont accessibles de manière globale. 
La  syntaxe  de  déclaration  d’une  constante  en  PHP  se  fait  avec  la  fonction  define()  de  la 
manière suivante :  
Syntaxe :  
define(string NOM_CONSTANTE, mixed valeur, case_sensitive=TRUE);
 
Exemple :  
define("PI", 3.14);
define("MESSAGE","Bonjour le Monde") ;
 
En  dehors  des  constantes  définies  par  l’utilisateur  il  existe  des  constantes  prédéfinies.  On 
peut citer : 
__FILE__      TRUE          E_PARSE 
__LINE__      FALSE          E_NOTICE 
PHP_VERSION      E_ERROR        E_ALL 
PHP_OS       E_WARNING 
 
II.7. Variables 
Le  langage  PHP  n’est  pas  un  langage  fortement  typé.  A  la  déclaration  d’une  variable,  son 
type n’est pas précisé. C’est l’assignation qui impose un type une variable, et ce type peut 
changer d’une assignation à une autre.  
A partir de PHP4, une variable peut être aussi bien assignée par valeur que par référence.  
Le nom d’une variable PHP s’écrit avec le symbole $ suivi de l’identificateur de la variable. Le 
nom est sensible à la casse. 
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                5 

 
PHP/MySQL 

 
Syntaxe : 
  $nom_variable ; 
Mais en règle générale la définition d’une variable est suivie d’une assignation. 
  $nom_variable  = valeur; 
 
Exemple 1: 
<?php
$reel = 0.3;
$entier = 22;
$chaine = "tout le monde !";
$phrase1 = "Bonjour $chaine !";
$phrase2 = "Bonjour" .$chaine ."!" ;
$phrase3 = 'Bonjour $chaine !';
?>

En imprimant le contenu de chacune de ces variables, on  aura comme affichage :  
0.3
22
tout le monde !
Bonjour tout le monde !
Bonjour tout le monde !
Bonjour $chaine !

Exemple 2 : 
<?php
$chaine1 = "Bonjour";
$chaine2 = &$chaine1; //$chaine2, Rréférence sur $chaine1.
$chaine2 = "$chaine2 tout le monde !";
?>
L’impression  des contenus de ces variables donnent cette fois‐ci la même chose ; i.e. 
Bonjour tout le monde !
Bonjour tout le monde !

En  dehors  des  variables  définies  par  l’utilisateur,  PHP  mes à  disposition  plusieurs  variables 
pré‐définies.  Mais plusieurs de ces variables dépendent du serveur sur lequel elles
tournent, de sa version et de sa configuration ou encore d'autres facteurs. De même,
certaines de ces variables ne sont pas accessibles en ligne de commande.
A partir de sa version 4.1.0, PHP met à disposition un ensemble de tableaux pré-définis,
automatiquement disponibles et visibles quelque soit le contexte. On les appelle des
variables super-globales.

Les variables super‐globales sont :  
$GLOBALS   : Référence toutes les variables disponibles dans un contexte global 
$_SERVER   : Variables de serveur et d'exécution 
$_GET    : Variables HTTP GET 
$_POST   : Variables HTTP POST 
$_FILES   : Variable de téléchargement (upload) de fichier via HTTP 
$_COOKIE   : Cookies HTTP 
$_SESSION   : Variables de session 
$_REQUEST   : Variables de requête HTTP 
$_ENV   : Variables d'environnement  
  etc. 
 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                6 

 
PHP/MySQL 

Variables Apache 
  Ces variables sont créées par le serveur Apache ; donc ne sont utilisables que lorsque 
le serveur Web est Apache.  
$SERVER_NAME 
$DOCUMENT_ROOT 
$HTTP_REFERER 
$REMOTE_ADDR 
$REMOTE_PORT 
etc. 
Mes aujourd’hui la plupart de ces variables sont obsolètes et sont accessibles via la tableau 
associatif $_SERVER. 
 
II.8. Les Tableaux 
Un  tableau  est  une  suite  de  valeurs  référencées  par  une  unique  variable.  PHP  gère 
dynamiquement  la  taille  des  tableaux.  Contrairement  à  ce  qu’on  observe  dans  plusieurs 
langages de programmation, le contenu d’un tableau en PHP peut être mixte sans problème.  
Les tableaux en PHP peuvent être soit indicés (les valeurs sont référencées par leur position 
en débutant à 0), soit associatifs (les valeurs sont référencées par des noms). 
Tableaux indicés 
 

$tab[0] = "élément 1" ; 
$tab[1] = "élément 2" ; 
$tab[2] = 12 ; 
 

On peut aussi faire de l’affectation automatique 
$tab[] = "élément 1" ;   //correspond à $tab[0]="élément 1" 
$tab[] = "élément 2" ; 
$tab[] = 12 ; 
 
En outre, la fonction array() offre un moyen d’initialiser facilement un tableau en les indiçant 
respectivement par 0, 1, etc. les éléments du tableau. 
$tab = array("éléments 1", "élément 2", 12) ; 
 
Tableaux associatifs 
Dans  un  tableau  associatif  les  indices,  au  lieu  d’être  numériques,  sont  des  chaines  de 
caractères. 
$mes["voiture"] = "BMW" ; 
$mes["filiere"] = "IIR" ; 
$mes["sport"] = "marche" ; 
Ou encore 
$mes = array ("voiture" => "BMW", 
         "filiere" => "IIR", 
         "sport" =>"marche") ; 
 
Tableaux multidimensionnels  
Les  tableaux  indicés  et  associatifs  se  généralisent  aux  tableaux  multidimensionnels,  pour 
lesquels l’indice ou la clé, est constituée de plusieurs valeurs (chacune des valeurs est entre 
crochets). 
Un tableau multidimensionnel est au fait un tableau de tableaux. 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                7 

 
PHP/MySQL 

 
Exemples : 
$tab[0][0] = "En haut à gauche" ; 
$tab[0][1] = "En haut à droite"; 
$tab[1][0] = "En bas à gauche"; 
$tab[1][1] = "En bas à droite"; 
 

$mes = array( 
"un" => array("premier","second"), 
"deux" => array("premier","second"), 
"trois" => array("premier","second")) ; 
 
II.9. Opérateurs 
II.9.1. Les opérateurs arithmétiques 
 

Opérateur  Exemple  Nom  Résultat 


‐  ‐$a  Négation  Opposé de $a. 
+  $a + $b  Addition  Somme de $a et $b. 
‐  $a ‐ $b  Soustraction  Différence de $a et $b.  
*  $a * $b  Multiplication  Produit de $a et $b. 
/  $a / $b  Division  Quotient de $a et $b.  
%  $a % $b  Modulo  Reste de $a divisé par $b. 
 

L'opérateur de division ("/") retourne une valeur entière (le résultat d'une division entière) si 
les deux opérandes sont entiers. 
 

II.9.2. Les opérateurs d'assignation 
Assignation simple  
=  opérateur simple d’affectation  
Opérateur associatifs ou opérateurs combinés 
Opérateur  Exemple  Equivalence 
+=  $x += $y  $x = $x + $y 
‐=  $x ‐= $y  $x = $x ‐ $y 
*=  $x *= $y  $x = $x * $y 
/=  $x /= $y  $x = $x / $y 
%=  $x %= $y  $x = $x % $y 
.=  $x .= $y  $x = $x . $y 
 

II.9.3. Opérateurs de comparaison 
 

Opérateur  Exemple  Nom  Résultat 


==  $a == $b  Egal  TRUE si $a est égal à $b. 
===  $a ===  Identique  TRUE si $a est égal à $b et qu'ils sont de même type  
$b 
!=  $a != $b  Différent  TRUE si $a est différent de $b. 
<>  $a <> $b  Différent  TRUE si $a est différent de $b. 
!==  $a !== $b  Différent  TRUE si $a est différent de $b ou bien qu'ils ne sont pas du même type.  
<  $a < $b  Plus petit que  TRUE si $a est strictement plus petit que $b. 
>  $a > $b  Plus grand  TRUE si $a est strictement plus grand que $b. 
<=  $a <= $b  Inférieur ou égal  TRUE si $a est plus petit ou égal à $b. 
>=  $a >= $b  Supérieur ou égal  TRUE si $a est plus grand ou égal à $b. 
 

II.9.4. Opérateurs d'incrémentation 
 

Opérateur  Exemple  Nom  Résultat 


++$a  Pre‐incrémente  Incrémente $a de 1, puis retourne $a.  
++ 
$a++  Post‐incrémente  Retourne $a, puis l'incrémente de 1. 
‐‐  ‐‐$a  Pré‐décrémente  Décrémente $a de 1, puis retourne $a.  

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                8 

 
PHP/MySQL 

$a‐‐  Post‐décrémente  Retourne $a, puis décrémente $a de 1. 


 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                9 

 
PHP/MySQL 

II.9.5. Opérateurs Logiques 
 

Opérateur  Exemple  Nom  Résultat 


and  $a and $b  ET (And)  TRUE si $a ET $b valent TRUE. 
or  $a or $b  OU (Or)  TRUE si $a OU $b valent TRUE. 
xor  $a xor $b  XOR (Xor)  TRUE si $a OU $b est TRUE, mais pas les deux en même temps. 
!  ! $a  NON (Not)  TRUE si $a n'est pas TRUE. 
&&  $a && $b  ET (And)  TRUE si $a ET $b sont TRUE. 
||  $a || $b  OU (Or)  TRUE si $a OU $b est TRUE. 
 

II.9.6. Opérateur de contrôle d'erreur 
PHP supporte un opérateur de contrôle d'erreur : c'est @. Lorsque cet opérateur est ajouté 
en préfixe d'une expression PHP, les messages d'erreur qui peuvent être générés par cette 
expression seront ignorés. 
 
II.9.7. Opérateur d'exécution 
PHP supporte un opérateur d'exécution : guillemets obliques ("``"). Notez bien qu'il ne s'agit 
pas  de  guillemets  simples.  PHP  essaie  d'exécuter  le  contenu  de  ces  guillemets  obliques 
comme  une  commande  shell.  Le  résultat  sera  retourné  (i.e.  :  il  ne  sera  pas  simplement 
envoyé  à  la  sortie  standard,  il  peut  être  assigné  à  une  variable).  Utilisez  les  guillemets 
obliques revient à utiliser la fonction shell_exec(). 
<?php
$output = `ls -al`;
echo "<pre>$output</pre>";
?>
<?php
$parFile="param.txt";
$parImage="mohona.gif";
$output=`C:\ms4w\Apache\cgi-bin\owtchart.exe $parFile $parImage`;
echo "<pre>$output</pre>";
?>
 
II.10. Structures de contrôle 
II.10.1. Structure conditionnelle  
if
Si l'expression est vraie exécuter l'instruction ou les instructions dans le bloc.  
Syntaxe : 
if (expression){ if (expression)
instruction1; instruction1;
...  
instructionN;
}

if...else 
Si l'expression est vraie exécuter les instructions du bloc 1 sinon exécuter celles du bloc 2.  
Syntaxe : 
if (expression){
instruction1;
...
}
else {
instruction1;
...

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                10 

 
PHP/MySQL 

}
if ... elseif ... else 
Si expression1 est vraie, exécuter le bloc 1, sinon, si expression2 est vraie exécuter le bloc 2, sinon si 
..., sinon exécuter le dernier bloc.  

if (expression1){
instruction1;
...
}
elseif (expression2){
instruction2;
...
}
elseif (expression3){
instruction3;
...
}
else {
instruction;
...
}

Opérateur conditionnel  ( ) ? : 
(condition) ? instruction si true : instruction si false;

switch 
Selon valeur de expression, exécuter les instructions associées.  
switch (expression){
case val1 : instructions; break;
case val2 : instructions; break;
...
default : instructions;
}

II.10.2. Structure itérative 
while 
Tant que l'expression est vraie faire les instructions  
while (expression){ instructions; }

do ... while 
Faire les instructions tant que l'expression est vraie  
do{
instructions;
}
while (expression)

for 
for(expression; test; expression_inc){
instructions;
}

foreach (à partir de PHP4 ; pour les tableaux seulement)
Pour chaque  
foreach($tab as $value){
instructions;

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                11 

 
PHP/MySQL 

}
Interruption de boucles 
break interrompt les boucles for, while.
continue interrompt l'exécution d'une itération et reprend à
l'itération suivante.

Interruption du script 
Exit
 
II.11. Fonctions 
a) Syntaxe de définition 
La syntaxe de définition d’une fonction est la suivante :  
 
function nom_de_la_fonction([$arg1 [, $arg2 […]]])
{
//liste des instructions
[return valeur ;]
}
Exemple : 
function writeln($msg)
{
echo $msg ."<br/>" ;
}
 

On peut appeler la fonction de l’une des façons suivantes : 
Writeln("Bonjour le Monde !") ;
$txt="Bonne lecture" ;
Writeln($txt) ;
 
Certains arguments d’une fonction peuvent avoir des valeurs par défaut. Lorsque c’est le cas, 
ces arguments doivent être passés en dernière position.  
Syntaxe : 
function nom_de_la_fonction([$arg1 [,[…]]][$darg1=val1 [,$darg2=val2
[…]]])
{
//liste des instructions
[return valeur ;]
}

return valeur ; est une instruction de retour optionnelle qui permet de retourner
(renvoyer) une valeur. Tous les types de variables peuvent être renvoyés, tableaux et
objets compris. Lorsque return est rencontrée lors de l’exécution du code d’une fonction,
la fonction finit son exécution immédiatement et passe le contrôle au programme
appelant en lui retournant valeur. 
 
Exemples : 
function writeln($msg="")
{
echo $msg ."<br/>" ;
}
 
function convert($mont, $tauxCh, $devise=" F CFA")
{
Echo $mont*$tauxCh ." " .$devise ;
}

function somme($premier, $second)


{

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                12 

 
PHP/MySQL 

return $premier + $second ;


}
Un appel de ces fonctions peut se faire de la façon suivante : 
writeln() ;
writeln("le texte à afficher") ;
writeln(12);
convert(18,656) ;
conver(24500, 0.0015244, " €") ;
echo somme(10, 54);

b) Passage de paramètres 
Il existe deux modes de passage de paramètres à une fonction : Passage par valeur, Passage 
par variable.  
Par  défaut,  les  arguments  sont  passés  par  valeur  à  une  fonction.  Ainsi  les  modifications 
apportées  à  cet  argument  dans  la  fonction  n’affectent  pas  sa  valeur  à  la  sortie  de  cette 
dernière (fin de l’exécution de la fonction). Dans un passage de paramètre par valeur c’est 
au fait une copie du paramètre qui est utilisée dans la fonction. 
Pour  que  les  modifications  apportées  à  un  paramètre  à  l’intérieur  d’une  fonction  puissent 
changer  la  valeur  de  l’argument  à  la  fin  de  l’exécution  de  la  fonction,  on  doit  faire  un  
passage de paramètre par variable. En PHP, on utilise le passage de paramètre par référence 
(héritage du C++).  
Pour  passer  un  argument  par  référence,  il  faut  utiliser  l’opérateur  '&'  devant  l'argument 
dans la déclaration de la fonction. 
 
<?php
function gras_chaine(&$string)
{
$string= "<B> $string</B>";
}
$str = 'Ceci est une chaîne';
Gras_chaine($str);
echo $str;
?>
 
c) Portée d’une variable 
Nous  aurions  pu  aborder  cette  notion  dans  la  session  des  variables  mais  avons  préféré  en 
parler ici pour une meilleure compréhension. 
La  notion  de  porté  d’une  variable fait  référence  à  sa  visibilité  et  dépend  du  contexte  dans 
lequel la variable est définie. Suivant le cas, la portée concernera la totalité d'un script PHP 
ou juste une partie du script.  
Une variable est dite de portée globale ou tout simplement variable globale, lorsqu’elle est 
visible (i.e. accessible) de partout (même à l’intérieur des fonctions) à partir de sa ligne de 
définition. Une variable globale est définie en dehors de toute fonction. 
Toute variable définie à l’intérieur d’une fonction est dite variable locale. Une telle variable 
n’est accessible qu’à l’intérieur de cette fonction. Donc sa portée ou sa visibilité est limitée à 
l’intérieur de cette fonction. 
Exemple : 
<?php
$c = 1;
function somme() {
$a = 2 ;
$b = 3 ;
$c = $a + $b; // $c est ici une variable locale différente de la
// variable globale $c de même nom.
}

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                13 

 
PHP/MySQL 

somme();
echo $c; // va afficher comme valeur : 1
?>
Comment faire alors pour accéder à une variable globale à l’intérieur d’une fonction ?  
Pour cela on fait recours au mot clé global ou au tableau associatif pré‐définie $GLOBALS. 
 

Exemple : 
<?php
$c = 1;
function somme() {
global $c; // donne accès à la variable globale $c
// à l’intérieur de la fonction
$a = 2 ;
$b = 3 ;
$c = $a + $b; // $c est ici la variable globale
}
somme();
echo $c; // va afficher comme valeur : 5
?>
 
<?php
$c = 1;
function somme() {
$a = 2 ;
$b = 3 ;
$GLOGALS["c"] = $a + $b; // accès à $c globale
$c=10 ;
}
somme();
echo $c; // va afficher comme valeur : 5
?>
Nota : Il n'y a aucune limite au nombre de variables globales qui peuvent être manipulées 
par une fonction. Il suffira de lister ces variables après le mot clé global en les séparant par 
une virgule. 
Syntaxe :   global $var1,$var2,…,$varn ; 
 

d) Fonctions variables 
PHP supporte le concept de fonctions variables. Cela signifie que si le nom d'une variable
est suivi de parenthèses, PHP recherchera une fonction Du nom du contenu de cette
variable, et essaiera de l'exécuter. Cela peut servir, entre autres, pour faire des fonctions
de rappel, des tables de fonctions...
Mais  les  fonctions  variables  ne  peuvent  pas  être  utilisées  avec  les  éléments  de  langage 
comme  echo,  print  ,  unset  ,  isset  ,  empty  ,  include  ,  require  etc.  Mais  avec  des  fonctions 
presonnelles. 
 
<?php
function premier() {
echo "ma première fonction<br />\n";
}
function second($arg = '' )
{
echo "ma seconde fonction : argument = '$arg'.<br />\n";
}
function write ($string)
{
echo $string;
}
$func = 'premier';
$func(); // Appel premier()
$func = 'second';
$func( 'test' ); // Appel second('test')
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                14 

 
PHP/MySQL 

$func = 'write';
$func('test'); // Appel write('test')
?>
e) Fonction internes 
PHP met à disposition de nombreuses fonctions et structures standards. Certaines fonctions 
requièrent la présence des extensions spécifiques de PHP, sans lesquelles on obtiendrait de 
messages d'erreurs. Pour connaitre les extensions compilées et installées avec votre version 
de PHP, il faut utiliser la fonction phpinfo ou la fonction get_loaded_extensions.   
Nous vous donnerons plus loin une liste non exhaustive de fonctions PHP à connaitre.  
 
f) Variable statique dans une fonction 
La  durée  de  vie  d’une  variable  est  le  temps  durant  lequel  cette  variable  existe.  En  règle 
générale, la durée de vie d’une variable globale s’étant du moment de sa création à la fin de 
l’existence du programme qui la contient. Tandis que la durée de vie d’une variable locale va 
de  sa  création  à  fin  de  l’exécution  de  la  fonction  qui  la  contient.  Autrement,  une  variable 
locale n’existe normalement que le temps de l’appel d’une fonction la contenant.  
Une  variable  statique  fait  exception  à  cette  règle.  En  effet,  une  variable  statique  est  une 
variable locale dont la durée de vie va au‐delà d’un appel de la fonction qui l’a créée. C’est 
une variable locale persistante qui est créée lors du premier appel de la fonction la content, 
mais maintenue en mémoire après la fin de l’exécution de cette dernière. Elle ne sera plus 
recréée  lors  d’un  nouvel  appel  mais  accessible  dans  la  fonction  avec  sa  valeur  lors  de  son 
dernier appel. 
Pour  rentre  une  variable  locale  statique,  on  place  le  mot  clé  static  devant  sa 
déclaration/définition.  
Exemple : 
<?php
function Test1()
{
$a = 0;
echo $a;
$a++;
}
?>

<?php
function Test2() {
static $a = 0;
echo $a;
$a++;
}
?>

A  chaque  appel  de  Test1(),  la  variable  locale  $a  sera  créée  ou  recréée  puis  initialisée  à  la 
valeur 0. Donc l’incrémentation n’aura aucun effet sur la valeur initiale de $a à chaque appel. 
Donc cette fonction affichera à chaque appel, la valeur 0. 
Par  contre,  au  premier  appel  de  la  fonction  Test2(),  la  variable  locale  $a  sera  créée  et 
initialisée à la valeur 0. Cette variable étant statique, elle va demeurer à la fin de l’appel. Au 
prochain appel, la variable $a ne va plus être créée (elle existe déjà). On pourra donc accéder 
à  sa  dernière  valeur  et  l’afficher.  Ainsi,  les  appels  successifs  de  Test2()  vont  entrainer 
l’affichage de 0, 1, 2, 3, etc. 
 
g) Fonctions include et require 
require() et  include(),  incluent et exécutent un fichier PHP.  
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                15 

 
PHP/MySQL 

require() et include() sont identiques, sauf dans leur façon d’inclure les fichiers et de gérer 
les erreurs. Ils produisent tous les deux une Alerte (message d’erreur en cas de problème) 
mais require() génère une erreur fatale, donc bloquante qui interrompt l’exécution du script. 
include()  ne  se  comporte  pas  de  cette  façon.  Elle  va  générer  un  message  d’erreur  mais  le 
script continuera son exécution. 
Autre  différence :  le  fichier  inclus  par  include()  est  ré‐évaluée  à  chaque  fois  que  la 
commande  est  exécutée,  tandis  que  require()  est  remplacée  par  le  fichier  cible  lors  de  la 
première exécution, que son contenu soit utilisé ou non. En effet, la commande require() se 
remplace elle‐même par le contenu du fichier spécifié, comme les préprocesseurs C le font 
avec la commande #include. De plus, cela se fait même s’il est placé dans une structure de 
contrôle ; ce qui n’est pas le cas une fois encore de include(). 
 
require_once() et include‐once() sont des variantes respectives de require() et include(). La 
principale différence ici est que vous êtes assurés que ce code ne sera ajouté qu'une seule 
fois, évitant de ce fait les redéfinitions de variables, de fonctions, etc. génératrices d'alertes.  
Syntaxe : 
include("nom_du_fichier") ;
ou encore  
include "nom_du_fichier");
 
Cette syntaxe reste valable pour require() aussi, et il est aussi possible de passer le nom du 
fichier à travers une variable. Il faut noter que le nom du fichier doit prendre en compte le 
chemin relatif d’accès. 
Exemple : 
<?php
include("config.inc.php");
require("scripts/fonctions.inc.php");
include "menu.inc.php";
?>
 
h) Quelques autres fonctions 
 
Fonctions générales 
Nom  Rôle  
abs($nombre)   Renvoie la valeur absolue de nombre 
Renvoie faux si la variable est définie et a une valeur différente de 0, "0", de la 
empty($variable) 
chaine vide "", d’un tableau ou d’un objet vide, de NULL. ; vrai sinon 
eval($commande)  Exécute le contenu de la chaine $commande. 
Exécute une commande système et renvoie la dernière ligne produite par 
exec($commande [,     
l’exécution. Si $tableau est passé, il contiendra toutes les lignes produites par 
          $tableau]) 
l’exécution de la commande. Voir aussi EscapeShellCmd 
defined("NOMCONSTANTE")  Renvoie vrai si la constante NOMCONSTANTE est définie 
header($chaine)  Produit un en‐tête http 
isset($variable)  Renvoie vrai si $variable est définie et différent de NULL, faut sinon 
mail($destinataire, $sujet    
Permet d’envoyer un mail. 
     [, $msg, $entete]) 
Fonction de hachage renvoyant une chaine de 32 octets. Normalement 
md5($chaine) 
irréversible. 
Passthru($commande)  Identique à la fonction exec, mais  son resultat est directement envoyé au 
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                16 

 
PHP/MySQL 

navigateur. 
phpinfo()  Affiche des information sur l’interpréteur PHP, etc. 
Etc.   
 
Fonctions pour les chaînes 
Nom  Rôle  
eval($chaine)  évalue $chaine comme si c'était du code PHP 
strlen($chaine)   retourne la longueur de $chaine 
chaine strtok($ch, $sep)   sépare $ch en fonction de $sep (séparateur) 
str_repeat ($ch, n)  répète n fois la chaîne 
sprintf(format, arg)  retourne une chaine formatée 
chr(ascii)  donne le caractère qui correspond au code ascii 
ord(car)  donne le code ascii qui correspond au caractère 
strpos(ch, ssch)   retourne la position de la 1ère occurrence de ssch dans ch 
strrpos(ch, car)   retourne la position de la dernière occurrence du caractère 
strspn(ch, enscar)   longueur de la sous‐chaîne dont les caractères sont entièrement dans enscar 
chaine strstr(ch, ssch)   retourne la portion de ch à partir de la 1ère occurrence de ssch et jusqu'à la fin 
stristr(ch, ssch)   strstr non sensible à la casse 
substr(ch, deb, l)   renvoie la sous‐chaîne de taille l qui commence à l'indice deb 
strcasecmp(ch1, ch2)   comparaison sans tenir compte de la casse 
strcmp(ch1, ch2)   retourne 0 si ch1 = ch2 
strToLower(ch)   convertit en minuscules 
strToUpper(ch)   convertit en majuscules 
ucfirst(ch)   met la première lettre en majuscule 
ucwords(ch)   met tous les mots de ch en majuscule 
chop(ch)   retourne la chaine sans les espaces 
trim(ch)   supprime les espaces de début et fin de chaîne 
Renvoie une chaine identique à $chaine en mettant le caractère 
addSlashed($chaien) 
d’échappement \ devant chaque ', " et \  (cote, double‐cote, anti‐slashe) 
explode($sep, $chaine)  Eclate $chaine dans un tableau sur la base de $sep qui est un séparateur. 
implode($tableau, $sep)  Fonction inverse de explode 
stripSlashes($chaine)  Fonction inverse de addSlashes 
 
Fonctions pour les tableaux 
Nom  Rôle  
arsort($tableau)  Trie le tableau associatif $tableau par ordre décroissant 
asort($tableau)  Même chose que arsort mais par ordre croissant 
count($tableau)  Renvoie le nombre d’éléments du tableau.  
reset($tableau)  Repositionne le pointeur interne de $tableau sur son premier élément 
key($tableau)  Renvoie la clé de l’élément courant du tableau sans modifier le pointeur interne 
 
Fonctions pour les expressions régulières 
Nom  Rôle  

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                17 

 
PHP/MySQL 

évalue l'expression et met les occurrences rencontrées dans ch dans le tableau 
ereg(exp, ch, tabocc)   tabocc la case 0 contient l'occurrence de l'expression, les autres cases les sous‐
occurrences. Retourne 0 si pas de correspondance 
remplace les sous‐chaînes de ch qui correspondent à l'expression exp par la 
ereg_replace(exp, rep, ch)   chaîne rep. exp peut être un code ascii  
ereg_replace(10, "<BR>", ch) remplace les \n par des <BR> 
eregi(exp, ch, tabocc)   comme ereg sans tenir compte de la casse 
eregi_replace(exp, rep, ch)   comme ereg_replace sans tenir compte de la casse 
split(exp, ch, limite)   retourne un tableau des sous‐chaînes 
 
Fonctions pour les dates 
Nom  Rôle  
checkdate(m, j, a) Retourne 1 si la date passée est valide, 0 sinon 
date($chaine_format)    retourne la date sous forme de chaine en respectant le format 
gmdate(format)   Comme la fonction date() mais au format Greenwich 
mktime(h, m, s,
retourne la valeur Timestamp qui correspond aux arguments 
mois, j, a) 
gmmktime(h, m, s,
Comme mktime() mais au format Greenwich 
mois, j, a)  
time()  Retourne la valeur de Timestamp 
 

Il  existe  beaucoup  d’autres  fonctions  PHP.  Nous  en  présenterons  quelques  unes  dans 
d’autres sections de ce cours.  
 
III. Les classes et les objets (PHP4, PHP5) 
La POO a pour but de faire gagner du temps au développeur, de faciliter la maintenance des 
programmes, leur sécurité, tout en favorisant la portabilité et la réutilisabilité des codes.  
Jusqu’au sa version 4, il y avait pas mal de lacunes dans l’approche Objet de PHP. Mais PHP 5 
apporte  un  tout  nouveau  model  objet.  La  gestion  des  objets  en  PHP  a  été  complètement 
réécrite, permettant de meilleures performances ainsi que plus de fonctionnalités. 
 
III.1. Déclaration/Définition  
Une  classe  est  un  ensemble  (collection)  d’attributs  (variables)  et  de  méthodes  (fonctions 
s’exécutant au sein d’un objet). La déclaration d'une classe se fait par l'utilisation du mot clé 
class, suivit du nom de la classe. 
La syntaxe de définition/déclaration d’une classe est la suivante : 
class nom_classe{



}
 

Nota  :  Le  nom  stdClass  est  utilisé  en  interne  par  Zend  et  ne  doit  pas  être  utilisé.  Vous  ne 
pouvez pas nommer une classe stdClass en PHP.  
PHP  se  réserve  l'usage de  tous  les noms  de  fonctions  commençant  par  __,  pour  sa  propre 
magie. Il est vivement recommandé de ne pas utiliser des noms de fonctions commençant 
par __, à moins que vous ne souhaitiez utiliser la magie qui y est associée. 
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                18 

 
PHP/MySQL 

En PHP 4 et +, seule l’initialisation des constantes membres est autorisée à l’intérieur de la 
structure d’une classe. Il faut plutôt faire recours aux constructeurs pour les initialisations de 
variables membres (ou attributs non constantes).  
 
III.2. Objet ou Instance d’une classe 
Une classe est un type. La déclaration d'une classe n'est pas suffisante pour utiliser les objets 
de la classe. Il faut donc créer des objets avant de pouvoir s'en servir. La création d'un objet 
à  partir  d'une  classe,  s'appelle  l'instanciation.  Une  instance  d’une  classe  est  un  objet  (une 
variable)  de  la  classe.  Pour  créer  une  instance  d’une  classe,  on  utilise  le  mot  clé  new.  La 
syntaxe est la suivante : 
$nom_objet = new nomclasse;

III.3. Attributs et méthodes d’une classe 
Les attributs d’une classe sont des sortes de variables internes à chaque objet de la classe, et  
qui ne sont accessibles qu'à travers celui‐ci du fait du principe de l’encapsulation.  
La déclaration d'un attribut au sein d'une classe se fait par l'utilisation du mot clé var suivi du 
nom de l'attribut.  
Attributs : données se rapportant ou caractérisant l’objet. 
Les méthodes quant à elles, sont des fonctions internes à l'objet. C’est à travers elles qu’il 
sera possible d'agir sur les attributs de l'objet. La déclaration d'une méthode (ou fonction) à 
l'intérieur d'une classe se fait de la même façon que dans un script classique. On utilise pour 
cela  le  mot  réservé  function  suivit  du  nom  de  la  méthode,  suivi  éventuellement,  entre 
parenthèse, de la liste des paramètres.  
Méthodes : Ensemble d’actions, comportements ou fonctions que l’objet peut accomplir. 
 
III.4. Encapsulation – spécificateurs d’accès  
Le  principe  de  l’encapsulation  est  de  rassembler  objet  et  méthodes  dans  une  même 
structure et masquer l’implémentation de l’objet et protéger l’accès aux membres (données, 
fontions)   ;  puis  ne  donner  l’accès  uniquement  qu’à  travers  certaines  fonctions  membres 
(méthodes) qui forment ce que l’on appelle l’interface. C’est un moyen de garantir l’intégrité 
des données de l’objet. 
 

Les droits d’accès aux données sont définit par les niveaux de visibilité qui sont eux‐mêmes 
définit par l’encapsulation. Il existe 3 niveaux de visibilité qui se traduisent par la présence 
de spécificateurs d’accès associés (apport de PHP 5). 
• public : tout est accessible de partout (niveau de protection faible). 
• protected :  seules  les  fonctions  membres  de  la  classe  et  des  classes  héritières 
(dérivées) ont accès aux données. 
• private : l’accès aux données est limité aux seules méthodes de la classe. 
 

Syntaxe générale 
class nom_classe{
[spécifcateur d’accès]
var $nomvar1;
...
var $nomvarn;
[spécifcateur d’accès]
function nomfonc1(){
instructions;

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                19 

 
PHP/MySQL 

[return x;]
}
...
function nomfoncn($arg1, $arg2){
instructions;
[return x;]
}
}
Exemple : 
<?php
class Panier {
var $items;
function add_item ($nbre_art, $num) {
$this->items[$nbre_art] += $num;
}
function remove_item($nbre_art, $num) {
if ($this->items[$nbre_art] > $num) {
$this->items[$nbre_art] -= $num;
return true;
} elseif ($this->items[$nbre_art] == $num) {
unset($this->items[$nbre_art]);
return true;
} else {
return false;
}
}
}
?>
ou bien  
 
<?php
class Panier {
private $items;
public function add_item ($nbre_art, $num) {
$this->items[$nbre_art] += $num;
}
public function remove_item($nbre_art, $num) {
if ($this->items[$nbre_art] > $num) {
$this->items[$nbre_art] -= $num;
return true;
} elseif ($this->items[$nbre_art] == $num) {
unset($this->items[$nbre_art]);
return true;
} else {
return false;
}
}
}
?>

III.5. Héritage 
Il  arrive  très  souvent  que  dans  une  classe  on  ait  besoin  d’un  ensemble  d’attributs  et  de 
fonctionnalités  définies  dans  une  autre  classe  plus  générique.  La  classe  qui  passe  ses 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                20 

 
PHP/MySQL 

attributs  voire  méthodes  à  une  autre  classe,  est  appelée  classe  mère  ou  superclasse  ou 
encore parente. La classe issue de la première est appelée classe fille ou classe dérivée. On 
parle alors de notion d’héritage. L’héritage conduit à la spécialisation ou à l’extension d’une 
autre classe. 
L’avantage c’est que la classe dérivée hérite de toutes les méthodes et attributs cessibles de 
la classe de base, mais peut définir ses propres méthodes et attributs. 
L’héritage se fait en pHPavec le mot clé ' extends '. 
Nota :  Une  classe  ne  peut  hériter  que  d'une  seule  autre  classe,  et  l'héritage  multiple  n'est 
pas supporté en PHP.  
 
III.6. Constructeur ‐ Destructeur 
Il existe aussi des méthodes particulières appelées constructeur et destructeur de la classe.  
Le constructeur est automatiquement appelé lors de la création d'un objet (instanciation de 
la  classe).  Il  permet  donc  d'initialiser  l'objet  à  sa  création  en  donnant  par  exemple  des 
valeurs à tous ou certains de ses attributs.  
 

Constructeur : 
En PHP4 Le constructeur d'une classe est une méthode qui porte le même nom que la classe 
dont  elle  est  le  constructeur.  Mais  à  partir  de PHP5,  le  constructeur  devient  une  méthode 
magique avec comme nom __construct suivi entre parenthèses des éventuels paramètres. 
Toutefois, pour des raisons de compatibilité ascendante, si PHP 5 ne peut pas trouver une 
fonction 
__construct(…) pour une classe donnée, il cherchera une fonction constructeur représentée, 
comme dans l'ancienne version (PHP < 5), par le nom de la classe. 
Nota : PHP n'appelle pas automatiquement le constructeur de la classe supérieure depuis le 
constructeur de la classe dérivée. Il est donc de notre responsabilité de propager l'appel des 
constructeurs. 
 

Destructeur : 
Un  destructeur  est  une  fonction  qui  est  appelée  juste  avant  la  destruction  d'un  objet,  soit 
avec la fonction unset soit par simple sortie d'une fonction (cas des variables locales).  
Il  n'existe  pas  de  destructeurs  en  PHP  4.  Il  faut  utiliser  la  fonction 
register_shutdown_function  en  lieu  et  place  pour  simuler  la  plus  part  des  effets  des 
destructeurs. 
 

Le concept de destructeur est introduit à partir de PHP 5 et le nom du destructeur s’écrit :  
__destruct()

Exemple : 
<?php
class BaseClass {
function __construct() {
print "Constructeur de BaseClass \n";
}
}
class SousClass extends BaseClass {
function __construct() {
parent::__construct();
print " Constructeur de SousClass \n";
}
}

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                21 

 
PHP/MySQL 

$obj1 = new BaseClass();


$obj2 = new SousClass();
?>
 
 
 
Nota : 
::  est  un  opérateur  de  contexte  de  classe.  On  l’appelle  encore  opérateur  de  résolution  de 
portée. Il fournit un moyen d'accéder aux membres statiques ou constants d’une classe ainsi 
qu'aux éléments de la classe parente, redéfinis par la classe. 
Le mot parent fait référence à une classe générique dont dérive directement la classe dans 
laquelle on se trouve. Cela évite d’utiliser le nom littéral de la classe parente dans le code, et 
garantit  la  facilité  de  maintenance  et  de  portabilité  si  jamais  le  nom  de  la  classe  parente 
venait à changer. 
 

III.7. Membres Statiques 
Le fait de déclarer des membres ou des méthodes comme statiques permet d'y accéder sans 
avoir  besoin  d'instancier  la  classe.  Un  membre déclaré  comme  statique  est  un  attribut  qui 
est une propriété de la classe et non des objets de la classe. Il ne peut de ce fait être accédé 
avec l'objet instancié d'une classe (bien qu'une méthode statique le peut). 
Le mot clé static de la déclaration statique vient après la déclaration de visibilité. Pour des 
raisons de compatibilité avec PHP 4, si aucune déclaration de visibilité n'est utilisée, alors le 
membre ou la méthode sera traité comme s'il avait été déclaré comme public . 
Comme  les  méthodes  statiques  sont  appelables  sans  instance  d'objet  créée,  la  pseudo 
variable $this n'est pas disponible dans la méthode déclarée en tant que statique. 
En fait, les appels de méthodes statiques sont résolus au moment de la compilation. Lorsque 
l'on  utilise  un  nom  de  classe  explicite,  la  méthode  est  déjà  identifiée  complètement  et 
aucune notion d'héritage n'est appliquée. Si l'appel est effectuée par le mot clé self , alors 
self est traduit en la classe courante. Ici aussi, aucune notion d'héritage n'est appliquée. 
 
<?php
class Foo
{
public static $my_static = 'foo';
public function staticValue() {
return self::$my_static;
}
}
class Bar extends Foo
{
public function fooStatic() {
return parent::$my_static;
}
}
print Foo::$my_static . "\n";
$foo = new Foo();
print $foo->staticValue() . "\n";
print $foo->my_static . "\n"; // propriété my_static non définie
// $foo::my_static n'est pas possible
print Bar::$my_static . "\n";
$bar = new Bar();
print $bar->fooStatic() . "\n";
?>

III.8. Membre Constant  
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                22 

 
PHP/MySQL 

Il est possible de définir des valeurs constantes (non modifiables) à l'intérieur d'une classe. 
Les constantes diffèrent des variables normales du fait qu'on n'utilise pas le symbole $ pour 
les déclarer ou les utiliser. Tout comme pour les membres statiques, on ne peut pas accéder 
aux valeurs constantes depuis une instance de l'objet (en utilisant $object::constant ). 
La valeur doit être une expression constante, non (par exemple) une variable, un membre de 
la classe, le résultat d'une opération mathématique ou un appel de fonction. 
<?php
class MyClass
{
const constant = 'valeur constante';
function showConstant() {
echo self::constant . "\n";
}
}
echo MyClass::constant . "\n";
$class = new MyClass();
$class->showConstant();
// echo $class::constant; n'est pas autorisé
?>
 
III.9. Classes abstraites 
PHP  5  introduit  la  notion  de  classes  et  de  méthodes  abstraites.  Toute  classe  contenant  au 
moins  une  méthode  abstraite  est  une  classe  abstraite  et  il n'est  pas  autorisé  de  créer  une 
instance d'une classe définie comme abstraite.  
Pour définir une méthode abstraite, il faut simplement déclarer la signature de la méthode 
et ne fournir aucune implémentation. 
Lors  de  l'héritage  depuis  une  classe  abstraite,  toutes  les  méthodes  marquées  comme 
abstraites dans la déclaration de la classe parent doivent être définies par l'enfant ; de plus, 
ces méthodes doivent être définies avec la même (ou plus faible) visibilité. Par exemple, si la 
méthode  abstraite  est  définie  comme  protégée,  l'implémentation  de  la  fonction  doit  être 
définie en tant que protégée ou publique. 
Il faut noter la présence du mot clé abstract qui précède la déclaration d’une classe ou d’une 
méthode abstraite.  
 
<?php
abstract class AbstractClass
{
abstract protected function getValue();
abstract protected function prefixValue($prefix);
// méthode commune
public function printOut() {
print $this->getValue() . "\n";
}
}

class ConcreteClass1 extends AbstractClass


{
protected function getValue() {
return "ConcreteClass1";
}
public function prefixValue($prefix) {
return "{$prefix}ConcreteClass1";
}
}

$class1 = new ConcreteClass1;

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                23 

 
PHP/MySQL 

$class1->printOut();
echo $class1->prefixValue('FOO_') ."\n";
?>
 
III.10. Interfaces 
Les interfaces objet permettent de créer du code qui spécifie quelles méthodes et variables 
une classe peut implémenter, sans avoir à définir comment ces méthodes seront gérées. 
Les interfaces sont définies en utilisant le mot clé interface, de la même façon qu'une classe 
standard mais sans aucun contenu de méthode. 
Toutes les méthodes déclarées dans une interface doivent être publiques. 
Pour implémenter une interface, l'opérateur implements est utilisé.  
Nota : Toutes les méthodes de l'interface doivent être implémentées dans une classe ; si ce 
n'est pas le cas, une erreur fatale sera émise.  
Les classes peuvent implémenter plus d'une interface en séparant chaque interface par une 
virgule. 
Exemples 
<?php
// Declaration de l'interface 'iTemplate'
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}

// Implémentation de l'interface

class Template implements iTemplate


{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}

// Ceci ne fonctionnera pas


// Fatal error: Class BadTemplate contains 1 abstract methods
// and must therefore be declared abstract (iTemplate::getHtml)
class BadTemplate implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
}
?>
 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                24 

 
PHP/MySQL 

IV. Communication 
IV.1. Envoi de données vers le navigateur 
Pour envoyer des données provenant de PHP vers le navigateur on formate ces données en 
générant du code HTML. Pour cela, on peut se servir de l’une des trois fonctions suivantes :  
echo param1, ..., paramn; //pas de parenthèse, conversion des param en chaînes
print("chaine"); // ou print($ch) ;
printf("%otf1 ... %otfn",param1,..., paramn); // on a ici une chaine format et un
// parametre pour chaque spécificateur

• Valeurs possibles après % pour les spécificateurs 

d   entier décimal 
c   caractère ASCII  
o   entier octal  
s   chaine 
x   entier hexadécimal  
f   double 
b   entier binaire  
e   double en notation scientifique
• option de contrôle du bloc : ‐ pour aligner le texte à gauche.  
• taille (t)  
printf("%-20s %4d","la chaine",23);  

IV.2. Réception de données d'un formulaire 
IL existe deux méthodes de soumission de données depuis un formulaire à savoir la méthode 
POST et la méthode GET.  
Il faut noter que dans les configurations antérieures du fichier php.ini on mettait la directive 
register_globals  à  On    ce  qui  faisait  que  lorsqu’on  soumettait  un  formulaire, 
automatiquement  les  variables  associées  aux  différents  champs  du  formulaire  se  créaient. 
Ainsi  si  un  champ  de  formulaire  se  nomme  'toto',  la  soumission  du  formulaire  entraine  la 
création  de  la  variable  $toto  avec  comme  contenu  la  valeur  du  contenu  du  champ  à  la 
soumission.  
Mais cette façon de faire présentait un certain nombre de trous de sécurité ; De sorte que 
depuis  PHP4  les  variables  globales  ont  été  sécurisées  en  mettant  par  défaut  l'option 
register_globals à Off.  
A  partir  de  cet  instant,  l’accès  aux  données  provenant  de  formulaire  se  fait  au  travers  de 
tableaux associatifs super globaux  $_GET, $_POST suivant le cas, ou encore de $_REQUEST. 
Exemple : voir TP

IV.3. Envoi d'un mail 
PHP  met  à  disposition  la  fonction  mail  qui  permet  d’envoyer  facilement  un  courrier 
électronique.   
Sa syntaxe est la suivante : 
mail ($to , $subject , $message [,$additional_headers [,$additional_parameters ]] ) 
 
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                25 

 
PHP/MySQL 

$to         : contient, le ou les destinataires du courrier. 
$subject         : sujet du mail à envoyer 
$message        : Le texte du message à envoyer 
$additional_headers  :  Chaîne  à  insérer  à  la  fin  des  en‐têtes  du  mail. Ce  paramètre  est 
typiquement  utilisé  pour  ajouter  des  en‐têtes  supplémentaires 
(From, Cc et Bcc). Les en‐têtes supplémentaires doivent être séparés 
par un caractère CRLF (\r\n). 
$additional_parameters : Le paramètre additional_parameters peut être utilisé pour passer 
des  paramètres  additionnels  au  programme  configuré  à  être  utilisé 
pour  envoyer  les  mails  en  utilisant  le  paramètre  de  configuration 
sendmail_path. 
Nota : Les paramètres additionnels ne sont pas obligatoires. 
 
Exemple 1 
<?php
$to = 'personne@example.com';
$subject = 'le sujet';
$message = 'Bonjour !';
$headers = 'From: webmaster@example.com' . "\r\n" .
'Reply-To: webmaster@example.com' . "\r\n" .
'X-Mailer: PHP/' . phpversion();

mail($to, $subject, $message, $headers);


?>

Exemple 2 : Envoi de mail au format HTML 
<?php
// Plusieurs destinataires
$to = 'aidan@example.com' . ', '; // notez la virgule
$to .= 'wez@example.com';

// Sujet
$subject = 'Calendrier des anniversaires pour Juillet';

// message
$message = '
<html>
<head>
<title>Calendrier des anniversaires pour Juillet </title>
</head>
<body>
<p>Voici les anniversaires à venir au mois de Juillet !</p>
<table>
<tr>
<th>Personne</th><th>Jour</th><th>Année</th>
</tr>
<tr>
<td>Josiane</td><td>3</td><td>1977</td>
</tr>
<tr>
<td>Emma</td><td>26</td><td>1984</td>
</tr>
</table>
</body>
</html>';
// Pour envoyer un mail HTML, l'en-tête Content-type doit être défini
$headers = 'MIME-Version: 1.0' . "\r\n";
$headers .= 'Content-type: text/html; charset=iso-8859-1' . "\r\n";
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                26 

 
PHP/MySQL 

// En-têtes additionnels
$headers .= 'To: Mary <mary@example.com>, Kelly <kelly@example.com>'
. "\r\n";
$headers .= 'From: Anniversaire <anniversaire@example.com>' . "\r\n";
$headers .= 'Cc: anniversaire_archive@example.com' . "\r\n";
$headers .= 'Bcc: anniversaire_verif@example.com' . "\r\n";
// Envoi
mail($to, $subject, $message, $headers);
?>

IV.4. Envoi de fichiers au serveur (upload) 
Pour  envoyer  un  fichier  au  serveur  depuis  un  formulaire,  il  faut  préciser  l'enctype,  c'est  à 
dire le type d'encodage du fichier. L'enctype à utiliser est multipart/form‐data. 
Exemple :
<form method="POST" action="upload.php" enctype="multipart/form-data">
<!-- Le contenu du formulaire est à placer ici... -->
</form>
 

Pour  insérer  dans  un  formulaire  un  champ  de  fichier,  il  faut  utiliser  la  balise  input  avec 
comme valeur de l’attribut type la valeur "file". 
<input type='file' name='donnee'>
Pour  limiter  la  taille  du  fichier  à  uploader  on  peut  ajouter  un  champ  caché  avec  les 
caractéristiques suivantes : 
<input type="hidden" name="MAX_FILE_SIZE" value="100000">
Nota : 100000 correspond à 100000 octets = 100Ko 
Cette méthode de contrôle de taille n’est pas fiable donc contournable. 
 

Un petit formulaire récapitulatif donne : 
<form method="POST" action="upload.php" enctype="multipart/form-data">
<input type='file' name='donnee'>
<input type="hidden" name="MAX_FILE_SIZE" value="100000">
</form>
 
upload.php est donc le fichier qui va s’exécuter à la soumission du formulaire. Mais avant de 
présenter le contenu de ce fichier, nous allons parler d’une nouvelle variable super‐globale 
$_FILES qui est créée juste à la soumission du formulaire à cause de la présence de enctype 
et de l’input de type file.  
$_FILES est un tableau associatif dont le contenu se présente comme suit : 
VARIABLE  SIGNIFICATION
$_FILES['donnee']['name']  Le nom du fichier
$_FILES['donnee']['tmp_name']  Le chemin du fichier temporaire
$_FILES['donnee']['size']  La taille du fichier (peu fiable, dépend du navigateur)
$_FILES['donnee']['type']  Le type MIME du fichier (peu fiable, dépend du navigateur)
$_FILES['donnee']['error']  Un code d'erreur si besoin
 
move_uploaded_file()  est  la  fonction  principale  utilisée  pour  faire  de  l’envoi  (upload)  de 
fichier.  
Si le upload marche, le fichier qui est envoyé sur le serveur distant, est copié dans un dossier 
que  nous  devons  préciser.  Ce  dossier  doit  être  créé  au  préalable  dans  l’arborescence  de 
notre site avec des droits d’écriture autorisés. 
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                27 

 
PHP/MySQL 

Il  faut  aussi  prendre  des  précautions  pour  ne  pas  permettre  aux  gens  d’envoyer  sur  votre 
serveur  n’importe  quel  type  de  fichier.  Imaginez  que  quelqu’un  envoie  un  script  php 
malveillant en lieu et place d’une image ou d’un fichier pdf.   
Généralement  pour  contrôler  le  type  de  fichier  envoyé,  on  met  en  place  un  tableau  des 
extensions  autorisées,  et  on  bloque  à  chaque  fois  les  extensions  non  autorisées.  Mais  la 
méthode la plus professionnelle reste la vérification du type MIME des fichiers uploadés. 

<?php
$dossier = 'upload/'; //dossier qui va recevoir le fichier uploadé
$fichier = basename($_FILES['donnee']['name']);
$taille_maxi = 100000;
$taille = filesize($_FILES['donnee']['tmp_name']);
$ext_autoriz = array('.png', '.gif', '.jpg', '.jpeg'); //pour images seules
$extension = strrchr($_FILES['donnee']['name'], '.');
//Début des vérifications de sécurité...
if(!in_array($extension, $ext_autoriz)) //Extension pas dans le tableau
{
$erreur = 'Vous devez uploader un fichier de type png, gif, jpg,
jpeg, txt ou doc...';
}
if($taille>$taille_maxi)
{
$erreur = 'Le fichier est trop gros...';
}
if(!isset($erreur)) //S'il n'y a pas d'erreur, on upload
{
//On formate le nom du fichier ici pour remplacer les caractères
//accentués et les espaces dans le nom du fichier...
$fichier = strtr($fichier,
'ÀÁÂÃÄÅÇÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝàáâãäåçèéêëìíîïðòóôõöùúûüýÿ',
'AAAAAACEEEEIIIIOOOOOUUUUYaaaaaaceeeeiiiioooooouuuuyy');
$fichier = preg_replace('/([^.a-z0-9]+)/i', '-', $fichier);

if(move_uploaded_file($_FILES['donnee']['tmp_name'], $dossier .
$fichier)) //Si la fonction renvoie TRUE, ça a fonctionné...
{
echo 'Upload effectué avec succès !';
}
else //Sinon (la fonction renvoie FALSE).
{
echo 'Echec de l\'upload !';
}
}
else
{
echo $erreur;
}
?>
 
 
 
 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                28 

 
PHP/MySQL 

V. MySQL et PHP 
Un  des  grands  atouts  de  PHP  est  sa  très  riche  collection  d’interfaces  (API)  avec  tout  un 
ensemble de SGBD. En particulier, il est possible à partir d’un script PHP de se connecter à 
une base de données MySQL pour récupérer des données et les traiter ou pour y insérer des 
données. 
MySQL est une base de données implémentant le langage SQL qui est un langage de gestion 
de base de données relationnelle très connu.  
Il  existe  un  outil  libre  et  gratuit  développé  par  la  communauté  des  programmeurs  libres : 
phpMyAdmin qui permet l’administration aisée des bases de données MySQL avec PHP. 
MySQL  permet  de  créer  plusieurs  bases  de  données  sur  un  même  serveur.  Une  base  de 
données est constituée de Tables contenants des enregistrements.  
Ce cours suppose connus quelques principes de base des bases de données relationnelles. 
 

V.1. Création / Suppression d’une base de données 
La création d’une base de données se fait très simplement à partir de la commande SQL : 
CREATE DATABASE NomBase ;

La commande de suppression d’une base de données est la suivante : 
DROP DATABASE [IF EXISTS] NomBase ;

Nota: NomBase est de nom de votre base de données. 
 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                29 

 
PHP/MySQL 

V.2. Création d’une table 
Pour la création de tables on utilise un Langage de Définition de Données (LDD) qui est une partie du 
langage SQL et dont le la commande principale est CREATE TABLE.   

La syntaxe est la suivante :  Exemple :  
CREATE TABLE NomTable CREATE TABLE Film
(champ1 type, (titre VARCHAR(30),
champ2 type, annee INTEGER,
- - - nomMES VARCHAR(30),
champN type prenomMES VARCHAR(30),
) ; anneeNaiss INTEGER
  ) ;

 
Table avec clé primaire 
Une  table  peut  avoir  plusieurs  clés  mais  l’une  d’entre  elles  doit  être  la  clé  primaire.  Pour 
créer une clé primaire, il faut ajouter dans le code de création de la table, la ligne : 
PRIMARY KEY (nom_champ)

La spécification d’une clé secondaire se fait à l’aide du mot clé UNIQUE. La syntaxe donne : 
UNIQUE nom_champ ou encore UNIQUE (nom_champ1, nom_champ2)

Table avec index 
Ajouter dans le code de création de la table, la ligne : 
KEY nom_champ* (nom_champ)
 
V.3. Suppression d’une table 
La suppression d’une table se fait à l’aide de la commande DROP TABLe. La syntaxe est la suivante :
  DROP TABLE 'mon_table'
 
V.4. Mise à jour d’une table (modification : nom, schéma) 
Pour  une  raison  ou  pour  une  autre,  on  peut  être  amené  à  changer  le  nom  voire  même  le 
schéma  d’une  table  en  y  ajoutant  par  exemple  d’autres  attributs  ou  en  modifiant  la 
définition de certains attributs. La commande utilisée dans ces conditions est ALTER TABLE 
dont la syntaxe générale est la suivante :    
ALTER TABLE nomTable ACTION description
 

Nota :    ACTION peut être ADD, MODIFY, DROP, RENAME 
    description est la commande de modification associée à ACTION 
 

Exemples :   ALTER TABLE Commande ADD libelle VARCHAR(30) ;


ALTER TABLE Commande MODIFY libelle VARCHAR(30) NOT NULL;
ALTER TABLE Commande DROP libelle;
ALTER TABLE Commande RENAME commandes;

V.5. Insertion de données dans une table 
Pour insérer un nouvel enregistrement dans une table on utilise la commande INSERT avec 
trois (3) variantes. 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                30 

 
PHP/MySQL 

• On indique la liste de toutes les valeurs à insérer, sans donner explicitement le nom 
des attributs mais en respectant strictement l’ordre et le nombre. 
INSERT INTO Film VALUES ('la femme', 1978, 12, 'drame') ;
• On veut insérer seulement une partie des attribues. Dans ce cas on donne la liste 
explicite de ces attributs. 
INSERT INTO Film (titre,genre) VALUES ('la femme', 'drame'); 
 

• Il est possible d’insérer directement dans une table le résultat d’une requête. Dans ce 
cas, la partie VALUES est remplacée par la requête. 
INSERT INTO ExtraitFilm
SELECT titre, annee
FROM Film ;
 
V.6. Sélection d’enregistrement (Interrogation) d’une table 
Pour rechercher dans une table les enregistrements qui satisfont à un ou plusieurs critères, 
on utilise la commande SELECT. Sa structure de base de cette commande SQL comprend les 
trois clauses SELECT, FROM et WHERE.  
Ce qui donne comme syntaxe de base : 

SELECT liste de champs (ou attributs)


FROM table (ou liste des tables)
WHERE conditions
Notons  que  la clause WHERE  est optionnelle.  En effet,  toutes  les  lignes  sont  sélectionnées 
lorsqu’elle est omise. Lorsque 'liste de champs' est remplacée par * cela signifie simplement 
tous les champs de la table ou des tables. 
Le résultat d’une requête SELECT est toujours une table résultat. 
 

'liste de champs' peut contenir : 
• simplement une liste d’attributs de la table ou bien * 
• des attributs renommer (utilisation du mot clé AS) 
• des fonctions appliquées à des attributs (LENGTH, COUNT, SUM, CONCAT,YEAR, etc.) 
Exemples : 

SELECT * FROM matable ;


SELECT nom, YEAR(SYSDATE()) - naiss AS age FROM Personne ;
SELECT count(*) FROM Personne
 
La clause WHERE 
Cette clause permet de spécifier une ou des conditions portant sur les attributs des tables du 
FROM.  Pour  gérer  des  fois  plusieurs  conditions,  on  utilise  de  manière  standard  les 
connecteurs  AND,  OR  et  NOT  puis  les  parenthèses  pour  changer  l’ordre  de  priorité  de  ces 
opérateurs. 
Pour effectuer certaines recherches par motif ou approximation, la clause LIKE est utilisée. 
L’utilisation  dans  la  formulation  de  cette  clause  du  caractère  '_'  signifie  n’importe  quelle 
caractère ;  le  '%'  par  contre  signifie  n’importe  quelle  chaîne  de  caractères.  Il  existe 
également le mot‐clé IN qui permet de tester l’appartenance de la valeur d’un attribut à un 
ensemble. 
Exemples : 
SELECT * FROM Film
WHERE genre='comédie' AND annee > 1985;

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                31 

 
PHP/MySQL 

SELECT * FROM Personne ;


WHERE nom LIKE '_a%'
Il faut retenir que le mot clé WHERE peut être utilisé dans les requêtes SELECT, DELETE et 
UPDATE et l'utilisation est cumulative grâce au AND ou OR mais pas dans le INSERT car on 
ne peut pas insérer à un endroit précis de la table, l'insertion se fait toujours à la fin. 
 

La clause DISTINCT 
L’utilisation des clés permet d’éviter les doublons dans les tables stockées, mais par contre, 
ils  peuvent  apparaître  dans  les  résultats  d’une  requête.  La  clause  DISTINCT,  placée  juste 
après le SELECT, permet de supprimer ces éventuels doublons. 
 

Exemple :    SELECT DISTINCT anneeNais FROM Eleves ; 


 

La clause ORDER BY 
Cette  clause  permet  de  trier  le  résultat  d’une  requête  suivant  un  ou  des  attributs.  Par 
défaut, le tri se fait de façon ascendante (ASC) ; mais à l’aide du mot‐clé DESC (diminutif de 
DESCRIBE) on impose au tri d’être décroissant. 
 

SELECT * FROM Personne ORDER BY nom, prenom ;


SELECT * FROM Personne ORDER BY nom, prenom DESC;
 

Nota :  Il  existe  d’autres  clauses  telles  que  la  clause  LIMIT,  la  clause  GROUP  BY  et  la  clause 
HAVING que nous allons examiner à travers des exemples. 
 
V.7. Mise à jour d’enregistrements d’une table 
Il  s’agit  ici  de  la  modification  de  la  valeur  de  certains  attributs  de  certains  enregistrement 
d’une table. Pour cela on utilise la commande UPDATE avec comme syntaxe : 
UPDATE nomTable SET champ1=val1, champ2=val2, … , champn=valn
WHERE condition
 

V.8. Suppression d’enregistrement d’une table 
La  destruction  d’un  ou  de  plusieurs  enregistrements  d’une  table  se  fait  à  l’aide  de  la 
commande DELETE dont la syntaxe est la suivante : 
 

DELETE FROM nomTable


WHERE condition
 
V.9. Fonction PHP pour opérer sur une Base de données MySQL 
Les fonctions PHP pour MySQL commencent toujours par "mysql_", en voici ci‐dessous une 
liste non exhaustive.  
ƒ mysql_affected_rows — Retourne le nombre de lignes affectées lors de la dernière
opération MySQL
ƒ mysql_change_user — Change le nom de l'utilisateur de la connexion active
ƒ mysql_client_encoding — Retourne le nom du jeu de caractères utilisé par le
client MySQL
ƒ mysql_close — Ferme la connexion MySQL
ƒ mysql_connect — Ouvre une connexion à un serveur MySQL
ƒ mysql_create_db — Crée une base de données MySQL
ƒ mysql_data_seek — Déplace le pointeur interne de résultat MySQL
Béthel ATOHOUN – IIR – ESGIS – Juin 2008                32 

 
PHP/MySQL 

ƒ mysql_db_name — Lit les noms des bases de données


ƒ mysql_db_query — Envoie une requête MySQL à un serveur MySQL
ƒ mysql_drop_db — Efface une base de données MySQL
ƒ mysql_errno — Retourne le numéro d'erreur de la dernière commande MySQL
ƒ mysql_error — Retourne le texte associé avec l'erreur générée lors de la dernière
requête
ƒ mysql_escape_string — Protège les caractères spéciaux SQL
ƒ mysql_fetch_array — Retourne une ligne de résultat MySQL sous la forme d'un
tableau associatif, d'un tableau indexé, ou les deux
ƒ mysql_fetch_assoc — Lit une ligne de résultat MySQL dans un tableau associatif
ƒ mysql_fetch_field — Retourne les données enregistrées dans une colonne MySQL
sous forme d'objet
ƒ mysql_fetch_lengths — Retourne la taille de chaque colonne d'une ligne de
résultat MySQL
ƒ mysql_fetch_object — Retourne une ligne de résultat MySQL sous la forme d'un
objet
ƒ mysql_fetch_row — Retourne une ligne de résultat MySQL sous la forme d'un
tableau
ƒ mysql_field_flags — Retourne des détails sur une colonne MySQL
ƒ mysql_field_len — Retourne la taille d'un champ de résultat MySQL
ƒ mysql_field_name — Retourne le nom d'une colonne dans un résultat MySQL
ƒ mysql_field_seek — Déplace le pointeur de résultat vers une position donnée
ƒ mysql_field_table — Retourne le nom de la table MySQL où se trouve une colonne
ƒ mysql_field_type — Retourne le type d'une colonne MySQL spécifique
ƒ mysql_free_result — Libère le résultat de la mémoire
ƒ mysql_get_client_info — Lit les informations sur le client MySQL
ƒ mysql_get_host_info — Lit les informations sur l'hôte MySQL
ƒ mysql_get_proto_info — Lit les informations sur le protocole MySQL
ƒ mysql_get_server_info — Lit les informations sur le serveur MySQL
ƒ mysql_info — Lit des informations à propos de la dernière requête MySQL
ƒ mysql_insert_id — Retourne l'identifiant généré par la dernière requête INSERT
MySQL
ƒ mysql_list_dbs — Liste les bases de données disponibles sur le serveur MySQL
ƒ mysql_list_fields — Liste les champs d'une table MySQL
ƒ mysql_list_processes — Liste les processus MySQL
ƒ mysql_list_tables — Liste les tables d'une base de données MySQL
ƒ mysql_num_fields — Retourne le nombre de champs d'un résultat MySQL
ƒ mysql_num_rows — Retourne le nombre de lignes d'un résultat MySQL
ƒ mysql_pconnect — Ouvre une connexion persistante à un serveur MySQL
ƒ mysql_ping — Vérifie la connexion au serveur MySQL, et s'y reconnecte au besoin
ƒ mysql_query — Envoie une requête à un serveur MySQL
ƒ mysql_real_escape_string — Protège les caractères spéciaux d'une commande
SQL
ƒ mysql_result — Retourne un champ d'un résultat MySQL
ƒ mysql_select_db — Sélectionne une base de données MySQL
ƒ mysql_set_charset — Sets the client character set
ƒ mysql_stat — Retourne le statut courant du serveur MySQL
ƒ mysql_tablename — Lit le nom de la table qui contient un champ
ƒ mysql_thread_id — Retourne l'identifiant du thread MySQL courant
ƒ mysql_unbuffered_query — Exécute une requête SQL sans mobiliser les résultats
MySQL
 

En règle générale on n'utilise pas plus d’une dizaine de ces fonctions , et c'est d'ailleurs sur 
elles que nous mettrons l'accent plus bas dans ce document.  
Nous avons :  
mysql_connect(),   mysql_select_db(),    mysql_query(), mysql_num_rows(),  mysql_fetch_array(), 
mysql_fetch_row(),    mysql_fetch_assoc(),   mysql_close() 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                33 

 
PHP/MySQL 

Ces fonctions sont le minimum à connaître pour interroger une base de données MySQL. 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                34 

 
PHP/MySQL 

V.9.1. Connexion 
Elle se déroule en deux étapes :   
  ‐ Connexion au serveur de base de données  
  ‐ Sélection de la base de données à utiliser 
1. La connexion au serveur se fait à l’aide de la fonction mysql_connect 
 

int mysql_connect (string [chaine_connexion], string [nom_utilisateur],


string [motPasse])
 
chaine_connexion  est  au  format  [hote[:port][:fichierSocket]].  Par  défaut  la  chaine  hote 
est  localhost,  le  port  étant  le  port  par  défaut  du  serveur  MySQL.  On  peut  également 
indiquer le chemin d’accès au fichier socket. 
nom_utilisateur  est  le  nom  de  l’utilisateur  MySQL.  Par  défaut  il  prend  la  valeur  de 
l’utilisateur sous lequel le serveur Apache a été lancé (typiquement nobody) 
motPasse est le mot de passe de cet utilisateur. Vide par défaut. 
 

La fonction renvoie, en cas de succès, un entier positif qui est un identifiant de connexion 
(ressource) et qui est utilisé pour identifier la connexion lors des accès ultérieurs. 
 

Une autre variante de la fonction mysql_connect est la fonction mysql_pconnect.  
Avec exactement le même nombre de paramètres que mysql_connect, mysql_pconnect 
fait  la  même  chose  que  mysql_connect  à  la  différence  qu’elle  ouvre  une  connexion 
persistante qui n’est pas refermée à la fin du script de connexion. 
La sélection de la base de données est faite à l’aide de la fonction mysql_select_db. 
 

int mysql_select_db (string nomBase,


int [connexion],
string [motPasse])
 

nomBase devient la courante sur laquelle s’effectueront toutes les requêtes qui seront 
exécutées. 
connexion représente la ressource qui identifie la connexion encoure.  
 
Exemple :
mysql_connect("localhost","root");
mysql_select_db("personne"); 
 
V.9.2. Interrogation (requête)  
Il  est  question  ici  de  la  formulation  et  de  l’exécution  de  la  requête  SQL  en  utilisant  la 
connexion courante.  
L’exécution de la requête se fait à l’aide de la fonction mysql_query 
int mysql_query(string requête [, int connexion])

si  la  requête  échoue,  la  fonction  renvoie  false,  sinon  elle  renvoie  une  valeur  positive. 
Dans le cas de requêtes SELECT, la valeur renvoyée est l’identifiant du résultat qui peut 
être utilisé dans les fonctions mysql_fetch_***. 

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                35 

 
PHP/MySQL 

Exemple 1 :
$link = mysql_connect("localhost","root");
mysql_select_db("personne");
$result = mysql_query("SELECT * from presonne", $link) ;

Exemple 2 : (une autre variante de l’exemple 1)


$link = mysql_connect("localhost","root");
mysql_select_db("personne");
$requete = "SELECT * from presonne" ;
$result = mysql_query($requete, $link) ;

 
V.9.3. Extraction de données 
 

L’exécution d’une requête de type INSERT, DELETE, UPDATE ne nécessite pas un traitement 
supplémentaire après l’appel de la fonction mysql_query. La situation n’est pas exactement 
la même dans le cas d’une requête SELECT. En effet, une fois la sélection faite, il faut accéder 
aux données pour les exploiter.  
Pour cela on utilise souvent la fonction mysql_fetch_array ou mysql_fetch_row ou encore 
mysql_fetch_assoc.  
 
array mysql_fetch_array(int resultat [, int typeResultat])

renvoie un tableau associatif contenant les attributs de la ligne courante, et positionne le 
curseur  sur  la  ligne  suivante.  Chaque  champ  du  tableau  est  indexé  par  le  nom  de 
l’attribut correspondant dans la clause SELECT de la requête SQL.  
La fonction renvoie false quand il n’y a pas de ligne. 
resultat  est l’identifiant de résultat renvoyé par la fonction mysql_connect. 
typeResultat est une constante facultative qui peut prendre l’une des valeurs suivantes : 
MYSQL_ASSOC, MYSQL_NUM, MYSQL_BOTH. 

Pour les autres fonctions, consulter l’aide en ligne  www.php.net/nom_fonction  

array mysql_fetch_row(int resultat)

Renvoie un tableau indicé contenant les attributs de la ligne courante, et


positionne le curseur sur la ligne suivante. Les champs sont numérotés à partir
de 0.

Exemple 1 :
……………………………………………………………
……………………………………………………………
……………………………………………………………
while ( $ligne = mysql_fetch_array($result) ) {
echo $ligne["nom"] . " " . $ligne["prenom"] ." <br>" ;

Béthel ATOHOUN – IIR – ESGIS – Juin 2008                36