Cours de PHP

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.


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

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 !";

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.

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 $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.
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.


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.

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


== $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


++$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.

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


PHP/MySQL
II.9.5. Opérateurs Logiques


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;
...

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;

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)

{

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.
}

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();
?>

<?php
$c = 1;
function somme() {
$a = 2 ;
$b = 3 ;
$GLOGALS["c"] = $a + $b; // accès à $c globale
$c=10 ;
}
somme();
?>
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')

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.

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

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

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.

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;

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

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";
}
}

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

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;

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;
}
}
?>


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 ]] )


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";

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">

</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.

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;
}
?>


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.


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.

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;

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

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()

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

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_***.

PHP/MySQL
Exemple 1 :
$link = mysql_connect("localhost","root");
$result = mysql_query("SELECT * from presonne", $link) ;
Exemple 2 : (une autre variante de l’exemple 1)

$link = mysql_connect("localhost","root");
$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>" ;

Cours de PHP

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

Cours de PHP

Transféré par

Droits d'auteur :

Formats disponibles

Opérateur Exemple Nom Résultat

Opérateur Exemple Nom Résultat

Opérateur Exemple Nom Résultat

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

Opérateur Exemple Nom Résultat

function somme($premier, $second)

return $premier + $second ;

$obj1 = new BaseClass();

class ConcreteClass1 extends AbstractClass

$class1 = new ConcreteClass1;

class Template implements iTemplate

// Ceci ne fonctionnera pas

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

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

SELECT liste de champs (ou attributs)

SELECT * FROM matable ;

SELECT * FROM Personne ;

Exemple : SELECT DISTINCT anneeNais FROM Eleves ;

SELECT * FROM Personne ORDER BY nom, prenom ;

DELETE FROM nomTable

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

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

int mysql_select_db (string nomBase,

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

array mysql_fetch_row(int resultat)

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

Vous aimerez peut-être aussi

mysql_db_name — Lit les noms des bases de données