Category Archives: PHP

PHP – Les bibliothèques de fonctions

Outre les fonctions, nous possédons en PHP un formidable outil, les classes, permettant, entre autre choses de regrouper nos fonctions sous un même intitulé, créant par la même une bibliothèque.

Les bibliothèques

Une bibliothèque en PHP est définie par une classe, et cette classe est toujours définie par le mot clé « class », suivit d’un nom, puis d’accolades.

Fichier bibliotheque.php :
<?php

  class MaBibliotheque
  {
  }

?>

Maintenant qu’on a pu définir une classe, on peut y définir des fonctions. Cependant, pour que notre classe fonctionne comme une bibliothèque, on doit précéder la déclaration de nos fonctions par le mot clé « static ». Créons ensemble une petite bibliothèque mathématiques, sachant additionner, soustraire, multiplier, et diviser.

Fichier bibliotheque.php v2 :
<?php

  class Maths
  {
    static function Ajouter($A, $B)
    {
      return $A + $B;
    }
    
    static function Soustraire($A, $B)
    {
      return $A - $B;
    }
    
    static function Multiplier($A, $B)
    {
      return $A * $B;
    }
    
    static function Diviser($A, $B)
    {
      return $A / $B;
    }
  }

?>

Mais comment accéder à notre bibliothèque ? Simplement en utilisant son nom, suivit de deux double-points (« :: »), suivit du nom de la fonction à utiliser. Bref, c’est pas si compliqué, je vais vous montrer comment faire, en affichant le résultat de quelques opérations.

Fichier bibliotheque.php v3 :
<?php

  class Maths
  {
    static function Ajouter($A, $B)
    {
      return $A + $B;
    }
    
    static function Soustraire($A, $B)
    {
      return $A - $B;
    }
    
    static function Multiplier($A, $B)
    {
      return $A * $B;
    }
    
    static function Diviser($A, $B)
    {
      return $A / $B;
    }
  }

  echo Maths::Ajouter(5, 3), '<br>';
  echo Maths::Soustraire(5, 3), '<br>';
  echo Maths::Multiplier(5, 3), '<br>';
  echo Maths::Diviser(5, 3), '<br>';

?>

Vous pouvez maintenant exécuter ce code si vous le souhaitez. En PHP, il existe une seconde façon d’accéder à sa bibliothèque. Vous pouvez définir une variable qui pointe vers le nom de votre bibliothèque.

Fichier bibliotheque.php v4 :
<?php

  class Maths
  {
    static function Ajouter($A, $B)
    {
      return $A + $B;
    }
    
    static function Soustraire($A, $B)
    {
      return $A - $B;
    }
    
    static function Multiplier($A, $B)
    {
      return $A * $B;
    }
    
    static function Diviser($A, $B)
    {
      return $A / $B;
    }
  }

  $M = Maths;
  echo $M::Ajouter(5, 3), '<br>';
  echo $M::Soustraire(5, 3), '<br>';
  echo $M::Multiplier(5, 3), '<br>';
  echo $M::Diviser(5, 3), '<br>';

?>

Cette notation peut être utile pour simplifier des noms de bibliothèque à rallonge, mais aussi à choisir entre deux versions de bibliothèque possédant la même structure.

Le mot clé « self »

Lorsque nous avons besoin d’accéder à une fonction interne de notre bibliothèque, nous pouvons utiliser le mot clé « self » plutôt que le nom canonique. C’est utile si vous souhaitez par la suite changer le nom de votre bibliothèque.

Fichier bibliotheque.php v5 :
<?php

  class Maths
  {
    static function Ajouter($A, $B)
    {
      return $A + $B;
    }
    
    static function Soustraire($A, $B)
    {
      return $A - $B;
    }
    
    static function Multiplier($A, $B)
    {
      return $A * $B;
    }
    
    static function Diviser($A, $B)
    {
      return $A / $B;
    }

    static function ExempleOperations()
    {
      echo self::Ajouter(5, 3), '<br>';
      echo self::Soustraire(5, 3), '<br>';
      echo self::Multiplier(5, 3), '<br>';
      echo self::Diviser(5, 3), '<br>';
    }
  }

  Maths::ExempleOperations();

?>
Les propriétés

Nous avons jusque là défini des fonctions, mais on pourrait très bien définir de la même façon des variables. Les variables d’une bibliothèque peuvent être utile au bon fonctionnement interne de ladite bibliothèque, ou être utilisées pour sa configuration. Ajoutons à notre exemple une fonction qui récupère un nombre aléatoire entre deux valeurs, « Minimum » et « Maximum », qui sera configuré au moment de l’exécution du script. Nous modifierons la fonction « ExempleOperations() » pour prendre en compte cette nouvelle fonction.

Fichier bibliotheque.php v6 :
<?php

  class Maths
  {
    static $Minimum = 0;
    static $Maximum = 10;

    static function Ajouter($A, $B)
    {
      return $A + $B;
    }
    
    static function Soustraire($A, $B)
    {
      return $A - $B;
    }
    
    static function Multiplier($A, $B)
    {
      return $A * $B;
    }
    
    static function Diviser($A, $B)
    {
      return $A / $B;
    }

    static function RecupererNombreAleatoire()
    {
      return rand(self::$Minimum, self::$Maximum);
    }

    static function ExempleOperations()
    {
      echo self::Ajouter(self::RecupererNombreAleatoire(), self::RecupererNombreAleatoire()), '<br>';
    }
  }

  Maths::$Minimum = 25;
  Maths::$Maximum = 50;
  Maths::ExempleOperations();

?>

Comme vous pouvez le constater, cela fonctionne exactement de la même façon que pour les fonctions.

Conclusion

Vous pouvez désormais écrire vos propres bibliothèques de fonctions, c’est cool na ? Vous savez désormais comment on déclare des variables statiques, des fonctions statiques, et vous en servir, que ce soit au sein de la classe de définition, ou en dehors de cette dite classe. Prochain article : La visibilité des propriétés et des fonctions.

Note: On pourrait très bien ne pas définir le mot clé « static » pour les fonctions, et uniquement les fonctions, il est obligatoire pour les variables. Si je vous ai appris à vous en servir, c’est pour prendre les bonnes habitudes de suite. Nous verrons dans un prochain article que nous pouvons nous passer de ce mot clé, mais c’est à réserver à certaines situations particulières. Bref, prenez la bonne habitude de déclarer vos fonctions « static », lorsqu’elles servent à de la simplification du code.

PHP – Les fonctions

Nous avons utilisé, dans les articles précédents, quelques fonctions de PHP : rand(), var_dump(), gettype(). Voyons à présent comment écrire nos propre fonctions en PHP.

Les fonctions on deux objectifs : le premier, la réutilisabilité du code – éviter d’écrire deux fois la même chose, le second objectif est de scinder un programme en plusieurs sous-programmes et par la même, de simplifier la lecture du code, et son débogage.

En PHP, une fonction se déclare toujours par le mot clé « function », suivit du nom de la fonction, d’une parenthèse ouvrante, des paramètres optionnels, puis d’une parenthèse fermante. Enfin, viennent les accolades pour définir le corps de la fonction.

Je vais une fois de plus reprendre l’exemple algorithmique de la partie Code <> / Général / Définition et algorithmie : « Je souhaites réaliser un programme qui me dit si je suis majeur ou mineur, et qui devra effectuer des actions précises dans les deux cas de figure. ».

Définissons cette fois-ci les actions par deux fonctions : « ActionMajeur() », et « ActionMineur() ». Déclarons-les ensemble :

Fichier functions.php :
<?php

  function ActionMineur()
  {
  }
  
  function ActionMajeur()
  {
  }

?>

Et c’est tout. Nos deux fonctions ont été définies, et ne comporte pour le moment aucun code. Ajoutons une phrase à afficher lorsque ces fonctions seront appelées.

Fichier functions.php v2 :
<?php

  function ActionMineur()
  {
    echo 'Vous êtes mineur!';
  }
  
  function ActionMajeur()
  {
    echo 'Vous êtes majeur!';
  }

?>

Voila ce que feront nos fonctions. Elles afficheront du texte spécifiant si on est mineur ou majeur. Ces deux fonctions ne sont pas exécutée automatiquement par PHP. Si on exécute le code actuel, on se retrouvera avec une page blanche.

Pour appeler une fonction, on utilise simplement son nom, suivit des parenthèses, et de ses paramètres s’il y en a. Ajoutons maintenant un peu de rand(), un petit embranchement conditionnel, et appelons nos fonctions.

Fichier functions.php v3 :
<?php

  function ActionMineur()
  {
    echo 'Vous êtes mineur!';
  }
  
  function ActionMajeur()
  {
    echo 'Vous êtes majeur!';
  }

  $age = rand(1, 30);

  echo 'Age choisi: ', $age, '<br>';

  if($age >= 18)
    ActionMajeur();
  else
    ActionMineur();

?>

Plutôt pratique n’est-ce pas ? Mais nous pouvons encore faire mieux. Toute fonction peut renvoyer une valeur, quelle qu’elle soit, avec le mot clé « return ». Nous allons le mettre en pratique en créant une fonction DefinirAge().

Fichier functions.php v4 :
<?php

  function RecupererAge()
  {
    $valeur_a_retourner = rand(1, 30);
    return $valeur_a_retourner;
  }

  function ActionMineur()
  {
    echo 'Vous êtes mineur!';
  }
  
  function ActionMajeur()
  {
    echo 'Vous êtes majeur!';
  }

  $age = RecupererAge();

  echo 'Age choisi: ', $age, '<br>';

  if($age >= 18)
    ActionMajeur();
  else
    ActionMineur();

?>

Nous pouvons simplifier la fonction RecupererAge() comme ceci :

  function RecupererAge()
  {
    return rand(1, 30);
  }

De cette manière, si on veut modifier la façon dont on récupère l’âge, il suffira de modifier la fonction « RecupererAge() ». On pourrait parfaitement imaginer que par la suite, nous chercherons l’âge depuis un formulaire ou encore une base de données. Cette méthode de simplifications à extrême n’est pas forcément toujours utile, mais cela vous donne une idée d’où je souhaite en venir.


Essayons maintenant de créer une fonction « Ajouter » qui prend deux paramètres, « A », et « B ». Nous retournerons le résultat de « A » + « B », puis nous l’afficherons. On tirera « A » et « B » aléatoirement.

Fichier functions2.php :
<?php

  $nombreA = RecupererNombreAleatoire();
  $nombreB = RecupererNombreAleatoire();
  
  echo $nombreA, ' + ', $nombreB, ' = ', Ajouter($nombreA, $nombreB);

  function RecupererNombreAleatoire()
  {
    return rand(5, 10);
  }
  
  function Ajouter($A, $B)
  {
    $Addition = $A + $B;
    return $Addition;
  }

?>

Ce qui nous intéresse ici est la fonction « Ajouter() », qui prend en compte 2 paramètres obligatoires « A » et « B ». Au début du fichier, nous avons défini deux variables, « nombreA » et « nombreB », et leur avons donné une valeur aléatoire via une fonction prévue à cet effet, comme nous avons pu le voir précédemment. J’ai ensuite utilisé la fonction « Ajouter() » avec mes deux nombres en paramètres. Ca tombe bien, la fonction « Ajouter() » demande deux paramètres. Ceux-ci ont été défini comme des variables (les paramètres sont toujours des variables), et ils ont été copié en mémoire avant l’appel de la fonction. C’est-à-dire que si maintenant, je décidais de modifier la valeur de « A » ou de « B » dans le corps de ma fonction « Ajouter() », eh bien « nombre1 » et « nombre2 » ne seront quant à eux, non modifié. Il est important de le préciser, car nous allons voir un peu plus loin comment on peut procéder si on souhaite modifier la valeur d’origine d’un paramètre.

Voyons maintenant comment procéder pour avoir des arguments facultatifs. Pour ce faire, il nous suffit simplement de déclarer une valeur par défaut au paramètre en question. Faisons-le en ajoutant un troisième argument, « C », qui sera optionnel, et vaudra 5 par défaut.

Fichier functions2.php v2 :
<?php

  $nombreA = RecupererNombreAleatoire();
  $nombreB = RecupererNombreAleatoire();
  $nombreC = RecupererNombreAleatoire();
  
  echo $nombreA, ' + ', $nombreB, ' + 5 = ', Ajouter($nombreA, $nombreB);
  echo '<br>';
  echo $nombreA, ' + ', $nombreB, ' + ', $nombreC, ' = ', Ajouter($nombreA, $nombreB, $nombreC);

  function RecupererNombreAleatoire()
  {
    return rand(5, 10);
  }
  
  function Ajouter($A, $B, $C = 5)
  {
    $Addition = $A + $B + $C;
    return $Addition;
  }

?>

Prenez le temps de bien comprendre ce qui a été fait. J’ai ajouté « C » à notre addition, qui par défaut prend la valeur « 5 ». Seulement, elle ne vaudra « 5 » que si on omet le paramètre lors de l’appel de la fonction « Ajouter() ». Si une valeur est spécifiée lors de l’appel de la fonction, alors le paramètre par défaut est écrasé par cette valeur. Testez ce code, et vous pourrez le constater par vous-même.

Les variables globales

Nous avons pu voir tout à l’heure que les variables « A » et « B » – et même « C » – de la fonction « Ajouter() » avait une portée limitée à la fonction. En aucun cas on ne peut accéder aux variables « nombreA », « nombreB », et « nombreC » de cette façon.

Cependant, nous pouvons accéder à une variable définie en dehors de toute fonction grâce au mot clé « global ». Voyons comment ça marche. Nous allons mettre une chaine de caractères dans une variable globale, l’afficher depuis une fonction, et appeler cette dite fonction.

Fichier functions3.php :
<?php

  $chaine = 'Du texte à afficher ...';
  AfficherTexte();
  
  function AfficherTexte()
  {
    global $chaine;
    echo $chaine;
  }

?>

Dans l’exemple ci-dessus, j’ai déclaré une variable « chaine » en dehors de toutes fonctions. Cette variable a automatiquement une portée globale par rapport au script. Pour la récupérer dans la fonction « AfficherTexte() », j’ai du déclarer la variable « chaine » précédé du mot clé « global ». J’ai ainsi pu afficher ma variable globale.

Prudence toutefois avec les variables globales, évitez-les au maximum, elles sont sources de bogues et de failles de sécurité.

La notion de référence

Outre les variable locales au fonctions, globales aux scripts, on peut aussi utiliser des références de variable. Une référence, c’est un peu comme l’adresse mémoire originelle d’une variable. Pour déclarer qu’une variable doit être passée en paramètre d’une fonction par une référence, il faut faire précéder le nom du paramètre par un « & ». Cela permet, dans le cas des tableaux par exemple, d’éviter de les copier en entier dans la mémoire, coûteux en performances. De manière générale, les références sont peu utilisées, cependant je vous conseille de vous en servir lorsque vous avez beaucoup de données à traiter par le biais d’une fonction. Attention toutefois à ne pas modifier le contenu de la variable, excepté intentionnellement. Le script suivant va vous montrer comment on fait, et ce que ça fait.

Fichier functions4.php :
<?php

  $Nombre = rand(1, 5);
  
  AfficherNombre($Nombre);
  NonModificationNombre($Nombre);
  AfficherNombre($Nombre);
  ModificationNombre($Nombre);
  AfficherNombre($Nombre);
  
  function ModificationNombre(&$Reference)
  {
    $Reference = rand(6, 10);
  }
  
  function NonModificationNombre($Valeur)
  {
    $Valeur = rand(6, 10);
  }

  function AfficherNombre($Valeur)
  {
    echo 'Mon nombre est ', $Valeur, '<br>';
  }

?>

Une fonction avec un paramètre obligatoire, donné par copie de valeur, on a déjà vu ça tout à l’heure. C’est le fonctionnement de la fonction « AfficherNombre() » qui prend un unique paramètre obligatoire, pour afficher le nombre choisi au hasard au début du script. Notez que j’ai utiliser ) chaque fois la variable « Nombre » en paramètre. Seule la fonction « ModificationNombre() » est capable de modifier « Nombre », car le paramètre est passé par référence. La fonction « NonModificationNombre() » est incapable de modifier la valeur d’origine de la variable, car le paramètre est passé sans référence. Un autre avantage notable des références, c’est de pouvoir avoir plus d’une variable de réponse à une fonction. Ca peut être utile, donc notez vous dans la tête que ça existe, et mettez la page en favoris pour avoir le snippet.

Conclusion

Vous savez désormais comment on déclare une fonction et ce qu’on peut en faire. Vous savez créer une fonction avec ou sans paramètre, avec référence ou non, et à quoi ça sert. Je n’ai plus rien à dire sur le sujet. Dans le prochain chapitre, nous parlerons des bibliothèques de fonctions.

PHP – Les boucles

Comme tout langage de programmation, on peut effectuer des boucles, d’une façon ou d’une autre. Elles vont seront nécessaire pour traiter un jeu de données par exemple. Tout comme les embranchements conditionnels, il existe deux façons d’écrire ces boucles. Voyons ces boucles une à une. J’utiliserais l’extension « a » pour désigner la première forme d’écriture, et l’extension « b » sa seconde forme.

For

La boucle « For », pour commencer, est généralement utilisée avec un compteur. Elle prend en compte 3 paramètres, chacun séparé par des « ; ». Le premier paramètre est celui d’initialisation des variables, le second paramètre la condition de sortie, et le troisième et dernier paramètre est l’opération à effectuer à la fin de chaque tour de boucle. Sachez que vous pouvez utilisez plusieurs variables d’initialisations et plusieurs opérations à effectuer en fin de boucle en les séparant par des « , ». Il est tout à fait possible de laisser tous les paramètres vide, permettant ainsi de créer une boucle infinie. Tout comme pour les embranchements conditionnels, des accolades sont obligatoires si vous souhaitez exécuter plus d’une instruction par tour de boucle.

For, exemple a :
<?php

  for($i = 0; $i < 10; $i = $i + 1)
  {
    echo $i;
    echo '<br>';
  }

?>
For, exemple b :
<?php

  for($i = 0; $i < 10; $i = $i + 1):

    echo $i;
    echo '<br>';

  endfor;

?>

Dans cet exemple, je déclare une variable « i » et l’initialise à « 0 », je souhaites que ma variable « i » n’atteigne pas « 10 », puis je demande à ma boucle « for » d’incrémenter « i » de « 1 » (« i » vaut « i » + « 1 »). La boucle for s’arrêtera toute seule lorsque la condition remplie (« $i < 10 ») ne sera plus vérifiée. Allez-y, testez l’un ou l’autre code, ça ne mange pas de pain.

While

La boucle « While » ne prend qu’un paramètre en considération, une condition. Tant que cette condition est remplie, la boucle continue. Tentons de compter de 0 à 9 inclus avec une boucle « While ».

While, exemple a :
<?php

  $i = 0;
  
  while($i < 10)
  {
    echo $i, '<br>';
    $i = $i + 1;
  }

?>
While, exemple b :
<?php

  $i = 0;
  
  while($i < 10):

    echo $i, '<br>';
    $i = $i + 1;

  endwhile;

?>

On a écrit la même chose que pour la boucle « For », mais en version « While ». Faites bien attention à ce que la condition du while, de telle sorte qu’elle puisse toujours, à un moment ou a un autre, se révéler fausse. J’ai dû explicitement incrémenter ma variable « i » de « 1 » à la fin de la boucle, autrement « i » aurait toujours été égal à « 0 » et il en aurait résulté une boucle infinie.

Do … While

Contrairement à la boucle « While », la boucle « Do … While » commence d’abord par faire un tour de boucle, puis c’est seulement à la fin de ce tour de boucle que la condition est vérifiée.

Do … While, exemple :
<?php

  $i = 0;
  
  do
  {
    echo $i, '<br>';
    $i = $i + 1;
  }while($i < 10);

?>

On a toujours compté de « 0 » à « 9 », mais d’une façon encore différente. Il n’existe pas de seconde forme d’écriture pour cette boucle, donc accolades obligatoires.

Foreach

La boucle « Foreach » est une boucle faite pour énumérer les éléments d’une liste ou d’un tableau, lorsqu’on ne connaît pas ses index. Créons un tableau de chaines (reprenons mes animaux de compagnie), puis énumérons-le de deux façons différentes.

Foreach, exemples :
<?php

  $tableau = array('Chat', 'Chien', 'Furet');
  
  foreach($tableau as $animal)
    echo $animal, '<br>';

  echo '-------<br>';  
  
  foreach($tableau as $cle => $animal)
  {
    echo $cle, ' => ' , $animal;
    echo '<br>';
  }

?>
Résultat de sortie :
Chat
Chien
Furet
-------
0 => Chat
1 => Chien
2 => Furet

Qu’est-ce que je viens de faire ? Je vous ai donné les deux façons d’écrire une boucle « foreach » pour énumérer les éléments d’un tableau donné. Au début, j’ai donc déclaré mon tableau, comme vu dans l’article sur les variables, puis j’ai énuméré le tableau « tableau » et nommé chaque élément de ce tableau « animal », via le mot clé « as ». Ensuite, j’ai récupéré la clé du tableau utilisée pour enregistrer la valeur de mon animal. Cela peut être utile lorsqu’on ne connaît pas l’index ou la clé d’enregistrement du tableau, mais qu’on souhaite le/la récupérer. La forme d’écriture a légèrement changée, en y ajoutant l’opérateur « => ».

Goto

Dernier genre de boucle possible, le « Goto ». C’est un genre de programmation assez ancien, et est complètement à proscrire. Il a été démontré à maintes reprises dans les débuts de l’informatique que l’instruction « goto » nous crée un « code spaghetti », résultant en de multiples sources de bogues. Je vais toutefois vous présenter une boucle effectuée avec un « goto », car même s’il ne devrait pas être utilisé, il peut toujours servir en de rares occasions.

Goto, exemple :
<?php

  $i = 0;
  
  monetiquette:
  
  echo $i, '<br>';
  $i = $i + 1;
  
  if ($i < 10)
    goto monetiquette;

?>

J’ai tout d’abord déclaré et initialisé « i » à « 0 », puis j’ai ensuite créé une « étiquette ». J’affiche ensuite notre variable, j’incrémente « i » de « 1 », puis je teste si sa valeur est inférieur à 10. Si c’est le cas, je vais à l’étiquette déclarée précédemment « monetiquette ». Ce genre de programmation est bien entendu réalisable, mais est véritablement à proscrire de nos jours. On a toujours une façon d’écrire cela plus élégamment – d’une autre façon.

Conclusion

Une dernière petite note, quelque soit votre boucle (mise à part le « goto »), vous pouvez forcer la sortie avec le mot clé « break » ou forcer la boucle à réitérer de suite via le mot clé « continue ». Voila, vous savez à peu près tout ce qu’il y a à savoir sur les boucles. Rendez-vous au prochain tutoriel pour en apprendre plus sur les fonctions.

PHP – Les embranchements conditionnels

Dans les articles précédents, nous avons appris à déclarer des variables – dont les tableaux, utiliser des opérateurs mathématiques, et l’opérateur de concaténation. Aujourd’hui nous allons voir un outil fort pratique en programmation, les embranchements conditionnels. C’est-à-dire qu’une partie du code ne sera exécutée que si la condition d’entrée est vraie.

Les conditions et ses opérateurs

Les embranchements conditionnels sont de la forme « if … else if … else ». En français : « Si … Sinon Si … Sinon ».

Je vais maintenant reprendre l’exemple donné dans la partie Code <> / Général / Définition et algorithmie : « Je souhaites réaliser un programme qui me dit si je suis majeur ou mineur, et qui devra effectuer des actions précises dans les deux cas de figure ».

En premier lieu, nous avons besoin d’une variable « age », définissons la dans un nouveau fichier PHP, à la valeur 25 pour commencer.

Fichier tutophp3/index.php :
<?php

  $age = 25;

?>

Voila qui est fait. Maintenant, j’aimerais effectuer une action lorsque je suis majeur, et une autre si je suis mineur. Définissons ces actions : on va simplement afficher, pour le moment, les chaines suivantes : « Vous êtes majeur! » et « Vous êtes mineur! ».

Fichier index.php, suite :
<?php

  $age = 25;

  if($age >= 18)
  {
    echo 'Vous êtes majeur!';
  }
  else
  {
    echo 'Vous êtes mineur!';
  }

?>

Pour le moment, le code n’affichera que la chaine « Vous êtes majeur! ». Changez la variable « age » à 15 par exemple, et il sera alors affiché « Vous êtes mineur! ». Notez que j’ai utilisé des accolades ouvrantes et fermantes. Celles-ci déclarent un bloc d’instructions. Elle sont complètement optionnelles si nous n’avons qu’une seule instruction. Comme c’est notre cas, nous allons modifier le fichier de sorte à le simplifier, en profiter pour transformer la variable « age » par de l’aléatoire (via la fonction PHP rand()), et nous en profiterons également pour afficher l’âge que le script aura choisi pour nous.

Fichier index.php, v2 :
<?php

  $age = rand(1, 30);

  echo 'Age choisi: ', $age, '<br>';

  if($age >= 18)
    echo 'Vous êtes majeur!';
  else
    echo 'Vous êtes mineur!';

?>

Allez-y, exécutez ce code à plusieurs reprises, et vous verrez qu’un choix a été fait entre l’action « mineur » et l’action « majeur ». Nous avons donc légèrement simplifié le script, et PHP nous choisi un nombre au hasard entre dans la fourchette [1 ; 30] (donc 1 et 30 inclus).

Il existe une autre façon d’écrire des conditions en PHP. La voici ci-après.

Fichier index.php, v3 :
<?php

  $age = rand(1, 30);

  echo 'Age choisi: ', $age, '<br>';

  if($age >= 18):
    echo 'Vous êtes majeur!';
  else:
    echo 'Vous êtes mineur!';
  endif;

?>

Notez que sous cette forme, on a ajouté un double-points (« : ») à la fin début de chaque embranchement conditionnel (juste après la condition), mais aussi la présence de « endif; » pour terminer l’embranchement conditionnel. Pourquoi la présence de ce « endif; » ? Simplement parce que sous cette forme, les accolades sont strictement inutiles –  vous pouvez donc exécuter plusieurs instructions à la suite. Vous pouvez toutefois en rajouter si vous le souhaitez.

Modifions un peu le code maintenant pour détecter un adolescent. Il n’y a pas vraiment d’âge pour laquelle cette période commence, cependant nous allons la fixer à 12.

Fichier index.php, v4a :
<?php

  $age = rand(1, 30);

  echo 'Age choisi: ', $age, '<br>';

  if($age >= 18)
    echo 'Vous êtes majeur!';
  elseif($age >= 12)
    echo 'Vous êtes adolescent!';
  else
    echo 'Vous êtes mineur!';

?>
Fichier index.php, v4b :
<?php

  $age = rand(1, 30);

  echo 'Age choisi: ', $age, '<br>';

  if($age >= 18):
    echo 'Vous êtes majeur!';
  elseif($age >= 12):
    echo 'Vous êtes adolescent!';
  else:
    echo 'Vous êtes mineur!';
  endif;

?>

Nous avons introduit le mot-clé « elseif ». Attention: dans sa seconde forme il doit obligatoirement être en un seul mot (lors de l’utilisation du double-point), cependant, sous sa première forme (celle avec les accolades), « elseif » peut être écrit « else if » (donc avec un espace, en deux mots). La différence étant subtile, notez-le bien dans votre tête ou mettez cette page dans vos favoris. Vous pouvez aussi consulter la page officielle ici : http://php.net/manual/fr/control-structures.elseif.php. Notez aussi qu’on ne peut pas mélanger ces deux écritures entre elle, lorsqu’elles font partie du même bloc conditionnel.

Les opérateurs de comparaison

Nous n’avons vu qu’un seul opérateur de comparaison jusque là : « Supérieur ou Egal à », noté « >= ». Je vais vous lister tous les opérateurs possible :

  • « > » : Supérieur à
  • « < » : Inférieur à
  • « >= » : Supérieur ou Egal à
  • « <= » : Inférieur ou Egal à
  • « == » : Egal à (deux signe « égal » car il est aussi utilisé pour les assignations)
  • « != » : Différent de
  • « === » : Strictement Egal (compare la valeur ET le type des variables)
  • « !== » : Strictement Différent de (compare la valeur ET le type des variables)

Tentons de comprendre à présent les 4 derniers opérateurs cités. Nous allons travailler sur un exemple précis. Prenons un chiffre, au hasard, le 5, et assignons-le d’abord comme un nombre entier, puis ensuite comme une chaine de caractères. Ensuite utilisons nos 4 derniers opérateurs de comparaisons.

Exemple de comparaisons :
<?php

  $varNumber = 5;
  $varString = '5';
  
  if ($varNumber == $varString)
    echo "5 == '5'";
  else if ($varNumber != $varString)
    echo "5 != '5'";

  echo '<br>';
  
  if ($varNumber === $varString)
    echo "5 === '5'";
  else if ($varNumber !== $varString)
    echo "5 !== '5'";

?>
Résultat :
5 == '5'
5 !== '5'

On remarque bien que dans le premier cas, PHP a convertit tout seul un nombre en chaine ou inversement, et a ensuite comparé les valeurs. La chaine de caractères se trouve alors être égale à notre entier. Cependant, dans le second cas de figure, une comparaison sur les types à été effectuée en plus de comparer les valeurs. Les valeurs ont beau être identique, les types des variables sont différent l’une de l’autre. Un conseil de pro, c’est de toujours vérifier les types des variables en plus des valeurs, cela permet d’éviter bien des bogues, et quelques failles de sécurité par-ci par-là. De plus, la comparaison typée est plus rapide a exécuter que son homologue non typée, du fait qu’il n’y a pas l’opération de conversion entre temps. Bref, question optimisations, c’est un point supplémentaire en faveur de la comparaison typée.

Les opérateurs logiques

Outre les opérateurs de comparaisons, il existe aussi les opérateurs logiques. Ceux-ci nous permettent d’effectuer plusieurs conditions en une seule.

Voici ces opérateurs :

  • « && » ou « and » : ET
  • « || » ou « or » : OU
  • « xor » : OU Exclusif
  • « ! » : NON
« && »

Ce cas permet de valider la condition que si les membres situés à gauche et à droite sont vrais.

« && » Exemple :
<?php

  $nombre1 = rand(-1, 1);
  $nombre2 = rand(-1, 1);

  if ($nombre1 > 0 && $nombre2 > 0)
    echo 'Les deux nombres sont positifs';
  else if ($nombre1 < 0 && $nombre2 < 0)
    echo 'Les deux nombres sont négatifs';
  else if ($nombre1 > 0 && $nombre2 < 0)
    echo 'N1 > 0 et N2 < 0';
  else if ($nombre1 < 0 && $nombre2 > 0)
    echo 'N1 < 0 et N2 > 0';
  else
    echo 'Au moins un nombre est nul';

?>
« || » :

Ce cas valide la condition si au moins un des deux membres est vrai, même si l’autre est faux.

« || » Exemple
<?php

  $nombre1 = rand(-1, 1);
  $nombre2 = rand(-1, 1);

  if ($nombre1 > 0 || $nombre2 > 0)
    echo 'Au moins un des deux nombres est  positif';
  else if ($nombre1 < 0 || $nombre2 < 0)
    echo 'Au moins un des deux nombres est négatif';
  else
    echo 'Les deux nombres sont soit positifs, soit négatifs, soit nuls';

?>
« xor »

Le « xor » est un peu plus compliqué. Il est vrai si un des membres est vrai et l’autre est faux. En revanche, si les deux membres de la condition sont vrais ou que les deux membres sont faux, alors la condition est fausse.

« xor » Exemple :
<?php

  $nombre1 = rand(-1, 1);
  $nombre2 = rand(-1, 1);

  if ($nombre1 > 0 xor $nombre2 > 0)
    echo 'Au moins un des deux nombres est positif et l\'autre est négatif ou nul.';
  else if ($nombre1 < 0 xor $nombre2 < 0)
    echo 'Au moins un des deux nombres est négatif et l\'autre est positif ou nul.';
  else if ($nombre1 > 0 xor $nombre2 < 0)
    echo '(N1 > 0 et N2 >= 0) OU (N1 <= 0 et N2 <= 0)';
  else if ($nombre1 < 0 xor $nombre2 > 0)
    echo '(N1 < 0 et N2 <= 0) OU (N1 >= 0 et N2 > 0)';
  else
    echo 'Un autre cas de figure.';

?>
« ! »

L’opérateur « ! » a pour effet d’inverser le résultat de la condition. Si la condition était vraie, elle devient fausse, et vice-versa.

« ! » Exemple :
<?php

  $nombre = rand(-1, 1);

  if (!($nombre > 0))
    echo 'Le nombre est négatif ou nul';
  else if (!($nombre < 0))
    echo 'Le nombre est positif ou nul';
  else
    echo 'Le nombre est nul';

?>
Le switch

Outre les conditions, il existe une autre façons de programmer un embranchement conditionnel, le « switch …  case ». Apprenons-en un peu plus en regardant un exemple. Imaginons que nous jetons un dé de 6 faces, et que suivant le chiffre tiré, une action doit être effectuée. Par exemple, avancez de 2 cases sur le plateau lorsque vous avez fait un 3, et gagner en puissance d’attaque lorsqu’on a fait un 6. On va faire ça en texte, comme tout bon rôliste se respecte.

Exemple Switch Case :
<?php

  $dice = rand(1, 6);
  
  echo 'Vous avez tiré un ' . $dice . '!<br>';
    
  switch($dice)
  {
    case 1:
      echo 'Vous perdez 1 point en armure.';
      break;
    
    case 2:
      echo 'Vous devez reculer votre personnage d\'1 case.';
      break;
    
    case 3:
      echo 'Vous pouvez avancer votre personnage de 2 cases.';
      break;
    
    case 4:
    case 5:
      echo 'Vous perdez ' . $dice . ' points de santé.';
      break;
    
    case 6:
      echo 'Votre puissance d\'attaque augmente de 5!';
      break;

    default:
      echo 'Jamais appelé';
  }

?>
Alternative d’écriture :
<?php

  $dice = rand(1, 6);
  
  echo 'Vous avez tiré un ' . $dice . '!<br>';
    
  switch($dice):

    case 1:
      echo 'Vous perdez 1 point en armure.';
      break;
    
    case 2:
      echo 'Vous devez reculer votre personnage d\'1 case.';
      break;
    
    case 3:
      echo 'Vous pouvez avancer votre personnage de 2 cases.';
      break;
    
    case 4:
    case 5:
      echo 'Vous perdez ' . $dice . ' points de santé.';
      break;
    
    case 6:
      echo 'Votre puissance d\'attaque augmente de 5!';
      break;

    default:
      echo 'Jamais appelé';

  endswitch;

?>

Comme vous pouvez le constater en testant les codes ci-dessus, qui sont strictement identique, on a pu définir des cas bien précis pour chaque valeur du dé. Pour chaque cas, nous avons le mot clé « case », suivi de la valeur a tester, suivit ensuite d’un double-points (un point-virgule est utilisable à la place du double-points, mais je vous déconseille fortement ce genre d’écriture exotique, sous peine de ne pas vous y retrouver si vous programmez dans plusieurs langages différents). Suivent ensuite une liste d’instructions, et terminées par l’instruction « break » pour « casser » et sortir du branchement conditionnel. Vous remarquerez que j’ai utilisé le cas « 4 » vide, permettant ainsi de passer au cas « 5 » lorsque le cas « 4 » est validé. L’étiquette et mot-clé « default » ne sera ici jamais appelé, car tous les cas du switch ont été pourvu, cependant, sachez qu’il existe pour éviter des bogues entre autres choses. Si je souhaitais augmenter le nombre de faces du dé, il serait alors judicieux de placer un code dans le cas « default », qui pourrait permettre, par exemple, d’effectuer une action par défaut, quelque soit la valeur tirée.

Notez aussi l’utilisation d’accolades obligatoires dans le premier cas, et aucune accolade dans le second. Nous avons ici la même règle que pour les conditions.

Conclusion

Vous savez désormais utiliser des embranchements conditionnels en PHP. Sachez que vous pouvez les imbriquer les un dans les autres, et que l’on peut utiliser plusieurs fois les opérateurs booléens dans une même condition. Utilisez des parenthèses dans des conditions complexes pour agir sur les priorités, comme en mathématiques. Pensez aussi à bien respecter les accolades, et tout devrait bien se passer. Vous avez aussi vu comment utiliser la fonction PHP rand(), qui peut se révéler utile.

Prochain chapitre : les boucles.

PHP – Variables et opérateurs

Cet article fait suite à mon introduction sur PHP. Dans l’introduction nous avons vu comment déclarer une variable chaine, et l’afficher. Dans cet article, nous verrons plus en détails le fonctionnement des variables et les opérateurs utilisable. Si vous ne savez pas ce qu’est un opérateur, vous pouvez toujours lire l’article Code <> / Général / Structure d’un programme.

Pour ceux qui ont sauté l’introduction, je rappelle que le PHP s’écrit entre les balises « <?php » et « ?> », que chaque ligne d’instruction se termine par un « ; », et qu’une variable se déclare simplement en préfixant son nom par un « $ ».

Les variables

En règle générale, dans un langage de programmation, lorsqu’on déclare une variable on en déclare son type et/ou sa taille (nombre entier, nombre à virgule, chaine de caractères, tableaux …). Ce n’est pas le cas en PHP, c’est pourquoi ce genre de langage est dénommé « faiblement typé », par opposition aux langages « fortement typé » tels que le C et le C++.

Il en résulte que le PHP est à la fois simple et complexe à apprendre. On peut écrire du code de mille et une façons, mais il y en a moins sujettes aux bogues ou failles de sécurité. Sachez qu’en PHP, il est tout de même possible de typer ses variables, mais on verra cela un peu plus tard. Nous pouvons connaître aussi le type d’une variable, et effectuer des comparaisons typées. Encore une fois, nous verrons cela plus tard, probablement dans les bonnes pratiques.

Je vais créer un répertoire « tutophp2 » sur mon serveur PHP et lui placer un fichier « index.php » à sa racine. Voyons maintenant comment déclarer simplement les différents type de variable en PHP.

Fichier « index.php » :
<?php

  $a = 5;
  $b = 3.1415;
  $c = 'Chaine';
  $d = "Chaine";

?>

Inutile d’exécuter ce code, il ne fait rien en soit à part assigner des valeur à des variables.

Explications

On a assigné un entier à « a », un nombre à virgule à « b », et une chaine de caractères à « c » et « d ». Les deux écritures pour l’assignation de « c » et « d » sont semblables dans ce cas-ci. Nous verrons un peu plus loin qu’il existe une subtile différence entre l’assignation de « c » et l’assignation de « d ».

Type des variables

Si on regarde de plus près nos variables, elles sont de trois types : « integer » (nombre entier), « double » (nombre à virgule), et « string » (chaine de caractères). Nous pouvons le vérifier grâce à la fonction « gettype » de PHP, qui prend en compte une variable de n’importe quel type en paramètre. Je parle ici de fonction et non d’instruction, mais l’appel à une fonction équivaut à une instruction. Nous avions vu dans l’introduction PHP l’instruction « echo » qui est en fait un mot clé, et surtout une fonction « magique ». Elle s’utilise sans parenthèse, et peut posséder un nombre de paramètres infini, quel que soit le type de paramètre qu’on lui donne. Utilisons-la maintenant, conjointement à de l’HTML pour la lisibilité, pour vérifier le type de nos variables.

Fichier index.php, v2 :
<?php

  $a = 5;
  $b = 3.1415;
  $c = 'Chaine';
  $d = "Chaine";

  echo gettype($a), '<br>';
  echo gettype($b), '<br>';
  echo gettype($c), '<br>';
  echo gettype($d), '<br>';

?>

Si nous exécutons ce code, notre page web nous indique bien :

integer
double
string
string

Nous nous rendons compte à présent que PHP « auto-type » les variables. Nous n’avons pourtant pas spécifié le type de nos variables. Essayons maintenant d’additionner « a » avec « b », et voyons le résultat.

Fichier index.php, v3 :
<?php

  $a = 5;
  $b = 3.1415;
  $c = 'Chaine';
  $d = "Chaine";
  $e = $a + $b;

  echo gettype($a), '<br>';
  echo gettype($b), '<br>';
  echo gettype($c), '<br>';
  echo gettype($d), '<br>';
  echo gettype($e), '<br>';

?>

Le code PHP ci-dessus nous ressort :

integer
double
string
string
double

Donc, un integer additionné à un double, ça nous donne un double. Ca parait cohérent, dans la mesure où PHP auto-type nos variables. PHP fait en fait ce qu’il veut de nos variables. S’il attend une chaine dans une fonction et qu’on lui donne un nombre, il convertit automatiquement le nombre en chaine de caractères. PHP est fait ainsi, et on ne le changera pas.

Les opérateurs

J’ai devancé quelque peu cette partie par l’introduction du « + » dans le code précédent. En PHP, on possède 6 opérateurs de bases. 5 opérateurs mathématiques, et un opérateur de concaténation de chaines de caractères.

Opérateurs mathématiques

On peut additionner (« + »), soustraire (« -« ), multiplier (« * »), diviser (« / »), et effectuer un modulo (« % »). N’oubliez jamais l’opérateur modulo, il vous servira plus que vous ne le pensez.

Opérateur de concaténation

Pour assembler deux chaines de caractères ensemble, on peut utiliser le « . ».


Mettons un peu tout cela en pratique. Cette fois, au lieu d’afficher le type de nos variables, on va afficher le résultat de nos opérations.

Fichier index.php, v4
<?php

  $a = 5;
  $b = 3.1415;
  $c = 'Chaine';
  $d = "Chaine";

  $e = $a + $b;
  $f = $a - $b;
  $g = $a * $b;
  $h = $a / $b;
  $i = $a % $b;
  $j = $c . ' - ' . $b;

  echo $e, '<br>', $f, '<br>', $g, '<br>', $h, '<br>', $i, '<br>', $j;

?>

Si on exécute ce code, voila ce qu’il nous produit :

8.1415
1.8585
15.7075
1.5915963711603
2
Chaine - 3.1415

Comme attendu et expliqué précédemment, la variable « b » a été automatiquement convertie en chaines de caractères. Cette souplesse dans les variables est vraiment pratique. Le résultat entre un integer et un double est un double, comme attendu.

Pour ceux qui ne savent pas ce qu’est un modulo, c’est simplement le reste de la division euclidienne entre deux nombres. Regardez sur Wikipédia pour en savoir plus.

Les tableaux

En programmation, on a souvent besoin des tableaux. Un tableau, en programmation, est une variable contenant d’autres variables. En PHP, il existe plusieurs manières de les définir. Je vais vous en présenter quelques-unes, et comment accéder à ces données. Il existe 2 façons d’enregistrer des variables dans des tableaux. La première, par indexation, en lui donnant un numéro (index). La seconde façon est de définir une clé. Le tableau, dans ce cas-ci, est équivalent à un dictionnaire de données dans d’autres langages de programmation.

L’indexation peut se faire soit automatiquement, soit en spécifiant l’index. Quant au dictionnaire de données, il faut obligatoirement définir une clé pour enregistrer ses variables. Voyons quelques exemples ensemble. Au passage, je vais vous apprendre de suite une fonction de débogage très utile en PHP. En effet, « var_dump() » permet de visualiser le type et le contenu de n’importe quelle type de variable. Cette fonction a un nombre d’arguments infini, ce qui me permet de m’en servir en une seule fois.

Fichier index.php v5 :
<?php

  $a = array();
  $b = array('chat', 'chien', 'furet');
  $c = array(0 => 'chat', 1 => 'chien', 5 => 'furet');
  $d = array(0 => 'chat', '1' => 'chien', 2 => 'furet');
  $e = array('animal_calins' => 'chat', 'animal_défense' => 'chien', 'animal_mignon' => 'furet');
  
  $f[0] = 'chat';
  $f[3] = 'chien';
  $f[10] = 'furet';
  
  $g['animal_calins'] = 'chat';
  $g['animal_défense'] = 'chien';
  $g['animal_mignon'] = 'furet';
  
  echo '<pre><code>';
  var_dump($a, $b, $c, $d, $e, $f, $g);
  echo '<br>--------------------<br>';
  echo $f[3], ' :: ', $d[1], ' :: ', $b['1'], ' :: ', $e['animal_défense'];
  echo '</code></pre>';

?>

Le code ci-dessus permet d’afficher ce contenu :

array(0) {
}
array(3) {
  [0]=>
  string(4) "chat"
  [1]=>
  string(5) "chien"
  [2]=>
  string(5) "furet"
}
array(3) {
  [0]=>
  string(4) "chat"
  [1]=>
  string(5) "chien"
  [5]=>
  string(5) "furet"
}
array(3) {
  [0]=>
  string(4) "chat"
  [1]=>
  string(5) "chien"
  [2]=>
  string(5) "furet"
}
array(3) {
  ["animal_calins"]=>
  string(4) "chat"
  ["animal_défense"]=>
  string(5) "chien"
  ["animal_mignon"]=>
  string(5) "furet"
}
array(3) {
  [0]=>
  string(4) "chat"
  [3]=>
  string(5) "chien"
  [10]=>
  string(5) "furet"
}
array(3) {
  ["animal_calins"]=>
  string(4) "chat"
  ["animal_défense"]=>
  string(5) "chien"
  ["animal_mignon"]=>
  string(5) "furet"
}

--------------------
chien :: chien :: chien :: chien

Pour commencer, mais qu’est-ce que j’ai fait ? Tout d’abord, « a » est un tableau vide. Pour « b »,  j’ai utilisé l’indexation automatique pour y enregistrer mes animaux de compagnie (index 0, 1, et 2). En « c », j’ai fait l’indexation explicitement. Si on analyse le résultat obtenu, j’ai des trous dans ce tableau : les index 2, 3, et 4 n’existent pas. En « d », j’ai fait l’indexation explicitement, mais avec une clé au milieu. Seulement si on regarde de plus près le résultat de sortie, en mémoire, ma clé « 1 » a été transformée en index 1, PHP ayant automatiquement converti ma chaine de caractères en nombre, sans qu’on ne lui ai rien demandé. En « e », j’ai utilisé des clés pour transformer le tableau en dictionnaire de données. En « f » et « g », j’ai juste déclaré mes tableau d’une façon différente.

A la fin du fichier, j’ai fait affiché plusieurs fois le mot « chien » depuis des tableaux différents. Vous noterez que j’ai utilisé un index pour « d » et une clé pour « b », alors que j’ai déclaré l’inverse. Dans le cas des tableaux, en PHP, toute clé qui contient un nombre est convertit en nombre implicitement, c’est ce qui fait à la fois la force, et la faiblesse du PHP. Une force, car c’est fort pratique, mais une faiblesse aussi car source de bogues ou de faille de sécurité.

Conclusion

Nous savons désormais comment créer des variables, dont les tableaux à une dimension, utiliser les opérateurs mathématique et l’opérateur de concaténation. Nous avons appris au passage comment déboguer un script en affichant le contenu des variables.

Dans le prochain article, nous verrons les embranchements conditionnels.

PHP – Introduction

Nous allons voir aujourd’hui comment fonctionne le PHP. Pour commencer, vous devez avoir un serveur de scripts PHP. Je ferais tout en PHP 7, sous un Windows / Apache / MySQL / PHP, le même que j’ai installé dans mon tutoriel WAMP. Si vous n’avez pas de serveur PHP sous la main, vous pouvez installer un WAMP ou un LAMP au choix à la main par l’intermédiaire de mes tutoriels, ou regardez pour une solution clés en main sur un moteur de recherche (ou louez un serveur PHP sur Internet). Je ferais tout mon tutoriel avec mon WAMP, je n’indiquerais donc pas l’utilisation du FTP ici.

Dans mon répertoire « c:\other\install\htdocs », j’ai créé un sous-répertoire « tutophp1 ». On va travailler sur le fichier « index.php ». Comme il nous faut un éditeur de code PHP, pour ma part, j’ai choisi PSPad, disponible sur http://www.pspad.com.

Avec PSPad, créez donc un nouveau fichier PHP (Menu « Fichier », « Nouveau fichier », sélectionnez « PHP », puis cliquez sur « OK ». Enregistrez le de suite dans le sous-répertoire « tutophp1 » sous le nom « index.php ».

Tout code PHP doit se situer entre les balises ouvrante « <?php » et fermante « ?> ». Si du code se trouve en dehors de ces deux balises, il sera alors interprété comme texte brut. Dans notre cas, nous allons utiliser PHP derrière un serveur web (Apache), par conséquent, nous allons travailler sur des pages Web avec un navigateur internet.

Hello World

Tout premier programme à écrire est un « Hello World », alors allons-y.

Fichier index.php :
<?php

  echo 'Hello Word!';

?>
Description du code
  1. On ouvre la balise « <?php » pour déclarer du code PHP.
  2. On demande a PHP d’écrire la chaine « Hello World! » dans notre document avec l’instruction « echo ». A la fin d’une ligne d’instruction, il faut toujours placer un « ; ».
  3. On ferme avec la balise « ?> » pour signaler à l’interpréteur PHP qu’on en a terminé avec lui.

Note: J’aurais pu placer la chaine entre deux guillemets plutôt que des apostrophes, ça aurait eu le même effet.

Enregistrez votre fichier, et si vous travaillez avec un serveur local, allez sur http://localhost/tutophp1/. Voila, on a affiché la chaine « Hello World! », pas très utile dans l’immédiat, mais c’est mieux que rien. On va maintenant ajouter du code HTML à notre page pour mieux comprendre l’intérêt de PHP. Cette fois, on écrira le code en dehors des balises « <?php » et « ?> ».

Fichier index.php, v2 :
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Hello World PHP</title>
  </head>
  <body>
    <?php

      echo 'Hello Word!';

    ?>
  </body>
</html>

Nous voici maintenant avec un code HTML 5 valide. Cette fois-ci, on a écrit directement du texte avant, et après le code PHP, pour avoir le même résultat que précédemment, avec un titre en plus.

Les variables

Utilisons maintenant une variable pour notre chaine, et écrivons cette chaine dans la balise <title> et dans le <body> de notre document.

Fichier index.php, v3 :
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>
      <?php

        $variable = 'Hello World!';
        echo $variable;

      ?>
    </title>
  </head>
  <body>
    <?php

      echo $variable;

    ?>
  </body>
</html>

Voila qui est fait. Enregistrez le fichier, puis regardez le résultat. Nous avons définit une variable avec le préfixe « $ », nous l’avons nommé « variable », assigné la valeur chaine « Hello World », puis donné à manger en paramètre à l’instruction PHP « echo ».

Nous avons pu sans problème intégré plusieurs bouts de code PHP au sein d’un document HTML. Cependant, de façon générale, pour que le code PHP puisse être interprété par le parseur PHP, il faut que le fichier porte l’extension « .php ».

Conclusion

Félicitations! Vous savez désormais comment on déclare du code PHP, et avez utilisé une variable chaine pour afficher un même texte à plusieurs endroits. Ceci n’est qu’une des vastes possibilités de PHP. On peut (presque) tout faire en PHP, cependant, il est limité par défaut, comme par exemple une limite de temps d’exécution fixée à 30 secondes (modifiable dans le fichier « php.ini »). D’autres limitations sont mises en œuvre, on les verra au fur et à mesure de mes articles.