ultra-concis PHP> date de dernière modification : 02/06/2022Ce document est (très) librement adapté de la doc PHP -- et aussi (un peu) du Précis & Concis PHP, aux éditions O'Reilly (par Rasmus Lerdorf himself). Il est lui-même un script PHP : toutes les valeurs de renvoi des exemples (en bleu) seront retournées (en rouge) par l'analyseur ("parser") PHP de l'hébergeur de cette page. Pour rester dans les limites du raisonnable, tout en faisant la part belle aux exemples, ce tutoriel se limite à la syntaxe de base et aux fonctions les plus courantes... > ce document a été réalisé à l'aide de EasyPHP 1.6 (www.easyphp.org/) sous Win2k, de l'éditeur ConTEXT (http://www.fixedsys.com/context/), "normalisé" avec Tidy (tidy.sourceforge.net/), et enfin testé avec les navigateurs Internet Explorer 6.0 et Mozilla 1.3. Si vous rencontrez des anomalies quelconques avec votre configuration, merci de me le faire savoir. sommaire
présentationPHP (acronyme récursif pour PHP Hypertext Preprocessor), développé initialement par Rasmus Lerdorf, est un langage de script qui fonctionne côté serveur -- contrairement au Javascript, par exemple, qui s'exécute sur la machine de l'utilisateur :-(On le trouve le plus souvent inséré dans une page HTML. L'analyseur PHP ne renverra au navigateur QUE du code HTML. PHP est donc aussi léger et transparent que l'air :-) Et c'est loin d'être sa seule qualité ! > le mieux est de placer le code entre les balises <?php et ?>, comme ceci : <html> <body> <?php echo "<b>Ceci est un déjà un script PHP !</b>"; ?> </body> </html>> puis d'enregistrer le fichier avec l'extension *.php. L'analyseur PHP (local ou non) retournera : Ceci est un déjà un script PHP !>> il est possible (voire courant) d'insérer des balises html dans du code PHP, tout comme du code PHP à l'intérieur de balises html : <?php $man="http://www.php.net/manual/fr/"; ?>retourne : manuel PHP en ligne haut, sommaire pré-requisDans ce tutoriel, nous présumons que vous avez un serveur web avec le support PHP activé, et que les fichiers terminés par l'extension .php sont traités par PHP. (...)Si votre serveur web supporte PHP, vous n'avez rien à faire. Simplement, créez un dossier, puis créez un fichier texte, avec l'extension .php : le serveur va automatiquement l'exécuter avec PHP. Il n'y a pas de compilation, ou d'installation compliquée. Gardez en tête que les fichiers sont comparables à des fichiers HTML, dans lesquels vous allez utiliser des balises magiques, qui feront beaucoup de choses pour vous. extrait du manuel PHP
Une certaine pratique du html est nécessaire à l'apprentissage de PHP ; ceux qui hésitent parmi les quelques dizaines de milliers de pages qui proposent des tutoriels peuvent se rendre là. > ceux qui pratiquent le Perl sont les bienvenus ; ils vont pouvoir se reposer un peu, ils l'ont bien mérité ;-) > ceux qui enregistrent leurs sources sous *.asp, bienvenue itou ; ils sauveront peut-être ainsi leur âme... > quant à ceux qui savent leur C, le royaume des cieux, même s'ils l'ignorent, leur appartient déjà. haut, sommaire la syntaxeles expressionsLes expressions sont la pierre angulaire de PHP. Une expression peut être : une instruction, une déclaration, une affectation, une comparaison...> si une instruction doit toujours se terminer par un point-virgule (sauf lorsqu'elle précède immédiatement une balise ?> de fin de bloc de code), ce n'est pas le cas d'une expression. > une expression renvoie une valeur booléenne TRUE (une valeur numérique différente de 0) ou FALSE, soit 0. > illustrons tout ceci avec l'opérateur ternaire (expression1) ? (expression2) : (expression3); emprunté au langage C, correspondant à l'instruction conditionnelle if/then/else : <?php ($a=1) ? (print "\$a renvoie 'vrai'") : (print "\$a renvoie 'faux'"); ?>retourne : $a renvoie 'vrai' <?php ($a=0) ? (print "\$a renvoie 'vrai'") : (print "\$a renvoie 'faux'"); ?>retourne : $a renvoie 'faux' les séquences d'échappement> le caractère d'échappement '\' protège certains caractères (les affiche tels quels à l'écran) :<?php echo "\$a = \"C'est comme ça...\""; ?>retourne : $a = "C'est comme ça..." > les séquences d'échappement, quant à elles, font de la mise en page :
>> si vos séquences d'échappement ne fonctionnent pas, encadrez votre code des balises HTML <pre> et </pre>. les commentaires> PHP supporte les commentaires du C, C++ et ceux du Shell Unix :
<?php
echo "Welcome !\t\t"; # commentaire sur une ligne
echo "Bienvenue !\t\t"; // commentaire sur une ligne
echo "Willkommen !\n"; /* commentaire sur
plusieurs lignes */
?>
retourne :
Bienvenue ! Welcome ! Willkommen ! contrôle d'erreurL'opérateur "@" placé devant une instruction (généralement une fonction) permet que le message d'alerte ou d'erreur généré par PHP soit ignoré :
<?php
if (unlink("texte.txt")) { // si (supprimer "texte.txt") retourne TRUE
print "\"texte.txt\" supprimé...";
} else { // sinon
print "\"texte.txt\" n'est pas supprimé...";
}
?>
retourne :
Warning: unlink() failed (No such file or directory) in index.php on line 333
"texte.txt" n'est pas supprimé...
>> pour éviter cela :
<?php
if (@unlink("texte.txt")) {
print "\"texte.txt\" supprimé...";
} else {
print "\"texte.txt\" n'est pas supprimé...";
}
?>
retourne : "texte.txt" n'est pas supprimé...haut, sommaire, la syntaxe les opérateursopérateurs arithmétiques
opérateurs de comparaison
opérateurs logiques
(*) priorité inférieure à celle de l'opérateur précédent > les opérateurs sur les bits, ainsi que la précédence des opérateurs sont traités en annexe haut, sommaire, les opérateurs types de donnéesIl n'est pas nécessaire de déclarer le type des données que l'on manipule, celui-ci est affecté dynamiquement par PHP.En revanche, il n'est pas inutile de connaître les différents types possibles : booléensUn booléen (cf les expressions) exprime une valeur VRAI 'TRUE', ou FAUX 'FALSE'.> les expressions suivantes étant strictement identiques, on ne sera pas, à priori, amené à utiliser explicitement un type booléen : <?php ($a == 0) == TRUE; ($a == 0) != FALSE; $a == 0; ?>> nous sommes d'accord. entiersUn entier (integer, ou int) est un nombre de l'ensemble des entiers naturels {..., -2, -1, 0, 1, 2, ...}.On peut l'exprimer de trois manières : <?php $a = 1234; /* nombre entier en base décimale */ $a = 02322; /* le même en base octale, préfixé 0 */ $a = 0x4D2; /* le même en base hexadécimale, préfixé 0x */ ?> réelsUn nombre réel (float, ou double), appelé aussi "à virgule flottante", peut être exprimé de deux manières :<?php $a = 1.234; $a = 1.2e3; /* notation scientifique */ ?> chaînes de caractèresUne chaîne (ou séquence) de caractères doit être encadrée de guillemets :> simples (' ') si elle ne contient rien qui nécessite d'être échappé ; > doubles (" ") si l'on veut que les séquences d'échappement et les variables qu'elle contient soient interprétées (on parle de "substitution de variables") : <?php $meilleurs = 'Marseille'; echo "$meilleurs, eux meilleurs !" ?>retourne : Marseille, eux meilleurs ! haut, sommaire, types de données les variables
définitionOn déclare une variable en lui attribuant un identifiant valide (commençant soit par un caractère alphabétique, soit par le caractère souligné '_') préfixé du signe dollar '$', et en lui assignant une valeur.> sauf si elle est déclarée au sein d'une définition de fonction, la portée d'une variable est globale (elle concernera le script entier à partir de la déclaration, ou de la redéclaration de la variable). > on assigne une valeur à une variable à l'aide du signe égal '=' : <?php $a = 3; /* assigne la valeur entière 3 à $a */ ?>valeur de $a : 3 > on peut assigner une valeur et le produit d'une opération arithmétique à une variable en même temps : <?php $a += 5; /* correspond à l'instruction $a = $a + 5 */ ?>valeur de $a : 8 > une variable peut être redéclarée ; sa valeur précédente sera chaque fois écrasée par la nouvelle valeur qu'on lui aura assignée : <?php $meilleurs = 'PSG'; echo "$meilleurs eux meilleurs !"; ?>retourne : PSG eux meilleurs ! assignation par référenceLe signe '&' permet d'assigner la valeur d'une variable source à une variable destination.> modifier la valeur de l'une modifiera aussi la valeur de l'autre : <?php $trop_meilleurs = 'Maseille'; $trop_meilleurs = &$meilleurs; echo "$trop_meilleurs y sont trop meilleurs..."; ?>retourne : PSG y sont trop meilleurs... concaténationLe point '.' permet de concaténer variables et chaînes de caractères :<?php $trop_meilleurs = $trop_meilleurs . " y sont trop meilleurs..."; /* ou bien : $trop_meilleurs .= " y sont trop meilleurs..."; */ echo $trop_meilleurs; ?>retourne : PSG y sont trop meilleurs... > la virgule ',' (uniquement avec la fonction echo()) permet elle aussi la concaténation : <?php echo $trop_meilleurs, " mais quand même moins que Marseille !"; ?>retourne : PSG y sont trop meilleurs... mais quand même moins que Marseille ! post-incrémentation/décrémentation
<?php
$a = 3;
$b = $a++; /* assigne la valeur de $a à $b,
puis incrémente $a */
?>
valeur de $a : 4valeur de $b : 3
<?php
$c = $a--; /* assigne la valeur de $a à $c,
puis décrémente $a */
?>
valeur de $a : 3valeur de $c : 4 pré-incrémentation/décrémentation
<?php
$d = ++$c; /* incrémente $c,
puis assigne la valeur obtenue à $d */
?>
valeur de $c : 5valeur de $d : 5
<?php
$e = --$d; /* décrémente $d,
puis assigne la valeur obtenue à $e */
?>
valeur de $d : 4valeur de $e : 4 haut, sommaire, les variables variables prédéfiniesdéfinitionLes variables prédéfinies (ou "superglobales") se présentent sous forme de tableaux associatifs (on parle aussi de "tableaux superglobaux"), dont les indices sont eux-mêmes des variables prédéfinies.> le plus évident d'entre eux est sans doute : $_SERVERLa disponibilité des champs de $_SERVER dépendent de la configuration du serveur sur lequel tourne PHP.Voici quelques-unes des entrées possibles :
> pour connaître les champs de la variable $_SERVER disponibles sur votre serveur, ou celui de votre FAI : <?php print_r($_SERVER); ?> >> la variable prédéfinie $GLOBALS est traitée à la section les fonctions. >> les variables prédéfinies $_POST, $_GET, $_COOKIE, $_FILES et $_REQUEST sont évoquées à la section traitement de formulaires. >> on parle de la variable prédéfinie $_SESSION à la section les sessions. haut, sommaire, variables prédéfinies les constantesdéfinitionContrairement à une variable, une constante ne peut pas être redéclarée.On la définit à l'aide de la fonction define(). > par convention, un nom de constante s'écrit en majuscule :
<?php
define ("MA_CONST", "Armatatuxa !");
?>
> si la constante est placée entre guillements lors de l'appel,
il n'y aura pas substitution :
<?php echo "MA_CONST retourne ", MA_CONST; ?>retourne : MA_CONST retourne armatatuxa > un caractère de concaténation est ici indispensable ; on peut tout aussi bien écrire : <?php echo "MA_CONST retourne ".MA_CONST; ?> constantes prédéfiniesIl existe beaucoup de constantes prédéfinies ; en voici un petit échantillon :__FILE__> le chemin complet de la page en cours :<?php echo __FILE__; ?> retourne : /var/www/home/ultra_php/index.php __LINE__> le numéro de la ligne de la constante :<?php echo "la ligne ", __LINE__, " ne contient aucune erreur ;-)"; ?>retourne : la ligne 930 ne contient aucune erreur ;-) PHP_VERSION<?php echo "la version de l'analyseur PHP est la : ", PHP_VERSION; ?>retourne : la version de l'analyseur PHP est la : 5.6.40 PHP_OS<?php echo "le système d'exploitation du serveur est ", PHP_OS; ?>retourne : le système d'exploitation du serveur est Linux > TRUE et FALSE (cf les booléens) sont aussi des constantes prédéfinies. >> la fonction get_defined_constants() renverra la liste exhaustive des constantes (pré)définies disponibles. haut, sommaire, les constantes les fonctionsdéfinitionUne fonction se définit à l'aide du mot-clé function, d'un identifiant valide, et de parenthèses '()'.> toute instruction PHP valide peut être contenue à l'intérieur du bloc délimité par les accolades '{}' :
<?php
function bateau() {
echo "fonction remplie !";
}
bateau(); // appel de fonction
?>
retourne : fonction remplie !> les parenthèses peuvent renfermer un ou plusieurs arguments :
<?php
function mult($i, $j) { // $i et $j sont des variables locales
return $i*$j; /* multiplie les valeurs des deux arguments
et retourne le résultat */
}
?>
> l'instruction return est utilisé soit pour retourner
une valeur (ou une variable), soit pour interrompre le déroulement
d'une fonction avec une valeur de retour (comme son homonyme en C).
>> pour implémenter cette fonction, passons-lui deux variables en argument :
<?php
$a = 5;
$b = 6;
$c = mult($a, $b); /* assignation de la valeur de retour
d'une fonction à une variable */
?>
valeur de $c : 30passation d'argumentsUne variable déclarée à l'intérieur d'une fonction n'a aucune valeur à l'extérieur (portée locale) :
<?php
$a=5;
function compteur_non_fonctionnel($i) {
$i++;
}
compteur_non_fonctionnel($a);
?>
valeur de $a : 5> l'opérateur d'adresse '&' permet à une variable locale de pointer sur l'adresse d'une globale :
<?php
function compteur_fonctionnel(&$i) {
/* $i pointe désormais sur l'adresse de la variable passée en argument
lors de l'appel de fonction */
$i++;
}
compteur_fonctionnel($a);
?>
valeur de $a : 6$GLOBALSUne variable déclarée à l'extérieur d'une fonction (portée globale) n'a pas cours à l'intérieur de celle-ci.Si l'on doit faire appel à une globale à l'intérieur d'une fonction, il faut la faire précéder du mot réservé global :
<?php
function nouveau_compteur () {
global $a;
$a++;
}
nouveau_compteur();
?>
valeur de $a : 7> la variable prédéfinie $GLOBALS est un tableau associatif dont les champs contiennent les globales déclarées dans le script :
<?php
function autre_compteur () {
$GLOBALS['a']++;
}
autre_compteur();
?>
valeur de $a : 8require()La fonction require() appelle et exécute un code contenu dans un fichier externe.> soit un fichier "phrase.inc" situé dans le même dossier que le présent fichier : le mot du jour : <?php require("phrase.inc"); ?> retourne : le mot du jour : Il vaut mieux qu'il pleuve un jour comme aujourd'hui qu'un jour où il fait beau ! >> l'extension .inc est par convention utilisée pour désigner un fichier de bibliothèque. include()La fonction include() est similaire à require(), à ceci près qu'avec include() le traitement ne s'interrompra pas en cas d'erreur, et le reste de la page s'affichera normalement.> voici le code d'un test idiot, appelant conditionnellement un fichier de bibliothèque ou un autre, selon l'indice criminogène de votre navigateur :
<?php
if (ereg ("MSIE", $HTTP_USER_AGENT)) {
include ('IE.inc');
}
else {
include ('NOT.inc');
}
?>
>> la fonction ereg() recherche
(et renvoie TRUE si elle trouve) la chaîne 'MSIE'
dans la chaîne retournée par $HTTP_USER_AGENT. haut, sommaire, les fonctions les tableauxdéclarationUne manière simple de déclarer un tableau est d'utiliser la fonction array() :
<?php
$tablo = array("premier élément",
"deuxième élément",
"troisième élément");
?>
> la fonction print_r permet
d'afficher une variable, quel que soit son type :
<?php print_r($tablo); ?>retourne :
Array
(
[0] => premier élément
[1] => deuxième élément
[2] => troisième élément
)
> ceci nous montre la structure ([indice] =>
element) d'un tableau. >> ajoutons un élément à notre tableau : <?php $tablo[] = "nouvel élément"; print_r($tablo); ?>retourne :
Array
(
[0] => premier élément
[1] => deuxième élément
[2] => troisième élément
[3] => nouvel élément
)
tableaux associatifsOn parle de tableau associatif lorsque l'on affecte une valeur à l'indice :
<?php
$tablo = array("patron" => "Marc-André",
"commercial" => "Louis-Christophe",
"Thierry"
);
print_r($tablo);
?>
retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
[0] => Thierry
)
> l'indice [0] est automatiquement affecté au premier
élément dépourvu d'indice. >> supprimons un élément : <?php unset($tablo[0]); print_r($tablo); ?>retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
)
> la fonction unset() permet de
supprimer une variable. >> ajoutons un élément avec un indice associé : <?php $tablo['secrétaire'] = "Valérie-Anne"; ?>>> affichons cet élément d'après son indice : <?php echo $tablo['secrétaire']; ?>retourne : Valérie-Anne >> + sur les tableaux : fonctions de tableaux haut, sommaire, les tableaux les structures de contrôleif/elseif
<?php
$a = 8;
$b = 9;
echo "révision sur la pré/post incrémentation :\n";
if (++$a == $b) { // si (expression) renvoie TRUE
echo "++\$a est égal à $b"; // instruction
} elseif ($a++ == $b) { // autre si (expression) renvoie TRUE
echo "\$a++ est égal à $b"; // instruction
} else { // sinon
echo "rien de tout ça !"; // instruction
}
?>
retourne :
révision sur la pré/post incrémentation : ++$a est égal à 9 > afin d'améliorer la lisibilité du code, et/ou sa maintenance, il est possible de le découper en blocs d'instructions :
<?php
$a = 8;
$b = 9;
?>
révision sur la pré/post incrémentation :<br>
<?php
if (++$a == $b) {
?>
++$a est égal à 9
<?php
} elseif ($a++ == $b) {
?>
$a++ est égal à 9
<?php
} else {
?>
rien de tout ça !
<?php
}
?>
retourne :
révision sur la pré/post incrémentation : ++$a est égal à 9> la lisibilité de cet exemple sera accrue par l'adoption d'une syntaxe alternative. switch/caseLes instructions switch et case remplacent avantageusement if/elseif lorsque les conditions sont plus nombreuses :
<?php
switch ($a+1) { // si ($a+1) est égal à
case ($a++): // $a++
print "(\$a+1) est égal à ($a++)"; // instruction
break; // sortir
case (++$a): // ++$a
print "(\$a+1) est égal à (++$a)"; // instruction
break; // sortir
case ($a+1): // $a+1
print "(\$a+1) est égal à ($a+1)"; // instruction
continue; // continuer
default; // rien de tout ça
print "rien de tout ça !"; // instruction
}
?>
retourne : rien de tout ça !
// forcément
:) do/while> permet d'exécuter l'instruction au moins une fois :
<?php
$i = 0;
do { // faire
print $i; // instruction
} while ($i > 0); // tant que (condition)
?>
retourne : 0while> ne garantit pas que l'instruction s'exécute :
<?php
$i = 0;
while ($i > 0) { // tant que (condition)
print $i; // instruction
}
?>
retourne : (rien) >> obtenons une sortie :
<?php
$i = 0;
while ($i < 10) {
print ($i++ . " ");
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9 forLa boucle for remplit les mêmes fonctions que la boucle while, mais son utilisation est plus concise :> la plus concise : <?php for ($i = 0; $i < 10; print "$i ", $i++); ?>retourne : 0 1 2 3 4 5 6 7 8 9
<?php
for ($i = 0; $i < 10; $i++){
print "$i ";
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9
<?php
for ($i = 0;;$i++) {
if ($i == 10) {
break;
}
print "$i ";
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9
<?php
$i = 0;
for (;;) {
if ($i == 10) {
break;
}
print "$i ";
$i++;
}
?>
retourne : 0 1 2 3 4 5 6 7 8 9 syntaxe alternativeLes structures concernées sont : if/elseif, switch, while, for et foreach.> il s'agit de remplacer les accolades d'ouverture '{' par le signe ':', et l'accolade finale de fermeture '}' par, respectivement : 'endif;', 'endswitch;', 'endwhile;', 'endfor;' et 'endforeach;'. > si l'on reprend l'exemple donné pour if/elseif, cela donne : <?php $a = 8; $b = 9; echo "révision sur la pré/post incrémentation :\n"; if (++$a == $b) : echo "++\$a est égal à $b"; elseif ($a++ == $b) : echo "\$a++ est égal à $b"; else : echo "rien de tout ça !"; endif; ?>retourne : révision sur la pré/post incrémentation : ++$a est égal à 9>> découpons à présent notre code : <?php $a = 8; $b = 9; ?> révision sur la pré/post incrémentation :<br> <?php if (++$a == $b) : ?> ++$a est égal à 9 <?php elseif ($a++ == $b) : ?> $a++ est égal à 9 <?php else : ?> rien de tout ça ! <?php endif; ?>résultat identique : révision sur la pré/post incrémentation : ++$a est égal à 9> c pas bô, ça ? haut, sommaire, les structures de contrôles traitement de formulaires$_POSTLe tableau superglobal $_POST couvre l'ensemble des champs renseignés par la méthode "post" d'un formulaire.> la valeur du champ "name" d'un formulaire est accessible dans les variables $_POST['valeur'] ou $_GET['valeur'] du script cible : > c'est à vous >> voici le code de l'exploit :D
<?php $tut=$_POST['tuto']; ?>
<form action="./sondage.php" method="post">
<select name="tuto">
<option
<?php
if ($tut=="horripilant") {
$tut="passionnant"; echo ' selected';
}
?>
>horripilant</option>
<option
<?php
if ($tut=="soporifique") {
$tut="fantastique"; echo ' selected';
}
?>
>soporifique</option>
<option
<?php
if ($tut=="lamentable") {
$tut="incontournable"; echo ' selected';
}
?>
>lamentable</option>
<option
<php
if($tut=="affreux") {
$tut="fabuleux"; echo ' selected';
}
?>
>affreux</option>
</select>
$_GETLe tableau $_GET couvre l'ensemble des champs renseignés par la méthode "get" d'un formulaire.> c'est encore à vous > code :
<?php
if ($_GET['go']) {
if (empty($_GET['pseudo'])||empty($_GET['qualite'])||empty($_GET['defaut'])) {
echo "Vous n'avez pas rempli tous les champs !";
} else {
echo $_GET['pseudo'] ?> , vous êtes <?php echo $_GET['qualite'] ?> , mais <?php echo $_GET['defaut']; ?> :) <?php
}
} else {
}
?>
> la fonction empty() retourne TRUE si la
chaîne passée en argument est vide.La méthode "get" d'un formulaire génère une chaîne de caractères, constituée d'autant de couples 'élément=valeur', séparés par un '&', que de champs remplis dans le formulaire. Cette chaîne est limitée à 255 caractères ; elle s'accroche à l'url de la page avec un point d'interrogation '?' : > par exemple, supposons que vous ayez rempli le formulaire avec les éléments suivants : <?php $_GET['pseudo']="Boulet"; $_GET['qualite']="gentil"; $_GET['defaut']="lourd"; ?>> l'url du formulaire donne quelque chose comme : http://thierry.lhomme.free.fr/php_scripts/form.php?pseudo=Boulet&qualite= \ gentil&defaut=lourd&go=OK> on peut analyser cette chaîne à l'aide de la fonction parse_url(), qui retourne, dans un tableau, les différents éléments constitutifs d'une url :
<?php
$tab=parse_url("http://thierry.lhomme.free.fr/php_scripts/form.php?pseudo= \
Boulet&qualite=gentil&defaut=lourd&go=OK");
print_r($tab);
?>
retourne :
Array
(
[scheme] => http
[host] => thierry.lhomme.free.fr
[path] => /php_scripts/form1.php
[query] => pseudo=Boulet&qualite=gentil&defaut=lourd&go=OK
)
> on peut exploiter ce dernier champ en faisant appel à la
fonction parse_str(), laquelle analyse une chaîne et
convertit les couples 'élément=valeur' en couples
'variables=valeur' :
<?php parse_str($tab['query']); echo "$pseudo, vous êtes $qualite, mais $defaut :)"; ?>retourne : Boulet, vous êtes gentil, mais lourd :) $_COOKIE
<?php
setcookie("ultra", "sans_valeur", time()+3600*24);
?>
> soit un cookie, créé par la fonction setcookie(),
nommé "ultra", de valeur "sans_valeur", et d'une
durée de vie de 24 heures :
<?php echo $_COOKIE['ultra']; ?>retourne (pour peu que vous ayez accepté le cookie) : > si le champ est vide alors que vous n'avez pas bloqué le cookie, rafraîchissez la page... >> pour une fois que vous pouvez voir la valeur d'un cookie s'afficher sur la page qui vous l'a envoyé :) $_FILESSoit un fichier uploadé par la méthode "post" d'un formulaire :<form enctype="multipart/form-data" action="traite_fichier.php" method="post"> <input type="hidden" name="MAX_FILE_SIZE" value="10000"> <input type="file" name="fichier"> <input type="submit" value="OK"> </form>> le fichier "traite_fichier.php" peut ressembler (sommairement) à ceci :
<?php
$rep_dest="../php_scripts/";
if(move_uploaded_file($_FILES['fichier']['tmp_name'],
$rep_dest . $_FILES['fichier']['name'])) {
print "\"fichier\" a bien été uploadé et placé dans \"php_scripts\" :)";
} else {
print "pas marché :("
}
?>
>> la fonction move_uploaded_file() vérifie si
l'upload s'est bien passé ET place le fichier dans
le répertoire spécifié. $_REQUESTUn tableau associatif constitué du contenu des variables $_GET, $_POST, $_COOKIE et $_FILES :> dans l'état actuel des choses, <?php print_r($_REQUEST); ?>retourne : Array ( ) haut, sommaire, traitement de formulaires les sessionsLes sessions permettent de conserver un certain nombre d'informations, sous forme de variables, de page en page au sein d'un site.> soit un formulaire session.php : <form action="./login.php" method="post"> votre pseudo : <input type="text" name="pseudo" value=""> votre pwd : <input type="password" name="pwd" value=""> validez : <input type="submit" name="go" value="OK">> le fichier login.php pourrait ressembler à ceci :
<?php
$pseudo_valide="moi";
$pwd_valide="aspro";
if ($_POST['pseudo']==$pseudo_valide && $_POST['pwd']==$pwd_valide) {
header('location: membre.php'); // redirige vers la page "membre.php"
} else {
echo "pseudo ou password invalide :("
}
?>
>> voici à quoi pourrait ressembler le début du fichier
membre.php :
<?php session_start(); // démarre la session ?> <html><body> <?php echo "Bonjour et bienvenue,".$_SESSION['pseudo_valide']." !"; ?> etc... <a href="deconnect.php">Déconnexion(<?php echo $_SESSION['pseudo_valide'] ?>)</a> etc...> la fonction session_start() doit être appelée avant toute balise html. Elle doit être présente dans chaque page où l'on fait appel aux variables de session. > ce que pourrait contenir le fichier deconnect.php : <?php session_start(); session_unset(); // supprime toutes les variables de session session_destroy(); // deux précautions valent mieux qu'une echo "vous devriez à présent être déconnecté(e) :)"; ?> haut, sommaire, les sessions les objetsLa programmation orientée objet (POO, pour les intimes) permet d'économiser du code.Elle mérite donc toute notre attention :) Le concept d'objet est indissociable du concept de classe. Une classe se crée à l'aide du mot réservé class et d'un identifiant valide. > dans sa plus simple expression, notre classe ressemble à ceci :
<?php
class commande {
var $client;
function panier() {
echo $this->client;
}
}
?>
> à l'intérieur d'une classe, on déclare ses variables (ou
"attributs") à l'aide du mot réservé var.> une fonction (ou "méthode"), agit sur les attributs à l'aide de la variable spéciale $this et de l'opérateur ->. Une variable externe associée à une classe devient un objet. Cette association est appelée "instanciation de l'objet". > un objet devient l'instance d'une classe grâce au mot réservé new : <?php $clampin01 = new commande(); ?>> on lui assigne une valeur via un attribut de la classe, et à l'aide de l'opérateur -> : <?php $clampin01->client = "Pierre Duvet"; ?>> attention ! un seul $ pour cette nouvelle variable. Appelons à présent la méthode : <?php $clampin01->panier(); ?>retourne : Pierre Duvet Afin que l'utilisation d'une classe soit un peu plus justifiée, rajoutons à notre méthode quelques fonctionnalités. Le propos sera de gérer le panier du client, et afficher sa commande :
<?php
class commande {
var $client;
function panier($ref, $nbre) {
echo "client : ".$this->client;
echo "<br>votre commande : ";
echo $this->ref += $nbre; // affiche le nombre d'articles
echo " $ref<br>a bien été enregistrée...";
}
}
?>
> passons notre première commande :
<?php
$clampin01->panier("trucs", 6);
?>
retourne :
client : Pierre Duvet Pour résumer cette courte introduction à la POO selon PHP (et rentabiliser quelque peu le code investi :)), créons un nouvel objet, et exploitons-le :
<?php
$clampin02=new commande(); // instanciation de l'objet
$clampin02->client="Marie Couette"; // assignation de valeur via l'attribut
$clampin02->panier("bidules", 8); // appel de méthode
?>
retourne :
client : Marie Couette haut, sommaire, les objets fonctions intégréesIl existe énormément de fonctions PHP intégrées ; on en trouvera la liste exhaustive ici : www.php.net/manual/fr/funcref.php> en voici quelques-unes parmi les plus courantes, classées par domaine d'utilisation (ce classement respecte celui de la doc pré-citée) :
fonctions de test de type> il existe une fonction de test pour chaque type de variables :
> exemple : <?php $a = 'zolie variable'; (is_string($a)) ? (print "\$a est une chaîne") : (print "\$a est autre chose") ?>retourne : $a est une chaîne fonctions de variablesisset()isset() permet de savoir si une variable est définie ou non :<?php (isset($a)) ? (print "\$a est une $a") : (print "\$a n'existe pas") ?>retourne : $a est une zolie variable unset()unset() détruit la ou les variable(s) passée(s) en argument :<?php unset ($a); (isset($a)) ? (print "\$a est toujours une $a") : (print "\$a n'existe plus") ?>retourne : $a n'existe plus print_r()print_r() affiche la structure simple d'une variable :<?php print_r($tablo); ?>retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
[secrétaire] => Valérie-Anne
)
var_dump()var_dump() affiche la structure complexe d'une variable :<?php var_dump($tablo); ?>retourne :
array(3) {
["patron"]=>
string(10) "Marc-André"
["commercial"]=>
string(16) "Louis-Christophe"
["secrétaire"]=>
string(12) "Valérie-Anne"
}
fonctions de chaînes
echo()echo() n'étant pas vraiment une fonction, mais une structure du langage, on n'est pas tenu d'utiliser les parenthèses '()'.> echo() (mais pas print()) permet de concaténer deux chaînes avec une virgule ',' : <?php $a = 'zolie variable'; /* ligne en question */ echo "et revoilà notre $a, déclarée ligne ", __LINE__ -1; ?>retourne : et revoilà notre zolie variable, déclarée ligne 2308 > remarquons au passage la souplesse de PHP, qui nous permet de situer très simplement la ligne en question. >> comme cette structure ne fonctionne pas avec echo() : <?php (isset($a)) ? (echo "\$a existe") : (echo "\$a n'existe pas") /* ne fonctionne pas */ ?>> nous l'utiliserons avec : print()print() n'étant pas non plus vraiment une fonction, la même remarque au sujet des parenthèses s'applique.> si l'on veut, on peut utiliser des parenthèses malgré tout :
<?php
(isset($a)) ? (print ("\$a existe")) : (print ("\$a n'existe pas"))
?>
retourne : $a existeprintf()printf() renvoie une chaîne formatée, à la manière de son célèbre homologue en C :<?php $char = 612; $chaine = "le code ASCII %s correspond à la lettre %c"; printf ($chaine, $char, $char); ?>retourne : le code ASCII 612 correspond à la lettre d > le format des arguments est sensiblement le même qu'en C :
implode()implode() permet de rassembler les éléments d'un tableau en une chaîne.> le premier argument est le signe utilisé comme séparateur de champs :
<?php
$chaine_de_tablo = implode(" | ", $tablo);
print $chaine_de_tablo;
?>
retourne : Marc-André | Louis-Christophe | Valérie-Anneexplode()explode() réalise l'opération inverse :
<?php
$tablo_tout_neuf = explode(" | ", $chaine_de_tablo);
print_r ($tablo_tout_neuf);
?>
retourne :
Array
(
[0] => Marc-André
[1] => Louis-Christophe
[2] => Valérie-Anne
)
>> évidemment, les indices sont passés à la trappe... strstr()strstr() recherche la première occurence d'une chaîne :<?php $email = 'user@example.com'; $domaine = strstr($email, '@'); print $domaine; ?>retourne : @example.com str_replace()str_replace() remplace une occurence dans la chaîne spécifiée :
<?php
$nouvel_email = str_replace('example.com', 'mydomain.net', $email);
print $nouvel_email;
?>
retourne : user@mydomain.netstr_pad()str_pad() complète la chaîne spécifiée, jusqu'à atteindre une taille n, avec le ou les caractère(s) fourni(s) en argument :<?php $message = "WELCOME !"; print str_pad($message, 20, "+-") . "\n"; print str_pad($message, 20, "+-", STR_PAD_LEFT) . "\n"; print str_pad($message, 20, "+-", STR_PAD_BOTH) . "\n"; ?>retourne : WELCOME !+-+-+-+-+-+ +-+-+-+-+-+WELCOME ! +-+-+WELCOME !+-+-+-> si aucun caractère de remplissage n'est fourni, str_pad() utilisera des espaces vides. str_repeat()str_repeat() retourne une chaîne dont le caractère fourni en argument sera multiplié n fois :
<?php
$chaine = str_repeat("+-", 10);
echo $chaine;
?>
retourne :
+-+-+-+-+-+-+-+-+-+- strrchr()strrchr() retourne le segment de la chaîne spécifiée qui commence avec le dernier caractère passé en argument :<?php $fichier = strrchr($_SERVER[PHP_SELF], "/"); echo $fichier; ?>retourne : /index.php substr()substr() retourne le segment de la chaîne spécifiée commençant par le nième argument de la chaîne (optionnellement de longueur n).> le premier argument de la chaîne est indexé à 0 : <?php $fichier = substr(strrchr($_SERVER[PHP_SELF], "/"), 1); echo $fichier; ?>retourne : index.php > la fonction basename() retourne le même résultat. fonctions de répertoiresopendir()opendir() permet d'ouvrir un répertoire (en y plaçant un pointeur) :
<?php
$rep="confidentiel";
if ($ptr=opendir($rep)) {
print "dossier \"$rep\" ouvert !";
} else {
print "impossible d'ouvrir \"$rep\" :(";
}
?>
retourne : dossier "confidentiel" ouvert !readdir()readdir() retourne le nom du fichier identifié par le pointeur.> pour lire tout le contenu du dossier ouvert (et se croire un moment sous Linux :)) :
&gt; ls -a confidentiel<br>
<?php
while ($file=readdir($ptr)) {
echo "$file\n";
}
?>
&gt;
retourne : > ls -a confidentiel ultra-secret.xyz .. . perso-privé.xyz révélations.xyz > rewinddir()rewinddir() replace le pointeur au début du répertoire ouvert.> reprenons l'exemple précédent, sans afficher le répertoire en cours ".", ni le répertoire parent ".." :
&gt; ls confidentiel<br>
<?php
rewinddir($ptr);
while ($file=readdir($ptr)) {
if ($file != "." && $file != "..") {
echo "$file\n";
}
}
?>
&gt;
retourne : > ls confidentiel ultra-secret.xyz perso-privé.xyz révélations.xyz > closedir()closedir() permet de fermer un répertoire ouvert avec opendir() :<?php closedir($ptr); ?>> closedir() est de type void, et ne renvoie donc pas de valeur ; pour tester le succès de l'appel de la fonction, il faut forcer un peu les choses :
<?php
if (@readdir($ptr)) { /* sans le "@" on se ferait incendier ;) */
print "\"$rep\" toujours ouvert !";
} else {
print "\"$rep\" fermé :)";
}
?>
retourne : "confidentiel" fermé :)fonctions de fichiers
basename()basename() renvoie le nom de base du fichier passé en argument :<?php echo basename($_SERVER[PHP_SELF]); ?>retourne : index.php > si l'on ne veut pas de l'extension : <?php echo basename($_SERVER[PHP_SELF], ".php"); ?>retourne : index copy()copy() copie un fichier source vers un fichier destination :
<?php
if (!copy(basename($_SERVER[PHP_SELF]), 'ultra_php.safe')) {
print "copie impossible";
} else {
print "copie effectuée";
}
?>
> les extensions '*.foo' des noms de fichiers doivent
être soigneusement 'quotées' (pour ne pas être assimilées à des
concaténations). Ceci fonctionne également :
<?php copy(basename($_SERVER[PHP_SELF]), ultra_php . '.safe') ?> fopen()fopen() ouvre un fichier (local ou distant) sous forme de flux et retourne un pointeur de fichier.> différents modes sont possibles :
(*) réduit la taille du fichier à 0. > fopen() tente de créer le fichier s'il n'existe pas :
<?php
$fichier = "kernighan.txt";
if (!$flux = fopen($fichier, "w+")) {
print "création de \"$fichier\" impossible :-(";
} else {
print "\"$fichier\" est ouvert en lecture / écriture...";
}
?>
"kernighan.txt" est ouvert en lecture / écriture... fclose()fclose() ferme un flux de fichier ouvert :
<?php
if (!fclose($flux)) {
print "\"$fichier\" est toujours ouvert...";
} else {
print "\"$fichier\" est fermé !";
}
?>
"kernighan.txt" est fermé ! fwrite()fwrite() permet d'écrire dans un fichier :
<?php
if (!$flux = fopen($fichier, "w")) {
print "ouverture de $fichier en écriture impossible :-(";
exit;
}
$texte = "'Text is everything,\n
data is just streams\n
of lines of text...'\n
-- Brian Kernighan";
if (fwrite ($flux, $texte)) {
print "le texte :\n\n" . "$texte\n\n" . "a bien été écrit dans \"$fichier\"";
} else {
print "je crois que ça n'a pas été possible :-(";
}
fclose($flux);
?>
retourne :
le texte : 'Text is everything, data is just streams of lines of text...' -- Brian Kernighan a bien été écrit dans "kernighan.txt" fgets()fgets() retourne une chaîne lue depuis un flux ouvert, jusqu'au premier retour à la ligne rencontré :<?php $flux = fopen($fichier, "r"); echo fgets($flux); fclose($flux); } ?>retourne : 'Text is everything, >> fgets() accepte un deuxième argument : la longueur de la chaîne lue, exprimée en octets. Par défaut, celle-ci est de 1024. Spécifions une valeur de 10 octets : <?php $flux = fopen($fichier, "r"); echo fgets($flux, 10); fclose($flux); } ?>retourne : 'Text is feof()feof() retourne TRUE lorsque le pointeur a atteint la fin du fichier :
<?php
$flux = fopen($fichier, "r");
while (!feof($flux)) {
echo fgets($flux);
}
?>
retourne :
'Text is everything, data is just streams of lines of text...' -- Brian Kernighan>> feof() ferme le flux ouvert, en conséquence de quoi l'appel à fclose() générerait des erreurs. readfile()readfile() lit (et retourne) un fichier entier :<?php readfile($fichier); ?>retourne : 'Text is everything, data is just streams of lines of text...' -- Brian Kernighan file()Comme readfile(), file() lit le contenu d'un fichier, mais le retourne dans un tableau :<?php $ker_tablo = file($fichier); print $ker_tablo[3]; } ?>retourne : -- Brian Kernighan filemtime()filemtime() renvoie la date à laquelle un fichier a été modifié :
<?php
echo "\"$fichier\" a été modifié le " . date("d/m/Y", filemtime($fichier));
?>
retourne : "kernighan.txt" a été modifié le 24/04/2024> si l'on ne souhaite la date de dernière modification que de la page en cours, on pourra utiliser : getlastmod()getlastmod() ne concerne que la page en cours et ne prend aucun argument :
<?php
echo "date de dernière modification : le " . date("d/m/Y", getlastmod());
?>
retourne : date de dernière modification : le 02/06/2022unlink()unlink() efface le fichier passé en argument :<?php unlink($fichier); ?>> à condition d'avoir les droits appropriés dessus ;-) fileperms()fileperms() renvoie les bits de permissions (au format décimal) du fichier passé en argument :<?php $perms = fileperms($fichier); echo $perms; ?>retourne : 33188 > si les vous préférez au format unix :
<?php
$octal_perms = sprintf("%o", $perms);
$unix_perms = (substr($octal_perms, 2));
echo $unix_perms;
?>
retourne : 0644chmod()Comme son homonyme sous unix, chmod() permet (au propriétaire du fichier) de changer les bits de permissions :
<?php
if (!chmod($fichier, 0755)) {
print "droits sur \"$fichier\" inchangés";
} else {
print "vous avez désormais tous les droits sur \"$fichier\"";
}
?>
fonctions de tableauxOutre array(), il existe beaucoup de fonctions permettant de manipuler des tableaux.Voici les plus courantes : each()each() permet de parcourir un tableau :
<?php
reset($tablo); /* obligatoire avec cette structure */
while (list($indice, $element) = each ($tablo)) {
echo "$indice : $element\n";
}
?>
retourne :
patron : Marc-André commercial : Louis-Christophe secrétaire : Valérie-Anne foreach()foreach() (PHP4 seulement) est un moyen simple de parcourir un tableau :
<?php
foreach ($tablo as $indice => $element) {
echo "$indice : $element\n";
}
?>
retourne :
patron : Marc-André commercial : Louis-Christophe secrétaire : Valérie-Anne array_keys()array_keys() retourne (dans un tableau) les indices du tableau passé en argument :<?php print_r(array_keys($tablo)); ?>retourne :
Array
(
[0] => patron
[1] => commercial
[2] => secrétaire
)
array_values()array_values() retourne (dans un tableau) les valeurs du tableau passé en argument :<?php print_r(array_values($tablo)); ?>retourne :
Array
(
[0] => Marc-André
[1] => Louis-Christophe
[2] => Valérie-Anne
)
array_push()array_push() ajoute de nouveaux éléments à un tableau :<?php array_push($tablo, "Olivier-Jacques"); print_r($tablo); ?>retourne :
Array
(
[patron] => Marc-André
[commercial] => Louis-Christophe
[secrétaire] => Valérie-Anne
[1] => Olivier-Jacques
)
> l'indice [1] attribué au dernier élément de
$tablo s'explique par le fait que l'indice [0]
avait déjà été attribué à un autre élément (cf tableaux associatifs). Même si cet élément a été
supprimé, son indice ne peut être réattribué à un autre.Les bases de données se comportent de la même façon. >> de la même façon, il n'est pas possible de renommer un indice. Si nous voulons que Olivier-Jacques soit compté comme technicien dans l'entreprise, il faudra d'abord supprimer son entrée actuelle : <?php unset($tablo[1]); $tablo['technicien']="Olivier-Jacques"; ?> count()count() retourne le nombre d'éléments d'un tableau :<?php $nbre_element=count($tablo); echo "notre entreprise compte $nbre_element personnes :<br>"; ?>retourne : notre entreprise compte 4 personnes : list()list() fait correspondre chaque élément d'un tableau à une variable.list() n'opère qu'avec les tableaux non-associatifs, c'est pourquoi nous devons créer un nouveau tableau : <?php $new_tablo=array_keys($tablo); list($boss, $comm, $secr, $tech) = $new_tablo; echo "le $boss, un $comm, une $secr et un $tech."; ?>retourne : le patron, un commercial, une secrétaire et un technicien. fonctions d'expressions régulièresLes expressions régulières sont utilisées pour manipuler des chaînes de caractères.PHP supporte les expressions régulières avancées de POSIX (POSIX 1003.2). Si vous avez quelques lacunes, je ne peux que vous conseiller cette excellente présentation des regex. > voici les fonctions disponibles : ereg(), eregi()ereg() recherche (et renvoie TRUE si elle trouve) une ou plusieurs séquence(s) de caractères dans une chaîne.> dans l'exemple suivant, on verifie si $email contient bien un arobase et un point :
<?php
if(ereg("@", $email) && ereg(".", $email)) {
print "email valide :)\n";
} else {
print "email non valide :(\n";
}
?>
retourne : email valide :)
> ereg() accepte un troisième argument : un tableau contenant les résultats de la recherche, et dont l'indice [0] contient une copie de la chaîne :
<?php
if(ereg("(user|moi)@(example|domain).(com|net)", $email, $result)) {
echo $result[0]." (".$result[1]."@".$result[2].".".$result[3].")";
} else {
print "pas trouvé :(";
}
?>
retourne : user@example.com (user@example.com)>> eregi() est similaire à ereg(), excepté qu'avec ereg() la recherche est sensible à la casse, tandis qu'avec eregi() elle ne l'est pas. ereg_replace(), eregi_replace()ereg_replace() remplace une séquence de caractères par une autre dans une chaîne :
<?php
$new_email=ereg_replace("^user", "moi", $email);
/* remplace la chaîne débutant par "user" par "moi" */
$new_email=ereg_replace("ex.mple", "mydomain", $new_email);
/* si l'on n'est pas sûr de l'orthographe */
$new_email=ereg_replace("com$", "net", $new_email);
/* remplace la chaîne finissant par "com" par "net" */
echo $new_email;
?>
retourne : moi@mydomain.net>> eregi_replace() est similaire à ereg_replace(), excepté qu' eregi_replace() est insensible à la casse. split(), spliti()Comme implode() (mais avec le support des expressions régulières), split() scinde une chaîne en un tableau :
<?php
list($nom, $dom, $suf) = split ("[@.]", $new_email);
echo "nom : $nom ; domaine : $dom ; suffixe : $suf";
?>
retourne : nom : moi ; domaine : mydomain ; suffixe : net>> spliti() est similaire à split(), excepté... sql_regcase()sql_regcase() retourne les différents caractères de la chaîne passée en argument par paire majuscule/minuscule entre crochets.Cette fonction sert à préparer une requête insensible à la casse, dans le format des expressions régulières :
<?php
echo sql_regcase("mysql");
?>
retourne : [Mm][Yy][Ss][Qq][Ll]fonctions MySQLPHP est compatible avec bon nombre de SGBD. Parmi ces derniers, et parcequ'il a beaucoup de choses en commun avec PHP (gratuité, disponibilité du code source, etc), MySQL est sans conteste le plus populaire.Voici les principales fonctions d'interfaçage MySQL de PHP :
mysql_connect()> se connecte au serveur avec le trio classique "serveur", "login", "pwd" en argument.mysql_error()> retourne le message d'erreur de Mysql.mysql_select_db()> selectionne la base passée en argument.mysql_query()> envoie la requête SQL passée en argument.mysql_num_rows()> retourne le nombre de lignes du résultat de la requête passée en argument.mysql_fetch_array()> retourne une ligne du résultat de la requête passée en argument sous forme d'un tableau associatif.mysql_free_result()> libère la mémoire allouée pour la requête passée en argument.mysql_close()> ferme la connection passée en argument.Soit une base dvdtek, constituée de trois tables : films, réalisateurs et acteurs. On souhaite connaître tous les films de Claude Chabrol dans lesquels joue Isabelle Huppert :
<?php
$db=mysql_connect("localhost", "moi", "aspro500");
mysql_select_db("dvdtek", $db);
$sql='SELECT titre, année
FROM films, réalisateurs, acteurs
WHERE réalisateurs.réal="claude chabrol"
AND acteurs.act="isabelle huppert"
ORDER BY année ASC';
$req=mysql_query($sql) or die(mysql_error());
$num=mysql_num_rows($req);
echo "$num film(s) trouvé(s) :<br>";
while ($row=mysql_fetch_array($req)) { // tant qu'il y aura des lignes...
echo $row['titre'].", ".$row['année']."<br>";
}
mysql_free_result($req);
mysql_close($db);
?>
devrait retourner :
6 film(s) trouvé(s) : Violette Nozière, 1978 Une affaire de femmes, 1988 Madame Bovary, 1991 La cérémonie, 1995 Rien ne va plus, 1997 Merci pour le chocolat, 2000 haut, sommaire, fonctions intégrées annexeopérateurs sur les bits
précédence des opérateurs(d'après Rasmus Lerdorf)> les opérateurs sont classés par ordre de priorité décroissante :
liensQuelques liens vers des pages qui ont beaucoup contribué à l'élaboration de celle-ci :
haut, sommaire, annexe > critiques, encouragements, menaces, dévotions, injures, remarques, suggestions... © Thierry Lhomme, 2003. http://thierrylhomme.developpez.com/  |
