COURS DE PHP
I
I
.
.
I
I
n
n
t
t
r
r
o
o
d
d
u
u
c
c
t
t
i
i
o
o
n
n
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
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.
I
I
I
I
.
.
B
B
a
a
s
s
e
e
s
s
d
d
u
u
l
l
a
a
n
n
g
g
a
a
g
g
e
e
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 : <?phpecho "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 • nullIl 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/>";
?>
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.
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.
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).
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étiquesOpé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 === $b
Identique TRUE si $a est égal à $b et qu'ils sont de même type
!= $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.
$a‐‐ Post‐décrémente Retourne $a, puis décrémente $a de 1.
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){ instruction1; ... instructionN; } if (expression) instruction1; 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; ...} 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;
}
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) {
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.
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 = '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() 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 F Foonnccttiioonnss ggéénnéérraalleess Nom Rôle abs($nombre) Renvoie la valeur absolue de nombre empty($variable) Renvoie faux si la variable est définie et a une valeur différente de 0, "0", de la chaine vide "", d’un tableau ou d’un objet vide, de NULL. ; vrai sinon eval($commande) Exécute le contenu de la chaine $commande. exec($commande [, $tableau]) Exécute une commande système et renvoie la dernière ligne produite par l’exécution. Si $tableau est passé, il contiendra toutes les lignes produites par 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 [, $msg, $entete]) Permet d’envoyer un mail. md5($chaine) Fonction de hachage renvoyant une chaine de 32 octets. Normalement irréversible. Passthru($commande) Identique à la fonction exec, mais son resultat est directement envoyé au
navigateur. phpinfo() Affiche des information sur l’interpréteur PHP, etc. Etc. F Foonnccttiioonnss ppoouurr lleess cchhaaîînneess 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 addSlashed($chaien) Renvoie une chaine identique à $chaine en mettant le caractère 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 F Foonnccttiioonnss ppoouurr lleess ttaabblleeaauuxx 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 F Foonnccttiioonnss ppoouurr lleess eexxpprreessssiioonnss rréégguulliièèrreess Nom Rôle
ereg(exp, ch, tabocc) évalue l'expression et met les occurrences rencontrées dans ch dans le tableau tabocc la case 0 contient l'occurrence de l'expression, les autres cases les sous‐ occurrences. Retourne 0 si pas de correspondance ereg_replace(exp, rep, ch) remplace les sous‐chaînes de ch qui correspondent à l'expression exp par la 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 F Foonnccttiioonnss ppoouurr lleess ddaatteess 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, mois, j, a) retourne la valeur Timestamp qui correspond aux arguments gmmktime(h, m, s, mois, j, a) Comme mktime() mais au format Greenwich 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.
I
I
I
I
I
I
.
.
L
L
e
e
s
s
c
c
l
l
a
a
s
s
s
s
e
e
s
s
e
e
t
t
l
l
e
e
s
s
o
o
b
b
j
j
e
e
t
t
s
s
(
(
P
P
H
H
P
P
4
4
,
,
P
P
H
H
P
P
5
5
)
)
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.
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;
[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
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"; }
$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"; ?>
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->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; } } ?>
I
I
V
V
.
.
C
C
o
o
m
m
m
m
u
u
n
n
i
i
c
c
a
a
t
t
i
i
o
o
n
n
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 ]] )
$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 = '[email protected]'; $subject = 'le sujet';
$message = 'Bonjour !';
$headers = 'From: [email protected]' . "\r\n" . 'Reply-To: [email protected]' . "\r\n" .
'X-Mailer: PHP/' . phpversion();
mail($to, $subject, $message, $headers); ?>
Exemple 2 : Envoi de mail au format HTML <?php
// Plusieurs destinataires
$to = '[email protected]' . ', '; // notez la virgule $to .= '[email protected]';
// 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";
// En-têtes additionnels
$headers .= 'To: Mary <[email protected]>, Kelly <[email protected]>' . "\r\n";
$headers .= 'From: Anniversaire <[email protected]>' . "\r\n"; $headers .= 'Cc: [email protected]' . "\r\n";
$headers .= 'Bcc: [email protected]' . "\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.
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; } ?>
