Cours PHP 5 complet

Array

(

  [a] => pomme   [b] => banane

  [c] => Array

   (

[0] => x

[1] => y

[2] => z

   ) )

Menu affichage  Source). Vous verrez ainsi le contenu de votre tableau tout indenté ce qui est beaucoup plus lisible.

PS : print_r peut être utilisé sur tous vos types de variables.

Il peut arriver que les conditionnelles n'aient pas le comportement souhaité à l'origine.

En effet, quelques fois, votre script ne rentre pas dans le if mais dans le else alors qu'il devrait faire le contraire.

Prenez la même méthode que précédemment en affichant le contenu de vos variables afin de voir ce qui cloche.

Prenez également attention aux tests de votre conditionnelle.

En effet, en écrivant par exemple :

exemple8

<?php $toto = 5; if ($toto = 4) {

echo '$toto vaut 4';

}

?>

Et bien votre code passera toujours dans le if, et il affichera toujours $toto vaut 4.

Ceci est du à l'utilisation d'un seul = pour faire votre test (vous faites en fait une affectation au lieu d'une comparaison qui elle se fait avec ==).

Le cas des boucles est plus ou moins similaire à celui des conditionnelles.

En effet, si votre boucle ne démarre pas du tout, vérifier la valeur de votre compteur à l'initialisation de la boucle. De même, si votre boucle semble tourner à l'infini, vérifier bien que la valeur pour la sortie de la boucle arrivera à coup sur.

Si par contre votre boucle effectue des traitements non voulus sur vos données, prenez l'habitude de placer un echo dans votre boucle afin de voir la valeur de vos variables à chaque passage de boucle.

Pour pourrez ainsi mieux apprécier le comportement de votre boucle sur vos variables.

Exemple :

exemple9

<?php $toto = 2;

for ($i = 0; $i < 5; $i++) { $resultat = $toto * $i;

echo 'Passage numéro '.$i.' => multiplication = '.$resultat;

© 2002 - 2007 - Page 4/7

echo '<br />';

}

?>

Les erreurs arrivent assez facilement avec l'utilisation des fichiers si l'on ne prend pas garde à certains points.

- d'une part le chemin pour accéder à votre fichier (chemins relatifs / absolus)

- d'autre part le chmod de ce fichier (afin de voir si vous avez les droits pour  accéder à ce fichier).

Voici plusieurs conseils qui vous permettront d'éviter certaines erreurs incompréhensibles avec MySQL.

Tout d'abord, prenez l'habitude de placer vos requêtes SQL dans des variables.

Cela peut paraître rédhibitoire au départ, mais cela a plusieurs avantages.

En effet, en plaçant vos requêtes SQL dans une variable (par exemple $sql, au lieu de faire directement un mysql_query) vous allez pouvoir afficher votre requête SQL (via un echo $sql), ce qui constitue un réel avantage dans le cas de requêtes contenant des variables gérées par PHP (cela vous permet de bien voir si la requête contient les bonnes valeurs pour chacun des éléments gérés par PHP).

Un autre avantage découle aussi de ce premier conseil.

En effet, si votre requête à l'air de bien passer mais que, a priori, la récupération des éléments de la requête pose problème, il arrive souvent que l'on se demande si c'est la requête qui s'est bien déroulée et qui ne retourne aucun résultat ou bien si c'est notre code de récupération qui pose problème.

Afin d'en avoir le coeur net, faites un echo de votre $sql, et copier coller votre requête dans votre PHPMyAdmin : si PHPMyAdmin sort bien un résultat, c'est que votre code de récupération n'est pas fameux.

En revanche, si votre PHPmyAdmin ne retourne rien, c'est bien que requête ne retourne aucun résultat.

De même, en avançant toujours dans cette direction, compter toujours le nombre de résultat retourné de votre requête SQL à l'aide d'un mysql_num_rows, ce qui va vous permettre d'afficher un texte au lieu de ne rien avoir sur l'écran et de ne pas comprendre pourquoi il n'y a rien sur l'écran.

Exemple :

exemple10

<?php

$sql = 'SELECT toto FROM table WHERE test="ok"';

$nb = mysql_num_rows ($req);

if ($nb == 0) {

echo 'Aucun résultat retourné.';

}

else {

// Récupération des résultats et affichage

}

mysql_free_result ($req); ?>

Prenez également l'habitude de mettre un or die muni de la fonction mysql_error sur vos lancement de requêtes SQL afin de voir (si la requête ne passe pas) ce qui pose problème.

Faites aussi toujours un mysql_free_result sur votre requête de type SELECT lorsque celle-ci est terminée afin de libérer la mémoire nécessaire à l'exécution de votre requête.

En effet, d'une part, cela soulage le serveur, et d'autre part, cela évite de récupérer les résultats d'une autre requête

© 2002 - 2007 - Page 5/7

Auteur : LA GLOBULE

Dernière révision du cours : le 30/05/2007 à 00:14

© 2002 - 2007 - Page 7/7

faite précédemment.

Enfin, si malgré toutes ces précautions, il vous arrive de bloquer sur une erreur, voici un tableau regroupant les erreurs les plus communes que l'on peut avoir en programmant avec PHP accompagnées de petits indices vous permettant de les résoudre.

© 2002 - 2007 - Page 6/7

Voyons maintenant un caractère propre à beaucoup de langages de programmation fonctionnels, dits, de haut niveaux : la portée des variables.

En effet, d'après le code suivant :

exemple1

<?php

$toto = 5;

// fin du script

?>

$toto est une variable qui sera accessible par votre script PHP une fois sa déclaration faite, c'est-à-dire juste après l'instruction $toto = 5.

On peut observer le même comportement lorsque l'on utilise des include.

En effet, une fois que l'on a déclaré une variable, cette variable est accessible directement dans tous les scripts que l'on inclut à notre script courant.

Exemple :

exemple2

<?php $toto = 5;

include (''); ?>

Ici, $toto sera accessible, c'est à dire que l'on pourra l'appeler directement (elle contiendra alors sa valeur : 5) dans le script .

Vous savez également, qu'une variable déclarée dans le corps d'une fonction n'est accessible que dans le corps de cette même fonction.

Par exemple :

exemple3

<?php $toto = 5; function ma_fonction () { echo $toto; }

ma_fonction(); ?>

Dans ce cas, l'exécution de ce code PHP n'affichera rien vu que $toto (contenu dans le code de la fonction

ma_fonction()) n'a strictement aucun rapport avec la variable $toto contenu dans le script courant.

On appellera la variable $toto (celle contenue dans le code de la fonction) comme étant une variable locale à la fonction ma_fonction() (elle n'est pas globale au script).

© 2002 - 2007 - Page 1/4

Sachez qu'il est possible d'utiliser dans le code même de vos fonctions des variables que vous avez déclarées dans votre script courant à l'aide du mot clé global.

Reprenons notre exemple précédent :

exemple4

<?php $toto = 5; function ma_fonction () { global $toto; echo $toto; }

ma_fonction();

?>

En effet, dans ce script, nous déclarons la variable (qui était jusque là locale) $toto comme étant une variable globale du script.

PHP sait alors qu'il doit récupérer la valeur de cette variable dans le script courant.

Vous pouvez également effectuer la même opération en utilisant le tableau associatif $_GLOBALS.

Le code suivant donnera le même résultat que le code précédent :

exemple5

<?php $toto = 5;

function ma_fonction () { echo $_GLOBALS["toto"];

}

ma_fonction(); ?>

Comme vous le voyez, le tableau $GLOBALS est un tableau associatif avec le nom des variables globales comme clef et les valeurs des éléments du tableau comme valeur des variables, ce qui ressemble un peu aux tableau associatifs que vous connaissez déjà comme $_POST ou $_GET qui vous permettent de récupérer la valeur des champs de vos

formulaires.

Les amateurs de programmation par objets doivent bien connaître ce terme de static :)

Une variable dite static est une variable locale à une fonction mais qui a la particularité de se souvenir de sa valeur.

Prenons comme exemple le code suivant :

exemple6

<?php function ma_fonction () { $toto = 1; echo $toto;

$toto++;

}

?>

© 2002 - 2007 - Page 2/4

Si je lance cette fonction 50 fois, vous allez tous penser que cette fonction affichera 50 fois la valeur 1, et vous aurez raison :)

Dans ce cas, l'incrémentation ne sert à rien puisque lorsque l'on a fini d'exécuter cette fonction PHP "perd connaissance" de la valeur de la variable $toto.

En revanche, si on déclare la variable $toto comme étant une variable statique (grâce au mot clé static), le comportement de cette fonction sera totalement différent.

En effet, vu que $toto est statique, PHP se souviendra de sa valeur lors de la dernière exécution de la fonction.

Avec le code suivant :

exemple7

<?php function ma_fonction () { static $toto = 1; echo $toto;

$toto++;

}

?>

Si je lance 50 fois ma fonction, et bien nous verrons sur l'écran, la suite des nombres entre 1 et 50.

Dans nos exemples précédents, vous avez que grâce au mot clé static, les fonctions pouvaient récupérer les valeurs des variables globales.

Sachez qu'il est également possible de modifier la valeur d'une variable d'un script (une variable globale) grâce à une fonction en utilisant un passage de variable par référence.

Le passage par référence se caractérise par l'utilisation d'un & avant le nom de votre variable dans les arguments de votre fonction.

Exemple :

exemple8

<?php $toto = 5; function ma_fonction ($var) { $var++;

} ma_fonction(&$toto); echo $toto;

?>

Pour les personnes qui ont fait du C, le passage par référence s'assimile à la notion de pointeur.

En passant une variable par référence à une fonction, nous ne passons pas en fait la variable en elle-même (la preuve : notre fonction utilise une variable $var alors qu'elle modifie tout de même la valeur de la variable $toto du script courant) mais une référence vers la zone mémoire où est stockée la valeur de notre variable $toto.

© 2002 - 2007 - Page 3/4

Notre fonction modifie alors directement cette zone mémoire en lui donnant une nouvelle valeur, ce qui explique que dans le script courant, et bien la valeur de $toto a changé.

Auteur : LA GLOBULE

Dernière révision du cours : le 30/05/2007 à 00:16

© 2002 - 2007 - Page 4/4

La librairie GD

Nous allons donc voir dans ce tutorial comment faire des images dynamiques (c'est-à-dire qui changent suivant certains paramètres) grâce à PHP, qui les générera.

La librairie GD peut être schématisée par  "un fichier" qui comporte de nombreuses fonctions permettant de travailler les images. Grâce à cette librairie, vous allez pouvoir modifier vos images, récupérer des informations sur ces images, voir même, créer vous-même vos propres images.

Avant de nous lancer dans la création de superbes images, une petite vérification s'impose.

Pour savoir si la librairie GD est installée sur votre serveur, vous devez faire un phpinfo. Pour cela, créer un fichier, par exemple , dans lequel vous allez placer le code suivant :

Ensuite, dans votre navigateur favori, affichez la page ainsi créée.

Faites défiler cette page jusqu'au moment où vous voyez quelque chose qui ressemble à ceci :

Là, si comme ici, le GD Support est enabled, c'est tout bon, vous pouvez continuer la lecture de ce tutorial. Enfin sachez également, que depuis la version 2.0 de la librairie, le format GIF n'est plus supporté, et il a été avantageusement remplacé par le format PNG.

Pour ceux qui n'ont pas la librairie installée, le seul remède est de demander gentiment à leur hébergeur de l'installer :)

Passons de suite à la création de notre première image dynamique.

Prenons par exemple le code suivant, très basique, permettant l'affichage d'une image. On a par exemple une page que l'on nommera , et qui contiendra :

exemple2

<html>

<head>

<title>Notre page de test</title>

</head>

<body>

<img src="/">

</body>

</html>

Et vous notez que bien le lien vers notre image désigne un fichier PHP. C'est tout à fait normal, vu que c'est PHP qui va générer notre image.

Voyons à présent le code de la page .

Imaginons que l'on désire dessiner un rectangle rouge (en fait nous n'allons pas dessiner un rectangle, nous allons en fait créer une image vide remplie avec de la couleur rouge).

On aura alors (pour la page ), le code suivant :

exemple3

<?php // on spécifie le type de document que l'on va créer (ici une image au format PNG

© 2002 - 2007 - Page 1/8

header ("Content-type: image/png");

// on dessine une image vide de 200 pixels sur 100

$image = @ImageCreate (200, 100) or die ("Erreur lors de la création de l'image");

// on applique à cette image une couleur de fond, les couleurs étant au format RVB, on

$couleur_fond = ImageColorAllocate ($image, 255, 0, 0);

// on dessine notre image PNG

ImagePng ($image); ?>

Et voila notre première image générée par PHP.

Cependant, quelques explications sont nécessaires et extrêmement importantes :

- lorsque l'on crée une page WEB avec PHP, on n'est pas obligé de dire à PHP que l'on crée une page WEB, en revanche, lorsque l'on crée une image, on est obligé de le spécifier avec l'instruction :

exemple4

<?php

- naturellement, si l'on désire créer une image de type JPG, on prendra soin d'écrire :

exemple5

<?php

- l'appel à la fonction ImageCreate nous retourne en fait une ressource ($image) correspondant à l'image que nous sommes en train de créer.

- nous faisons ensuite appel à la fonction ImageColorAllocate qui a deux fonctions principales : premièrement, elle crée une couleur stockée dans une variable pouvant être réutilisée ultérieurement (ici $couleur_fond), et deuxièmement, elle enregistre cette couleur dans la palette de l'image $image.

Notez aussi, et c'est extrêmement important, que cette couleur étant la première couleur enregistrée dans la palette, elle correspondra en fait à la couleur de fond de notre image (en fait, la première couleur enregistrée dans la palette de couleur correspond à la couleur de fond de l'image).

- on utilise alors la fonction ImagePng pour afficher notre ressource, soit donc notre image ($image).

- notez également que si nous avions créé une image de type JPG, nous aurions utilisé ici l'instruction ImageJpeg.

Après ce premier exemple tout simple, vous devez sûrement vous dire qu'il n'y a rien de dynamique dans tout cela, et que votre Photoshop ferait bien mieux.

A première vue, oui.

Mais vu que notre image est générée par PHP, nous pouvons lui fournir des paramètres. Et l'avantage, il est là. C'est-à-dire que vous allez pouvoir créer des images différentes en fonction de certains paramètres.

On aura alors, par exemple (pour la page ) :

exemple6

<html>

<head>

<title>Notre page de test</title>

© 2002 - 2007 - Page 2/8

</head>

<body>

Sélectionner l'intensité des différentes teintes :<br />

<form action="" method="post">

Rouge (un nombre entre 0 et 255) : <input type="text" name="rouge"><br />

Vert (un nombre entre 0 et 255) : <input type="text" name="vert"><br />

Bleu (un nombre entre 0 et 255) : <input type="text" name="bleu"><br />

<input type="submit" value="Voir">

</form>

</body>

</html>

Et prenons par exemple le code suivant pour la page (nous ne ferons pas ici la vérification des champs du formulaire : en effet, on supposera que l'utilisateur saisi bien à chaque fois un nombre entre 0 et 255) :

exemple7

<?php

// on teste nos 3 variables pour nos couleurs

if (isset($_POST['rouge']) && isset($_POST['vert']) && isset($_POST['bleu'])) {

// on spécifie le type de document que l'on va créer (ici une image au format PNG header ("Content-type: image/png");

// on dessine une image vide de 200 pixels sur 100

$image = @ImageCreate (200, 100) or die ("Erreur lors de la création de l'image");

// on applique à cette image une couleur de fond, les couleurs étant       au format RVB, on obtiendra ici la couleur que l'utilisateur aura spécifié en paramètre du

formulaire

$couleur_fond = ImageColorAllocate ($image, $_POST['rouge'], $_POST['vert'], $_POST['bleu']);

// on dessine notre image PNG ImagePng ($image);

} else { echo 'Les variables du formulaire ne sont pas déclarées.';

}

?>

Pas mal, non ?

Cela diffère donc des repères classiques mathématiques où l'origine du repère est toujours situé dans le coin inférieur gauche.

Et ceci est très important.

En effet, pratiquement toutes les fonctions de cette librairie vous demanderont les coordonnées de différents points. Autant se mettre tout de suite en accord avec le système.

Conseil :

Vu que l'axe des x est orienté de la "gauche" vers la "droite", lorsque vous allez utiliser des fonctions permettant de dessiner des rectangles, des droites, etc, l'idéal est de toujours fournir en arguments les coordonnées du point le plus à gauche de votre figure, puis les coordonnées du point le plus à droite.

Après cette petite précision, voici un autre exemple intéressant de l'utilisation de la librairie GD.

En effet, vous affichez parfois des images sur vos sites WEB, et beaucoup de vos photos partent dans la nature (pillées

© 2002 - 2007 - Page 3/8

la plupart du temps par des visiteurs peu attentionnés).

Ne serait-il pas sympathique de pouvoir protéger vos photos à l'aide d'une petite incrustation permettant de "copyrighter" votre image ?

Et bien c'est tout à fait possible.

Pour ce faire, voyons le code pour notre fichier PHP contenant le code générant cette image "copyrightée" (fichier par exemple) :

exemple8

<?php

// on spécifie le type de fichier créer (ici une image de type jpeg) header ("Content-type: image/jpeg");

// on crée deux variables contenant les chemins d'accès à nos deux fichiers :

$fichier_source contenant le lien vers l'image à "copyrighter", $fichier_copyright contenant le lien vers la petite vignette contenant le copyright (bien sur, on prendra soin de placer les images sources dans un répertoire "caché" sinon le copyright ne sert

à rien si les visiteurs ont accès aux images sources)

$fichier_source = "";

$fichier_copyright = "";

// on crée nos deux ressources de type image (par le biais de la fonction

$im_source = ImageCreateFromJpeg ($fichier_source);

$im_copyright = ImageCreateFromJpeg ($fichier_copyright);

// on calcule la largeur de l'image qui va être copyrightée

$larg_destination = imagesx ($im_source);

// on calcule la largeur de l'image correspondant à la vignette de copyright

$larg_copyright = imagesx ($im_copyright);

// on calcule la hauteur de l'image correspondant à la vignette de copyright $haut_copyright = imagesy ($im_copyright);

// on calcule la position sur l'axe des abscisses de la vignette

$x_destination_copyright = $larg_destination - $larg_copyright;

// on réalise la superposition, le dernier paramètre étant le degré de transparence de la vignette (cependant, allez voir la fin de ce même tutorial pour une définition

complète de tous les arguments de cette fonction)

@imageCopyMerge ($im_source, $im_copyright,

$x_destination_copyright, 0, 0, 0, $larg_copyright,

$haut_copyright, 70);

// on affiche notre image copyrightée

Imagejpeg ($im_source);

?>

Ensuite, afin de voir le résultat, il suffit d'écrire une page toute simple affichant l'image , avec une insertion d'image du genre (par exemple) :

exemple9

Bien sur, pour rendre ce script vraiment dynamique, il suffit de passer à l'image en paramètre le nom du fichier image à "copyrighter".

En effet, comme dans le premier exemple avec l'image basique, on peut faire un lien ressemblant à :

exemple10

© 2002 - 2007 - Page 4/8

<img src="/">

Et ensuite, dans le script , on récupère la variable $_GET['fichier'] qui sera en fait le nom du fichier de

l'image à "copyrighter".

Je vous fais confiance pour cette partie :)

Voyons maintenant un autre exemple de l'utilisation de cette librairie : la création de miniatures.

En effet, vous voulez mettre vos photos en ligne, et jusqu'ici, vous faisiez vos miniatures à la main :

- c'était long

- pas toujours réussi

Détaillons maintenant le code permettant de créer vos miniatures.

En revanche, ici, à la différence des exemples précédents, nous n'allons pas afficher à la volée une image générée par PHP.

En effet, nous allons en fait écrire un script PHP, qui, avec le lien vers une image de type JPG, va créer une miniature de cette même image qui sera sauvegardée sur votre espace disque.

Le nom de la miniature sera en fait le nom du fichier original, précédé de la mention mini_.

On aura alors le code suivant pour ce script de création de miniatures :

exemple11

<?php

// on donne à PHP le lien vers notre image à miniaturiser

$Image = "";

// on impose la taille de la largeur ou de la hauteur de la photo (le choix entre la largeur ou la hauteur se fait automatiquement, suivant que la photo est "horizontale" ou

"verticale")

$ratio = 150;

// on crée une ressource représentant en fait l'image à miniaturiser

$src=imagecreatefromjpeg($Image);

// on récupère les paramètres de notre image (getimagesize est une fonction qui retourne un tableau contenant les paramètres d'une image : sa largeur, son hauteur, son type,

etc )

$size = getimagesize($Image);

// on test si la largeur de l'image est supérieur à sa longueur

if ($size[0] > $size[1]) {

// on crée une ressource pour notre miniature

$im=imagecreate(round(($ratio/$size[1])*$size[0]), $ratio);

// on place dans la ressource que nous venons de créer une copie de l'image originelle, redimensionnée et réechantillonée

imagecopyresampled($im, $src, 0, 0, 0, 0, round(($ratio/$size[1])*$size[0]),$ratio,

$size[0], $size[1]);

}

else {

// si la largeur est inférieure ou égale à la hauteur, on entre dans ce cas

// on crée une ressource pour notre miniature

$im=imagecreate($ratio, round(($ratio/$size[0])*$size[1]));

// on place dans la ressource que nous venons de créer une copie de l'image originelle, redimensionnée et réechantillonée

$size[0], $size[1]); }

// on définit le nom de notre miniature

© 2002 - 2007 - Page 5/8

$miniature = "mini_$Image";

// on crée notre miniature

ImageJpeg ($im, $miniature); ?>

Et surtout, remarquez bien que nous n'avons pas utilisé la fonction header.

En effet, ici, on ne cherche pas à "afficher" une image générée à la volée.

Ce script inspecte en fait une image, et à partir de celle-ci, il en crée une nouvelle.

Pour voir le résultat de cette opération, et donc voir votre miniature, vous devrez créer une page html contenant la balise suivante :

exemple12

Enfin, afin d'accroître vos talents de Picasso des temps modernes, voyons un dernier exemple : la création d'un histogramme pour un script de statistiques par exemple.

En effet, bon nombre de scripts de statistiques affichent la popularité de vos pages sur de jolis dessins.

Et bien sachez que c'est possible de faire quelque chose d'équivalent à l'aide de la librairie GD.

Pour ce faire, je vous propose la création d'un histogramme permettant d'afficher des "bâtons" représentants le nombre de pages vues de votre site sur une année (un bâton représentant un mois de l'année).

Pour ce faire, voici par exemple le code du script (il s'agira d'une image dynamique, crée à la volée, l'utilisation d'un header sera donc nécessaire) :

exemple13

<?php

// on définit un tableau contenant le nombre de page vues par mois : par exemple, on suppose que 1500 pages du site ont été vues en janvier, 2450 en février, etc Bien sur, pour que ce script soit vraiment valides, vous n'allez pas déclarer ce tableau, car sinon, les bâtons seront toujours les mêmes :) Vous allez plutôt effectuer une requête SQL sur votre base de données permettant de récupérer le nombre de pages vues de votre site par mois. Ensuite, il suffira d'appeler le script avec ces 12 paramètres dans votre

page html (en faisant par exemple : <img

$visite_par_mois[1]=1500;

$visite_par_mois[2]=2450; $visite_par_mois[3]=800;

$visite_par_mois[4]=1780;

$visite_par_mois[5]=1900;

$visite_par_mois[6]=2450;

$visite_par_mois[7]=1684;

$visite_par_mois[8]=1845;

$visite_par_mois[9]=3450;

$visite_par_mois[10]=980;

$visite_par_mois[11]=1234;

$visite_par_mois[12]=500;

// on calcule le nombre de pages vues sur l'année

$max_visite = max($visite_par_mois);

// on spécifie le type d'image que l'on va créer, ici ce sera une image au format PNG header ("Content-type: image/png");

// on définit la largeur et la hauteur de notre image

$largeur = 550;

$hauteur = 300;

// on crée une ressource pour notre image qui aura comme largeur $largeur et $hauteur comme hauteur (on place également un or die si la création se passait mal afin d'avoir un petit message d'alerte)

© 2002 - 2007 - Page 6/8

$im = @ImageCreate ($largeur, $hauteur) or die ("Erreur lors de la création de l'image")

;

// on place tout d'abord la couleur blanche dans notre table des couleurs (je vous rappelle donc que le blanc sera notre couleur de fond pour cette image). $blanc = ImageColorAllocate ($im, 255, 255, 255);

// on place aussi le noir dans notre palette, ainsi qu'un bleu foncé et un bleu clair

$noir = ImageColorAllocate ($im, 0, 0, 0);

$bleu_fonce = ImageColorAllocate ($im, 75, 130, 195);

$bleu_clair = ImageColorAllocate ($im, 95, 160, 240);

// on dessine un trait horizontal pour représenter l'axe du temps

ImageLine ($im, 20, $hauteur-40, $largeur-15, $hauteur-40, $noir);

// on affiche le numéro des 12 mois for ($i=1; $i<=12; $i++) {

if ($i==1) {

ImageString ($im, 2, 42, $hauteur-38, $i, $noir);

} else {

ImageString ($im, 2, ($i)*42, $hauteur-38, $i, $noir);

}

}

// on dessine un trait vertical pour représenter le nombre de pages vues ImageLine ($im, 20, 30, 20, $hauteur-40, $noir);

repertoire /fonts/) imagettftext($im, 14, 0, $largeur-70, $hauteur-10, $noir, "", "Mois")

; imagettftext($im, 14, 0, 10, 20, $noir, "", "Nb. de pages vues"); imagettftext($im, 14, 0, $largeur-250, 20, $noir, "", "Statistiques pour l'année 2003");

// on parcourt les douze mois de l'année for ($mois=1; $mois <= 12; $mois++) { if ($visite_par_mois[$mois]!="0") {

// on calcule la hauteur du baton

$hauteurImageRectangle = ceil(((($visite_par_mois[$mois])*($hauteur-50))/

$max_visite)); if ($mois=="1") {

// si le mois est janvier, on affiche notre premier baton

// on affiche le premier baton noir

ImageFilledRectangle ($im, 42, $hauteur-$hauteurImageRectangle, 42+14, $hauteur

-41, $noir);

// on affiche le second baton, bleu foncé, qui sera un peu plus petit que le noir afin de recouvrir une partie du noir

ImageFilledRectangle ($im, 44, $hauteur-$hauteurImageRectangle+2, 42+12,

$hauteur-41-1, $bleu_fonce);

// on affiche le dernier baton, bleu clair, qui sera un peu plus petit que le bleu foncé afin de recouvrir une partie du bleu foncé (on obtiendra ainsi un effet de

dégradé)

ImageFilledRectangle ($im, 48, $hauteur-$hauteurImageRectangle+2, 42+8,

$hauteur-41-1, $bleu_clair);

}

else {

// si le mois est different de janvier, on affiche les autres batons

ImageFilledRectangle ($im, ($mois)*42, $hauteur-$hauteurImageRectangle, ($mois)

*42+14, $hauteur-41, $noir);

ImageFilledRectangle ($im, ($mois)*42+2, $hauteur-$hauteurImageRectangle+2, (

$mois)*42+12, $hauteur-41-1, $bleu_fonce);

ImageFilledRectangle ($im, ($mois)*42+6, $hauteur-$hauteurImageRectangle+2, (

© 2002 - 2007 - Page 7/8

$mois)*42+8, $hauteur-41-1, $bleu_clair);

}

}

}

// on dessine le tout

Imagepng ($im);

?>

Vous noterez quelque chose de très important : en effet, pour faire les dégradés sur les bâtons, nous avons en fait dessiné plusieurs rectangles les uns sur les autres (et donc des rectangles de plus en plus petits).

En clair, quand on dessine par-dessus quelque chose, et bien ce quelque chose disparaît au profit de la nouvelle forme que l'on vient de dessiner (tout comme des calques sous Photoshop).

Aller hop, à vos pinceaux maintenant, et surtout n'oubliez pas d'aller jeter un coup d'oeil sur le manuel PHP afin de découvrir toutes les descriptions des instructions utilisées dans ce cours.

Auteur : LA GLOBULE

Dernière révision du cours : le 30/05/2007 à 00:18

© 2002 - 2007 - Page 8/8

Les expressions régulières

Maintenant que nous avons une certaine assurance avec PHP, il serait grand temps de commencer à réfléchir aux expressions régulières.

En effet, les expressions régulières vous permettront d'analyser différentes chaînes de caractères (principalement saisies par un client dans un formulaire) et ainsi vérifier que la chaîne correspond bien à ce que l'on demande.

De plus, les expressions ne servent pas qu'à la vérification de la "conformité" d'une chaîne de caractère, puisqu'elles vont permettront également d'améliorer grandement l'utilisation de votre site.

Les expressions régulières ont été empruntées au système POSIX. De nombreux scripts Perl les utilisent également.

Il s'agit d'un système extrêmement ingénieux permettant de retrouver un mot, voir même une phrase complète (d'une certaine forme) dans un texte, suivant un modèle que l'on aura défini, le pattern.

Par exemple, à l'aide des expressions régulières, vous pourrez facilement vérifier l'adresse email qu'un visiteur dans un champs d'un formulaire de votre site (ceci en testant l'allure de la chaîne de caractère saisie par ce client : on testera entre autre si il y a bien un @ dans cette chaîne de caractères, mais juste un seul, que la chaîne qui suit ce @ est bien un nom de domaine, et que la chaîne qui précède le @ est bien un identifiant valide, c'est-à-dire sans caractères interdits, etc ).

Pour la suite du cours, je vais vous parlez seulement des modèles (pattern).

Ce sont ces modèles, qui sont en fait des sortes de masques que l'on applique sur une chaîne de caractères ou un texte pour trouver une suite de caractères bien précise.

Par la suite, il existe diverses fonctions utilisant ces modèles afin d'isoler ces suites de caractères, et d'agir sur eux, et je vous renvoies donc à la documentation pour les étudier (je vous rappelle que ce n'est pas de la fainéantise de ma part de ne pas vous parler de ces fonction, mais il y en a tellement, que le cours serait gigantesque ; et de plus, si vous arriver à créer vos propres modèles, vous n'aurez aucun mal à utiliser ces fonctions avec ces modèles).

Les symboles ^ et $

Dans une expression régulière, le symbole ^ représente le début d'un modèle, et le symbole $ représente la fin d'un modèle.

Voyons de suite quelques exemples :

^La globule : identifie une chaîne de caractères qui commence par "La globule"enfin$ : identifie une chaîne de caractères qui se finit par "enfin"^mot$ : identifie une chaîne de caractères qui commence par "mot" et qui fini par "mot", il s'agit donc de la chaîne de caractères "mot" elle-mêmetest: identifie une chaîne de caractères qui contient le mot

"test"

Jusque là, tout va bien.

En effet, vous pouvez remarquer que si vous n'employer ni ^ ni $ (dernier exemple), cela implique que votre modèle peut se reproduire n'importe où à l'intérieur de votre chaîne de caractères, puisque le modèle n'est ni collé au début de la chaîne (on utilise pas de ^) ni à la fin de la chaîne (on utilise pas de $).

Les symboles *, + et ?

Dans les expressions régulières, les symboles *, + et ? servent à indiquer le nombre de fois qu'un caractère ou une suite de caractères puisse apparaître.

+ indiquera que le caractère (ou la suite de caractères) qui le précède ne pourra apparaître soit, une fois, soit plusieurs fois.

© 2002 - 2007 - Page 1/3

Exemple : %[^a-zA-Z]% : identifie une chaîne de caractères avec un caractère qui n'est pas une lettre (soit en fait un chiffre ou autres chose, mais pas une lettre) entre deux signes pourcentage

Note 2 :

Pour utiliser les caractères ^, ., [, $, (, ), |, *, +, {, dans vos expressions régulières, vous devrez les protéger avec un \ juste avant ceux-ci (car en effet, ces caractères ont une signification spéciale, et donc pour pouvoir les utiliser, il faut les protéger).

Sous - note :

N'oubliez pas que les expressions entre crochets sont une exception à cette règle.

En effet à l'intérieur des crochets, tous les caractères spéciaux, y compris l'antislash , perdent leurs puissances spéciales (en clair, dans les crochets, vous ne devez pas protéger les caractères spéciaux avec un \).

Enfin !!!

A première vue, les expressions régulières ne sont pas simple d'utilisation, mais croyez moi, elles sont extrêmement puissantes.

Et maintenant que vous êtes familier avec les modèles, pourquoi ne pas aller faire un tour du côté de la documentation, afin de voir avec quelles fonctions s'utilisent ces précieuses expressions régulières ?

Ce tutorial est fini, pour votre plus grande joie, ainsi que la mienne :)

Auteur : LA GLOBULE

Dernière révision du cours : le 30/05/2007 à 00:19

© 2002 - 2007 - Page 3/3

? indiquera que le caractère (ou la suite de caractères) qui le précède ne pourra apparaître soit, aucune fois, soit une et une seule fois.

Voyons alors quelques exemples :

Les accolades {}

Par extensions aux symboles précédents, vous pouvez également des limites qui s'utilisent à l'intérieur d'accolades et qui indiquent le nombre d'occurrence de la chaîne recherchée.

De même, comme pour les symboles *, + et ?; elles affectent l'élément qui les précède.

Voyons tout de suite des exemples : ab{2} : identifie une chaîne de caractère composée d'un a suivit d'exactement deux b (en clair, seule la chaîne "abb" passe à travers ce modèle)ab{2,} : identifie une chaîne de caractère composée d'un a suivi d'au moins deux b (par exmple, "abb" ou "abbb" respectent ce modèle)ab{3,5} : identifie une chaîne de caractère composée d'un a suivi de trois à cinq b ("abbb", "abbbb" et "abbbbb" sont les seules chaînes qui respectent ce modèle) Sachez que vous devez toujours indiquer le premier chiffre dans vos accolades, alors que le second n'est pas obligatoire.

Vous pouvez également remarquer que l'on peut retrouver la fonction des symboles *, + et ? avec des limites appropriées. En effet, le symbole :

* correspond en fait à la limite {0,}+ correspond en fait à la limite {1,}? correspond en fait à la limite {0,1} Les parenthèses

Afin de quantifier une chaîne de caractères, vous devez utiliser des parenthèses.

Les exemples étant beaucoup plus parlant que du bla-bla, voici quelques exemples :

a(bc)* : identifie une chaîne de caractères commençant par un a suivi d'aucune ou de plusieurs séquence de caractères "bc"a(bc){1,5}* : identifie une chaîne de caractères commencant par un a suivi d'une à cinq fois la séquence de caractères "bc" Le symbole |

Le symbole | fonctionne comme l'opérateur booléen OU.

Voyons quelques exemples :

Le symbole . (le point) représente n'importe quel caractère unique.

Exemple :

^.{3,}$ : identifie une chaîne de caractères comportant exactement trois caractères Les crochets []

Les expressions entre crochets ( []) indiquent les caractères qui sont permis à un endroit précis d'un modèle.

Les exemples :

 [ab] : identifie une chaîne de caractères contenant un "a" ou un "b" (ce qui revient au même d'écrire le modèle a|b) [a-d] : identifie une chaîne de caractères qui contient les lettres minuscules comprises entre le "a" et le "d" (ce qui équivalent de a|b|c|d ou de [abcd])^[a-zA-Z] : identifie une chaîne de caractères qui commence par une lettre minuscules ou bien par une lettre majuscule [0-9]% : identifie une chaîne de caractères qui contient un pourcentage à un seul chiffre,[a-zA-Z0-9]$ : identifie une chaîne de caractères qui finit par une virgule suivi d'un caractère (lettre ou chiffre)

Note 1 :

Vous pouvez également lister les caractères que vous ne voulez pas en utilisant le symbole ^ comme premier symbole dans vos crochets.

© 2002 - 2007 - Page 2/3

La programmation objet (concepts fondamentaux)

En programmation, un modèle est une abstraction de la réalité.

Par conséquent, un modèle est une vue subjective de la réalité, mais toutefois, cette vue est toujours pertinente.

En effet, un modèle définit une frontière entre la réalité et la perspective de l'observateur. Il ne s'agit donc pas de la réalité, mais d'une vue très subjective de la réalité.

Par conséquent, un modèle doit permettre de faciliter la compréhension d'un système étudie, mais aussi, de simuler ce système.

Aujourd'hui, en programmation, il existe deux principaux modèle de représentation du monde : le modèle fonctionnel (que vous connaissez déjà) et le modèle objet (que nous allons donc étudier).

Jusqu'à aujourd'hui, vous connaissiez la programmation en PHP avec une approche fonctionnelle.

Avec une approche fonctionnelle, vos programmes étaient composés d'une série de fonctions, qui ensemble, assuraient certains services.

Il s'agit d'une approche logique, cohérente et intuitive de la programmation.

Cette approche a un avantage certain que l'on appelle la factorisation des comportements.

En effet, une découpe fonctionnelle intelligente consiste à factoriser certains comportements d'une application, ce qui veut dire que pour créer une fonction d'une application, rien ne vous empêche d'utiliser un autre ensemble de fonctions (qui sont donc déjà écrites).

Mais (il y a toujours un mais ^^), l'approche fonctionnelle a aussi ses défauts, comme par exemple une maintenance complexe en cas d'évolution de votre application.

La factorisation des comportements n'a pas que des avantages. En effet, si on y réfléchit deux minutes, maintenant, nos fonctions sont devenues interdépendantes.

Et ceci implique qu'une simple mise à jour de l'application à un point donné peut impacter en cascade sur d'autres fonctions de notre application.

Naturellement, nous pouvons toujours essayer d'écrire des fonctions les plus génériques possibles mais cela rend le développement de l'application beaucoup plus complexe.

De plus, en cas d'évolution de l'application, même si la structure générale de l'application reste valide, la multiplication des points de maintenance (dus au chaînage des fonctions à cause de la factorisation des comportements) rend l'adaptation extrêmement difficile.

Et dans ce cas, l'application sera alors retouchée dans sa globalité.

Prenons un exemple concret : on a en notre possession une application permettant de gérer une bibliothèque, et suite à la demande du client, notre application doit maintenant être capable de gérer une médiathèque, c'est-à-dire que l'on pourra emprunter, non seulement des livres, mais aussi, des CD-ROM, des DVD, etc

Nous devrons donc faire évoluer toutes les portions de code qui utilisent la base documentaire, et ce, afin de gérer les données et les actions propres aux différents type de documents.

Exemple : notre application, alors qu'elle ne gérait que des livres, pouvait mettre une sorte de carton jaune à un emprunteur lorsqu'il ne rendait pas son livre dans les temps.

Or, maintenant que notre bibliothèque est devenue une médiathèque, et si l'on désire que le délai avant le fameux carton jaune dépende du document emprunté (le carton jaune arrivera plus ou moins tard, suivant le document emprunté : un livre, un CD-ROM, un DVD, etc ), et bien il va falloir prévoir une règle de calcul pour chaque type de document.

Au final, c'est pratiquement la totalité de l'application qu'il va falloir adapter pour gérer les nouveaux types de documents et les traitements correspondants.

© 2002 - 2007 - Page 1/3

Nous adaptons en fait cette méthode suivant l'objet que nous étudions (un avion se déplace dans les airs, un train sur des rails et une voiture sur la route).

L'agrégation constitue une relation entre deux classes, spécifiant que les objets d'une classe sont des composants de l'autre classe.

Une relation d'agrégation permet donc de définir des objets composés d'autres objets.

L'agrégation permet d'assembler des objets de base, afin de construire des objets plus complexes.

Notre objet eau de type molécule est en fait une combinaison de trois objets :

- hydrogene1 qui est un objet de la classe atome (c'est une instance de la classe atome).

- hydrogene2 qui est un objet de la classe atome (c'est une instance de la classe atome). - oxygene qui est un objet de la classe atome (c'est une instance de la classe atome).

Notre molécule est donc compose de trois atomes : hydrogene1, hydrogene2 et oxygene.

En conclusion, vous devez savoir que le concept objet est un concept stable et éprouvé.

A cela, deux raisons principales :

- l'approche fonctionnelle n'est pas adaptée au développement d'applications qui évoluent sans cesse et dont la complexité croit continuellement (plusieurs dizaines de milliers de lignes de code). - l'approche objet a été inventée pour faciliter l'évolution d'applications complexes.

De nos jours, les outils orientés objets sont fiables et performants (les compilateurs C++ par exemple produisent un code robuste et optimisé).

Mais, malgré les apparences, il est beaucoup plus naturel pour nous, êtres humains, de décomposer un problème informatique sous forme d'une hiérarchie de fonctions atomiques et de données, qu'en terme d'objets et d'interaction entre ces objets.

De plus, le vocabulaire précis est souvent un facteur d'échec important dans la mise en oeuvre d'une approche objet.

C'est pour cela qu'il faut penser objet des le départ, au lieu d'essayer de convertir une série de fonction en une classe.

Auteur : LA GLOBULE

Dernière révision du cours : le 30/05/2007 à 00:23

© 2002 - 2007 - Page 3/3

Les modifications que nous avons apportées à notre application de médiathèque, nous permettent de penser qu'une approche objet sera beaucoup plus avantageuse quant à la réutilisation du code déjà écrit.

Mais qu'est ce qu'un objet ?

Un objet est une entité comportant des frontières précises et qui possède une identité (un nom).

De plus, un ensemble d'attributs caractérisent l'état d'un objet, et l'on dispose d'un ensemble d'opérations (les méthodes) qui permettent d'agir sur le comportement de notre objet.

Un objet est l'instance d'une classe, et une classe, est un type de données abstrait, caractérisé par des propriétés (ses attributs et ses méthodes) communes à des objets et elle permet de créer des objets possédant ces propriétés.

Exemple : prenons le cas de notre bibliothèque.

titre et auteur sont les attributs de notre classe, c'est-à-dire les caractéristiques communes à tous nos objets "Livre". En clair, tous les livres auront un titre et un auteur.

De plus, notre classe dispose des méthodes emprunter() et rendre() qui s'appliquerons à nos objets "Livre" (on agira alors directement sur notre objet "Livre"). monLivre représente quant à lui, une instance de la classe Livre, il s'agit donc d'un objet qui porte le nom monLivre.

Les autres concepts importants de l'approche objet sont :

- l'encapsulation

- l'héritage (ainsi que le polymorphisme)

- l'agrégation

L'encapsulation consiste à masquer les détails d'implémentation d'un objet, et ce, en définissant une interface. En clair, vous n'avez pas besoin de savoir comment est conçu cet objet à la base pour pouvoir l'utiliser. Une interface est quant à elle, une vue externe d'un objet et elle définit les services accessibles pour modifier le comportement de l'objet.

L'encapsulation facilite l'évolution d'une application car elle stabilise l'évolution des objets.

En effet, bous pouvons très bien modifier l'implémentation des attributs d'un objet sans pour autant modifier son interface. Elle garantit de plus l'intégrité des données vu qu'elle permet d'interdire l'accès direct aux attributs des objets (on doit alors passer par des assesseurs).

Un assesseur étant une méthode d'accès pour connaître ou modifier la valeur d'un attribut d'un objet.

L'héritage est un mécanisme de transmission des propriétés d'une classe (ses attributs et ses méthodes) vers une sous-classe (la sous-classe héritant de la classe principale).

Grâce à l'héritage, une classe peut aussi être spécialisée en d'autres classes, afin d'y ajouter des caractéristiques spécifiques (ajout de méthodes par exemple) ou d'en adapter certaines.

La spécialisation et la généralisation permettent de construire des hiérarchies de classes.

L'avantage principal de l'héritage est qu'il vous permet de d'éviter la duplication de code, et il encourage à la réutilisation de même code.

La classe Livre hérite des propriétés de la classe Document.

Ce qui veut dire que les objets Livre auront un auteur, un éditeur, mais aussi un numéro et un titre. De plus, comme on peut emprunter() ou rendre() un document, on pourra également emprunter() et rendre() un livre (ceci, parce que la classe Livre hérite de la classe Document).

On pourra également lire() ou photocopier() un livre.

En revanche, un document n'aura pas d'auteur ni d'éditeur, et on ne pourra pas le lire, ni même le photocopier (ces propriétés font partie de la classe Livre, or un document n'est pas un livre : c'est un livre qui est un document, et non l'inverse).

Quand au polymorphisme, celui-ci représente la faculté d'une méthode à pouvoir s'appliquer à des objets de classes différentes. Il augmente donc la généricité de votre code.

Chacune des trois classes (Voiture, Train et Avion) héritent des méthodes de la classe Véhicule.

Ces trois classes, auront donc accès à la méthode deplacer() de la classe Véhicule.

Or, dans ces trois "sous classes", nous avons choisit de redéfinir la méthode deplacer() de la classe Véhicule.

© 2002 - 2007 - Page 2/3

La programmation objet (première approche)

Apres avoir vu les concepts fondamentaux de la programmation objet, attardons nous sur la programmation objet vu du côté de PHP.

Pour cela, je vous propose de réaliser notre premier classe : une classe qui vous servira à envoyer des mails.

Jusqu'à présent, pour envoyer des mails, vous deviez recopier toujours le même code avec des en-têtes à n'en plus finir.

Afin de commencer sur de bonnes bases, je vous conseille de stocker votre classe de mails dans un fichier PHP, comme par exemple , puis d'include ce fichier dans vos scripts lorsque vous en aurez besoin.

Attaquons tout de suite le code de notre classe !

Voici les premières lignes de code de notre classe :

exemple1

<?php class SendMail { var $destinataire; var $objet; var $texte;

}

?>

Comme vous le voyez, la déclaration d'une classe en PHP démarre par le mot clé class suivi du nom de la classe. Nous ouvrons alors une accolade ouvrante qui délimite le début de la déclaration des méthodes et des attributs de la classe (la déclaration de la classe se terminant avec une accolade fermante).

Ensuite, nous joignons 3 variables à notre classe : $destinataire, $objet et $texte.

Ces 3 variables sont en fait les caractéristiques communes des objets (les attributs) que nous allons pouvoir créer grâce à notre classe.

Noter que l'on déclare ces attributs avec le mot réservé var.

En clair, cela veut dire que tous les objets que nous allons créer avec cette classe (des mails en l'occurrence) auront toujours un destinataire, un objet et un texte.

Vous pouvez déclarer autant d'attributs de classe que vous le souhaitez.

Premier exemple d'utilisation :

exemple2

<?php

// on inclut le code de notre classe include ("");

// on déclare notre objet (en fait, dans le langage objet, on dit que l'on crée une

instance de la classe SendMail) $message = new SendMail ();

// on affecte des valeurs aux attributs de notre objet

$message->destinataire = "";

$message->objet = "Scoop mondial !";

$message->texte = "Voici mon premier mail utilisant une classe mail :)";

?>

Noter l'utilisation de l'opérateur -> qui permet d'affecter des valeurs aux attributs de notre objet.

© 2002 - 2007 - Page 1/4

Vous vous doutez bien qu'à ce niveau là, aucun mail n'a été envoyé :)

Cependant, vous pouvez vérifier que notre objet possède bien les attributs que nous lui avons fourni en faisant des :

exemple3

<?php echo $message->destinataire; // retournera : echo $message->objet; // retournera : Scoop mondial ! echo $message->texte; // retournera : mon premier mail utilisant une classe mail :) ?>

Pour envoyer notre mail, nous allons écrire une méthode pour notre classe qui utilisera la fonction mail de PHP ainsi que les attributs de notre objet.

On aura alors (pour notre classe) :

exemple4

<?php class SendMail {

var $destinataire; var $objet; var $texte;

function envoyer() { mail ($this->destinataire, $this->objet, $this->texte);

}

}

?>

Détaillons la méthode envoyer().

Notre méthode utilise la fonction de mail de PHP, et elle prend en argument les valeurs des attributs de notre classe. Cependant, remarquez l'utilisation de $this.

$this indique l'instance courante de notre classe.

Cet objet représente donc notre objet $message que nous utilisons dans notre script.

Vous pouvez écrire autant de méthodes que vous le souhaitez pour votre classe.

Cependant, sachez que vous ne pouvez écrire qu'une seule méthode ayant le même nom que le nom de votre classe (il s'agit en fait du constructeur de la classe qui a un rôle particulier au sein de la classe, nous le détaillerons plus tard).

Envoyons maintenant notre mail grâce à notre méthode envoyer() :

exemple5

<?php

include (""); $message = new SendMail ();

$message->destinataire = "";

$message->objet = "Scoop mondial !";

$message->texte = "Voici mon premier mail utilisant une classe mail :)";

// on applique la méthode envoyer() à notre objet $message grâce à l'opérateur ->

$message->envoyer(); ?>

Plutôt pratique non ? :)

© 2002 - 2007 - Page 2/4

comment fonctionne une classe. Du moment que vous savez à quoi servent vos méthodes (leur rôle), vous pouvez les utiliser sans comprendre ce qu'il se passe derrière (le code de la classe en elle-même).

Mais vous pouvez aussi réutilisez vos classes dans d'autres scripts (ce qui reste l'avantage principal de cette forme de programmation).

Voyons maintenant le constructeur d'une classe.

En effet, toute classe contient une méthode dite "constructeur" et cette méthode a toujours le même nom que le nom de la classe en question.

Sans le savoir, lorsque vous avez écrit le code :

exemple6

<?php

Et bien vous avez appelé le constructeur par défaut de la classe SendMail.

Cependant, comme vous l'avez remarqué, notre classe SendMail ne comporte pas de méthode SendMail() (le constructeur d'une classe est la méthode de cette classe qui porte le même nom que le nom de la classe), et bien dans ce cas, PHP utilise un constructeur par défaut qui n'affecte en rien sur les propriétés de notre objet.

Toutefois, vous pouvez vous-même écrire un constructeur dans votre classe.

Mais il faut savoir que le code que vous allez mettre dans votre constructeur va se répercuter sur tous les objets qui seront instances de votre classe.

Prenons un exemple simple :

Imaginer que vous ayez une classe Bonhomme.

Un des attributs de cette classe serait $nom, représentant le nom de notre bonhomme.

Si vous instancier votre classe simplement (en faisant donc un new Bonhomme() tout simple) alors que vous n'avez pas spécifié de constructeur, PHP va vous créer un Bonhomme sans nom (l'attribut $nom de notre objet sera vide). Cependant, vous pouvez très bien écrire vous-même votre propre constructeur pour donner un nom à votre Bonhomme dès sa création.

Revenons alors à notre classe SendMail, et nous allons lui spécifier un constructeur qui va permettre de définir si le mail à envoyé sera au format texte ou html.

exemple7

<?php class SendMail { var $destinataire; var $objet; var $texte;

// on ajoute un attribut $entete à notre classe var $entete;

// le constructeur de notre classe qui prend un paramètre function SendMail ($type = "texte") { if ($type == "texte") {

$this->entete = "Content-type: text/plain; charset=iso-8859-1n";

}

elseif ($type == "html") {

$this->entete = "Content-type: text/html; charset=iso-8859-1n"; }

} function envoyer() {

© 2002 - 2007 - Page 3/4

mail ($this->destinataire, $this->objet, $this->texte, $this->entete); }

}

?>

Vous remarquerez alors que grâce à notre constructeur, nous allons pouvoir rapidement créer des mails au format texte ou bien au format html.

Exemple :

exemple8

<?php

include ("");

// $message sera un mail au format texte $message = new SendMail ();

// $message2 sera un mail au format texte $message2 = new SendMail ("texte");

// $message3 sera un mail au format html

$message3 = new SendMail ("html"); ?>

En résumé, le constructeur de la classe sert souvent à initialiser certains attributs des objets crées à partir de la classe.

Attention, une classe ne peut contenir qu'un seul constructeur.

Ce cours vous a donc présenté quelques rudiments de la programmation par objet en PHP, cependant, vous avez du remarquez que contrairement au premier cours (les concepts fondamentaux), de nombreux concepts n'ont pas étés traités ici.

Ces concepts seront traités dans un futur cours afin de ne pas trop vous embrouillez les idées : trop de notions nouvelles d'un coup peut nuire à la compréhension de cette forme de programmation déjà bien complexe.

Auteur : LA GLOBULE

Dernière révision du cours : le 30/05/2007 à 00:22

© 2002 - 2007 - Page 4/4

Et bien c'est tout à fait possible de faire ceci en PHP.

En effet, grâce aux variables dynamiques vous allez pouvoir utiliser des noms de variables qui sont eux mêmes (les noms), variables, ce qui veut dire que vous allez utiliser des noms de variables qui sont affectés et utilisés dynamiquement dans votre script.

D'après ce que l'on vient dire, une variable dynamique serait alors une variable qui aurait comme nom la valeur d'une variable, par exemple $var.

En effet, si nous définissons la variable $hello, avec en valeur la chaîne de caractères Coucou, on aurait la chose suivante :

exemple1

<?php

$var = 'hello'; $hello = 'Coucou'; echo ${$var};

?>

C'est à dire la valeur de la variable $hello.

En utilisant le code :

exemple2

<?php

$var ='hello'; $hello = 'Coucou'; echo $hello; ?>

Nous aurions eu exactement le même résultat.

Vous remarquez alors au passage le fonctionnement d'une variable dynamique :

- on initialise une variable ayant une certaine valeur

- on veut utiliser une autre variable ayant comme nom la valeur de notre variable précédente : pour cela, nous déclaronsnotre variable avec un $, puis avec l'intitulé de notre variable précédent entre deux crochets, ce qui donne : ${$var}

Malgré, cette brève description des variables dynamiques, j ai comme l'impression que vous n'êtes pas du tout convaincu.

Mais à quoi bon peuvent elles bien servir ces variables dynamiques ?

Tout simplement à faire du dynamique :)

Imaginons que l'on ai dans notre script PHP deux variables de type tableau (ou array) et que l'on désire accéder à l'un de ces tableaux.

Au lieu de faire des tests fous pour savoir à quel tableau on veut accéder, il nous suffit de créer une variable de type chaîne de caractères contenant le nom de notre tableau (celui que l'on désire parcourir) et d'utiliser une variable dynamique pour accéder à notre tableau.

© 2002 - 2007 - Page 1/4

Exemple :

$tableau1 = array ('test', 'toto', 'titi');

$tableau2 = array ('humpf', 'grmbl');

$var = 'tableau1'; $nb_elements = count (${$var}); for ($i=0; $i<$nb_elements; $i++) {

// on accede aux éléments du tableau $tableau1 echo ${$var}[$i].'<br />';

}

?>

Ce qui affichera donc :

L'exemple peut vous paraître un peu bête, mais regardez le de plus près : en effet, si nous décidons du jour au lendemain de changer le nom de notre tableau (afin de parser un autre tableau), nous n'aurons qu'une seule ligne à modifier :

exemple4

<?php

(On aurait en fait écrit le nom d'un nouveau nom de tableau)

Alors qu'en n'utilisant pas les variables dynamiques, nous aurions du modifier cette même ligne, mais aussi la ligne

concernant le comptage du nombre d'élément de notre tableau mais aussi la ligne contenue dans notre boucle for (le echo).

Les variables apportent alors leur lot d'avantages :

- la clarté du code

- du code dynamique réutilisable

- des solutions à des problèmes liés à la dynamique d'un script (comme par exemple généré un formulaire contenant unnombre indéfini de champs)

Avant de poursuivre ce cours, sachez également que le nombre de variables dynamiques utilisées est théoriquement sans limites.

Vous pouvez très bien faire, par exemple :

exemple5

<?php

$var = 'toto'; $toto = 'test'; $test = 'humpf';

echo ${${$var}}; ?>

© 2002 - 2007 - Page 2/4

Voyons maintenant un cas concret sur lequel il est intéressant d'utiliser les variables dynamiques.

Imaginez que vous ayez un formulaire, et dans la page de traitement de ce formulaire, plusieurs actions sont possibles.

Jusqu'à présent, pour faire votre page de traitement, vous deviez enchaîner une série de if elseif else (ou même mieux en utilisant un case) afin de savoir dans quel cas vous vous trouvé, et de plus, vous deviez écrire un bon paquet de ligne de code pour décrire chaque action.

En effet, imaginons que notre formulaire contienne un champ caché contenant une des valeurs suivantes (au choix) : - insert

- delete

- update- select

Voici alors le code d'une page de traitement possible de ce formulaire :

exemple6

<?php

$champ_cache = $_POST['champ_cache'];

function insert() { // code

}

function delete() { // code

} function update() { // code

}

function select() { // code

}

if ($champ_cache == 'insert' || $champ_cache == 'delete' || $champ_cache == 'update' ||

$champ_cache == 'select') { $champ_cache();

}

?>

Dans ce cas précis, on parlera de fonction dynamique.

Car comme vous pouvez le constater, on utilise la valeur d'une variable pour désigner le nom d'une fonction.

Voyons un autre cas d'utilisation, où là, nous allons pouvoir générer dynamiquement un formulaire.

Générer un formulaire dynamiquement veut dire que la personne utilisant le formulaire pourra choisir, elle-même, le nombre de champs de type text contenu dans ce formulaire, et grâce aux variables dynamiques, nous allons pouvoir récupérer la valeur de ces champs sans connaître auparavant le nombre de champs de ce formulaire (vu que ce nombre est décidé par la personne utilisant le formulaire)

Voici le code :

exemple7

<?php

// si l'utilisateur soumet le formulaire on affiche la valeur de tous les champs du

formulaire

if (isset($_POST['submit']) && $_POST['submit'] == "Envoyer"){ // on affiche le nombre de champs du formulaire echo 'Nombre de champs : '.$_POST['nb_champs'].'<br />';

// on affiche la valeur des champs du formulaire

© 2002 - 2007 - Page 3/4

for ($i=1; $i<=$_POST['nb_champs']; $i++){

$dynamique = 'champs_'.$i; $value = $_POST[$dynamique];

echo 'Valeur du champ '.$i.' : '.$value.'<br />';

}

}

// sinon on affiche le formulaire avec la possibilité d'ajout des champs au formulaire else{

}

// si la personne clic sur "un champs en +", on ajoute un champs if (isset($_POST['submit']) && $_POST['submit'] == "Un champs en +"){ $_POST['nb_champs']++;

}

// on affiche le formulaire echo '<FORM METHOD="post">';

// on place un champ caché contenant un entier ayant comme valeur le nombre de champs du formulaire echo '<INPUT TYPE="hidden" NAME="nb_champs" VALUE="'.$_POST['nb_champs'].'">';

// on affiche tous les champs du formulaire for ($i=1; $i<=$_POST['nb_champs']; $i++){ echo '<INPUT TYPE="text" name="champs_'.$i.'"><br />';

}

// on place un bouton permettant de rajouter un champs echo '<INPUT TYPE="submit" NAME="submit" VALUE="Un champs en +"><br />'; // on place un bouton permettant de soumettre le formulaire echo '<INPUT TYPE="submit" NAME="submit" VALUE="Envoyer">'; echo '</FORM>';

}

?>

Alors, convaincu ?

Auteur : LA GLOBULE

Dernière révision du cours : le 30/05/2007 à 00:24

© 2002 - 2007 - Page 4/4