Atelier régional de formation de Formateurs aux technologies de l’information
Système d’Information
Création et gestion d’un site Web dynamique
[ php / MySQL + SPIP ]
du 8 au 13 décembre- Université de Bamako
Atelier animé par:
Philippe DROUOT, Africa Computing
Courriel :
Romain Rolland TOHOURI
Courriel :
Edem Kwame KOSSI
Courriel :
Siriman KEITA
Courriel :
Jusqu'ici, nous avons conçu des pages Web dites statiques : même avec du DHTML (Dynamic HTML), le contenu des pages est celui que le webmestre a explicitement indiqué.
Il est possible de modifier le contenu en fonction du contexte grâce à un langage de scripts qui permet de créer des pages dites dynamiques. Par exemple, on peut se connecter à une base de données afin d'y enregistrer des données ou de récupérer des informations sur un utilisateur.
Le web dynamique consiste simplement à générer tout ou partie de la page HTML qui va s'afficher, selon la demande.
L'idée est la suivante : le client demande quelque chose (un article par exemple) ; le serveur web plutôt que de servir une page déjà faite (une page statique), va créer cette page dans l'instant et la renvoyer au client.
PHP est un langage de script permettant d'intégrer des instructions de programmation puissantes directement dans du code HTML. Le serveur traite les scripts PHP d'une page et génère dynamiquement la page HTML résultat des fonctions PHP. Le principal intérêt de PHP est que celui-ci permet de créer facilement des pages dynamiques résultats de calculs ou de requêtes SQL effectuées sur une base de données.
Qu'appelle t'on une page dynamique ? Deux appels consécutifs d'une même page dite dynamique peuvent donner deux pages HTML différentes (la page est statique au niveau du client web mais elle est générée dynamiquement au niveau du serveur).
PHP peut également générer des fichiers PDF, s'interfacer avec des serveurs de messagerie, des serveurs LDAP ou encore générer des images et graphiques GIF à la volée, etc.
L'utilisation d'un langage de script tel que PHP est un passage obligé pour réaliser un site à contenu évolutif et riche sans avoir à passer son temps à modifier sans cesse les pages du site : plusieurs personnes alimentent, à partir d'une simple interface Web, une ou plusieurs bases de données qui servent à générer le contenu du site en fonction des demandes des utilisateurs.
Remarque : Contrairement à ce que certains disent, l'acronyme PHP ne signifie pas "People Hate Perl", mais bizarrement "Personal Home Pages". Ce nom est hérité de la première version de PHP. Aujourd'hui, par concensus, "PHP : PHP Hypertext PreProcessor". En effet l’origine de PHP est assez surprenante. PHP est né avec le site de Rasmus Lerdof en 1994: une page personnelle, avec son CV qui permettait à l'origine de conserver une trace des utilisateurs. A l'époque PHP supportait déjà des requêtes SQL et, comme cela arrive souvent sur le Web, des internautes ont rapidement voulu leur propre copie du programme. Rasmus a donc décidé de mettre en ligne la version 1.0 de PHP (Personal Home Page). A la surprise de son auteur, PHP est devenu rapidement très populaire.
Javascript : le code Javascript est interprété par le client Web alors que le code PHP est directement interprété par le serveur Web (avec PHP seul le résultat est visible au niveau du client).
? De ce fait, leur utilisation est différente : Javascript est surtout utilisé pour la présentation et la manipulation d'une page html (menu déroulant, bannière, etc.. ) alors que PHP sert surtout à générer automatiquement du contenu à partir de bases de données.
Perl : Perl est le langage le plus populaire pour les solutions SGI. Il permet de supporter des technologies complexes tels qu'un moteur de recherche. Contrairement à PHP, Perl ne peut pas s'intégrer directement dans une page web ce qui implique une mise au point beaucoup plus délicate et plus complexe qu'avec PHP. Sans compter que la force de PHP réside dans le fait que celui-ci supporte directement les requêtes SQL.
ASP : ASP ou Active Server Page est la solution proposée par Microsoft avec son serveur Web IIS (Internet Information Server) pour créer des pages dynamiques. L'intérêt de ASP est que celui-ci utilise les fonctionnalités de Perl. Format propriétaire Microsoft, ASP inclue beaucoup moins de fonctionnalités que PHP. De ce fait si le serveur Internet n'est pas sous Windows, nous n'avons aucun intérêt à utiliser des scripts ASP au lieu de scriots ASP.
? Le passage des pages statiques, en langage HTML, aux pages dynamiques, en PHP, ASP, Perl ou tout autre langage, demande un minimum d'apprentissage. Mais, c'est un passage obligé si l'on veut faire un site de qualité, évolutif et riche sans passer son temps à modifier sans cesse des pages. PHP et ASP sont les deux langages de scripts qui devraient avoir une très forte progression du fait de leur simplicité, de leur intégration dans les pages HTML et du fait qu'ils provoquent moins de phénomènes de rejet que Perl (plus réservé aux programmeurs expérimentés). Le temps consacré à l'apprentissage de ces langages sera très largement compensé par les nouvelles possibilités offertes et par l'automatisation de tous les traitements fastidieux.
Rappelons que PHP est un langage de scripts dynamique côté serveur, c'est à dire que c'est le serveur web qui exécute les scripts.
Dans la pratique, il est peu aisé de mettre en ligne par FTP sur un serveur distant une page contenant du PHP à chaque fois que l’on veut tester son code. Cela s’avère très rapidement fastidieux. De ce fait pour effectuer des développements PHP, il est impératif d’effectuer des tests en local ce qui nécessite l’installation sur sa machine d’un serveur http (Apache, le serveur libre leader), de PHP et du serveur de bases de données MySQL. Si vous êtes sous Linux, Apache, PHP et MySQL est sans aucun doute livré sur votre distribution.
Sous Windows, il existe un package nommé easyphp qui permet d’installer rapidement le trio Apache / PHP / MySQL :
Une fois installée, lancez easyphp et vous aurez un serveur Apache en mémoire avec le module php ainsi que le serveur de bases de données MySQL. Dans votre navigateur, tapez ou pour visualiser la page par défaut que délivre votre serveur apache (sur n’importe quelle machine et sur n’importe quel système d’exploitation, par convention l’adresse IP 127.0.0.1 et le nom localhost désignent votre carte réseau).
Si vous avez installé EasyPHP, le répertoire proposé par défaut est c:\Program files\EasyPHP
Vous y remarquerez plusieurs sous répertoires dont apache et www. Les fichiers de configurations d’Apache se trouvent dans apache/conf et ceux sont ces fichiers qui précisent que le serveur http utilise le langage de scirpt php ou par exemple que les pages locales du serveur sont situées dans le répertoire c:\Program files\EasyPHP\www
Il convient par conséquent d’avoir quelques connaissances du fichier de configuration d’Apache afin pouvoir intervenir si nécessaire.
Configuration d’Apache :
Ouvrez le fichier C:/Program
Parmi les principales directives, on y trouve :
Racine du serveur Apache : ServerRoot "C:/Program Files/EasyPHP/apache"
Emplacement par défaut des pages html : DocumentRoot "C:/Program Files/EasyPHP/www"
Journal d'erreur par défaut : ErrorLog logs/error_log (Emplacement relatif à ServerRoot)
Emplacement par défaut des pages html : DocumentRoot /home/httpd/html
Pages par défaut : DirectoryIndex
Test de PHP et configuration de PHP:
Le code PHP s'intègre au milieu d'une page HTML mais la plupart du temps pour que le serveur Apache sache qu'il faut interpréter le code PHP, la page doit avoir comme extension .php (pour PHP4) ou .php3 (pour PHP3). Le code php peut être placé n’importe où parmi le code HTML entre les balises <? et ?> ou encore <?php et ?> (les deux syntaxes sont généralement autorisées).
Une ligne de commande php se termine toujours par le symbole ;
La première fonction à mémoriser est la fonction phpinfo() qui permet d’obtenir des informations sur la configuration de php.
Editez un fichier texte avec le bloc-note par exemple r c:\Program files\EasyPHP\www\ et saisissez < ? phpinfo() ; ?>
phpinfo affiche de nombreuses informations sur le PHP, concernant sa configuration courante : options de compilation, extensions, version, informations sur le serveur, et environnement (lorsque compilé comme module), environnement PHP, chemins, utilisateur, en-têtes HTTP, et licence GNU Public License. Comme tous les systèmes sont configurés différemment, phpinfo sert généralement à vérifier la configuration ainsi que les variables prédéfinies, pour une plate-forme donnée. De plus, phpinfo est un outil de déboguage, car il affiche le contenu de toutes les variables EGPCS (Environnement, GET, POST, Cookie, Serveur). Phpinfo constitue donc la fonction PHP la plus importante.
Pour configurer PHP, il vous faut intervenir sur le fichier . Pour localiser ce fichier, le plus simple est de consulter les informations générées par phpinfo().
Il est tout à fait possible de mélanger, au sein d'une même page, des instructions HTML et des instructions PHP. Pour que le serveur qui vous héberge puisse comprendre qu'il va devoir interpréter un script en PHP, il faut lui indiquer le début et la fin du code, de même façon que vous le feriez pour du javascript par exemple.
Depuis la version 3 de PHP, plusieurs balises sont acceptées. On peut ainsi indifféremment écrire :
<? Instructions PHP?>
ou
<?php Instructions PHP?>
ou
<script langage="php"> Instructions PHP</script>
Votre premier programme PHP :
<BODY>
Voila du <B>HTML</B>
<P>
<?
echo "Voilà un peu de <B>PHP</B>";
?>
<P>
Encore un peu de <B>HTML</B>
</BODY>
Et appelons cette première page
Le résultat obtenu à l'écran est le suivant :
Voilà duHTML
Voilà un peu dePHP
Encore un peu deHTML
Attention Il faut passer par le serveur pour visualiser le résultat, puisque c'est lui qui interprète le langage PHP. Si le fichier a été enregistré à la racine de DocumentRoot, nous pourrons le visualiser à l'adresse (ou si le hostname localhost n’est pas définit).
De plus, en affichant le code source de la page obtenue, on remarque que le code a été interprété par le serveur : le PHP a disparu, on ne lit que du code HTML ! Pour vous en rendre compte, affichez le code source de la page obtenue.
Lorsque le client fait appel à une page PHP, le serveur traite d'abord le script. Il envoie ensuite le résultat au client sous forme de page HTML qui peut être interprétée et affichée par le navigateur.
Un exemple de page dynamique :
Nous allons dans un premier temps créer un formulaire simple qui permettra de saisir du texte et de soumettre la requête à une page dynamique qui affichera le résultat.
<html>
<head>
<title>Formulaire</title>
</head>
<body>
<p>Bonjour, quel est votre nom ?</p>
<form method="get" action="">
<input type="text" name="nom" value="Anonyme">
<input type="submit" value="OK">
</form>
</body>
</html>
Résultat de la page
Tapez le code de cette page à l'aide du bloc-notes de Windows puis enregistrez-le sous .
Cette page Web statique crée un formulaire dans lequel on met un champ texte appelé nom à remplir où l'on inscrit par défaut "Anonyme" et un bouton pour valider. "value=" n'est pas indispensable mais peut souvent être utile pour éviter de faire saisir des informations que l'on connaît déjà (c'est la valeur par défaut).
Il s'agit maintenant de traiter cette information dans une autre page qui va afficher un message de bienvenue personnalisé. Cette page doit être dynamique puisque son contenu va changer en fonction de la valeur de la variable nom. Ce sera une page PHP qui portera le nom . C'est la page appelé dans le formulaire (action="") du fichier .
<html>
<head>
<title>Réception formulaire</title>
</head>
<body>
<? echo "Bonjour ".$nom; ?>
</body>
</html>
Le point (.) est l'opérateur de concaténation de chaînes de caractères. On est désormais capable de faire du dynamisme ! En effet lorsque l'on soumet le formulaire, on est en mesure d'afficher le nom entré dans celui-ci. Le résultat obtenu est équivalent à entrer l'URL : ?nom=xxxx.
Résultat de la page appelée par
Attention ! Pour que le code soit interprété par le serveur, il faut placer les fichiers et dans un répertoire adéquat (accessible au serveur) et passer par le serveur pour les interpréter. On peut par exemple créer un répertoire tests à la racine du serveur web et y placer les 2 fichiers. L'url à appeler sera alors http://127.0.0.1/tests/ (vérifier auparavant que le serveur Apache est en marche : le point rouge de l'icone EasyPHP doit clignoter).
La grande force de PHP réside dans son utilisation conjointe avec une base de donnée : ce qui permet de fournir un contenu évolutif sans avoir à passer sans cesse son temps à modifier les pages html. PHP s'interface avec la quasi totalité des SGBD du marché. Pour utiliser MySQL, le plus simple est de s’appuyer sur l’excellente interface graphique phpMyAdmin. Si vous utilisez EasyPhp, phpMyAdmin est déjà installée par défaut et vous y avez accès par (par défaut le login du super utilisateur est root et le mot de passe est vide).
Pourquoi vouloir réinventer la roue ?
Il existe de très nombreuses applications php prêtes à l'emploi couvrant la plupart des domaines : Annuaire, Bannières, Bases de Données, Livre d'Or, WebMail, Moteur de recherche, Portail, Newsletter, E-Commerce, Petites Annonces, Formation, Forum, Sondage, etc..
Avant de vous lancer dans de longs développements, assurez vous que l'application que vous souhaitez n'existe pas déjà quitte à y effectuer quelques modifications afin de correspondre exactement à vos besoins.
Exemples: installation d’un forum et d’un chat
phpMyChat est une application de Chat en PHP, supportant des bases MySQL, PostgreSQL et ODBC. Disponible en de nombreuses langues.
Exercice : télécharger phpMyChat sur et installez le.
Exercice : télécharger phpBB sur et installez le.
Vous constaterez que la procédure d’installation de certaines applications est très spécifique. La plupart du temps l’installation d’une application php/MySQL consiste à créer une base, y lancer à partir d’un fichier déjà préparé les requêtes SQL permettant de créer les tables et les champs nécessaire au fonctionnement puis à éditer un fichier de type afin de spécifier l’adresse du serveur de base de donnée, le nom de la base et le login et password associé. Une interface spécifique facilite parfois cette procédure.
Lorsque PHP commence à traiter un fichier, il ne fait qu'afficher le texte HTML qu'il rencontre. Si vous renommez un fichier .html en .php, il fonctionnera exactement comme avant.
Si vous voulez insérer des commandes PHP dans votre fichier, vous devez indiquer à PHP le début d'une telle séquence, en passant en mode PHP.
Il y a quatre moyens pour passer du mode HTML au mode PHP :
<? echo ("exemple en Php.\n"); ?>
<?php echo("exemple en Php.\n"); ?>
<script language="php">
echo ("exemple en Php.\n");
</script>
<% echo ("exemple en Php.\n"); %>
La deuxième méthode est généralement utilisée, car elle permet une implémentation aisée de PHP avec la prochaine génération de XHTML.
La première possibilité n'est valable que si vous l'avez activée. Soit en faisant appel à la fonction short_tags() (NdT : semble avoir disparu), soit en utilisant l'option d'exécution short_open_tag dans le fichier de configuration, soit en utilisant l'option de compilation --enable-short-tags.
La quatrième possibilité est seulement disponible si vous l'avez activée en utilisant soit l'option d'exécution asp_tags, soit en utilisant l'option de compilation --enable-asp-tags.
Note : Le support de la quatrième possibilité, ASP-style, a été ajouté dans la version 3.0.4.
Les instructions sont séparées comme en C ou en Perl par un point virgule à chaque fin d'instruction.
La balise de fin (?>) implique la fin d'un instruction, et donc ajoute implicitement un point virgule. Les deux exemples suivants sont équivalents.
<?php
echo "Ceci est un test";
?>
<?php echo "Ceci est un test" ?>
Le PHP supporte les commentaires comme en C, C++ et Shell Unix. Par exemple:
<?php
echo "Ceci est un test"; // Ceci est un commentaire
/* Ceci est un commentaire
sur plusieurs lignes*/
echo "Ceci est encore un test";
echo "Enfin, le test final"; # Ceci est un commentaire
?>
Le premier type de commentaire ne commente que jusqu'à la fin de la ligne ou bien jusqu'à la fin du bloc, cela dépend du premier rencontré.
:
C'est le type le plus simple. Un booléen exprime les valeurs de vrai TRUE ou FALSE.
Vous pouvez utiliser les constantes 'TRUE' et 'FALSE' pour spécifier une valeur de type booléen. Généralement, vous les créerez avec un des opérateurs qui retourne une valeur booléen, pour le passer à une structure de contrôle.
Lors des conversions de valeurs de type booléen, les valeurs suivantes sont considérées comme fausse (FALSE) : Le booléen FALSE
Toutes les autres valeurs sont considérées comme vraies (TRUE) (y compris les ressources).
-1 est considère comme vrai!
:
Un entier est un nombre de l'ensemble des entiers naturels Z : Z = { ., -2, -1, 0, 1, 2, }. Il est possible de spécifier les nombres entiers (integers) de toutes les manières suivantes : décimale (base 10), hexadécimale (base 16), octale (base 8) éventuellement précédé du signe moins (-).
Pour utiliser la notation octale, vous devez préfixer le nombre avec un zéro; pour utiliser la notation hexadécimale, vous devez préfixer le nombre avec 0x.
<?php
$a = 1234; # nombre entier en base 10
$a = -123; # nombre entier négatif
$a = 0123; # nombre entier en base 8, octale (équivalent à 83 en base 10)
$a = 0x12; # nombre entier en base 16, hexadécimale
# (équivalent à 18 en base 10)
?>
La taille des entiers dépend de la plate-forme de support, mais la valeur maximale est généralement de 2 milliards et des poussières (c'est un entier signé de 32 bits). PHP ne supporte pas les entiers non signés.
Pour explicitement convertir une valeur en integer, utilisez les operateurs de transtypage (int) ou (integer).
Nombre à virgule flottante:
Les nombres à virgule flottante (connus aussi sous le vocable de "double" ou "float" "nombre rééls") peuvent être spécifiés en utilisant la syntaxe suivante:
<?php
$a = 1.234;
$a = 1.2e3;
?>
Il est fréquent que de simples fractions décimales telles que 0.1 ou 0.7 ne puissent être converties au format interne binaire sans une légère perte de précision. Cela peut conduire à des résultats étonnants : par exemple, floor((0.1+0.7)*10) retournera 7 au lieu de 8 car le résultat de la représentation interne est 7.9999999999 .
Tout ceci est lié au fait qu'il est impossible d'exprimer certaines fractions en un nombre fini de chiffres.
Par exemple 1/3 s'écrira 0.3333333 en mode décimal.
Ne faites donc jamais confiance aux nombres à virgule jusqu'à leur dernière décimale, et ne comparez jamais ces nombres avec l'opérateur d'égalité.
:
Le moyen le plus simple de spécifier une chaîne de caractères est d'utiliser les guillemets simples : '.
Pour spécifier un guillemet simple littéral, vous devez l'échapper avec un anti-slash (\), comme dans de nombreux langages. Si un anti-slash doit apparaître dans votre chaîne ou bien en fin de chaîne, il faudra le doubler. Notez que si vous essayez d'échapper n'importe quel autre caractère, l'anti-slash sera conservé! Il n'y a pas besoin d'échapper d'autres caractères que le guillemet lui-même.
Note : En PHP 3, une alerte sera affichée si cela arrive avec un niveau de rapport d'erreur de E_NOTICE.
Note : Contrairement aux autres syntaxes, les variables présentes dans la chaîne ne seront PAS remplacées par leurs valeurs.
<?php
echo 'Ceci est une chaîne simple';
echo 'Arnold a coutume de dire : "I\'ll be back"';
// affiche : "I'll be back"
echo 'Etes vous sûr de vouloir effacer le dossier C:\\*.*?';
// affiche : Etes vous sûr de vouloir effacer le dossier C:\*.*?
echo 'Etes vous sûr de vouloir effacer le dossier C:\*.*?';
// affiche : Etes vous sûr de vouloir effacer le dossier C:\*.*?
echo 'Je suis en train de mettre une nouvelle ligne comme ceci : \n';
// affiche : Je suis en train de mettre une nouvelle ligne comme ceci : \n
?>
Si la chaîne est entourée de guillemets doubles, PHP va comprendre certaines séquences de caractères :
| Séquence | Valeur |
| \n | Nouvelle ligne (linefeed, LF ou 0x0A (10) en ASCII) |
| \r | Retour à la ligne(carriage return, CR ou 0x0D (13) en ASCII) |
| \t | Tabulation horizontale (HT ou 0x09 (9) en ASCII) |
| \\ | Antislash |
| \$ | Caractère $ |
| \" | Guillemets doubles |
| \[0-7]{1,3} | Une séquence de caractères qui permet de rechercher un nombre en notation octale. |
| \x[0-9A-Fa-f]{1,2} | Une séquence de caractères qui permet de rechercher un nombre en notation hexadécimale. |
Si vous essayez d'utiliser l'anti-slash sur n'importe quelle autre séquence, l'anti-slash sera affiché dans votre chaîne. Le plus important des chaînes à guillemets doubles est le fait que les variables qui s'y trouvent seront remplacées par leurs valeurs.
Les caractères d'une chaîne sont accessibles en spécifiant leur offset (le premier caractère est d'offset 0) entre accolade, après le nom de la variable.
Note : Pour assurer la compatibilité ascendante, vous pouvez toujours accéder aux caractères avec des crochets. Mais cette syntaxe est obsolète en PHP 4.
Exemples de chaînes:
<?php
/* Affectation d'une chaîne. */
$str = "Ceci est une chaîne";
/* Concaténation. */
$str = $str . " avec un peu plus de texte";
/* Une autre méthode de concaténation. */
$str .= " et une nouvelle ligne à la fin.\n";
/* Cette chaîne finira comme : '<p>Nombre: 9</p>' */
$num = 9;
$str = "<p>Nombre: $num</p>";
/* Celle-ci sera '<p>Nombre: $num</p>' */
$num = 9;
$str = '<p>Nombre: $num</p>';
/* Premier caractère d'une chaîne */
$str = 'Ceci est un test.';
$first = $str{0};
/* Dernier caractère d'une chaîne. */
$str = 'This is still a test.';
$last = $str{strlen($str)-1};
?>
:
Un tableau array peut être créé avec la fonction array(). Cette fonction prend en argument des structures key => value, séparées par des virgules.
La syntaxe "index => valeur", séparée par des virgules, définit les index et leur valeur. Un index peut être une chaîne ou un nombre. Si l'index est omis, un index numérique sera automatiquement généré (commençant à 0). Si l'index est un entier, le prochain index généré prendra la valeur d'index la plus grande + 1. Notez que si deux index identiques sont définis, le dernier remplacera le premier.
L'exemple suivant montre comment créer un tableau à deux dimensions, comment spécifier les index d'un tableau associatif, et comment générer automatiquement des index numériques.
<?php
$fruits = array (
"fruits" => array ("a" => "orange", "b" => "banane", "c" => "pomme"),
"numbres" => array (1, 2, 3, 4, 5, 6),
"trous" => array ("premier", 5 => "deuxième", "troisième")
);
?>
Si vous omettez une clé lors de la spécification d'un tableau, l'indice maximum + 1 sera utilisé comme clé par défaut. Si aucun indice numérique n'a été généré, ce sera 0. Si vous spécifiez une qui a déjà été assigné, la nouvelle valeur écrasera la précédente.
array( key => value , ) // key is either string ou entier integer positif // value peut être n'importe quoi
Vous pouvez aussi modifier un tableau existant en lui assignant simplement des valeurs.
L'assignement de valeurs de tableau se fait en spécifiant la clé entre crochets. Si vous omettez la clé ("$tableau[]"), la valeur sera ajoutée à la fin du tableau.
$arr[key] = value;
$arr[] = value;
// key est soit une chaîne, soit un entier
// value peut être n'importe quoi
Si $arr n'existe pas, il sera créé. Cela en fait une alternative pour créer un tableau. Pour modifier une valeur, assignez lui une nouvelle valeur. Pour supprimer une valeur, utilisez la fonction unset().
Le type tableau de PHP est très souple. Voici quelques exemples d'utilisation :
<?php
// ceci
$a = array( 'couleur' => 'rouge'
, 'gout' => 'sucre'
, 'forme' => 'rond'
, 'nom' => 'pomme'
, 4 // cette clé sera 0
);
// est complétement équivalent à
$a['couleur'] = 'rouge';
$a['gout'] = 'sucre';
$a['forme'] = 'rond';
$a['nom'] = 'pomme';
$a[] = 4; // cette clé sera 0
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
// va créer le tableau array( 0 => 'a' , 1 => 'b' , 2 => 'c' )
// ou plus simplement array('a' , 'b' , 'c' )
?>
:
Pour initialiser un objet, vous devez utiliser la commande "new" afin de créer l’instance de l'objet.
<?php
class foo {
function faire_foo () {
echo "Faisant foo.";
}
}
$bar = new foo;
$bar->faire_foo();
?>
:
Une ressource (resource en anglais), est un type spécial, qui représente une référence sur une ressource externe. Les ressources sont créées par des fonctions dédiées.
Grâce au système de comptabilisation des références introduit en PHP 4 (avec le moteur Zend), PHP détecte automatiquement qu'une ressource n'est plus utilisée (comme Java). Dans ce cas, toutes les ressources systèmes utilisées par cette ressource sont libérées automatiquement.
Note : Les connexions persistantes représentent un cas particulier, elles ne seront PAS détruites.
:
La valeur spéciale NULL représente l'absence de valeur. Une variable avec la valeur NULL n'a pas de valeur.
Il y a seulement une valeur de type NULL, et c'est la constante NULL, insensible à la casse.
<?php
$var = Null;
?>
Note : La valeur NULL a été introduite en PHP 4.
PHP ne nécessite pas de déclaration explicite du type d'une variable. Le type d'une variable est déterminé par le contexte d'utilisation. Par exemple, si vous assignez une chaîne de caractères à la variable var, var devient une chaîne de caractère. Si vous assignez un nombre entier à var, elle devient un entier.
Un exemple de convertisseur automatique de type est l'opérateur '+'. Si un des opérandes est de type double, alors tous les opérandes sont évalués comme des variables de type double et le résultat est de type double. Sinon, tous les opérandes sont évalués comme des variables de type entier et le résultat sera du type entier. Il est à noter que cela NE CHANGE PAS le type des opérandes. Le seul changement est la manière dont les opérandes sont évaluées.
<?php
$foo = "0"; // $foo est une chaîne de caractères (ASCII 48)
$foo += 2; // $foo est maintenant du type entier (2)
$foo = $foo + 1.3; // $foo est maintenant du type double (3.3)
?>
Le comportement de la conversion automatique est actuellement indéfinie.
<?php
$a = "1"; // $a est une chaîne
$a[0] = "f"; // Mais que sont les index de chaîne?
?>
Etant donné que PHP supporte l'indexation de chaîne avec des offsets identiques à celles des tableaux, l'exemple ci-dessus conduit à un problème : est ce que $a est un tableau, dont le premier élément est "f", ou bien est ce que "f" est le premier élément de la chaîne de caractères $a?
Les versions courantes de PHP interprète le second assignement comme un index de chaîne, et donc $a devient "f", et le résultat de cette conversion automatique doit être considéré comme indéfini. PHP 4 a introduit la syntaxe avec les accolades pour accéder aux caractères d'une chaîne. Utilisez plutôt le code ci-dessous :
<?php
$a = "abc"; // $a est une chaîne
$a{1} = "f"; // $a vaut maintenant "afc"
?>
La conversion de type en PHP fonctionne de la même manière qu'en C: le nom du type désiré est écrit entre parenthèses devant la variable à transtyper ("cast").
<?php
$foo = 10; // $foo est un entier
$bar = (double) $foo; // $bar est un double
?>
Les conversions autorisées sont:
(int), (integer) - type entier
(bool), (boolean) - booléen
(real), (double), (float) - type double
(string) - ctype chaîne
(array) - type tableau
(object) - type objet
Il est à noter que les tabulations et les espaces sont autorisés à l'intérieur des parenthèses, donc les lignes suivantes sont équivalentes :
<?php
$foo = (int) $bar;
$foo = ( int ) $bar;
?>
:
En PHP , les variables sont représentées par un signe dollar "$" suivi du nom de la variable. Le nom est sensible à la casse (ie : $x != $X).
Les noms de variables suivent les mêmes règles de nommage que les autres entités PHP. Un nom de variable valide doit commencer par une lettre ou un souligné (_), suivi de lettres, chiffres ou soulignés.
<?php
$var = "Jean";
$Var = "Paul";
echo "$var, $Var"; // affiche "Jean, Paul"
$4site = 'pas encore'; // invalide : commence par un nombre
$_4site = 'pas encore'; // valide : commence par un souligné
$maïs = 'jaune'; // valide; 'ï' est ASCII 239.
?>
En PHP 3, les variables sont toujours assignées par valeur. C'est-à-dire, lorsque vous assignez une expression à une variable, la valeur de l'expression est recopiée dans la variable. Cela signifie, par exemple, qu'après avoir assigné la valeur d'une variable à une autre, modifier l'une des variables n'aura pas d'effet sur l'autre.
PHP 4 permet aussi d'assigner les valeurs aux variables par référence. Cela signifie que la nouvelle variable ne fait que référencer (en d'autres terme, "devient un alias de", ou encore "pointe sur") la variable originale. Les modifications de la nouvelle variable affecteront l'ancienne, et vice versa. Cela signifie aussi qu'aucune copie n'est faite : l'assignation est donc beaucoup plus rapide. Cela se fera notamment sentir dans des boucles, ou lors d'assignation de grands objets (tableaux).
Pour assigner par référence, ajoutez simplement un & (ET commercial) au début de la variable qui est assignée (la variable source). Dans l'exemple suivant, Mon nom est Pierre s'affichera deux fois :
<?php
$a = 'Pierre'; // Assigne la valeur 'Pierre' à $a
$b = &$a; // Référence $a avec $b.
$b = "Mon nom est Pierre"; // Modifie $b
echo $a; // $a est aussi modifiée
echo $b;
?>
PHP fourni un grand nombre de variables prédéfinies. Cependant, beaucoup de ces variables ne peuvent pas être présentées ici, car elles dépendent du serveur sur lequel elles tournent, de la version du serveur, et de la configuration du serveur, ou encore d'autres facteurs.
L'utilisation des variables prédéfinies de PHP , comme les tableaux superglobaux , est recommandé
| $GLOBALS | Contient une référence sur chaque variable qui est actuellement disponible dans l'environnement d'exécution global. Les clés de ce tableau sont les noms des variables globales. |
| $_SERVER | Les variables fournies par le serveur web, ou bien directement liées à l'environnement d'exécution du script courant. C'est la nouvelle version de l'ancienne variable $HTTP_SERVER_VARS , qui est maintenant obsolète, mais toujours là. |
| $_GET | Les variables fournies par le protocole HTTP en méthode GET. C'est la nouvelle version de l'ancienne variable $HTTP_GET_VARS qui est maintenant obsolète, mais toujours là. |
| $_POST | Les variables fournies par le protocole HTTP en méthode POST. C'est la nouvelle version de l'ancienne variable $HTTP_POST_VARS qui est maintenant obsolète, mais toujours là. |
| $_COOKIE | Les variables fournies par le protocole HTTP, dans les cookies. C'est la nouvelle version de l'ancienne variable $HTTP_COOKIE_VARS qui est maintenant obsolète, mais toujours là. |
| $_FILES | Les variables fournies par le protocole HTTP, suite à un téléchargement de fichier. C'est la nouvelle version de l'ancienne variable $HTTP_POST_FILES qui est maintenant obsolète, mais toujours là. |
| $_ENV | Les variables fournies par l'environnement. C'est la nouvelle version de l'ancienne variable $HTTP_ENV_VARS qui est maintenant obsolète, mais toujours là. |
| $_REQUEST | Les variables fournies au script par n'importe quel mécanisme d'entrée et qui ne doit recevoir une confiance limitée. Note : lorsque vous exécutez un script en ligne de commande, cette variable ne va pas inclure les variables argv et argc . Elles seront présentes dans la variable $_SERVER |
| $_SESSION | Les variables qui sont actuellement enregistrées dans la session attachée au script. which are currently registered to a script's session.C'est la nouvelle version de l'ancienne variable $HTTP_SESSION_VARS . |
La portée d'une variable dépend du contexte dans lequel la variable est définie. Pour la majorité des variables, la portée concerne la totalité d'un script PHP. Mais, lorsque vous définissez une fonction, la portée d'une variable définie dans cette fonction est locale à la fonction. Par exemple:
<?php
$a = 1;
include "b.inc";
?>
Ici, la variable $a sera accessible dans le script inclus b.inc . Cependant, dans les fonctions définies par l'utilisateur, une nouvelle définition de cette variable sera donnée, limitée à la fonction. Toute variable utilisée dans une fonction est par définition, locale. Par exemple :
<?php
$a = 1; /* portée globale */
function test() {
echo $a; /* portée locale */
}
test();
?>
Le script n'affichera rien à l'écran car la fonction echo utilise la variable locale $a, et celle-ci n'a pas été assignée préalablement dans la fonction. Vous pouvez noter que ce concept diffère un petit peu du langage C dans lequel une variable globale est automatiquement accessible dans les fonctions, à moins d'être redéfinie localement dans la fonction. Cela peut poser des problèmes si vous redéfinissez des variables globales localement. En PHP, une variable globale doit être déclarée à l'intérieur de chaque fonction afin de pouvoir être utilisée dans cette fonction. Par exemple:
<?php
$a = 1;
$b = 2;
function somme() {
global $a, $b;
$b = $a + $b;
}
somme();
echo $b;
?>
Le script ci-dessus va afficher la valeur 3 . En déclarant globales les variables $a et $b locales de la fonction somme(), toutes les références à ces variables concerneront les variables globales. Il n'y a aucune limite au nombre de variables globales qui peuvent être manipulées par une fonction.
Une deuxième méthode pour accéder aux variables globales est d'utiliser le tableau associatif prédéfini $GLOBALS. Le précédent exemple peut être réécrit de la manière suivante:
<?php
$a = 1;
$b = 2;
function somme() {
$GLOBALS["b"] = $GLOBALS["a"] + $GLOBALS["b"];
}
somme();
echo $b;
?>
Une autre caractéristique importante de la portée des variables est la notion de variable static . Une variable statique a une portée locale uniquement, mais elle ne perd pas sa valeur lorsque le script appelle la fonction. Prenons l'exemple suivant:
<?php
function test() {
$a = 0;
echo $a;
$a++;
}
?>
Cette fonction est un peu inutile car à chaque fois qu'elle est appelée, elle initialise $a à 0 et affiche "0". L'incrémentation de la variable ($a++) ne sert pas à grand chose, car dès que la fonction est terminée la variable disparaît. Pour faire une fonction de comptage utile, c'est-à-dire qui ne perdra pas la trace du compteur, la variable $a est déclarée comme une variable statique:
<?php
function test() {
static $a = 0;
echo $a;
$a++;
}
?>
Maintenant, à chaque fois que la fonction Test() est appelée, elle affichera une valeur de $a incrémentée de 1.
Les variables statiques sont essentielles lorsque vous faites des appels récursifs à une fonction. Une fonction récursive est une fonction qui s'appelle elle-même. Il faut faire attention lorsque vous écrivez une fonction récursive car il est facile de faire une boucle infinie. Vous devez vérifier que vous avez bien une condition qui permet de terminer votre récursivité. La fonction suivante compte récursivement jusqu'à 10:
<?php
function test() {
static $count = 0;
$count++;
echo $count;
if ($count < 10) {
test();
}
$count--;
}
?>
Il est pratique d'avoir parfois des noms de variables qui sont variables. C'est-à-dire un nom de variable qui est affectée et utilisée dynamiquement. Une variable classique est affecté avec l'instruction suivante:
<?php
$a = "bonjour";
?>
Une variable dynamique prend la valeur d'une variable et l'utilise comme nom d'une autre variable. Dans l'exemple ci-dessous, bonjour peut être utilisé comme le nom d'une variable en utilisant le "$$" précédent la variable. C'est-à-dire
<?php
$$a = "monde";
?>
A ce niveau, deux variables ont été définies et stockées dans l'arbre des symboles PHP : $a avec comme valeur "bonjour" et $bonjour avec comme valeur "monde". Alors, l'instruction
<?php
echo "$a ${$a}";
?>
produira le même affichage que :
<?php
echo "$a $bonjour";
?>
c'est-à-dire : bonjour monde .
:
Une constante est un identifiant (un nom) qui représente une valeur simple. Comme son nom le suggère, cette valeur ne peut jamais être modifiée durant l'exécution du script (les constantes magiques __FILE__ et __LINE__ sont les seules exceptions).
Le nom d'une constante est sensible à la casse, par défaut. Par convention, les constantes sont toujours en majuscules.
Les noms de constantes suivent les mêmes règles que n'importe quel nom en PHP. Un nom de constante valide commence par une lettre ou un souligné ( _ ), suivi d'un nombre quelconque de lettre, chiffres ou soulignés.
Tous comme les superglobals, les constantes sont accessibles de manière globale. Vous pouvez la définir n'importe où, et y accéder depuis n'importe quelle fonction.
:
Vous pouvez définir une constante en utilisant la fonction define . Une fois qu'une constante est définie, elle ne peut jamais être modifiée, ou détruite.
Seuls les types de données scalaires peuvent être placés dans une constante : c'est à dire les types booléen, entier, double et chaîne de caractères (soit booléen , entier , &double; et chaîne de caractères ).
Vous pouvez accéder à la valeur d'une constante en spécifiant simplement son nom. Contrairement aux variables, vous ne devez PAS préfixer le nom de la constante avec $ .
Vous pouvez aussi utiliser la fonction constant , pour lire dynamiquement la valeur d'une constante, dont vous obtenez le nom dynamiquement (retour de fonction, par exemple).
Utilisez la fonction get_defined_constants() pour connaître la liste de toutes les fonctions définies.
Note : Les constantes et les variables globales utilisent deux espaces de noms différents. Ce qui implique que TRUE et $TRUE sont généralement différents (en tous cas, ils peuvent avoir des valeurs différentes).
Lorsque vous utilisez une constante non définie, PHP suppose que vous utilisez le nom de la constante. Une note sera générée. Utilisez la fonction defined pour savoir si une constante existe ou pas.
Il y a des différences entre les constantes et les variables :
<?php
define("CONSTANTE", "Bonjour le monde.");
echo CONSTANTE; // affiche "Bonjour le monde."
echo Constante; // affiche "Constante" et une note.
?>
:
| Exemple | Nom | Résultat |
| $a + $b | Addition | Somme de $a et $b. |
| $a - $b | Soustraction | Différence de $a et $b. |
| $a * $b | Multiplication | Produit de $a et $b. |
| $a / $b | Division | Quotient de $a et $b. |
| $a % $b | Modulo | Reste de $a divisé par $b. |
:
L'opérateur d'assignation le plus simple est le signe "=". Le premier réflexe est de penser que ce signe veut dire "égal à". Ce n'est pas le cas. Il signifie que l'opérande de gauche se voit affecter la valeur de l'expression qui est à droite du signe égal.
La valeur d'une expression d'assignation est la valeur assignée. Par exemple, la valeur de l'expression '$a = 3' est la valeur 3. Cela permet d'utiliser des astuces telles que :
<?php
$a = ($b = 4) + 5;
// $a est maintenant égal à 9, et $b vaut 4.
?>
En plus du simple opérateur d'assignation, il existe des "opérateurs combinés" pour tous les opérateurs arithmétiques et pour les opérateurs sur les chaînes de caractères. Cela permet d'utiliser la valeur d'une variable dans une expression et d'affecter le résultat de cette expression à cette variable. Par exemple :
<?php
$a = 3;
$a += 5;
// affecte la valeur 8 à la variable $a.
// correspond à l'instruction '$a = $a + 5');
$b = "Bonjour ";
$b .= " tout le monde!";
// affecte la valeur "Bonjour tout le monde!" à
// la variable $b
// identique à $b = $b." tout le monde!";
?>
On peut noter que l'assignation copie le contenu de la variable originale dans la nouvelle variable (assignation par valeur), ce qui fait que les changements de valeur d'une variable ne modifieront pas la valeur de l'autre. Cela peut se révéler important lors de la copie d'un grand tableau durant une boucle.
PHP 4 supporte aussi l'assignation par référence, en utilisant la syntaxe $var = &$othervar; , mais ce n'était pas possible en PHP 3. 'L'assignation par référence' signifie que les deux variables contiennent les mêmes données, et que la modification de l'une affecte l'autre. D'un autre côté, la recopie est très rapide.
:
Les opérateurs de comparaison, comme leur nom l'indique, vous permettent de comparer deux valeurs.
| Exemple | Nom | Résultat |
| $a == $b | Egal | Vrai si $a est égal à $b. |
| $a === $b | Identique | Vrai si $a est égal à $b et qu'ils sont de même type ( PHP 4 seulement). |
| $a != $b | Différent | Vrai si $a est différent de $b. |
| $a <> $b | Différent | Vrai si $a est différent de $b. |
| $a < $b | Plus petit que | Vrai si $a est plus petit strictement que $b. |
| $a > $b | Plus grand | Vrai si $a est plus grand strictement que $b. |
| $a <= $b | Inférieur ou égal | Vrai si $a est plus petit ou égal à $b. |
| $a >= $b | Supérieur ou égal | Vrai si $a est plus grand ou égal à $b. |
Un autre opérateur conditionnel est l'opérateur ternaire (":?"), qui fonctionne comme en langage C.
<?php
// Exemple d'utilisation pour l'opérateur ternaire
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];
// L'expression ci-dessus est identique à
if (empty($_POST['action'])) {
$action = 'default';
} else {
$action = $_POST['action'];
}
?>
L'expression (expr1) ? (expr2) : (expr3) renvoie la valeur de l'expression expr2 si l'expression expr1 est vraie, et l'expression expr3 si l'expression expr1 est fausse.
:
PHP supporte un opérateur de contrôle d'erreur : c'est @. Lorsque cet opérateur est ajouté en préfixe d'une expression PHP, les messages d'erreur qui peuvent être générés par cette expression seront ignorés.
Si l'option track_errors est activée, les messages d'erreurs générés par une expression seront sauvés dans la variable globale $php_errormsg. Cette variable sera écrasée à chaque erreur. Il faut alors la surveiller souvent pour pouvoir l'utiliser.
<?php
/* Erreur intentionnelle (le fichier n'existe pas): */
$my_file = @file ('non_persistent_file') or
die ("Impossible d'ouvrir le fichier : L'erreur est : '$php_errormsg'");
// Cela fonctionne avec n'importe quelle expression, pas seulement les fonctions
$value = @$cache[$key];
// la ligne ci-dessus n'affichera pas d'alerte si la clé $key du tableau n'existe pas
?>
L'opérateur @ ne fonctionne qu'avec les expressions. La règle générale de fonctionnement est la suivante : si vous pouvez prendre la valeur de quelque chose, vous pouvez le préfixer avec @. Par exemple, vous pouvez ajouter @ aux variables, fonctions, à include, aux constantes, etc. Vous ne pourrez pas le faire avec des éléments de langage tels que les classes, if et foreach , etc.
La plupart des fonctions d'accès aux bases de données ne retournent pas d'erreur PHP . Il faut y accéder avec une fonction du type base_de_donnees_get_error().
:
PHP supporte un opérateur d'exécution : guillemets obliques ("``"). Notez bien la différence entre les guillemets simples (sur la touche Shift 4), et ceux-ci (sur la touche AltGr 7). PHP essaiera d'exécuter le contenu de ces guillemets obliques comme une commande shell. Le résultat sera retourné (i.e. : il ne sera pas simplement envoyé à la sortie standard, il peut être assigné à une variable).
<?php
$output = `dir ..`;
echo "<pre>$output</pre>";
?>
Cet opérateur est désactivé lorsque le safe mode est activé ou bien que la fonction shell_exec est désactivée.
:
PHP supporte les opérateurs de pré et post incrémentation et décrémentation, comme en C.
| Exemple | Nom | Résultat |
| ++$a | Pré-incrémente | Incrémente $a de 1, puis retourne $a. |
| $a++ | Post-incrémente | Retourne $a, puis l'incrémente de 1. |
| --$a | Pré-décrémente | Décrémente $a de 1, puis retourne $a. |
| $a-- | Post-décrémente | Retourne $a, puis décrémente $a de 1. |
:
| Exemple | Nom | Résultat |
| $a and $b | ET (And) | Vrai si $a ET $b sont vrais. |
| $a or $b | OU (Or) | Vrai si $a OU $b est vrai |
| $a xor $b | XOR (Xor) | Vrai si $a OU $b est vrai, mais pas les deux en même temps. |
| ! $a | NON (Not) | Vrai si $a est faux. |
| $a && $b | ET (And) | Vrai si $a ET $b sont vrais. |
| $a || $b | OU (Or) | Vrai si $a OU $b est vrai. |
La raison pour laquelle il existe deux types de "ET" et de "OU" est qu'ils ont des priorités différentes.
:
Il y a deux opérateurs de chaînes. Le premier est l'opérateur de concaténation ('.'), qui retourne la concaténation de ses deux arguments. Le second est l'opérateur d'assignation concaténant ( .= ).
<?php
$a = "Bonjour ";
$b = $a . "Monde!";
// $b contient "Bonjour Monde!"
$a = "Bonjour ";
$a = $a . "Monde!";
// $a contient "Bonjour Monde!"
?>
:
Le seul opérateur en PHP pour les tableaux est l'opérateur + . Cet opérateur ajoute le tableau de droite au tableau de gauche. Les clés communes sont laissées inchangées.
<?php
$a = array("a" => "pomme", "b" => "banane");
$b = array("a" =>"poire", "b" => "fraise", "c" => "cerise");
$c = $a + $b;
echo "<pre>";
var_dump($c);
echo "</pre>";
?>
L'instruction if est une des plus importantes instructions de tous les langages, PHP inclus. Elle permet l'exécution conditionnelle d'une partie de code. Les fonctionnalités de l'instruction if sont les mêmes en PHP qu'en C :
<?php
if (expression)
commandes
?>
L'exemple suivant affiche la phrase a est plus grand que b si $a est plus grand que $b :
<?php
if ($a > $b)
print "a est plus grand que b";
?>
Souvent, vous voulez que plusieurs instructions soient exécutées après un branchement conditionnel. Bien évidemment, il n'est pas obligatoire de répéter l'instruction conditionnelle autant de fois que vous avez d'instructions à exécuter. A la place, vous pouvez rassembler toutes les instructions dans un bloc. L'exemple suivant affiche a est plus grand que b , et assigne la valeur de la variable $a à la variable $b:
<?php
if ($a > $b) {
print "a est plus grand que b";
$b = $a;
}
?>
Vous pouvez imbriquer indéfiniment des instructions if les unes dans les autres, ce qui permet une grande flexibilité dans l'exécution d'une partie de code suivant un grand nombre de conditions.
Souvent, vous voulez exécuter une instruction si une condition est remplie, et une autre instruction si cette condition n'est pas remplie. C'est à cela que sert else . else fonctionne après un if et exécute les instructions correspondantes au cas oú l'expression du if est FALSE . Dans l'exemple suivant, ce bout de code affiche a est plus grand que b si la variable $a est plus grande que la variable $a , et a est plus petit que b sinon:
<?php
if ($a > $b) {
print "a est plus grand que b";
} else {
print "a est plus petit que b";
}
?>
Les instructions après le else ne sont exécutées que si l'expression du if est FALSE , et si elle n'est pas suivi par l'expression elseif .
elseif , comme son nom l'indique, est une combinaison de if et de else . Comme l'expression else , il permet d'exécuter une instruction après un if dans le cas oú le "premier" if est évalué comme FALSE . Mais, à la différence de l'expression else , il n'exécutera l'instruction que si l'expression condionnelle elseif est évaluée comme TRUE . L'exemple suivant affichera a est plus grand que b , a est égal à b ou a est plus petit que b :
<?php
if ($a > $b) {
print "a est plus grand que b";
} elseif ($a == $b) {
print "a est égal à b";
} else {
print "a est plus petit que b";
}
?>
Vous pouvez avoir plusieurs elseif qui se suivent les uns après les autres, après un if initial. Le premier elseif qui sera évalué à TRUE sera exécuté. En PHP , vous pouvez aussi écrire "else if" en deux mots et son comportement sera identique à la version en un seul mot. La sémantique des deux expressions est légèrement différente, mais au bout du compte, le résultat sera exactement le même.
L'expression elseif est exécutée seulement si le if précédent et tout autre elseif précédent sont évalués comme FALSE , et que votre elseif est évalué à TRUE .
La boucle while est le moyen le plus simple d'implémenter une boucle en PHP . Cette boucle se comporte de la même manière qu'en C. L'exemple le plus simple d'une boucle while est le suivant :
<?php
while (expression) commandes
?>
La signification d'une boucle while est très simple. PHP exécute l'instruction tant que l'expression de la boucle while est évaluée comme TRUE . La valeur de l'expression est vérifiée à chaque début de boucle, et, si la valeur change durant l'exécution de l'instruction, l'exécution ne s'arrêtera qu'à la fin de l'itération (chaque fois que PHP exécute l'instruction, on appelle cela une itération). De temps en temps, si l'expression du while est FALSE avant la première itération, l'instruction ne sera jamais exécutée.
Comme avec le if , vous pouvez regrouper plusieurs instructions dans la même boucle while en les regroupant à l'intérieur de parenthèses ou en utilisant la syntaxe suivante:
<?php
while (expression): commandes endwhile;
?>
Les exemples suivants sont identiques, et affichent tous les nombres de 1 à 10:
<?php
/* exemple 1 */
$i = 1;
while ($i <= 10) {
print $i++; /* La valeur affiche est $i avant l'incrémentation
(post-incrémentation) */
}
/* exemple 2 */
$i = 1;
while ($i <= 10):
print $i;
$i++;
endwhile;
?>
Les boucles do..while ressemblent beaucoup aux boucles while , mais l'expression est testée à la fin de chaque itération plutôt qu'au début. La principale différence par rapport à la boucle while est que la première itération de la boucle do..while est toujours exécutée (l'expression n'est testée qu'à la fin de l'itération), ce qui n'est pas le cas lorsque vous utilisez une boucle while (l'expression est vérifiée au début de chaque itération).
Il n'y a qu'une syntaxe possible pour les boucles do..while :
<?php
$i = 0;
do {
print $i;
} while ($i>0);
?>
La boucle ci-dessus ne va être exécutée qu'une seule fois, car lorsque l'expression est évaluée, elle vaut FALSE (car la variable $i n'est pas plus grande que 0) et l'exécution de la boucle s'arrête.
Les utilisateurs familiers du C sont habitués à une utilisation différente des boucles do..while , qui permet de stopper l'exécution de la boucle au milieu des instructions, en l'encapsulant dans un do..while (0) la fonction break. Le code suivant montre une utilisation possible:
<?php
do {
if ($i < 5) {
print "i n'est pas suffisamment grand";
break;
}
$i *= $factor;
if ($i < $minimum_limit) {
break;
}
print "i est bon";
process i
} while(0);
?>
for
Les boucles for sont les boucles les plus complexes en PHP . Elles fonctionnent comme les boucles for du langage C. La syntaxe des boucles for est la suivante:
<?php
for (expr1; expr2; expr3) statement
?>
La première expression ( expr1 ) est évaluée (exécutée), quoi qu'il arrive au début de la boucle.
Au début de chaque itération, l'expression expr2 est évaluée. Si l'évaluation vaut TRUE , la boucle continue et l'instruction est exécutée. Si l'évaluation vaut FALSE , l'exécution de la boucle s'arrête.
A la fin de chaque itération, l'expression expr3 est évaluée (exécutée).
Les expressions peuvent éventuellement être laissées vides. Si l'expression expr2 est laissée vide, cela signifie que c'est une boucle infinie (PHP considère implicitement qu'elle vaut TRUE , comme en C). Cela n'est pas vraiment très utile, à moins que vous souhaitiez terminer votre boucle par l'instruction conditionnelle break.
Considérons les exemples suivants. Tous affichent les chiffres de 1 à 10:
<?php
/* exemple 1 */
for ($i = 1; $i <= 10; $i++) {
print $i;
}
/* exemple 2 */
for ($i = 1;;$i++) {
if ($i > 10) {
break;
}
print $i;
}
/* exemple 3 */
$i = 1;
for (;;) {
if ($i > 10) {
break;
}
print $i;
$i++;
}
/* exemple 4 */
for ($i = 1; $i <= 10; print $i, $i++) ;
?>
Bien évidemment, le premier exemple est le plus simple de tous (ou peut être le quatrième), mais vous pouvez aussi pensez qu'utiliser une expression vide dans une boucle for peut être utile parfois.
PHP supporte aussi la syntaxe alternative suivante pour les boucles for :
<?php
for (expr1; expr2; expr3): statement; ; endfor;
?>
foreach
PHP 4 (mais pas PHP 3) inclut une commande foreach , comme en Perl ou d'autres langages. C'est un moyen simple de passer en revue un tableau. Il y a deux syntaxes possibles : la seconde est une extension mineure mais pratique de la première:
<?php
foreach(array_expression as $value) commandes
foreach(array_expression as $key => $value) commandes
?>
La première forme passe en revue le tableau array_expression . A chaque itération, la valeur de l'élément courant est assignée à $value et le pointeur interne de tableau est avancé d'un élément (ce qui fait qu'à la prochaine itération, on accédera à l'élément suivant).
La deuxième forme fait exactement la même chose, mais c'est la clé de l'élément courant qui est assigné à la variable $key .
Lorsque foreach démarre, le pointeur interne de fichier est automatiquement ramené au premier élément du tableau. Cela signifie que vous n'aurez pas à faire appel à reset avant foreach .
Note : De plus, notez que foreach travaille sur une copie du tableau spécifié, et pas sur le tableau lui-même. Par conséquent, le pointeur de tableau n'est pas modifié, comme il le serait avec la fonction each et les modifications faites dans le tableau ne seront pas prises en compte dans le tableau original.
Note : foreach n'accepte pas l'opérateur de suppression des erreurs @ .
Vous pouvez remarquer que les exemples suivants fonctionnent de manière identique :
<?php
reset($arr);
while (list(, $value) = each ($arr)) {
echo "Valeur: $value<br>\n";
}
foreach ($arr as $value) {
echo "Valeur: $value<br>\n";
}
?>
Les exemples suivants sont aussi fonctionnellement identiques :
<?php
reset($arr);
while (list($key, $value) = each ($arr)) {
echo "Clé: $key; Valeur: $value<br>\n";
}
foreach ($arr as $key => $value) {
echo "Clé: $key; Valeur: $value<br>\n";
}
?>
Voici quelques exemples de plus :
<?php
/* exemple foreach 1 : la valeur seulement */
$a = array (1, 2, 3, 17);
foreach ($a as $v) {
print "Current value of \$a: $v.\n";
}
/* exemple foreach 2 : la valeur et sa clé d'index */
$a = array (1, 2, 3, 17);
$i = 0; /* uniquement pour l'illustration */
foreach($a as $v) {
print "\$a[$i] => $v.\n";
$i++;
}
/* exemple foreach 3 : la clé et la valeur */
$a = array (
"un" => 1,
"deux" => 2,
"trois" => 3,
"dix-sept" => 17
);
foreach($a as $k => $v) {
print "\$a[$k] => $v.\n";
}
/* exemple foreach 4 : tableaux multi-dimensionnels */
$a[0][0] = "a";
$a[0][1] = "b";
$a[1][0] = "y";
$a[1][1] = "z";
foreach($a as $v1) {
foreach ($v1 as $v2) {
print "$v2\n";
}
}
/* exemple foreach 5 : tableaux dynamiques */
foreach(array(1, 2, 3, 4, 5) as $v) {
print "$v\n";
}
?>
L'instruction switch équivaut à une série d'instructions if . En de nombreuses occasions, vous aurez besoin de comparer la même variable (ou expression) avec un grand nombre de valeurs différentes, et d'exécuter différentes parties de code suivant la valeur à laquelle elle est égale. C'est exactement à cela que sert l'instruction switch .
Les deux exemples suivants sont deux manières différentes d'écrire la même chose, l'une en utilisant une séries de if , et l'autre en utilisant l'instruction switch :
<?php
if ($i == 0) {
print "i égale 0";
}
if ($i == 1) {
print "i égale 1";
}
if ($i == 2) {
print "i égale 2";
}
switch ($i) {
case 0:
print "i égale 0";
break;
case 1:
print "i égale 1";
break;
case 2:
print "i égale 2";
break;
}
?>
Il est important de comprendre que l'instruction switch exécute chacune des clauses dans l'ordre. L'instruction switch est exécutée ligne par ligne. Au début, aucun code n'est exécuté. Seulement lorsqu'un case est vérifié, PHP exécute alors les instructions correspondantes. PHP continue d'exécuter les instructions jusqu'à la fin du bloc d'instructions du switch , ou bien dès qu'il trouve l'instruction break . Si vous ne pouvez pas utiliser l'instruction break à la fin de l'instruction case , PHP continuera à exécuter toutes les instructions qui suivent. Par exemple :
<?php
switch ($i) {
case 0:
print "i égale 0";
case 1:
print "i égale 1";
case 2:
print "i égale 2";
}
?>
Dans cet exemple, si $i est égal à 0, PHP va exécuter quand même toutes les instructions qui suivent. Si $i est égal à 1, PHP exécutera les deux dernières instructions. Et seulement si $i est égal à 2, vous obtiendrez le résultat escompté, c'est-à-dire, l'affiche de "i égal 2". Donc, l'important est de ne pas oublier l'instruction break (même s'il est possible que vous l'omettiez dans certaines circonstances).
Dans une commande switch , une condition n'est évaluée qu'une fois, et le résultat est comparé à chaque case . Dans une structure elseif , les conditions sont évaluées à chaque comparaison. Si votre condition est plus compliquée qu'une simple comparaison, ou bien fait partie d'une boucle, switch sera plus rapide.
La liste de commandes d'un case peut être vide, auquel cas PHP utilisera la liste de commandes du cas suivant.
<?php
switch ($i) {
case 0:
case 1:
case 2:
print "i est plus petit que 3 mais n'est pas négatif";
break;
case 3:
print "i égale 3";
}
?>
Un case spécial est default . Ce cas est utilisé lorsque tous les case ont échoués. Il doit être le dernier cas listé. Par exemple :
<?php
switch ($i) {
case 0:
print "i égale 0";
break;
case 1:
print "i égale 1";
break;
case 2:
print "i égale 2";
break;
default:
print "i n'est ni égal à 2, ni à 1, ni à 0.";
}
?>
Une autre chose à mentionner est que l'instruction case peut être une expression à de type scalaire, c'est-à-dire nombre entier, nombre à virgule flottante et chaîne de caractères. Les tableaux sont sans intérêt dans ce contexte-là.
<?php
switch ($i):
case 0:
print "i égale 0";
break;
case 1:
print "i égale 1";
break;
case 2:
print "i égale 2";
break;
default:
print "i n'est ni égal à 2, ni à 1, ni à 0";
endswitch;
?>
La fonction include inclut et éxécute le fichier spécifié en argument.
Cette documentation s'applique aussi à la fonction require . Les deux structures de langage sont identiques, hormis dans leur gestion des erreurs. include produit une Alerte (warning) tandis que require génère une erreur fatale . En d'autres termes, n'hésitez pas à utiliser require si vous voulez qu'un fichier d'inclusion manquant interrompe votre script. include ne se comporte pas de cette façon, et le script continuera son exécution. Assurez-vous d'avoir bien configuré le include_path aussi.
Lorsqu'un fichier est inclus, le code qu'il contient hérite des variables qui existent dans ce contexte. Toute variable accessible à la ligne qui réalise l'exécution est aussi accessible dans le fichier inclus.
Exemple avec include :
<?php
$couleur = 'verte';
$fruit = 'pomme';
?>
<?php
echo "Une $couleur $fruit"; // Une
include '';
echo "Une $color $fruit"; // Une verte pomme
?>
Si l'inclusion intervient à l'intérieure d'une fonction, le code inclus sera alors considéré comme faisant partie de la fonction. Cela modifie donc le contexte de variables accessibles.
Inclusion de fichiers dans une fonction :
<?php
function foo() {
global $couleur;
include '';
echo "Une $couleur $fruit";
}
/* est dans le contexte de foo() *
* donc $fruit n'est pas dispnibles hors de *
* cette fonction. $couleur l'est, car c'est *
* une variable globale */
foo(); // Une verte pomme
echo "Une $couleur $fruit"; // Une verte
?>
Gestion du retour : il est possible d'éxécuter une commande return dans un fichier inclus pour en terminer le traitement et retourner au fichier appelant. De plus, il est possible de retourner des valeurs des fichiers inclus. Vous pouvez prendre et traiter la valeur retournée par la fonction, comme toute autre fonction.
<?php
$var = 'PHP';
return $var;
?>
<?php
$var = 'PHP';
?>
<?php
$foo = include '';
echo $foo; // prints 'PHP'
$bar = include '';
echo $bar; // prints 1
?>
$bar a la valeur de 1 car l'inclusion était réussie. Notez la différence entre les deux exemples ci-dessus. Le premier utilise la commande return dans le fichier inclus, alors que le second ne le fait pas. .
Une fonction peut être définie en utilisant la syntaxe suivante :
<?php
function Test ($arg_1, $arg_2, , $arg_n) {
echo "Exemple de fonction.\n";
return $retval;
}
?>
Lorsqu'une fonction est définie de manière conditionnelle, comme dans les exemples ci-dessous, leur définition doit précéder leur utilisation.
Fonctions conditionnelles :
<?php
$makeTest = true;
/* Impossible d'appeler Test() ici,
car cette fonction n'existe pas.
Mais nous pouvons utiliser TestBis() */
TestBis();
if ($makeTest) {
function Test ()
{
echo "Je n'existe pas tant que le programme n'est pas passé ici.\n";
}
}
/* Maitenant, nous pouvons appeler Test()
car $makeTest est maintenant vrai */
if ($makeTest) Test();
function TestBis() {
{
echo "J'existe dès de début du programme.\n";
}
?>
Fonctions dans une autre fonction :
<?php
function Test()
{
function TestBis()
{
echo "Je n'existe pas tant que Test() n'est pas appelé.\n";
}
}
/* Impossible d'appeler TestBis() ici
car il n'existe pas. */
Test();
/* Maintenant, nous pouvons appeler TestBis(),
car l'utilisation de Test() l'a rendu
accessible. */
TestBis();
?>
PHP ne supporte pas le surchargement de fonction, ni la destruction ou la redéfinition de fonctions déjà déclarées.
Par défaut, les arguments sont passés à la fonction par valeur (donc vous pouvez changer la valeur d'un argument dans la fonction, cela ne change pas sa valeur à l'extérieur de la fonction). Si vous voulez que vos fonctions puissent changer la valeur des arguments, vous devez passer ces arguments par référence.
Si vous voulez qu'un argument soit toujours passé par référence, vous pouvez ajouter un '&' devant l'argument dans la déclaration de la fonction :
<?php
function ajoute(&$string) {
$string .= ', et un peu plus.';
}
$str = 'Ceci est une chaîne';
ajoute($str);
echo $str; // affiche 'Ceci est une chaîne, et un peu plus.'
?>
Si vous souhaitez passer une variable par référence à une fonction mais de manière ponctuelle, vous pouvez ajouter un '&' devant l'argument dans l'appel de la fonction:
<?php
function Test ($var) {
$var .= ', et un peu plus.';
}
$str = Ceci est une chaîne';
Test ($str);
echo $str; // affiche 'Ceci est une chaîne'
Test (&$str);
echo $str; // affiche 'Ceci est une chaîne, et un peu plus.'
?>
Les valeurs sont renvoyées en utilisant une instruction de retour optionnelle. Tous les types de variables peuvent être renvoyés, tableaux et objets compris.
<?php
function carre ($num) {
return $num * $num;
}
echo carre (4); // affiche '16'.
?>
Vous ne pouvez pas renvoyer plusieurs valeurs en même temps, mais vous pouvez obtenir le même résultat en renvoyant un tableau.
<?php
function petit_nombre() {
return array (0, 1, 2);
}
list ($zero, $one, $two) = petit_nombre();
?>
Pour retourner une référence d'une fonction, utilisez l'opérateur & aussi bien dans la déclaration de la fonction que dans l'assignation de la valeur de retour.
<?php
function &retourne_reference() {
return $uneref;
}
$newref =& retourne_reference();
?>
Qu’elle est la différence entre du bon code et du mauvais code ? C’est très simple, le bon code, quand il est vraiment bon, peut être lu comme un livre. Vous pouvez commencer par n’importe où et au premier regard savoir à quoi servent les lignes que vous lisez, dans quelles circonstances elles s’exécutent et quelle configuration elles nécessitent.
Pour faciliter la maintenance du code, vous avez tout intérêt à créer plusieurs fichiers de code source afin de séparer le code en groupes logiques, et intégrer ces différents fichiers avec les fonctions include ou require. Par exemple, lorsque vous écrivez une application se reposant sur une base de données, un groupe de fonctions se charge uniquement de gérer les accès : ce code constitue une entité propre qui peut être détachée sans problème du reste du programme. Il en est de même pour les données de configuration, les entêtes et le pieds de page personnalisés, les modèles, et tout ce que vous pouvez extraire de votre projet sous forme d’entité séparée.
Avantages :
- Vous aurez à gérer des fichiers de code source plus petits et de maintenance plus aisée ;
- Vous pouvez modifier un fichier particulier sans avoir à modifier le projet complet ;
- Vous pouvez détacher des ressources du projet et les réutiliser dans d’autres projets ;
- Plusieurs personnes peuvent travailler simultanément sur le même projet.
:
void sort ( array array ,intsort_flags)
sort trie le tableau array . Les éléments seront triés du plus petit au plus grand.
Exemple avec sort :
<?php
$fruits = array("papaye","orange","banane","ananas");
sort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
echo "fruits[".$key."] = ".$val."\n";
}
?>
Cet exemple va afficher :
fruits[0] = ananas
fruits[1] = banane
fruits[2] = orange
fruits[3] = papaye
Les fruits ont été classés dans l'ordre alphabétique. $
Constantes de type de tri :
SORT_REGULAR - compare les éléments normalement
SORT_NUMERIC - compare les éléments numériquement
SORT_STRING - compare les éléments comme des chaînes de caractères
:
int krsort ( array array ,intsort_flags)
krsort trie un tableau en ordre inverse et suivant les clés, en maintenant la correspondance entre les clés et les valeurs. Cette fonction est pratique pour les tableaux associatifs.
Exemple avec krsort :
<?php
$fruits = array("d"=>"papaye","a"=>"orange","b"=>"banane","c"=>"ananas");
ksort($fruits);
for(reset($fruits); $key = key($fruits); next($fruits)) {
echo "fruits[$key] = ".$fruits[$key]."\n";
}
?>
Cet exemple va afficher :
fruits[a] = orange
fruits[b] = banane
fruits[c] = ananas
fruits[d] = papaye
:
void asort ( array array , int sort_flags )
asort() trie un tableau de telle manière que la corrélation entre les index et les valeurs soit conservée. L'usage principal est lors de tri de tableaux associatifs où l'ordre des éléments est important.
<?php
$fruits = array( "d"=>"papaye",
"a"=>"orange",
"b"=>"banane",
"c"=>"ananas");
asort($fruits);
for(reset($fruits); $key = key($fruits); next($fruits)) {
echo "fruits[$key] = ".$fruits[$key]."\n";
}
?>
Cet exemple va afficher:
fruits[c] = ananas
fruits[b] = banane
fruits[a] = orange
fruits[d] = papaye
Les fruits ont été triés par ordre alphabétique, et leurs index respectifs ont été conservés.
:
void rsort ( array array ,intsort_flags)
rsort effectue un tri en ordre décroissant (du plus grand au plus petit).
Exemple avec rsort :
<?php
$fruits = array("papaye","orange","banane","ananas");
rsort($fruits);
for (reset($fruits); list($key,$value) = each($fruits); ) {
echo "fruits[$key] = ", $value, "\n";
}
?>
Cet exemple va afficher :
fruits[0] = papaye
fruits[1] = orange
fruits[2] = banane
fruits[3] = ananas
Les fruits ont été classés dans l'ordre alphabétique inverse.
:
int count ( mixed var )
- count() retourne le nombre d'éléments dans var, qui est généralement un tableau (et tout le reste n'aura qu'un élément).
- count() retourne 1 si la variable n'est pas un tableau.
- count() retourne 0 si la variable n'est pas créée.
- count() peut retourner 0 pour une variable qui n'a pas été affectée, ou pour un tableau vide. Utilisez plutôt isset() pour tester si la variable existe.
<?php
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count ($a);
//$result == 3
?>
:
mixed current ( array array )
Chaque tableau entretient un pointeur interne, qui est initialisé lorsque le premier élément est inséré dans le tableau.
current ne fait que retourner l'élément courant pointé par le pointeur interne du tableau array . current ne déplace pas le pointeur.
Si le pointeur est au-delà du dernier élément de la liste, current retourne FALSE .
:
array each ( array array )
each() retourne la paire (clé/valeur) courante du tableau array et avance le pointeur de tableau. Cette paire est retournée dans un tableau de 4 éléments, avec les clés 0, 1, key, et value. Les éléments 0 et key contiennent le nom de la clé et, et 1 et value contiennent la valeur.
Si le pointeur interne de tableau est au-delà de la fin du tableau, each() retourne FALSE.
<?php
$foo = array("bob", "fred", "jussi", "jouni", "egon", "marliese");
$bar = each($foo);
?>
$bar contient maintenant les paires suivantes:
0 => 0
1 => 'bob'
key => 0
value => 'bob'
<?php
$foo = array ("Robert" => "Bob", "Seppo" => "Sepi");
$bar = each ($foo);
?>
$bar contient maintenant les paires suivantes:
0 => 'Robert'
1 => 'Bob'
key => 'Robert'
value => 'Bob'
each() est utilisé conjointement avec list() pour étudier tous les éléments d'un tableau; par exemple, $HTTP_POST_VARS:
//Affichage de $http_post_vars avec each()
<?php
echo "Valeurs transmises par la méthode POST:<br>";
reset ($HTTP_POST_VARS);
while (list ($key, $val) = each ($HTTP_POST_VARS)) {
echo "$key => $val<br>";
}
?>
Après chaque each(), le pointeur de tableau est déplacé au dernier élément, ou sur le dernier élément, lorsqu'on arrive à la fin.
:
void list ( mixed )
Tout comme array(), list() n'est pas une véritable fonction, mais une construction syntaxique, qui permet d'assigner une série de variables en une seule ligne.
Note : list fonctionne uniquement avec des tableaux à indexation numérique, et suppose que l'indexation commence à 0.
<?php
$info = array('café', 'noir', 'cafeine');
// Liste de toutes les variables
list($liquide, $couleur, $puissance) = $info;
print "$drink est $couleur et la $puissance le rend particulier.\n";
// Liste de certaines variables
list($liquide, , $puissance) = $info;
print "$liquide contient de la $puissance.\n";
// Ou bien, n'utilisons que le troisième
list( , , $puissance) = $info;
print "J'ai besoin de $puissance!\n";
?>
:
array array_merge ( array array1 , array array2 ,array )
array_merge rassemble les éléments de plusieurs tableaux ensembles, en ajoutant les valeurs de l'un à la fin de l'autre. Le résultat est un tableau.
Si les tableaux ont des clés en commun, la dernière valeur rencontrée écrasera l'ancienne. Pour les valeurs numériques, cela n'arrive pas, car alors, les valeurs sont ajoutées en fin de tableau.
Exemple avec :
<?php
$array1 = array ("couleur" => "rouge", 2, 4);
$array2 = array ("a", "b", "couleur" => "vert", "forme" => "trapézoïde");
$result = array_merge ($array1, $array2);
print_r($result);
?>
Note : Les clés communes seront écrasées successivement par les clés identiques suivantes.
:
| Fonction | Description |
| reset() | replace le pointeur de tableau array au premier élément |
| key() | retourne l'index de la clé courante dans un tableau |
| next() | retourne l'élément suivant du tableau, ou FALSE s'il n'y a plus d'éléments. Le pointeur de interne de tableau est avancé d'un élément. |
| prev() | repositionne le pointeur interne de tableau à la dernière place qu'il occupait, ou bien retourne FALSE s'il ne reste plus d'éléments. |
| end() | déplace le pointeur interne du tableau array jusqu'au dernier élément. |
:
array getdate ( int timestamp )
getdate retourne un tableau associatif contenant les informations de date et d'heure du timestamp timestamp (lorsqu'il est fourni), avec les champs suivants :
Exemple avec getdate
<?php
$aujourdhui = getdate();
$mois = $aujourdhui['month'];
$mjour = $aujourdhui['mday'];
$annee = $aujourdhui['year'];
echo "$mjour/$mois/$annee";
?>
:
array localtime ( int timestamp , bool is_associative )
localtime retourne un tableau identique à la structure retournée par la fonction C localtime. Le premier argument timestamp est un timestamp UNIX. S'il n'est pas fourni, l'heure courante est utilisée. Le second argument is_associative , s'il est mis à 0 ou ignoré, force localtime à retourner un tableau à index numérique. S'il est mis à 1, retourne un tableau associatif, avec tous les éléments de la structure C, accessible avec les clés suivantes :
:
bool checkdate ( int month , int day , int year )
checkdate retourne TRUE si la date représentée par le jour day , le mois month et l'année year est valide, et sinon FALSE . Notez bien que l'ordre des arguments n'est pas l'ordre français. La date est considérée comme valide si :
:
stringsubstr( stringstring , intstart , intlength )
substr retourne le segment de string définit par start et length .
Si start est positif, la chaîne retournée commencera au caractère numéro start , dans la chaîne string . Le premier caractère est numéroté zéro.
Exemple avec substr :
<?php
$rest = substr("abcdef", 1); // retourne "bcdef"
$rest = substr("abcdef", 1, 3); // retourne "bcd"
$rest = substr("abcdef", 0, 4); // retourne "abcd"
$rest = substr("abcdef", 0, 8); // retourne "abcdef"
// Accéder aux caractères vis les accolades
$string = 'abcdef';
echo $string{0}; // retourne a
echo $string{3}; // retourne d
?>
Si start est négatif, la chaîne retournée commencera au caractère numéro start dans la chaîne string .
Exemple de start négatif :
<?php
$rest = substr("abcdef", -1); // retourne "f"
$rest = substr("abcdef", -2); // retourne "ef"
$rest = substr("abcdef", -3, 1); // retourne "d"
?>
Si length est fourni et positif, la chaîne retourné contiendra au plus length caractères, en commençant à partir du caractère start (en fonction de la taille de la chaîne string ). Si string est plus petite que start , substr retournera FALSE .
Si length est fourni et négatif, alors le même nombre de caractères seront omis, en partant de la fin de la chaîne string . Si start représente une position hors de la chaîne, une chaîne vide sera retournée.
Utiliser une valeur négative de length :
<?php
$rest = substr("abcdef", 0, -1); // retourne "abcde"
$rest = substr("abcdef", 2, -1); // retourne "cde"
$rest = substr("abcdef", 4, -4); // retourne ""
$rest = substr("abcdef", -3, -1); // retourne "de"
?>
:
stringtrim( stringstr , stringcharlist )
trim retourne la chaîne str , après avoir supprimé les caractères invisibles en début et fin de chaîne. Si le second paramètre charlist a été omis, trim supprimera les caractères suivants :
Il est aussi possible de spécifier les caractères à supprimer en utilisant le paramètre charlist . Listez simplement les caractères que vous voulez supprimer dans ce paramètre. Avec .. , vous pourrez spécifier des intervalles de caractères.
Exemle avec trim :
<?php
$text = " Voici quelques mots :) ";
$trimmed = trim($text);
// $trimmed = "Voici quelques mots :) "
$trimmed = trim($text," .");
// $trimmed = "Voici quelques mots :)"
$clean = trim($binary,"\0x00..\0x1F");
// supprime tous les caractères de contrôle ASCII au début de la chaîne de caractères.
// (de 0 à 31 inclus)
?>
:
intstrlen( stringstr )
strlen retourne la taille de la chaîne string .
exemple :
< ?php
$userimput = ?test?
if(strlen($userinput) >30) {
echo(?La saisie ne doit pas dépasser 30 caractères?);
}
?>
:
arrayexplode( stringseparator , stringstring , intlimit )
explode retourne un tableau de chaines. Ce sont les sous-chaînes, extraites de string , en utilisant le séparateur separator .
Si limit est fourni, le tableau retourné aurant un maximum de limit éléments, et le dernier élément du tableau contiendra le reste de la chaîne string .
Si separator est une chaîne vide (""), explode retournera FALSE . Si separator contient une valeur qui n'est pas contenue dans string , alors explode retournera un tableau, contenant la chaîne string entière.
Exemple avec explode :
<?php
$pizza = "garniture1 garniture2 garniture3 garniture4";
$pieces = explode(" ", $pizza);
$data = "foo:*:1023:1000::/home/foo:/bin/sh";
list($user,$pass,$uid,$gid,$gecos,$home,$shell) = explode(":",$data);
?>
:
stringimplode( stringglue , arraypieces )
implode retourne une chaîne contenant la représentation en chaîne de caractères de tous les éléments du tableau pieces , dans le même ordre, avec la chaîne glue , placée entre deux éléments.
Exemple avec implode :
<?php
$array = array('nom', 'email', 'telephone');
$comma_separated = implode(",", $array);
print $comma_separated;
// nom,email,telephone
?>
:
mixedstr_replace( mixedsearch , mixedreplace , mixedsubject , int&count )
str_replace retourne une chaîne ou un tableau, dont toutes les occurences de search dans subject ont été remplacée par replace .
Si subject est un tablaeu, alors le remplacement se fera sur chaque élément du tableau, et la valeur retournée sera aussi un tableau.
Si search et replace sont des tableaux, alors str_replace prendra une valeur de chaque tableau, et l'utilisera pour faire le remplacement dans subject . Si replace a moins de valeurs que search , alors une chaîne vide sera utilisée pour effectuer les search est un tableau et que replace est une chaîne, alors la chaîne de remplacement sera utilisée pour chaque élément de search .
Exemple avec str_replace
<?php
$bodytag = str_replace("%body%", "black", "<body text=%body%>");
?>
int header ( string string ,boolreplace,inthttp_response_code)
header permet de spécifier une en-tête HTTP lors de l'envoi des fichiers HTML. Reportez-vous à HTTP 1.1 Specification () pour plus d'informations sur les en-têtes HTTP.
Il y a cependant deux en-têtes spéciaux. Le premier est "Location". Non seulement il renvoie une en-tête au client, mais en plus, il envoie un statut de redirection à Apache. Du point de vue de l'auteur de script, cela importe peu, mais pour ceux qui connaissent les rouages internes d'Apache, c'est primordial.
<?php
header("Location:
/* Redirige le client vers le site PHP */
exit();
/* Garantit que le code ci-dessous n'est jamais exécuté. */
?>
Le deuxième type d'appel spécial regroupe toutes les en-têtes qui commencent par "HTTP/" (la casse n'est pas importante). Par exemple, si vous avez votre page d'erreur 404 Apache qui pointe sur un script PHP, c'est une bonne idée que de vous assurer que le script PHP génère une erreur 404. La première chose à faire dans votre script est :
<?php
header("HTTP/1.0 404 Not Found");
?>
| Fonction | Description | Code PHP | Rés. |
| addslashes() | Ajoute des anti-slashes devant les caractères spéciaux | $res = addslashes("L'a"); | L\'a |
| stripslashes() | Retire les anti-slashes devant les caractères spéciaux. | $res = stripslashes("L\'a"); | L'a |
| dechex() | Retourne la valeur Hexadécimale d'un nombre (ici 2548). | $res = dechex("2548"); | 9f4 |
| ceil() | Retourne le nombre entier supérieur ici (12,1). | $res = ceil("12.1"); * | 13 |
| chunk_split() | Permet de scinder une chaîne en plusieurs morceaux. | $res = chunk_split("DGDFEF","2","-"); | DG-DF-EF- |
| htmlentities() | Remplace les caractères par leur équivalent HTML (si ils existent). | $res = htmlentities("&"); | & |
| strstr() | Recherche le premier caractère 'p' dans la chaîne et affiche le reste de la chaîne y compris le 'p'. | $res = strstr ("", "p"); | |
| strlen() | Retourne la longueur de la chaîne | $res = strlen("lachainedecaracteres"); | 20 |
| strtolower() | Passe tous les caractères en minuscules. | $res = strtolower("LA CHAINE dE caRActERes"); | la chaine de caracteres |
| strtoupper() | Passe tous les caractères en MAJUSCULES. | $res = strtoupper("LA CHAINE dE caRActERes"); | LA CHAINE DE CARACTERES |
| str_replace() | Remplace un caractère par un autre dans une chaîne. Tiens compte de la casse. | $res = str_replace("a","o","Lalala"); | Lololo |
| trim() | Efface les espaces blancs (\n, \r, etc) au début et à la fin d'une chaîne (pas au milieu). | $res = trim(" Salut le monde "); | Salut le monde |
| ucfirst() | Met la première lettre de chaque chaîne en Majuscule. | $res = ucfirst("salut le monde. ca va ?"); | Salut le monde. ca va ? |
| ucwords() | Met la première lettre de chaque mot d'une chaîne en Majuscule. | $res = ucwords("salut le monde"); | Salut Le Monde |
| strpos() | Recherche la position du premier caractères trouvé. Retourne le nombre de caractères placés avant lui (ici 4). | $res = strpos("abcdef","e"); | 4 |
| ereg() | Recherche si une chaîne de caractère est contenue dans une autre (ex. recherche si "ABCDE" contient "BCD"). | if(ereg("BCD","ABCDEF")) | oui |
| * La virgule sous PHP est représentée par un point "." , ainsi 12,1 s'écrit : 12.1 ! | |||
MySQL est un système de gestion de base de données (SGBD). C'est un ensemble d'applications permettant de manipuler les données (ajout, suppression, modification et lecture), mais aussi de contrôler l'accès.
Les données sont structurées de la manière suivante :
Un ensemble de données connexes regroupées en enregistrement.
Un ensemble d'enregistrements groupés dans une table.
Un ensemble de tables groupées dans une base de données.
L'ensemble des bases de données composant le serveur de données.
Le serveur de données est composé de plusieurs bases de données afin de mieux organiser les données, mais aussi fixer des règles d'accès différentes pour chacune d'entre elles. C'est souvent le cas des hébergeurs qui attribuent une base de données pour chaque site avec des droits d'accès réservés à ce dernier.
Attention : si vous avez votre propre serveur de données, vous pouvez être tenté de créer plusieurs bases pour mieux vous organiser, mais il faut savoir que dans ce cas, vous ne pouvez pas "mixer" (jointure) des données en provenance de tables placées dans des bases différentes.
L'utilisation de MySQL avec PHP s'effectue en 4 temps :
On peut ajouter à ça, un 5ème temps facultatif dans le cas d'une connexion simple : fermeture de la connexion.
Pour se connecter au serveur de données, il existe 2 méthodes :
» Ouverture d'une connexion simple avec la fonction mysql_connect
» Ouverture d'une connexion persistante avec la fonction mysql_pconnect
La deuxième méthode diffère de la première par le fait que la connexion reste active après la fin du script, mais tous les hébergeurs n'autorisent pas cette possibilité, et on a même tendance à penser qu'il n'est pas bon de l'utiliser (Pour plus d'informations, lisez les remarques sur les connexions persistantes de la doc PHP).
Pour se connecter, il faut paramétrer l'adresse du serveur de données ainsi que votre nom d'utilisateur (" login " en anglais) et votre mot de passe (" password " en anglais). En retour, vous obtenez un identifiant. Si l'identifiant est à 0, une erreur s'est produite pendant la phase de connexion. Cette erreur peut venir du fait que l'on ne peut pas joindre le serveur (ex : panne réseau), que le nom du serveur n'est pas bon, que vous n'êtes pas autorisé à accéder à ce serveur ou que votre mot de passe n'est pas correct.
Maintenant, si l'identifiant est différent de 0, tout c'est bien passé et vous êtes connecté au serveur de données.
Remarque : Vous pouvez garder cet identifiant dans une variable, mais si vous n'ouvrez pas d'autres connexions en parallèle, ce n'est pas utile.
Exemple : connexion à une base de données sur " Free " :
<?php
if( mysql_connect( '' , 'monchat.moustique' , 'miaou' ) > 0 )
echo 'Connexion réussie !' ;
else
echo 'Connexion impossible !' ;
?>
En fait, les étapes sélection et requête peuvent être faites en même temps, mais il est plus simple si vous utilisez une seule base, de la sélectionner avant de commencer vos requêtes. Ainsi, toutes les requêtes à venir utiliseront cette base par défaut.
Pour faire cette sélection, utilisez la fonction mysql_select_db et vous lui passez en paramètre, le nom de votre base.
Si la connexion n'aboutit pas, la fonction vous retourne "False" (ou "0" si vous préférez) sinon elle retourne "True".
Remarque : Si cela vous chante, ou si vous avez ouvert plusieurs connexions en parallèle, vous pouvez ajouter un second paramètre qui est l'identifiant de la connexion. Si vous n'en donnez pas, la fonction utilise la dernière connexion ouverte.
Exemple :
Connexion à la base de donnée " ma_base "
<?php
if( mysql_select_db( 'ma_base' ) == True )
echo 'Sélection de la base réussie' ;
else
echo 'Sélection de la base impossible' ;
?>
Maintenant, le plus intéressant, c'est d'accéder aux données, soit pour les lire, soit pour les modifier ou encore les supprimer. Pour faire cela, il n'y a pas de fonctions du genre mysql_read, mysql_write, …etc. En fait, on utilise un langage qui s'appelle le langage SQL (Structured Query Language). Je vous renvoie donc aux différents articles déjà en ligne sur ce site (SQL par l'exemple 1ère (SELECT) et 2ème partie).
Pour envoyer ces requêtes, on peut utiliser 2 fonctions :
- mysql_query dans le cas où la base de données serait déjà sélectionnée
- mysql_db_query dans le cas où l'on voudrait sélectionner la base en même temps.
Comme pour la connexion, cette fonction retourne un identifiant qui est à "0" lorsqu'une erreur s'est produite.
Contrairement aux autres fonctions (connexion et sélection), cet identifiant est très important, il est utilisé pour retrouver les données rapatriées par une requête de sélection.
Lorsque l'on fait une requête de sélection, MySQL retourne les données et PHP les place en mémoire. L'identifiant permet donc de retrouver ces données en mémoire. En fin de script, la mémoire est libérée et les données sont donc perdues. Il est possible de libérer la mémoire, pour ne pas surcharger le serveur, avant la fin du script au moyen de la commande mysql_free_result.
Exemple :
On part du principe que la base de données est déjà sélectionnée et on veut avoir des informations sur le membre nommé "moustique" :
<?php
$requete = "SELECT * FROM membres WHERE pseudo = 'moustique' ";
$resultat = mysql_query( $requete );
?>
Suite à une requête de sélection
Après l'exécution d'une requête de sélection, les données ne sont pas "affichées", elles sont simplement mises en mémoire, il faut donc aller les chercher enregistrement par enregistrement et les afficher avec un minimum de traitement.
PHP gère un pointeur de résultat, c'est à dire qu'il repère un enregistrement parmi les autres, et lorsque l'on veut en lire un, c'est celui qui est pointé qui sera retourné.
Lorsque vous utilisez une fonction de lecture, le pointeur est déplacé sur l'enregistrement suivant et ainsi de suite jusqu'à ce qu'il n'y en ait plus.
Les fonctions qui retournent un enregistrement sont : mysql_fetch_row, mysql_fetch_array et mysql_fetch_object et prennent comme paramètre l'identifiant de la requête.
Les 3 exemples suivants partent d'une requête "SELECT nom, prenom, date FROM membres."
mysql_fetch_row :Cette fonction retourne un enregistrement sous la forme d'un tableau simple.
<?php
$enregistrement = mysql_fetch_row( $resultat );
// Affiche le champ - nom -
echo $enregistrement[0] . '<br>';
// Affiche le champ - prenom -
echo $enregistrement[1] . '<br>';
// Affiche le champ - date -
echo $enregistrement[2] . '<br>';
?>
mysql_fetch_array : Cette fonction retourne un enregistrement sous la forme d'un tableau associatif.
<?php
$enregistrement = mysql_fetch_array( $resultat );
// Affiche le champ - prenom -
echo $enregistrement['prenom'] . '<br>';
// Affiche le champ - nom -
echo $enregistrement['nom'] . '<br>';
// Affiche le champ - date -
echo $enregistrement['date'] . '<br>';
?>
mysql_fetch_object :Cette fonction retourne un enregistrement sous forme d'une structure (objet).
<?php
$enregistrement = mysql_fetch_object( $resultat );
// Affiche le champ - date -
echo $enregistrement->date . '<br>';
// Affiche le champ - nom -
echo $enregistrement->nom . '<br>';
// Affiche le champ - prenom -
echo $enregistrement->prenom . '<br>';
?>
Si il n'y a pas ou plus d'enregistrement à lire, ces fonctions retournent "false."
Enfin, si vous voulez savoir combien d'enregistrements ont été retournés par la sélection, vous pouvez utiliser la commande mysql_num_rows qui prend comme paramètre l'identifiant de la requête.
Il existe une autre fonction pour lire des enregistrements, mais je vous déconseille de l'utiliser car elle est beaucoup moins performante, et présente peu d'intérêt, c'est la fonction mysql_result. Je ne la détaille pas, vous pouvez vous reporter à la documentation PHP si vous voulez vraiment l'utiliser !
Exemple : On affiche le nombre d'enregistrement et on parcourt l'ensemble des données en les affichant au moyen d'une boucle :
<?php
echo 'Il y a ' . mysql_num_rows( $resultat ) . ' membre(s)';
while( $enregistrement = mysql_fetch_array( $resultat ))
{
echo $enregistrement['nom'] . ' ' . $enregistrement['prenom'];
echo ' – ' . $enregistrement['date'] . '<br>' ;
}
?>
Suite à une requête d'insertion
Une requête d'insertion ne retourne pas de donnée en principe, mais il y a une chose que l'on peut exploiter, c'est la valeur d'un champ auto incrémenté.
En effet, si un champ est déclaré "auto incrémenté", il est souvent utile de connaître la valeur de ce champ après l'insertion, c'est le rôle de la fonction mysql_insert_id qui ne prend aucun paramètre et retourne la valeur de la dernière requête d'insertion effectuée.
Exemple :Suite à une requête d'insertion, on veut afficher le numéro auto incrémenté :
<?php
echo "Votre numéro d'identifiant est " . mysql_insert_id();
?>
Suite à une requête de modification
Lorsque l'on change les données en insérant, supprimant ou modifiant, il est possible de connaître le nombre d'enregistrements affectés par la requête. C'est la fonction mysql_affected_rows qui ne prend pas de paramètres comme la fonction mysql_insert_id.
Toutefois, il existe une petite exception : lorsque vous exécutez une commande "DELETE" sans la clause "WHERE", tous les enregistrements sont effacés, mais pour optimiser cette requête, mySQL supprime tout bonnement le fichier et le recrée immédiatement. A partir de ce moment, on n'est pas capable de savoir combien d'enregistrements il y avait avant, et la fonction mysql_affected_rows retourne "0".
Exemple : Suite à une commande "UPDATE", on voudrait savoir combien de lignes ont été modifiées :
<?php
echo mysql_affected_rows() . 'enregistrement(s)modifié(s)';
?>
Vous pouvez fermer la connexion au moyen de la fonction mysql_close, mais il est bon de savoir que cette opération sera faite lorsque le script se terminera. C'est donc une opération facultative, à mon goût et c'est pourquoi je n'entrerai pas dans le détail.
Vous avez vu qu'il était possible de savoir si la requête a fonctionné, mais que faire quand ça ne fonctionne pas ?
D'une manière générale, si la requête n'a pas marché, il y a une erreur dans la syntaxe dans votre requête et il n'est pas très judicieux de continuer le script. Mais avant de quitter brutalement, il est important de pouvoir expliquer ce qui n'a pas marché. Pour cela, on utilise la fonction mysql_error qui ne prend pas de paramètres.
Cette fonction vous indique généralement votre erreur dans la langue de Shakespeare.
Une bonne méthode pour se retrouver facilement est de faire comme suit :
<?php
$resultat = mysql_query( $requete )
or die ( 'Erreur dans la requête : ' . $requete . '<br>Avec l\'erreur : ' . mysql_error() );
?>
Variables intermédiaires :
Il est TRES fortement conseillé de ne pas écrire les paramètres de connexion directement dans la fonction car si une erreur survient, PHP va afficher la ligne incriminée, laissant apparaître votre mot de passe aux yeux de tous !
C'est pour cette raison que l'on utilise des variables intermédiaires. Voici un exemple de script
<?php
$mysqlserver = '';
$mysqlloggin = 'mon_login';
$mysqlpassword = 'secret';
mysql_connect( $mysqlserver , $mysqlloggin , $mysqlpassword ) ;
?>
De même pour la sélection de la base de données.
L'idéal, c'est de placer ces variables dans un fichiers de configuration protégé par un ".htaccess" (si vous utilisez Apache)
Opération réccurrente :
Dans la majorité des cas, vous utiliserez toujours la même base de données, sur le même serveur. C'est pour cette raison que je vous conseille d'écrire un script contenant les fonctions de connexion et de sélection :
<?php
// Dans ce fichier, vous placez vos paramètres de connexion
// [ voir : Variables intermédiaires ]
// $mysqlserver , $mysqlloggin , $mysqlpassword et $mysqlmaindb
require '.php3' ;
// connexion au serveur de données
@mysql_connect( $mysqlserver , $mysqlloggin , $mysqlpassword )
or die( 'Connexion au serveur de données impossible' ) ;
// Sélection de la base de données
@mysql_select_db( $mysqlmaindb )
or die( 'Sélection de la base de donnée impossible' ) ;
?>
Remarque : Vous avez vu que j'utilise le préfixe @ qui a pour rôle de désactiver les rapports d'erreur. En effet, si une erreur survient (lors d'une connection par exemple), un rapport d'erreur est généré, et si vous n'avez pas fixé le "error_reporting" à 0, un "warning" est affiché par PHP, ce qui n'est pas toujours du plus bel effet ! [ Merci Métabaron pour cette précision oubliée :-) ]
Contrôle des erreurs :
Il n'est pas rare, dans les phases de développement, de faire des erreurs dans une requête SQL, et si vous ne faites pas de contrôle, vous risquez d'avoir des petits soucis pour les retrouver. Je conseille TRES FORTEMENT de créer une fonction qui fait la requête et le contrôle en même temps :
<?php
// Cette fonction fait la même chose que "die" mais
// vous pouvez faire
// une mise en forme qui correspond plus à votre site.
function erreur( $message )
{
echo $message ;
exit ;
}
// fonction pour faire des requêtes
function requete( $requete )
{
if($resultat = mysql_query( $requete )) return $resultat ;
erreur( "Erreur dans la requête : $requete<br>" . mysql_error() ) ;
}
?>
Synthèse :
Aux vues de ces conseils, on peut envisager de les synthétiser sous forme d'un script que l'on utilisera dans chacun de nos développements, ce qui donnerait :
.php3
<?php
$mysqlserver = '';
$mysqlloggin = 'mon_login';
$mysqlpassword = 'secret';
$mysqlmaindb = 'ma_base';
?>
.php3
<?php
// Cette fonction fait la même chose que "die" mais vous pouvez
// faire une mise en forme qui correspond plus à votre site.
function erreur( $message )
{
echo $message ;
exit ;
}
// emplacement des données de connexion
require '.php3';
// connexion au serveur de données
@mysql_connect( $mysqlserver , $mysqlloggin , $mysqlpassword )
or erreur( 'Connexion au serveur de données impossible' ) ;
// Sélection de la base de données
@mysql_select_db( $mysqlmaindb )
or erreur( 'Sélection de la base de donnée impossible' ) ;
// fonction pour faire des requêtes
function requete( $requete )
{
if($resultat = mysql_query( $requete )) return $resultat ;
erreur( "Erreur dans la requête : $requete<br>" . mysql_error() ) ;
}
?>
Pour portez une application de MySQL vers Oracle, vous vous exposez à une charge de travail imposante à moins de faire appel à une couche d’abstraction telle que PHPLib ()
En effet, les fonctions permettant d’accéder à MySQL et Oracle sont différentes : mysql_connect correspond à ora_logon(), mysql_query() à ora_parse() , etc…
La couche d’abstraction de base de données et une API offrant un ensemble de fonctions destinées à exploiter une multitude de base de données indépendamment de l’implémentation. Vous pouvez ainsi basculer de MySQL à Oracle en toute simplicité sans avoir à modifier tout le code.
Exemple d’utilisation de PHPLib :
// Instancie la classe Example_DB
$db = new Example_DB ;
// Se connecte au SGBDR
$db->connect("test","localhost","root","");
// Crée une instruction SQL
$sql = “SELECT * FROM test”;
// Exécute la requite
$db-> query($sql);
// Boucle dans le jeu de résultat
while ($db->next_record()) [
// etc…
Lorsque qu’une personne se connecte sur votre site, elle ouvre une session. Il est parfois intéressant de conserver les valeurs de certaines variables tout au long de cette session.
Exemple : La personne entre un login et un mot de passe pour accéder au site et on souhaite vérifier au début de chaque page du site que cette personne est bien autorisée.
Solutions possibles :
On peut éventuellement transmettre la valeur de ces variables dans l’URL mais il s’agit parfois de données sensibles, de tableaux, d’objets… Ce n’est pas une solution élégante et elle n’est pas toujours réalisable. Cette solution est totalement irrecevable quand il s’agit de sécurité. De plus, une URL est limitée à 255 caractères.
On peut également enregistrer ces données en utilisant un cookie sur la machine du client. Ceci pose plusieurs problèmes : si le client n’accepte pas les cookies, ce qui est relativement courant, on ne peut stocker les données. De plus, c’est une solution client-side assez peu fiable au niveau sécurité par nature.
Aucune de ces solutions n’est réellement satisfaisante pour ce que nous souhaitons faire. De nombreux moyens de gérer les sessions ont été développées reposant en général sur des bases de données. PHP4 introduit des fonctions permettant de gérer les sessions relativement simplement. C’est l’objet du présent article.
1. Du côté du serveur
Lors de l’ouverture d’une session, une id de session est attribuée au client. Celle-ci permet de l’identifier et d’accéder à ses variables de session.
Les variables de session sont enregistrées sur le serveur dans le répertoire session.save_path défini dans la configuration de PHP sous la forme d’un fichier texte par session.
A l'aide de l'id de session de l'utilisateur, PHP peut retrouver la valeur des variables de session dans le fichier texte correspondant.
Simplifions : Une personne se connecte avec son login et son mot de passe. On lui donne l’id de session 1. On enregistre son login et son mot de passe comme variables de session. Sur le serveur, un fichier texte session_1 est créé. Il contient login="login rentré"; password="mot de passe rentré". C'est une simplification assez grossière mais n'hésitez pas à aller voir à quoi ressemble un tel fichier dans le répertoire session.save_path (configuration de PHP).
On comprend assez vite la nécessité de transmettre l'id de session de l'utilisateur de page en page. Cette question sera abordée au paragraphe 3.
2. Les fonctions utilisées
PHP4 dispose d'un certain nombre de fonctions permettant de manipuler les sessions. Voici les plus utiles :
session_start : cette fonction est à mettre en tête de toutes les pages où vous souhaitez avoir accès à vos variables de session. Il ne doit y avoir aucun code affichable avant l'utilisation de cette fonction sous peine d'erreur (headers already sent).
Cette fonction ouvre une session s'il n'existe pas de session déjà ouverte. Si une session a déjà été ouverte et que l'id de session a été correctement transmise à la page, elle reprend la session existante et permet l'accès aux variables de session correspond à cette session.
session_id([id]) : définit l'id de session à utiliser ou renvoie l'id de session utilisée. Lors d'un session_start, une id de session est automatiquement générée par PHP. Il n'est donc en général pas nécessaire de la définir.
session_name([nom]) : définit le nom de la session en cours ou renvoie le nom utilisé par la session en cours. Le nom par défaut est défini par le défini dans la configuration de PHP.
session_register("variable") : permet d'enregistrer la variable de session passée en paramètre. Il est à noter que pour enregistrer $login, il faut utiliser session_register("login").
session_is_registered("variable") : vérifie si la variable spécifiée en paramètre est enregistrée dans la session active.
session_unregister("variable") : détruit une variable de session préalablement enregistrée.
session_destroy() : détruit la session active.
Reprenons l'exemple vu précédemment.
<?php
session_start(); // Démarre la session. Spécifie une id de session.
$login="nom"; // On définit la variable classique $login
$password="mot de passe"; // On définit la variable classique $password
session_register("login"); // On enregistre $login dans la session
session_register("password"); // On enregistre $password dans la session
header("Location: ?".session_name()."=".session_id());
exit(); // Redirection. On en reparle dans le II.3.
?>
Exemple 2 :
<?php
// Ici $login et $password ne sont pas définis
session_start();
// Ils sont définis à partir d'ici.
echo $login;
echo $password;
if($login!="nom") session_destroy(); // destruction de la session
?>
Cet exemple simple devrait vous permettre de comprendre comment sont manipulées les variables de session. Si l'on souhaite modifier la valeur d'une variable de session, il faut procéder comme suit :
<?php
session_start();
echo $login; // il a la valeur de la variable de session correspondante.
// la variable $login présente dans notre page prend une valeur différente de
// celle présente dans la session. La variable de session $login n'a pas été
// modifiée ; elle a toujours la même valeur !
$login="nouveau_login";
echo $login; // Affiche "nouveau_login"
// Met à jour la variable de session $login avec la nouvelle valeur à savoir
// "nouveau_login"
session_register("login");
?>
Les sessions ne sont pas à utiliser dans tous les cas. Il est parfois plus simple et plus élégant d'utiliser d'autres solutions. Les sessions ne s’appliquent pas de toute façon à toutes les situations.
Les sessions ne permettent pas de conserver des informations d’une visite à une autre. Pour cela, il faut soit recourir aux cookies pour enregistrer des données sur l’ordinateur du client (avec toujours les mêmes problèmes que précédemment), soit utiliser un système d’identification reposant sur une base de données.
Pour transmettre des informations vers une seule page, les sessions peuvent être lourdes à mettre en place. On peut alors soit recourir à un passage dans l’URL pour des informations courtes et peu sensibles, soit utiliser les champs cachés d’un formulaire du type <input type="hidden" name="variable" value="valeur">.
En conclusion, l'utilisation des sessions PHP4 peut être très intéressante mais elles ne sont pas à utiliser à tort et à travers. Leur utilisation est notamment très différente de l'utilisation des cookies.
Ce paragraphe reprend quelques messages d'erreurs fréquents ainsi que les erreurs les plus souvent commises lors de l'utilisation des sessions. Cette liste est loin d'être exhaustive. N'hésitez pas à faire part de vos erreurs et du diagnostic correspondant dans les commentaires.
Erreur 1 :
Warning: Cannot send session cookie - headers already sent by (output started at c:\easyphp\www\:2) in c:\easyphp\www\ on line 4
Warning: Cannot send session cache limiter - headers already sent (output started at c:\easyphp\www\:2) in c:\easyphp\www\ on line 4
C'est l'erreur la plus classique. Un caractère affichable est présent avant le session_start. Ceci peut être un simple espace ou passage à la ligne avant le <? Ou un echo qui ne doit pas être avant le session_start.
Erreur 2 :
Fatal error: The script tried to execute a method or access a property of an incomplete object. Please ensure that the class definition utilisateur of the object you are trying to operate on was loaded _before_ the session was started in on line 26
La classe d'une instance utilisée comme variable de session n'a pas été déclarée avant le session_start. PHP n'arrive pas à gérer cette variable de session car il ne connaît pas la structure de l'objet.
Page 1
