Tutorial PHP : comment apprendre PHP pour débutants

PHP est l’un des langages de pro­gram­ma­tion les plus courants pour la pro­gram­ma­tion côté serveur. Au fil du temps, PHP est devenu un élément in­dis­pen­sable de nombreux sites Web et tech­no­lo­gies Internet modernes. Apprendre PHP peut toutefois être un défi con­si­dé­rable pour les débutants. Dans ce tutoriel PHP, nous vous pré­sen­tons les bases de ce langage de pro­gram­ma­tion apprécié, ainsi que les prin­ci­paux opé­ra­teurs, boucles et fonctions.

PHP tutorial : ce que vous devez prévoir

Notre tutoriel s’adresse avant tout aux débutants. Afin de mieux com­prendre la plupart des exemples, il est cependant utile de connaître les bases du dé­ve­lop­pe­ment Web moderne et du HTML. Afin de suivre les exemples présentés sur votre or­di­na­teur, les prérequis suivants doivent être respectés :

• Serveur Web incluant un in­ter­prète PHP
• PHP installé
• Na­vi­ga­teur Web
• Éditeur de texte

Pour le serveur, nous vous re­com­man­dons d’utiliser l’en­vi­ron­ne­ment de test local XAMPP, qui est fourni gra­tui­te­ment par Apache Friends pour les systèmes d’ex­ploi­ta­tion Windows, Linux et macOS. XAMPP est purement un serveur de test. Le pack logiciel permet aux dé­ve­lop­peurs Web de mettre en place très ra­pi­de­ment un en­vi­ron­ne­ment de test complet pour les scripts, les pages HTML et les feuilles de style. Un fonc­tion­ne­ment sécurisé sur Internet en tant que serveur Web n’est pas garanti pour autant. Un guide d’ins­tal­la­tion détaillé est dis­po­nible dans notre tutoriel XAMPP.

Bases de PHP : la syntaxe du langage de script

Si vous avez configuré votre serveur Web local (par exemple en utilisant XAMPP), vous devez vérifier si PHP a été installé cor­rec­te­ment et est prêt à exécuter des scripts. Un script est un programme qui n’est pas préa­la­ble­ment compilé en code binaire. Il est en effet exécuté par un in­ter­prète. Ouvrez votre éditeur de texte favori et importez le script PHP suivant :

<?php
phpinfo();
?>

Close

Les scripts PHP pré­sen­tent toujours une structure au schéma identique. La balise PHP ouvrante <?php indique qu’un en­vi­ron­ne­ment script est débuté. Elle est suivie du code PHP, présenté sous forme d’ins­truc­tions. Dans notre exemple, la fonction phpinfo() est appelée. La plupart des fonctions PHP né­ces­si­tent un ou plusieurs pa­ra­mètres entre pa­ren­thèses ; dans phpinfo(), ces pa­ra­mètres sont op­tion­nels : phpinfo( INFO_ALL ). Chaque énoncé se termine par un point-virgule (;). Enfin, pour fermer l’en­vi­ron­ne­ment script, on utilise la balise PHP fermante suivante : ?>.

Sau­ve­gar­dez le fichier texte au format .php (script PHP) en le renommant test, puis démarrez votre serveur Web. Si vous utilisez l’en­vi­ron­ne­ment de test XAMPP, placez test.php dans le ré­per­toire XAMPP à l’em­pla­ce­ment htdocs (C:\xampp\htdocs).

Le fichier d’exemple est ensuite ac­ces­sible via l’URL suivante dans le na­vi­ga­teur Web : http://localhost/test.php. Si vous utilisez un serveur Web différent ou une con­fi­gu­ra­tion per­son­na­li­sée du logiciel XAMPP, sé­lec­tion­nez l’URL en fonction du chemin de fichier cor­res­pon­dant.

Saisissez l’URL http://localhost/test.php pour ordonner à votre na­vi­ga­teur Web de demander le fichier test.php au serveur Web. Le serveur Apache HTTP Server ou le logiciel de serveur Web de votre choix récupère le fichier dans le ré­per­toire approprié. L’extension .php indique que le fichier contient du code PHP. L’in­ter­prète PHP intégré au serveur Web est désormais activé. Il analyse le document et lit la balise PHP ouvrante <?php, qui signale le début du code PHP. L’in­ter­prète est capable d’exécuter le code PHP et de générer une sortie HTML, fournie par le serveur Web au na­vi­ga­teur.

Si PHP est cor­rec­te­ment installé, la page Web suivante devrait ap­pa­raître comme résultat de l’exécution du script :

Close

La fonction phpinfo() est l’abré­via­tion de la valeur par défaut phpinfo(INFO_ALL), qui affiche des in­for­ma­tions dé­tail­lées sur la con­fi­gu­ra­tion PHP de votre serveur Web. Si aucune version de PHP ne peut être trouvée, le na­vi­ga­teur Web affiche un message d’erreur ou transmet le code PHP au na­vi­ga­teur sans l’in­ter­pré­ter.

« Hello World! » ou comment publier du texte grâce à la fonction echo

Si PHP a été cor­rec­te­ment installé, vous pouvez écrire votre premier script per­son­na­lisé en utilisant l’ins­truc­tion PHP echo. Con­trai­re­ment à phpinfo(), echo n’est pas une fonction au sens propre. Il s’agit plutôt d’une structure de langage qui permet de générer une chaîne de ca­rac­tères sub­sé­quente sous forme de texte.

Pour commencer votre nouveau script, ouvrez un nouveau document PHP et inscrivez la ligne de code suivante :

<?php
echo 'Hello World!';
?>

La balise ouvrante <?php débute l’en­vi­ron­ne­ment de script. Elle est suivie par la structure de langage echo, par la chaîne de ca­rac­tères Hello World! entre guil­le­mets et par la balise ?> qui ferme le script. Soyez vigilant au point-virgule après l’ins­truc­tion. Il est évi­dem­ment possible d’utiliser n’importe quel texte à la place de Hello World!.

En­re­gis­trez ensuite le script sous le nom hello.php dans le dossier htdocs sur votre serveur Web, puis ouvrez le fichier via l’URL http://localhost/hello.php dans le na­vi­ga­teur. Si le code a été cor­rec­te­ment transféré, la fenêtre du na­vi­ga­teur doit main­te­nant afficher la chaîne de ca­rac­tères que vous utilisez :

Close

Chaque texte publié grâce à echo peut être paramétré avec des balises HTML si né­ces­saire. Ces balises sont ensuite in­ter­pré­tées par le na­vi­ga­teur Web selon la spé­ci­fi­ca­tion HTML. Jugez par vous-même avec l’exemple de script suivant :

<?php
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>

Le résultat de l’exécution du script s’affiche ensuite dans le na­vi­ga­teur Web de la façon suivante :

Close

Grâce à la balise <h1>, la chaîne Hello World! est in­ter­pré­tée par le na­vi­ga­teur Web comme un titre de premier niveau. Elle est suivie d’un saut de ligne au­to­ma­tique et du pa­ra­graphe de texte <p>.

En fonction des besoins, echo peut être utilisée avec des guil­le­mets simples (’) et doubles (“). Si vous souhaitez seulement publier du texte, le choix des guil­le­mets n’est pas important. Il le devient en revanche lorsque les variables PHP entrent en jeu.

Les variables

La structure de langage echo va bien au-delà de la simple pu­bli­ca­tion d’un texte qui, fi­na­le­ment, pourrait être mise en œuvre sans PHP, sur la base du HTML. La réelle valeur ajoutée d’echo repose sur les variables, ces éléments per­met­tant à l’ins­truc­tion de créer des textes de manière dynamique.

Les uti­li­sa­teurs de PHP ren­contrent des variables, par exemple sous la forme suivante : « $exemple ».

Chaque variable se compose d’un signe dollar ($) suivi du nom de la variable. On utilise les variables dans les scripts PHP pour intégrer des données externes dans des pages Web. Il peut s’agir de valeurs de dif­fé­rents types, de simples nombres et chaînes de ca­rac­tères à des textes entiers, en passant par des struc­tures de document HTML.

Le langage PHP compte sept types de variables :

En général, le contenu est géré de façon cen­tra­li­sée, à l’aide de systèmes de bases de données. Il est également possible de définir les valeurs des variables di­rec­te­ment dans le script. Ce type d’af­fec­ta­tion fonc­tionne selon le schéma suivant :

$exemple = "Valeur";

Le symbole dollar ca­rac­té­ris­tique est suivi du nom de la variable (dans ce cas, exemple) et est connecté par le signe égal (=) à une valeur encadrée de doubles guil­le­mets. Les valeurs des variables de type Integer et Float sont inscrites sans guil­le­mets, de la façon suivante : $exemple = 24; ou $exemple = 2.7;.

PHP offre une grande liberté en ce qui concerne le nom des variables, que vous pouvez nommer à votre guise tant que les con­traintes suivantes sont res­pec­tées :

• Chaque variable doit commencer par le symbole dollar.
• Un nom de variable est une chaîne composée de lettres, de chiffres et de tirets, du type : $exemple_1.
• Un nom de variable valide commence toujours par une lettre ou un tiret, comme suit : $exemple1 ou $_exemple, mais jamais par un chiffre (faux : $1exemple).
• PHP est sensible à la casse : le langage de script fait une dis­tinc­tion entre ma­jus­cules et mi­nus­cules. $exemple est donc différent de $Exemple.
• Le nom de la variable ne doit contenir ni espaces ni sauts de ligne (faux : $exemple 1).
• Les chaînes de ca­rac­tères que PHP réserve à d’autres fins ne peuvent pas être per­son­na­li­sées (par exemple $this).

Voici un exemple :

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1> 
<p>This dynamic web page was created by $author.</p>";
?>

La balise PHP ouvrante est suivie de la dé­fi­ni­tion de la variable : on utilise la valeur John Doe pour $author. Pendant l’exécution du script, la variable $author est remplacée par la valeur John Doe à chaque fois qu’elle est spécifiée dans l’en­vi­ron­ne­ment du script. L’image ci-dessous illustre la manière dont ceci est présenté dans le na­vi­ga­teur.

Close

Si la page Web n’a pas été créée par John Doe mais par son collègue allemand Max Mus­ter­mann, modifiez sim­ple­ment la variable $author pour corriger l’erreur.

Close

Ceci est par­ti­cu­liè­re­ment efficace si une variable in­ter­vient plus d’une fois dans un script. Dans ce cas, une seule mo­di­fi­ca­tion suffit pour en corriger toutes les oc­cur­rences, puisque c’est ici que la valeur de la variable est définie.

C’est là que réside la puissance de PHP : le contenu peut être intégré sous forme de variables. Cette fonc­tion­na­lité constitue la base du dé­ve­lop­pe­ment Web dynamique. À l’inverse des pages Web statiques, dis­po­nibles sous forme de pages HTML prêtes à l’emploi, les pages Web dy­na­miques ne sont créées que lorsque l’uti­li­sa­teur cherche à les afficher. L’in­ter­prète PHP utilise les variables pour charger les éléments in­di­vi­duels de la page Web à laquelle on souhaite accéder : pour ce faire, il a recours à dif­fé­rentes bases de données dont il assemble les éléments dans une page HTML adaptée à une requête spé­ci­fique.

Les avantages de ce concept sont évidents : lorsque des éléments du site Web (par exemple dans la zone de pied de page) sont modifiés, il n’est pas né­ces­saire de procéder à des ajus­te­ments manuels sur chaque sous-page du projet Web. Il suffit au contraire de mettre à jour l’entrée en question dans la base de données. De cette façon, la révision est au­to­ma­ti­que­ment adoptée pour toutes les pages Web qui incluent les données cor­res­pon­dantes en tant que variables. Si une variable est définie plusieurs fois dans un script, chaque nouvelle dé­fi­ni­tion remplace la pré­cé­dente. L’ins­truc­tion echo met toujours en œuvre la valeur actuelle d’une variable.

<?php
$author = "John Doe";
echo "<h1>Hello World!</h1> 
<p>This dynamic web page was created by $author.</p>";
$author = "Max Mustermann";
echo " <p>Supported by $author.</p>";
?>

Close

Dans l’exemple de code, la variable $author reçoit d’abord la valeur John Doe, qui est ensuite remplacée par Max Mus­ter­mann.

En ce qui concerne les guil­le­mets, les règles sont dif­fé­rentes. En effet, à l’inverse des chaînes de ca­rac­tères, les variables in­di­vi­duelles n’ont pas besoin d’être citées entre guil­le­mets :

<?php
$author = "John Doe";
echo $author;
?>

Ceci n’est pas valable si la variable est utilisée dans une chaîne de ca­rac­tères. Dans ce cas, utilisez les doubles guil­le­mets (“). Ceux-ci per­met­tent d’indiquer à l’in­ter­prète PHP qu’il doit chercher dans la chaîne de ca­rac­tères des variables pouvant être rem­pla­cées par les valeurs associées. Les chaînes de ca­rac­tères entre guil­le­mets simples (’) sont in­ter­pré­tées et affichées comme des in­for­ma­tions en texte brut, bien qu’il s’agisse de variables.

<?php
$author = "John Doe";
echo '<h1>Hello World!</h1> 
<p>This dynamic web page was created by $author.</p>';
?>

Close

Si vous oubliez com­plè­te­ment les guil­le­mets, PHP signale une erreur de syntaxe.

Messages d’erreur et masquage

En cas d’erreurs syn­taxiques, le code PHP n’est pas valide et l’in­ter­prète PHP émet un message d’erreur. Par exemple, ceci se produit si l’on utilise l’ins­truc­tion echo avec une chaîne de ca­rac­tères sans guil­le­mets :

<?php
echo Hello World!;
?>

En général, les messages d’erreur com­por­tent des in­for­ma­tions sur l’origine d’une erreur et four­nis­sent des éléments sig­ni­fi­ca­tifs pour la corriger.

Close

L’exemple indique une erreur à la ligne 2 de notre code du programme, soit exac­te­ment là où nous avons vo­lon­tai­re­ment oublié les guil­le­mets.

Des erreurs de syntaxe se pro­dui­sent également lorsque vous publiez des ca­rac­tères sous forme de texte qui sont associés à une tâche par­ti­cu­lière en PHP, les guil­le­mets notamment (’). En PHP, les ca­rac­tères de ce type ne peuvent être publiés de la même manière qu’un texte seulement si vous informez l’in­ter­prète que le caractère en question n’est plus contraint d’assumer sa tâche initiale. Dans le cas de guil­le­mets simples, il existe deux options : vous pouvez placer une chaîne de ca­rac­tères avec des guil­le­mets simples entre guil­le­mets doubles ou masquer les guil­le­mets avec un backslash (\), comme suit :

<?php
echo '\'Hello World!\' ';
?>

Close

Il est même possible de combiner des guil­le­mets simples et doubles :

<?php
echo " 'Hello World!' ";
?>

Mais pas de la façon suivante :

<?php
echo ' 'Hello World!' ';
?>

Pour plus de li­si­bi­lité des exemples, des espaces ont été insérés entre les guil­le­mets, mais il ne faut pas en ajouter dans la pratique.

Les opé­ra­teurs de con­ca­té­na­tion

Si vous souhaitez publier si­mul­ta­né­ment plusieurs variables dans un script PHP, vous pouvez procéder de la façon suivante, expliquée pré­cé­dem­ment :

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo "<h1>Hello World!</h1> 
<p>This dynamic web page was created by $author1 and $author2.</p>";
?>

Il vous suffit d’écrire les deux variables avec le reste du texte à publier dans la chaîne de ca­rac­tères placée entre guil­le­mets doubles. PHP détecte au­to­ma­ti­que­ment les variables grâce au signe dollar ($) et insère les valeurs cor­res­pon­dantes.

Close

Cependant, cette méthode est mal vue par la plupart des pro­gram­meurs, car le principe le plus répandu veut que les variables ne fassent pas partie de la chaîne de ca­rac­tères. Ceci s’explique notamment par le fait que cette sé­pa­ra­tion est prescrite dans de nombreux langages de pro­gram­ma­tion. En outre, PHP exige également la sé­pa­ra­tion de la chaîne et de la variable lorsque l’on travaille avec des appels de fonction ou des variables plus complexes. Il est donc conseillé d’appliquer sys­té­ma­ti­que­ment cette sé­pa­ra­tion, même dans le cas d’une pu­bli­ca­tion de texte brut, bien que ce ne soit pas ab­so­lu­ment né­ces­saire.

Lorsque l’on travaille avec des variables, il est essentiel de gérer plusieurs éléments liés entre eux pour la pro­duc­tion. En PHP, c’est le rôle de l’opérateur de con­ca­té­na­tion (.).

Le code de l’exemple ci-dessus doit res­sem­bler à ceci s’il est programmé de façon « propre » :

<?php
$author1 = "John Doe";
$author2 = "Max Mustermann";
echo '<h1>Hello World!</h1> 
<p>This dynamic web page was created by ' . $author1 . ' and ' . $author2 . '.</p>';
?>

Close

Il s’agit donc de trois chaînes de ca­rac­tères et deux variables qui sont con­ca­té­nés en une seule chaîne.

Il est à noter qu’un opérateur de con­ca­té­na­tion assemble les chaînes de ca­rac­tères ou les variables sans espaces. Si une espace est né­ces­saire, elle doit être intégrée entres les guil­le­mets, comme dans l’exemple.

Les pro­gram­meurs utilisent l’opérateur de con­ca­té­na­tion non seulement pour connecter les chaînes et les variables lors de l’affichage du texte, mais également pour apporter des ex­ten­sions aux variables. L’exemple suivant illustre cette uti­li­sa­tion :

<?php
$example = 'Hello ';
$example .= 'World';
echo $example;
?>

Pour étendre la valeur d’une variable, re­dé­fi­nis­sez-la, mais ajoutez également l’opérateur de con­ca­té­na­tion point (.) avant le signe égal. C’est l’abré­via­tion courante pour $example = $example . ‘World’.

PHP ajoute la nouvelle valeur à celle définie au préalable. Si vous souhaitez insérer une espace entre les deux valeurs, insérez-la à la fin de la première chaîne de ca­rac­tères, comme dans l’exemple.

Close

Insérer du PHP en HTML

L’in­ter­prète PHP déchiffre uni­que­ment le code compris entre les balises PHP ouvrante et fermante :

<?php [Cette chaîne est interprétée par PHP] ?>

Toutes les autres sections du document sont ignorées par l’in­ter­prète et trans­mises au serveur Web telles quelles. Le code PHP peut ainsi être intégré à des documents HTML, au choix, par exemple pour créer un modèle de système de gestion de contenu. Assurez-vous que les documents HTML contenant du code PHP sont en­re­gis­trés dans des fichiers PHP. Sinon, le document n’est pas prétraité par l’in­ter­prète PHP, mais livré di­rec­te­ment au na­vi­ga­teur Web, ce qui ferait ap­pa­raître le code du programme sous forme de texte sur le site Web. On peut donc imaginer l’in­ter­prète PHP comme un collègue un peu paresseux du serveur Web, qui ne travaille que lorsqu’on lui demande de le faire, par exemple en ouvrant une balise PHP. Si vous souhaitez combiner HTML et PHP, rédigez la page HTML selon la structure classique du document, puis en­re­gis­trez-la sous l’extension de fichier .php :

<!DOCTYPE html>
<html lang="de">
    <head>
        <meta charset="utf-8">
        <title>My first PHP page</title>
    </head>
        <body>
    <h1>Hello World</h1>
    <p>What is the current time and date?</p>
    </body>
</html>

Ajoutez ensuite un script PHP dans votre document HTML. Il s’agit de veiller à ce que l’in­té­gra­lité du code du programme se trouve à l’intérieur des balises PHP.

<!DOCTYPE html>
<html lang="de">
    <head>
        <meta charset="utf-8">
        <title>My first PHP page</title>
    </head>
    <body>
    <h1>Hello World</h1>
    <p>What is the current time and date?</p>
    <p>Your current time and date is: 
    <?php 
    echo date("d.m.Y H:i:s");
    ?>.</p>
    </body>
</html>

Dans l’exemple, nous avons combiné la structure de langage echo avec la fonction PHP date() pour afficher la date et l’heure actuelles sous forme de texte côté serveur. Le paramètre de la fonction spécifie le format souhaité sous la forme d’une chaîne de ca­rac­tères :

d.m.Y H:i:s = jour.mois.année heure:minute:seconde

Si un na­vi­ga­teur Web sollicite ce type de fichier, l’in­ter­prète PHP exécute d’abord le script, puis écrit l’heure actuelle sous forme de texte dans le document HTML. L’heure est ensuite transmise grâce au serveur Web et affichée dans le na­vi­ga­teur en tant que page Web.

Close

La fonction com­men­taires de PHP

De même que le code HTML, PHP peut être commenté à volonté. Tant que cela est signalé dans la syntaxe, les com­men­taires dans le code source sont ignorés par l’in­ter­prète PHP. PHP propose trois al­ter­na­tives dif­fé­rentes.

Si vous souhaitez iden­ti­fier une ligne entière comme un com­men­taire, et donc l’exclure de l’in­ter­pré­ta­tion, vous devez utiliser le hashtag (#) ou deux barres obliques à la suite (//). Dans l’exemple de code suivant, ces deux options sont ap­pli­quées :

<?php
#This is a single-line comment!
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
//This is also a single-line comment!
?>

L’éditeur de texte Notepad++ affiche les com­men­taires en vert. Les passages de texte iden­ti­fiés comme des com­men­taires dans l’en­vi­ron­ne­ment de script n’arrivent pas dans le na­vi­ga­teur Web, à l’inverse des com­men­taires HTML, car ils sont ignorés par l’in­ter­prète PHP lors de l’exécution du script.

Close

Vous pouvez également insérer des com­men­taires sur plusieurs lignes. Pour ce faire, marquez le début d’une section de com­men­taire par une barre oblique suivie d’un as­té­risque (/*) et la fin par un as­té­risque suivi d’une barre oblique (*/).

<?php
/*
This is a multiple-lines comment block
that spans over multiple
lines
*/
echo '<h1>Hello World!</h1>
<p>This is my first PHP page.</p>';
?>

Ces com­men­taires ainsi marqués ne sont pas analysés et n’ap­pa­rais­sent donc pas sur le site Web.

Close

Les pro­gram­meurs utilisent des com­men­taires pour struc­tu­rer le code source de leurs scripts, pour laisser des notes pour une mo­di­fi­ca­tion ul­té­rieure ou pour ajouter des in­for­ma­tions internes, comme l’auteur ou la date.

Les com­men­taires sont op­tion­nels et doivent être utilisés avec par­ci­mo­nie pour assurer une bonne li­si­bi­lité du code source.

Calculer avec des variables

Dans le cadre de ce tutoriel PHP, nous avons déjà présenté les variables. Nous leur avons jusqu’à présent surtout assigné des valeurs de chaînes de ca­rac­tères. Nous allons main­te­nant traiter les variables re­pré­sen­tant des nombres entiers (integers) ou des nombres à virgule flottante (floats).

Si les variables sont dotées de valeurs nu­mé­riques, PHP offre la pos­si­bi­lité d’effectuer des calculs. Com­men­çons par une simple addition de deux nombres entiers :

<?php
$number1 = 237;
$number2 = 148;
$result = $number1 + $numer2;
echo "result: " . $result;
?>

Tout d’abord, nous at­tri­buons aux variables $number1 et $number2 les entiers 237 et 148, puis dé­fi­nis­sons une variable $result, qui cor­res­pond à la somme des variables $number1 et $number2. Pour ce faire, nous utilisons l’opérateur arith­mé­tique +(plus). Enfin, nous utilisons la structure de langageecho pour afficher le résultat de cette addition sous forme de texte. Notez qu’il n’est pas né­ces­saire d’utiliser des guil­le­mets lorsque l’on attribue des valeurs nu­mé­riques aux variables.

Close

L’exemple de code suivant présente une sélection de calculs ma­thé­ma­tiques qui peuvent être effectués avec PHP côté serveur. Les opé­ra­teurs PHP utilisés cor­res­pon­dent es­sen­tiel­le­ment aux ca­rac­tères ma­thé­ma­tiques nor­ma­li­sés.

<?php
$number1 = 10;
$number2 = 5;
$addition = $number1 + $number2; //Addition
$subtraction = $number1 - $number2; //Subtraction
$multiplication = $number1 * $number2; //Multiplication
$division = $number1 / $number2; //Division 
$exponentiation = $number1 ** $number2; //Exponentiation
?>

<?php 
echo "Result of addition: " . $addition ."<br />"; 
echo "Result of subtraction: " . $subtraction . "<br />"; 
echo "Result of multiplication: " . $multiplication . "<br />";
echo "Result of division: " . $division . "<br />";
echo "10 to the 5th power (10^5): " . $exponentiation . "<br />";
echo "Square root of 81: " . sqrt(81) . "<br />";
?>

Close

Pour les calculs complexes, il est possible de combiner les dif­fé­rents opé­ra­teurs arith­mé­tiques dans un même script :

<?php
$number1 = 10;
$number2 = 5;
$result = 2 *$number1 + 5* $number2 - 3 * sqrt(81);
echo "Result: " . $result; 
?>

L’in­ter­prète PHP détermine les valeurs des variables et les calcule ainsi :

2 *10 + 5* 5 - 3 * √81 = 20 + 25 – 27 = 18

La fonction sqrt() calcule la racine carrée du paramètre entre pa­ren­thèses. L’ordre tra­di­tion­nel des opé­ra­teurs en ma­thé­ma­tiques s’applique : les mul­ti­pli­ca­tions sont prio­ri­taires sur les additions ou sous­trac­tions. L’ins­truc­tion echo renvoie le résultat sous la forme d’une chaîne de ca­rac­tères pour le na­vi­ga­teur Web.

Close

En PHP, les termes entre pa­ren­thèses sont aussi analysés en priorité. Voici main­te­nant un exemple avec des nombres à virgule flottante :

<?php
$number1 = 2.5;
$number2 = 3.7;
$result = 2 *($number1 + 5)* ($number2 - 3) * sqrt(81);
echo "Result: " . $result; 
?>

Close

À l’instar de tous les langages de pro­gram­ma­tion courants, PHP permet aux opé­ra­teurs d’augmenter ou de diminuer les valeurs nu­mé­riques de 1. On distingue l’opérateur pré-in­cré­men­ta­tion, l’opérateur pré-dé­cré­men­ta­tion, l’opérateur post-in­cré­men­ta­tion et l’opérateur post-dé­cré­men­ta­tion.

Nous vous pré­sen­tons à présent des opé­ra­tions de calcul avec des opé­ra­teurs de dé­cré­men­ta­tion et d’in­cré­men­ta­tion. Le premier exemple porte sur la pré-in­cré­men­ta­tion. Le script suivant augmente la valeur de la variable $number de 1, en­re­gistre la nouvelle valeur dans la variable $result, puis restitue sa valeur sous forme de chaîne :

<?php
$number = 0;
$result = ++$number;
echo "Result: " . $result;
?>

Si l’on augmente la valeur 0 de 1, on obtient le résultat 1.

Close

Pour calculer le pré-décrément de la variable $number, nous utilisons le même script, en rem­pla­çant toutefois l’opérateur pré-in­cré­men­tal (++) par l’opérateur pré-dé­cré­men­tal (–) :

<?php
$number = 0;
$result = --$number;
echo "Result: " . $result;
?>

Nous diminuons ainsi la valeur 0 de la variable $number pour obtenir le résultat -1.

Close

Le script suivant indique clai­re­ment comment augmenter une valeur avant et après sa pu­bli­ca­tion :

<?php
$x = 0;
echo '<p>Result: ' . ++$x;
echo '<br>x has the value ' . $x;
echo '<p>Result: ' . $x++;
echo '<br>x has the value ' . $x, '</p>';
?>

Dans les deux cas, nous obtenons le même résultat. Dans le cas d’une pré-in­cré­men­ta­tion, la valeur x est augmentée avant la pu­bli­ca­tion à la ligne 3, et dans le cas d’une post-in­cré­men­ta­tion, elle est augmentée après la pu­bli­ca­tion à la ligne 5.

Close

Les su­per­glo­bals $_GET et $_POST

Vous con­nais­sez à présent les bases de PHP, vous savez comment gérer les variables, vous pouvez les con­ca­té­ner et faire des calculs. Nous vous ex­pli­quons main­te­nant pourquoi les variables cons­ti­tuent un concept central dans la pro­gram­ma­tion de scripts. L’une des fonctions im­por­tantes des langages de script réside dans la capacité d’évaluer la saisie de l’uti­li­sa­teur et de trans­fé­rer les valeurs vers un autre script. Pour ce faire, PHP s’appuie sur les su­per­glo­bals $_GET et $_POST, des variables système pré­dé­fi­nies et dis­po­nibles dans tous les domaines valides. En tant que tableaux as­so­cia­tifs (arrays),$_GET et $_POST stockent un ensemble de variables sous forme de chaînes dans une variable.

Les arrays PHP peuvent être vi­sua­li­sés comme une commode à plusieurs tiroirs, chacun d’entre eux per­met­tant de stocker des données. Afin de vous souvenir ensuite de ce qui se trouve dans chacun de ces tiroirs, étiquetez-les avec un nom de variable. Selon le type de tableau (ou array), il peut s’agir d’un index ou d’une clé (key). Lorsque que vous attribuez un index sous forme de nombre à chaque tiroir dans des tableaux indexés, cela revient à étiqueter les tiroirs d’un array as­so­cia­tif avec une clé sous la forme d’une chaîne (string).

Les su­per­glo­bals $_GET et $_POST con­tien­nent une série de variables sous forme de clés per­met­tant d’accéder aux valeurs associées à ces clés. Voici en détail comment cela fonc­tionne.

Transfert de données avec $_GET

Le su­per­glo­bal $_GET re­pré­sente un tableau de variables trans­mises à un script PHP grâce à une URL.

Si vous vous rendez de temps en temps sur des blogs, desboutiques en ligne ou des forums, vous avez peut-être remarqué que l’on y trouve des URL étranges. On utilise en général une structure qui obéit au schéma suivant :

http://nomdhote/dossier/nomdefichier.php?nomdevariable=valeurdevariable

Pour un blog, cela se traduit ainsi :

http://www.exemple-blog.fr/index.php?id=1

Ce type d’URL peut fa­ci­le­ment être décomposé : sur un serveur Web avec le domaine exemple-blog.fr se trouve un fichier nommé index.php, qui sert à créer un site Web dynamique. Il contient en général du code HTML et PHP, ainsi que des ré­fé­rences à des fichiers types (template) et des feuilles de style externes, soit tout le né­ces­saire pour afficher un site Web.

Il s’agit pro­ba­ble­ment d’une page Web dynamique, comme l’indique l’ajout après le point d’in­ter­ro­ga­tion (?) de id=1. Cela s’appelle une chaîne de requête HTTP : elle contient une variable (id) et une valeur (1) associée à un signe égal (=). Les pa­ra­mètres URL de ce type sont par exemple utilisés pour créer une page Web dynamique, charger du contenu à partir d’une base de données ou sé­lec­tion­ner un template approprié.

Les pages Web dy­na­miques per­met­tent de séparer le contenu et la pré­sen­ta­tion. L’index.php contient certes toutes les in­for­ma­tions sur la structure du site Web, mais doit être complété avec du contenu. Ces in­for­ma­tions sont gé­né­ra­le­ment stockées dans une base de données et peuvent être ré­cu­pé­rées à l’aide des pa­ra­mètres de la chaîne de requête HTTP. Dans notre exemple, l’URL d’index.php contient le paramètre id=1, qui spécifie quel contenu doit être lu depuis la base de données et chargé dans index.php. Pour un blog, cela cor­res­pond en général à l’ID d’un article par­ti­cu­lier. De cette façon, il est possible de trouver une entrée spé­ci­fique dans un forum et un produit spé­ci­fique sur une boutique en ligne.

Si une URL contient plusieurs pa­ra­mètres, ceux-ci sont reliés entre eux grâce à une es­per­luette (&).

www.exemple-blog.fr/index.php?page=article&id=1

Pour illustrer l’uti­li­sa­tion de $_GET avec un exemple de code, il n’est pas forcément né­ces­saire d’utiliser une base de données. Dans le script suivant, nous utilisons le su­per­glo­bal $_GET pour lire les valeurs des variables forenameetsurname d’une chaîne de requête HTTP, et les écrire dans les variables PHP $variable1 et $variable2 :

<?php
$variable1 = $_GET['forename'];
$variable2 = $_GET['surname'];
echo "Hello " . $variable1 . " " . $variable2 . "!";
?>

Le script est généré grâce à l’URL suivante :

localhost/hello.php?forename=John&surname=Doe

Nous at­tri­buons donc les pa­ra­mètres forename=Johnetsurname=Doe. Comme pour les autres exemples, les valeurs sont publiées grâce à la structure de langage echo.

Close

Un transfert de données via $_GET rend au­to­ma­ti­que­ment les données visibles dans la barre d’adresse. Il est donc possible de savoir à tout moment quels sont les pa­ra­mètres trans­fé­rés. Ceci présente l’avantage de pouvoir stocker les variables dans des hy­per­liens. De plus, les uti­li­sa­teurs peuvent stocker des URL, y compris des chaînes de requêtes HTTP, en tant que signets dans le na­vi­ga­teur.

Cependant, le fait que les pa­ra­mètres GET soient listés en texte clair dans l’URL rend cette méthode inu­ti­li­sable pour le transfert de données sensibles, comme les for­mu­laires en ligne. En outre, la quantité de données pouvant être trans­fé­rée à l’aide de $_GET est limitée, car les URL ont une longueur maximale.

Il est possible de con­tour­ner ces res­tric­tions grâce à la méthode HTTP POST. Les données ainsi trans­fé­rées sont dis­po­nibles dans le su­per­glo­bal $_POST.

Transfert de données via $_POST

Pendant que les données à trans­fé­rer sont trans­mises en tant que pa­ra­mètres URL avec la méthode GET, avec $_POST, les données sont trans­fé­rées dans le corps d’une requête HTTP. Ceci permet également de trans­fé­rer de grandes quantités de données d’un script à un autre.

L’une des ap­pli­ca­tions centrales de la méthode HTTP POST réside dans le transfert des données de for­mu­laire HTML. Pour mieux com­prendre, voici l’exemple d’une ins­crip­tion à une news­let­ter.

Créez un nouveau fichier PHP nommé page1.php et copiez le bloc de code suivant :

<form method="post" action="page2.php" >
Please send the newsletter to: <br />
Forename: <input type="text" name="forename" /><br />
Surname: <input type="text" name="name" /><br />
Email address: <input type="text" name="email" /><br />
<input type="submit" value="Submit Form" />
</form>

L’élément HTML <form> est utilisé pour créer des for­mu­laires. Il contient deux attributs dans la balise ouvrante : methodetaction. L’attribut method vous permet de définir la méthode de transfert : dans ce cas, il s’agit de HTTP-POST. L’attribut action en­re­gistre l’URL d’un script qui reçoit toutes les données saisies dans les champs suivants. L’exemple montre un for­mu­laire HTML avec trois éléments de saisie (input type=“text”) et un bouton d’envoi (input type=“submit”). Le fichier page2.php est défini comme le des­ti­na­taire des données.

Afin d’illustrer le transfert de données via $_POST, nous utilisons pour l’in­ter­pré­ta­tion des données du for­mu­laire un script simple, qui en­re­gistre les valeurs trans­mises en tant que variables PHP et les publie sous forme de texte. Pour ce faire, créez un fichier page2.php et copiez-y le code de programme suivant :

<?php
$forename = $_POST["forename"];
$surname = $_POST["surname"];
$email = $_POST["email"]; 
echo "Hello " . $forename . " " . $surname . ", <br /> 
Your are registered with the following email address: " . $email . ".";
?>

Sau­ve­gar­dez ensuite les deux fichiers PHP dans le dossier htdocs de votre serveur de test, puis ouvrez le fichier page1.php dans le na­vi­ga­teur Web en sai­sis­sant l’URL suivante : http://localhost/page1.php. Votre na­vi­ga­teur affiche main­te­nant l’interface Web in­te­rac­tive de votre for­mu­laire HTML.

Close

Entrez ensuite les in­for­ma­tions d’iden­ti­fi­ca­tion et appuyez sur le bouton Submit pour trans­fé­rer les variables d’un script à l’autre. Une fois que vous aurez confirmé votre saisie sur page1.php, vous serez redirigé vers page2.php. La fenêtre du na­vi­ga­teur affiche le résultat de l’exécution du script en fonction des données trans­mises.

Close

Les entrées d’uti­li­sa­teurs col­lec­tées via les champs de saisie de page1.php sont ré­cu­pé­rées par page2.php selon le schéma suivant :

$_POST["Nom du champ de saisie"]

De cette façon, la ligne $forename = $_POST[“forename”] récupère l’entrée dans le champ de saisie forename et l’en­re­gistre dans la variable $forename. La variable $forename peut ainsi être publiée comme une chaîne de ca­rac­tères avec echo.

L’élément if et les opé­ra­teurs com­pa­ra­tifs PHP

Jusqu’à présent, nous avons défini des variables, les avons trans­fé­rées d’un script à l’autre et les avons publiées sous forme de chaînes. Dans l’étape suivante, vous ap­pren­drez à attribuer certaines con­di­tions à l’exécution de fragments de code.

L’élément de langage if vous permet d’écrire des scripts de sorte que les ins­truc­tions ne prennent effet que lorsqu’une condition que vous avez dé­ter­mi­née au préalable est remplie ; il peut par exemple s’agir de la saisie d’un mot de passe correct. En PHP, les con­di­tions sont définies de la façon suivante :

<?php
if(expression)
    {
    statement;
    }
?>

Ce code se lit comme suit : l’ins­truc­tion (statement) n’est exécutée que si la condition dans l’ex­pres­sion est remplie. Une condition est toujours remplie lorsque l’élément if affiche le résultat TRUE (vrai). Sinon, il est considéré comme FALSE (faux) et l’ins­truc­tion est ignorée.

En règle générale, l’élément if vérifie si la valeur d’une variable cor­res­pond à ce qui a été défini au préalable dans la condition. Cette structure de contrôle est en général mise en œuvre sur la base d’opé­ra­teurs com­pa­ra­tifs.

Les opé­ra­teurs com­pa­ra­tifs

Les opé­ra­teurs com­pa­ra­tifs sont utilisés pour formuler des con­di­tions, afin de mettre deux arguments dans une relation logique, qui peuvent être in­ter­pré­tés selon le principe vrai (TRUE) ou faux (FALSE). Si l’on utilise des opé­ra­teurs com­pa­ra­tifs dans les struc­tures de contrôle PHP, ceux-ci sont appliqués à deux variables dans l’ex­pres­sion d’un élément if :

if ($a == $b) 
    {
    statement;
    }

La structure se lit ainsi : si la variable $a est égale à $b, les ins­truc­tions définies dans statement sont exécutées.

Les opé­ra­teurs com­pa­ra­tifs PHP sont basés sur le langage de pro­gram­ma­tion C et leur or­tho­graphe diffère en partie des symboles ma­thé­ma­tiques clas­siques. En voici un aperçu dans le tableau ci-dessous :

Le script suivant permet de clarifier cette structure de contrôle en comparant deux entiers. C’est l’opérateur com­pa­ra­tif < (Est inférieur) qui est utilisé :

<?php
$number1 = 10;
$number2 = 20;
if($number1 < $number2) { 
    echo "The condition is fulfilled ";
}

Nous dé­fi­nis­sons les variables $number1 et $number2, puis leur at­tri­buons les valeurs 10et20. Nous éta­blis­sons ensuite la condition suivante : si $number1 est inférieur à $number2, la chaîne spécifiée dans l’ins­truc­tion echo doit être affichée.

Le résultat de l’exécution du script contient la réponse : 10 est inférieur à 20 et l’élément ifrenvoie le résultatTRUE. La condition est donc remplie (« The condition is fulfilled »).

Close

Si vous voulez définir des ins­truc­tions qui sont exécutées lorsqu’une condition n’est pas remplie, ajoutez la structure de langage else à la structure de contrôle if afin de former une ins­truc­tion if-else en PHP :

<?php
if(condition a)
    {
    Instruction b;
    }
else 
    {
    Instruction c
    }
?>

Ce script permet également de vérifier si la condition a renvoie un résultat TRUE ou FALSE. Si la condition a est valide (TRUE), l’ins­truc­tion b est exécutée. Dans le cas contraire (FALSE), le programme passe outre l’ins­truc­tion b et exécute à la place l’ins­truc­tion c.

Com­plé­tons notre script avec la structure else et rem­pla­çons l’opérateur com­pa­ra­tif < (Est inférieur) par == (Est égal) :

<?php
$number1 = 10;
$number2 = 20;
if($number1 == $number2) 
    { 
    echo "The condition is fulfilled";
    }
else 
    {
    echo "The condition is not fulfilled";
    }
?>

Cette fois, l’élément if donne le résultat FALSE. La valeur de la variable $number1 est dif­fé­rente de celle de $number2. La condition n’est pas remplie. Cela signifie que la condition n’est pas exécutée selon la structure if, mais selon la structure else.

Close

La négation des con­di­tions se fait par un point d’ex­cla­ma­tion (!) précédant l’ex­pres­sion.

<?php
$number1 = 10;
$number2 = 20;
if ($number1 == $number2) 
    { 
    echo "The numbers are equal.";
    }
if (!($number1 == $number2))
    {
    echo "The numbers are not equal.";
    }
?>

Cet exemple montre la condition $number1 == $number2 et sa négation !($number1 == $number2), qui cor­res­pond à ($number1 != $number2).

L’une des ap­pli­ca­tions concrètes de ifetelse réside par exemple dans la requête de mot de passe basée sur un for­mu­laire HTML. En voici un exemple avec nos fichiers PHP page1.phpetpage2.php.

Commencez par ouvrir page1.php et entrez-y le code de for­mu­laire suivant :

<form action="page2.php" method="post">
Please enter your password: <input type="password" name="password" />
<input type="submit" value="Submit" />
</form>

La structure cor­res­pond au for­mu­laire déjà créé. Mais cette fois, un seul champ de saisie suffit : la requête du mot de passe. Comme pré­cé­dem­ment, les saisies de l’uti­li­sa­teur sont envoyées au script page2.php.

Nous l’adaptons avec le code suivant afin que la saisie du mot de passe soit comparée à un mot de passe mémorisé :

<?php
$password = $_POST["password"];
if($password=="qwertz123")
    {
    echo "The password was correct ";
    }
else
    {
    echo "The password was false";
    }
?>

Le code se lit de cette manière : pour commencer, nous at­tri­buons une valeur à la variable $password de la ligne 2, que nous obtenons à l’aide de la méthode HTTP POST. Nous dé­fi­nis­sons ensuite la structure de contrôle suivante : à la ligne 3, l’élément if doit vérifier si la valeur de la variable $password est conforme à la chaîne qwertz123. Si c’est le cas, nous obtenons la chaîne de ca­rac­tères The password was correct. Si if donne le résultat FALSE, else in­ter­vient à la ligne 7 et affiche la chaîne de ca­rac­tères The password was false.

Accédons main­te­nant au script page2.php grâce à l’URL http://localhost/page1.php.

Close

Le na­vi­ga­teur nous présente l’affichage Web de notre for­mu­laire HTML de requête de mot de passe. Il s’agit alors de saisir le mot de passe quertz123 défini dans le script page2.php et de cliquer sur le bouton Submit.

Close

Le na­vi­ga­teur Web nous redirige au­to­ma­ti­que­ment vers page2.php. En arrière-plan, la structure de contrôle if compare notre entrée avec le mot de passe stocké : elle affiche le résultat « qwertz123 == qwertz123 is TRUE » et la chaîne de ca­rac­tères The password was correct.

Testez par vous-même ce qui se passe si vous tapez un mot de passe différent de celui mémorisé dans le champ de saisie.

Les opé­ra­teurs logiques

Les con­di­tions que vous dé­fi­nis­sez à l’aide d’opé­ra­teurs com­pa­ra­tifs dans l’ex­pres­sion de la structure if peuvent être, si né­ces­saire, liées à d’autres con­di­tions dans la même ex­pres­sion. PHP est basé sur les opé­ra­teurs logiques ANDetOR.

Pour lier les con­di­tions, PHP confère aux opé­ra­teurs logiques des con­nexions fortes et faibles. Si vous n’utilisez qu’une seule des deux or­tho­graphes, vous ne re­mar­que­rez aucune dif­fé­rence dans la pratique. Si vous combinez les deux or­tho­graphes, vous cons­ta­te­rez que OR et || con­nec­tent plus étroi­te­ment que AND et OR. De plus, AND et && sont plus étroi­te­ment connectés que OR et ||. Cet ordre est com­pa­rable à la séquence de clas­se­ment des opé­ra­teurs qui s’applique aux opé­ra­teurs ma­thé­ma­tiques (la mul­ti­pli­ca­tion est prio­ri­taire sur les additions et sous­trac­tions : *permet une connexion plus forte que+).

L’une des ap­pli­ca­tions concrètes de cette fonc­tion­na­lité est la requête de mot de passe. En général, les in­for­ma­tions d’iden­ti­fi­ca­tion com­pren­nent un mot de passe secret et un nom d’uti­li­sa­teur. La connexion n’est réussie que si les deux entrées cor­res­pon­dent aux données en­re­gis­trées dans le système.

Ouvrons à nouveau notre for­mu­laire de requête de mot de passe page1.php et ajoutons un champ de saisie pour le nom d’uti­li­sa­teur :

<form action="page2.php" method="post">
Username: <input type="text" name="username" /><br />
Password: <input type="password" name="password" /><br />
<input type="submit" value="Submit" />
</form>

Dans l’étape suivante, nous devons également adapter la structure de contrôle de l’élément if. Pour ce faire, nous utilisons l’opérateur logique AND afin de connecter la condition pour la requête du mot de passe à une condition pour la requête du nom d’uti­li­sa­teur.

<?php
$username = $_POST["username"];
$password = $_POST["password"];
if($username=="John Doe" AND $password=="qwertz123")
    {
    echo "Welcome to the internal area" . $username . "!";
    }
else
    {
    echo "Access denied";
    }
?>

Notre script page2.php récupère main­te­nant les valeurs du nom d’uti­li­sa­teur (username) et du mot de passe (password), puis les en­re­gistre dans les variables $username et $password. L’ex­pres­sion de l’élément if contient désormais deux con­di­tions reliées à l’opérateur logique AND. La structureifrenvoie le résultatTRUEseulement si ces deux con­di­tions sont remplies ($username==“John Doe” et $password==“qwertz123”).

Puisque l’on obtient le nom d’uti­li­sa­teur à partir du champ de saisie username, il est possible de l’utiliser di­rec­te­ment pour la pu­bli­ca­tion de texte via echo : Welcome to the internal area est suivi de la valeur de la variable $username. Si l’une des deux con­di­tions n’est pas remplie, c’est le texte suivant qui s’affiche : Access denied.

Close

Les opé­ra­teurs logiques peuvent être combinés à loisir. La règle suivante s’applique alors : l’opérateur AND est prio­ri­taire par rapport à OR. De même que pour les équations ma­thé­ma­tiques, vous pouvez également utiliser les pa­ren­thèses en PHP pour in­fluen­cer cet ordre de priorité.

Les boucles (while, for)

Il est parfois né­ces­saire qu’un script passe plusieurs fois à travers une certaine section de code avant que le reste du code ne soit exécuté. Pour ce faire, les langages de pro­gram­ma­tion utilisent le concept de boucles, également appelées boucles PHP. Il existe trois types de boucles :

• La boucle while
• La boucle do-while
• La boucle for

La boucle while

Il s’agit du type de boucle le plus simple proposé par PHP. La cons­truc­tion de base cor­res­pond au schéma suivant :

while (Condition)
    {
    Étapes de la boucle et autres instructions
    }

La boucle while ordonne à PHP d’exécuter les ins­truc­tions se­con­daires tant que la condition while est remplie. L’in­ter­prète PHP vérifie donc la condition au début de chaque passage de boucle. L’exécution du code se­con­daire ne s’in­ter­rompt que lorsque la condition while n’est plus remplie. Ce principe peut être illustré par un simple script de calcul :

<?php
$number = 1;
while ($number <= 10) {
    echo $number++ . "<br />";  
    }
?>

Dans la section « Calculer avec des variables », nous avons introduit le principe de l’incrément. Dans le script suivant, nous l’utilisons à nouveau, mais cette fois-ci avec un opérateur post-incrément pour augmenter de 1 la valeur de la variable entière $number à chaque passage de boucle après la pu­bli­ca­tion de texte via echo. Comme condition pour la boucle while, nous dé­fi­nis­sons : $number supérieur ou égal à 10. L’ins­truc­tion echo est donc répétée jusqu’à ce que $number ait atteint une valeur su­pé­rieure à 10.

Close

Le résultat de l’exécution du script est une chaîne qui renvoie la valeur de la variable $number pour chaque passage de boucle avant qu’elle ne soit in­cré­men­tée. Le script compte donc de 1 à 10 et met fin à l’exécution du code dès que la condition while n’est plus remplie.

La boucle do-while

La structure de la boucle do-while est similaire à celle de la boucle while. La seule dif­fé­rence est que la condition n’est pas vérifiée au début de chaque passage de boucle, mais uni­que­ment à la fin. Le schéma de base d’une boucle do-while cor­res­pond à l’exemple suivant :

do {
     Étapes de la boucle et autres instructions
     } 
    while (Condition)

Programmé comme une boucle do-while, le script précédent res­sem­ble­rait à ceci :

<?php
$number = 1;
do {
    echo $number++ . "<br />";
    }
while ($number <= 10); 
?>

Dans ce cas, le résultat reste le même. La par­ti­cu­la­rité de la boucle do-while est qu’elle est parcourue au moins une fois, même si la condition n’est pas remplie lors d’un passage de boucle.

La boucle for

Dans l’ensemble, une boucle for au sein d’un script PHP présente les mêmes fonc­tion­na­li­tés qu’une boucle while. Cependant, la valeur de départ, la condition et l’ins­truc­tion sont écrites sur une seule ligne au lieu d’être réparties sur trois lignes ou plus. La structure de base de la boucle for cor­res­pond au schéma suivant :

for (valeur de départ; condition; étape de la boucle)
    Instructions

Avec une boucle for, l’exemple précédent pourrait donc être rédigé comme suit :

<?php
for($number= 1; $number<= 10; $number++) {
    echo $number . "<br /> ";
}
?>

Tout d’abord, la valeur 1 est définie pour la variable $number. PHP vérifie ensuite si la condition $number <=1 est remplie. Si c’est le cas, la boucle continue et les ins­truc­tions situées sous la boucle sont exécutées (il s’agit ici de l’ins­truc­tion echo). Vient ensuite l’exécution de l’étape de boucle. Dans ce cas, peu importe que l’on choisisse la pré-in­cré­men­ta­tion ou la post-in­cré­men­ta­tion, car cette ins­truc­tion est toujours exécutée avant la pu­bli­ca­tion. Une fois l’étape de boucle terminée, le passage suivant de la boucle peut débuter.

La valeur de départ, la condition et l’étape de boucle sont des éléments op­tion­nels d’une boucle for. En théorie, il est même possible de créer des boucles vides, bien que ce soit redondant.

C’est à vous de décider si vous rédigez vos scripts PHP avec une boucle for ou while. Un argument plaide toutefois en faveur des boucles for: leur uti­li­sa­tion offre en effet une meilleure vue d’ensemble des données générales de la boucle. Cela réduit le risque de rédiger ac­ci­den­tel­le­ment une boucle infinie qui s’exécute jusqu’à ce que la mémoire de l’in­ter­prète soit pleine. Ceci peut arriver avec l’exemple précédent si l’on oublie d’augmenter la valeur de la variable $number.

Cependant, si la boucle doit être exécutée au moins une fois, quelle que soit la condition, la boucle do-while est celle qui convient le mieux.

Les ins­truc­tions break et continue

Le dé­rou­le­ment d’une boucle while, do-while ou for peut être influencé par les ins­truc­tions breaketcontinue. Utilisez break pour in­ter­rompre une boucle à n’importe quel moment, et continue pour sauter le passage d’une boucle. Les deux ins­truc­tions sont liées à une condition par l’in­ter­mé­diaire de if. L’exemple suivant montre notre script de calcul avec break :

<?php
for ($number = 1; $number <= 10; $number++) {
    if ($number == 5) {
      echo "The script stops at 5";
      break;
    }
echo $number . "<br /> ";
}
?>

Dans la boucle for, nous avons défini que la valeur de la variable $number doit être in­cré­men­tée de 1 à partir d’une valeur de départ de 1 dans chaque boucle, jusqu’à ce que la variable atteigne 10. Cette boucle est alors arrêtée plus tôt que prévu avec l’ins­truc­tion break dès que $number atteint 5. La structure de langage echo ne produit donc que les nombres de 1 à 4.

Close

Si nous sou­hai­tons juste sauter le cinquième tour sans pour autant in­ter­rompre l’ensemble de la boucle, nous devons remplacer l’ins­truc­tion break par continue.

<?php
for ($number=1; $number <= 10; $number++) {
    if ($number == 5) {
      echo "We skip number 5!<br />";
      continue;
    }
echo $number . "<br /> ";
}
?>

À la place du chiffre 5, PHP affiche la ligne de texte We skip number 5! définie sous if.

Close

Les opé­ra­tions sur des fichiers

Le contenu Web dynamique est basé sur une sé­pa­ra­tion du contenu et de la pré­sen­ta­tion. Les langages de script tels que PHP offrent donc dif­fé­rentes fonc­tion­na­li­tés qui per­met­tent de charger du contenu à partir de sources de données externes dans des fichiers types (template). Dans la pratique, ces sources de données con­sis­tent es­sen­tiel­le­ment en des bases de données gérées par des systèmes tels que MySQL. Retrouvez les ins­truc­tions cor­res­pon­dantes dans notre tutoriel MySQL.

Il est également possible d’intégrer des données issues de fichiers. Dans l’exemple suivant, nous ex­pli­quons comment lire des fichiers sous forme de chaînes dans un script PHP et comment stocker les pu­bli­ca­tions de texte de votre script dans des fichiers.

Lire des fichiers

PHP offre diverses fonc­tion­na­li­tés pour lire le contenu d’un fichier, en par­ti­cu­lier file()etfile_get_contents(). Si la fonction file_get_contents() lit tout le contenu d’un fichier dans une chaîne de ca­rac­tères, la fonction file() en sau­ve­garde le contenu sous forme de tableau. Chaque élément du tableau cor­res­pond à une ligne du fichier. Avec file(), il est donc plus facile de modifier in­di­vi­duel­le­ment chaque ligne.

Nous pré­sen­tons les opé­ra­tions sur fichier PHP sur le fichier texte example.txt, que nous stockons dans le dossier htdocs de notre serveur de test. Le fichier contient quatre lignes de texte à titre d’exemple :

Lorem ipsum dolor sit amet, con­sec­te­tuer adi­pis­cing elit. Aenean commodo ligula eget dolor. Aenean massa. Cum sociis natoque penatibus et magnis dis par­tu­rient montes, nascetur ridiculus mus. Donec quam felis, ultricies nec, pel­len­tesque eu, pretium quis, sem.

Pour commencer, nous importons l’in­té­gra­lité du fichier sous forme de chaîne de ca­rac­tères. Pour ce faire, il est né­ces­saire d’attribuer le nom du fichier cor­res­pon­dant en tant que paramètre à la fonction file_get_contents(). Ceci fonc­tionne selon le schéma suivant :

file_get_contents('example.txt')

Nous pouvons désormais tra­vail­ler avec la chaîne importée. Par exemple, nous pouvons l’assigner à une variable et la modifier sous forme de texte dans le na­vi­ga­teur Web :

<?php
$example = file_get_contents('example.txt');
echo $example;
?>

Close

Dans l’affichage du na­vi­ga­teur, nous cons­ta­tons que la chaîne de texte s’affiche sans pa­ra­graphes. Les sauts de ligne du fichier d’origine ne sont pas visibles. Ceci s’explique par le fait que le na­vi­ga­teur Web in­ter­prète la sortie de texte du script comme du code HTML. Les alinéas définis dans les éditeurs de texte sont donc perdus lors du processus. Si vous souhaitez conserver la structure d’origine, il existe plusieurs options. Vous pouvez ajouter ma­nuel­le­ment un saut de ligne (br) au code HTML dans le fichier source en utilisant Re­cher­cher et remplacer, pa­ra­mé­trer <pre> pour définir le contenu du fichier, assigner la propriété CSS white-space: pre-wrap à la zone ou utiliser la fonction nl2br() pour indiquer à PHP que les sauts de ligne (new lines) doivent être au­to­ma­ti­que­ment convertis en saut de ligne HTML (breaks). Cette fonction s’utilise comme suit :

<?php
$example = file_get_contents('example.txt');
echo nl2br($example);
?>

Si vous utilisez la structure de langage echo en com­bi­nai­son avec nl2br(), PHP insère un saut de ligne HTML avant chaque nouvelle ligne.

Close

Si vous souhaitez éditer in­di­vi­duel­le­ment les lignes d’un fichier, utilisez la fonction file(). Elle permet en effet de lire un fichier, de numéroter toutes les lignes com­men­çant par 0 et d’en­re­gis­trer leur contenu comme éléments d’un tableau. Appliquée à notre exemple, cette fonction se présente comme suit :

[0] = Lorem ipsum dolor sit amet, con­sec­te­tuer adi­pis­cing elit

[1] = Aenean commodo ligula eget dolor. Aenean massa.

[2] = Cum sociis natoque penatibus et magnis dis par­tu­rient montes, nascetur ridiculus mus.

[3] = Donec quam felis, ultricies nec, pel­len­tesque eu, pretium quis, sem

Pour éditer les contenus res­pec­tifs avec echo, il vous suffit de spécifier le numéro de ligne que vous souhaitez modifier. Par exemple, le script suivant affiche seulement la première ligne du fichier example.txt sur le na­vi­ga­teur :

<?php
$example = file("example.txt");
echo $example [0];
?>

Close

Écrire dans des fichiers

PHP n’est pas seulement capable de lire les fichiers. Le langage de script vous permet également de créer des fichiers et de les décrire avec du contenu. Pour ce faire, nous utilisons la fonction PHP file_put_contents(). Ceci pré­sup­pose deux pa­ra­mètres : d’une part le nom du fichier à créer ou à mettre à jour, d’autre part les données sous forme de chaîne ou de tableau. Le script suivant crée le fichier test.txt et écrit la chaîne de ca­rac­tères This is a test! à la première ligne. L’ajout de \r\n provoque un saut de ligne dans le fichier cible.

<?php
file_put_contents("test.txt", "This is a test! \r\n");
echo "test.txt was created!";
?>

Close

Dans la mesure où file_put_contents ne fournit pas d’affichage pour le na­vi­ga­teur nous ajoutons une ins­truc­tion echo qui indique l’action à exécuter.

S’il y a déjà un fichier du même nom dans le dossier cible, celui-ci sera écrasé. Pour éviter cette opération, réglez le paramètre FILE_APPEND de la façon suivante :

<?php
file_put_contents("test.txt","The test was successul! \r\n", FILE_APPEND);
echo "test.txt was updated!";
?>

Si vous utilisez file_put_contents() avec le paramètre FILE_APPEND, les nouveaux contenus sont ajoutés aux contenus existants.

Close

Ce que PHP écrit dans le fichier cible n’a pas toujours besoin d’être défini dans le script. Vous pouvez également trans­fé­rer du contenu d’un fichier à un autre. Le script suivant lit le contenu d’example.txt et l’insère dans le fichier test.txt :

<?php
$example = file_get_contents("example.txt");
file_put_contents("test.txt", $example, FILE_APPEND);
echo "test.txt was updated!";
?>

Close