Category Archives: Code <>

Code

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.

La Programmation Orientée Objet

Nous avons vu précédemment la structure générale d’un programme, dans les grandes lignes. Aujourd’hui je vais vous parler de la programmation orientée objet (POO). La POO est un paradigme de programmation informatique élaboré dans les années 1960-1970. C’est suffisamment ancien et suffisamment utilisé dans presque tous les langages de programmation pour que je vous en parle.

Définition d’un objet

Un objet, en programmation informatique, représente un concept, une idée, ou toute autre entité. Il peut représenter une personne, un livre, un ordinateur … Il possède une structure interne et un comportement, et sait interagir avec ses pairs. On pourrait considérer un objet comme un sous-programme interne au logiciel que l’on développe. De nos jours, c’est un concept important à prendre en compte lors du développement de son programme, permettant de le simplifier au possible, telles que les fonctions qui simplifient déjà le programme.

Un objet possède des propriétés (dans le cas d’une voiture par exemple, ce serait la couleur de la carrosserie, le nombre de rapports de la boite de vitesses, la vitesse maximale …), mais aussi des méthodes, permettant d’agir sur l’objet en question – des actions (toujours dans le cas d’une voiture : avancer, reculer, tourner …).

Représentation d’un objet

En programmation, un objet peut être vu comme un conteneur, possédant des variables (propriétés), et des fonctions (méthodes) pouvant agir sur lui-même. L’objet une fois définit devient un nouveau type de variable à part entière. Vous connaissiez les entiers (signés ou non), les nombres à virgule, maintenant vous connaissez aussi les objets.

Nous pouvons représenter simplement un objet de la manière ci-après, mais ce n’est qu’un exemple de représentation, et est très personnel. De plus, je souhaite rester au format texte pour dessiner le schéma.

Voiture
+-- CHAMPS
|   +-- CouleurCarrosserie
|   +-- NombreRapports
|   +-- VitesseMaximale
+-- METHODES
    +-- Avancer
    +-- Reculer
    +-- Tourner

Encore une fois, ce n’est qu’une façon de représenter schématiquement un objet, et cet objet est de toutes façons incomplet (il manque la vitesse courante, la position de la voiture …).

Ce sera tout pour la théorie, dans la pratique, les possibilités sur les objets sont plus nombreuses que de simplement avoir des champs et des méthodes, mais tout dépendra du langage de programmation utilisé. Vous verrez donc la suite en fonction du langage de programmation que vous souhaitez apprendre.

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.

HTML 5 – Les formulaires

Une page web qui affiche du texte, des images, et tout, c’est cool. Mais on peut aussi demander des informations aux visiteurs, tels que leur adresse email, leur nom, ou simplement de laisser un message. De quels outils disposons-nous en HTML 5 ? Les formulaires sont la réponse à cette question.

Tout formulaire commence doit être contenu dans les balises <form></form>. Il ne peut y avoir d’autre formulaire à l’intérieur. Il existe bien une possibilité pour avoir un design plus responsive, mais je n’en parlerais pas, car elle n’est pas compatible avec tous les navigateurs.

<form>

La balise <form> en elle même possède plusieurs attributs. Le premier, « action », définit la page cible où envoyer les données du formulaire. Le second attribut, « method », permet de définir une méthode d’envoi. Ce denier peut prendre la valeur « GET » ou « POST ». Par défaut, si l’attribut « method » est omis, c’est la méthode « GET » qui sera utilisé. La différence entre les deux méthodes, c’est qu’avec « GET », toutes les données seront envoyées dans l’url de destination (ex: http://monsite.fr/formulaire.html?nom=monnom&commentaire=mon&nbsp;commentaire). Avec la méthode « POST », les données sont envoyées séparément de l’url de destination (l’url resterait donc http://monsite.fr/formulaire.html). C’est une méthode recommandée, surtout si vous faites un formulaire de connexion où le mot de passe doit être envoyé.

Cependant, pour traiter ces informations, il vous faudra un programme du côté du serveur qui héberge vos pages. Celui-ci peut être écris en C++, ASP, PHP, ou autre. Je travaillerais personnellement avec le PHP pour vous montrer comment récupérer les données d’un formulaire et les traiter efficacement. Lisez mon blog section Code<> / PHP pour en apprendre plus; Cet article n’a que pour but de vous informer quant au fonctionnement des formulaires en HTML 5.

Note: On peut aussi traiter les formulaires avec du JavaScript, côté client (donc chez le visiteur), mais il est rare de le faire, d’autant plus en HTML 5.

La balise <form> peut donc avoir un attribut « action », qui s’il est omis, renverra automatiquement le formulaire sur la même page. Plutôt pratique, mais déconseillé de le laisser vide.

Un début de formulaire ressemble donc à ceci :

<form action="formulaire.html" method="POST">
</form>
<input>

La balise <input> est plutôt vaste. Elle prendra des formes diverses et variées en fonction de son attribut « type ». Elle doit posséder un attribut « name » pour avoir la possibilité de récupérer sa valeur par le biais du programme côté serveur. Ces balises ne se referment pas, on entrera jamais du texte ou quoique soit d’autre entre deux balises <input> et </input>. Toutes les balise <input> peut avoir l’attribut « required » pour signaler au navigateur que le champ est obligatoire. Si le champ est laissé vide et que le visiteur clique sur le bouton d’envoi du formulaire, le navigateur affiche alors l’erreur et n’enverra pas le formulaire. Certains champs <input> peuvent utiliser en plus l’attribut « placeholder » pour afficher du texte en arrière-plan lorsque le champ n’est pas rempli, et qui s’effacera au premier caractère entré par le visiteur. Vous pouvez spécifier aussi l’attribut « value » pour soit mettre une valeur par défaut, soit spécifier une valeur de choix (ex: <input type= »radio »>).

<input type= »text »>

Permet au visiteur d’entrer du texte brut, sur une ligne. On peut spécifier l’attribut « maxlength » pour définir une longueur maximale de la chaine d’entrée.

<input type= »password »>

Permet au visiteur d’entrer un mot de passe. Similaire au type « text », mais les caractères ne sont pas visible.

<input type= »submit »>

Affiche un bouton qui enverra le formulaire. Pour définir son texte, utilisez l’attribut « value ».

<input type= »email »>

Permet de demander une adresse email au visiteur. Si l’adresse est invalide, le navigateur affichera une erreur au moment d’envoyer le formulaire, et annulera son envoi. Permet aussi aux smartphones d’afficher un clavier différent lors de la saisie.

<input type= »radio »>

Permet de demander un choix au visiteur par le biais d’un bouton radio (exemple: est-il un homme ou une femme ?). Pour que plusieurs <input> « radio » puissent fonctionner de concert, il faudra leur attribuer le même nom. De plus, il faudra spécifier l’attribut « value » pour connaître la valeur choisie. Vous pouvez spécifiez l’attribut « checked » pour présélectionner une option.

<input type= »checkbox »>

Permet d’afficher une case à cocher, pour valider par exemple des CGU ou activer ou non certaines options sur votre site. Peut utiliser l’attribut « checked ».

<input type= »button »>

Permet d’afficher un bouton, qui typiquement, ne fera rien. Il est généralement utilisé conjointement avec du JavaScript pour effectuer des actions précises. Utilisez l’attribut « value » pour lui attribuer un texte à afficher.

<input type= »url »>

Vous demander au visiteur d’indiquer l’adresse d’un site web. Ce champ ressemble au type « text », mais le navigateur attendra une adresse valide. Permet aussi aux smartphones d’afficher un clavier différent lors de la saisie. Note: Ce type de champs n’est pas forcément compatible avec tous les navigateurs.

Petit exemple de formulaire :
<form action="formulaire.html" method="post">
  <div><input type="text" name="nom" placeholder="Votre nom" required></div>
  <div><input type="password" name="motdepasse" required></div>
  <div>Êtes-vous un homme ou une femme ?</div><div>Homme <input type="radio" name="genre" value="homme" checked>
  Femme <input type="radio" name="genre" value="femme"></div>
  <div>Afficher votre nom sur le site ? <input type="checkbox" name="afficher_nom"></div>
</form>

Note: Si vous ne voulez pas avoir d’erreur 404 avec votre navigateur, enregistrez ce formulaire dans un fichier nommé « formulaire.html ».

Il existe d’autres types d'<input>, mais ne sont pas forcément pris en charge par tous les navigateurs, ce qui est regrettable. A vous de voir si vous souhaitez vous en servir ou non. Dans tous les cas, pour les champs de type « date », « range », « number » ou encore « color », il reste la possibilité d’utiliser du JavaScript pour obtenir le même effet.

<textarea>

Si vous voulez que votre visiteur vous laisse un commentaire par exemple, c’est cette balise qu’il vous faut. Elle permet au visiteur d’entrer du texte sur plusieurs lignes. Cette balise par contre, se referme!

Exemple :
<form action="formulaire.html method="post">
  <textarea name="commentaire">Texte du visiteur</textarea>
</form>
<label>

Le label permet de spécifier un titre au champ voulu. C’est une balise qui doit se refermer, et qui utilise l’identifiant du champ (attribut « id » du champ, et attribut « for » du <label>) pour faire effet (on peut cliquer sur le label, qui aura le même effet que de cliquer sur le champ associé).

Exemple :
<form action="formulaire.html" method="post">
  <label for="nom">Votre nom : </label><input type="text" name="nom" id="nom" placeholder="Entrez votre nom ici" required>
</form>
Conclusion

Voila, vous ne connaissez maintenant un minimum sur les formulaires. Encore une fois, pour traiter les envois de formulaires, on utilisera en règle générale un langage de programmation côté serveur. J’utiliserais moi-même le PHP, je vous conseillerais donc de regarder dans le menu Code <> puis PHP.

CSS 3 – Les classes et les identifiants

Pour styliser une page web, on a le CSS, ça on l’a vu. On a vu dans l’introduction qu’on pouvait styliser les balises HTML. Ce qu’on va voir aujourd’hui c’est l’utilisation des classes CSS, et des identifiants HTML.

Les classes

Une classe CSS commence toujours par un « . ». Elle peut être attachée à une balise précise, ou être complètement détachée des balises pour être un peu plus généraliste.

Nous allons reprendre l’exemple HTML suivant (fichier « index.html »):

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma seconde feuille de styles</title>

    <link rel="stylesheet" type="text/css" href="index.css">
  </head>
  <body>
    <h3>Ma seconde feuille de styles</h3>
    <p>Petit paragraphe d'<span>exemple</span> avec des <span>classes</span>.</p>
  </body>
</html>

Dans notre feuille de styles « index.css » on pourrait mettre des classes. Pour quoi faire ? Simplement pour séparer deux types de contenus distincts, mais utilisant la même balise HTML. Dans le code HTML que je viens de vous fournir, on a deux fois la balise <span>. Si on utilise la feuille de styles de l’introduction, on aurait alors les deux mots « exemple » et « classes » en italique. Je souhaiterais que le premier reste en italique, mais que le second soit en caractères gras.

Nous allons le faire, avec des classes. Comme je l’ai dit précédemment, une classe CSS se définit toujours en commençant par un « . ». Nommons une classe « Italique », et une autre classe « Gras ».

Contenu du fichier « index.css » :

.Italique { font-style: italic; }
.Gras { font-weight: bold; }

Voila mes deux classes de définies. Utilisons-les maintenant dans l’exemple ci-dessus grâce à l’attribut HTML « class ». Puisque nous avons une classe générique, nous pouvons nous en resservir pour un autre élément HTML. Ajoutons donc un paragraphe italique.

Contenu du fichier « index.html » :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma seconde feuille de styles</title>

    <link rel="stylesheet" type="text/css" href="index.css">
  </head>
  <body>
    <h3>Ma seconde feuille de styles</h3>
    <p>Petit paragraphe d'<span class="Italique">exemple</span> avec des <span class="Gras">classes</span>.</p>
    <p class="Italique">Copyrights Zebra's</p>
  </body>
</html>
Les identifiants

Dans les attributs HTML existe l’identifiant définit par « id ». Celui-ci est censé être unique dans le document. Il est toutefois régulièrement utilisé en JavaScript pour identifier facilement un élément HTML précis. Sachez qu’on peut se servir des identifiants HTML au sein d’une feuille de styles.

Page « index.html », modifié avec des identifiants :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma seconde feuille de styles</title>

    <link rel="stylesheet" type="text/css" href="index.css">
  </head>
  <body>
    <h3>Ma seconde feuille de styles</h3>
    <p>Petit paragraphe d'<span id="Italique">exemple</span> avec des <span id="Gras">classes</span>.</p>
    <p id="Copyrights">Copyrights Zebra's</p>
  </body>
</html>

En CSS, pour utiliser un identifiant HTML, il faut précéder son nom par un « # ».

Fichier « index.css », modifié avec les identifiants :

#Italique { font-style: italic; }
#Gras { font-weight: bold; }

#Copyrights { font-style: italic; }

Voila, ouvrez la page HTML avec votre navigateur, nous avons le même résultat que précédemment.

Simplifications

Notre dernier exemple peut être simplifié. Lorsqu’on utilise le même style sur plusieurs éléments HTML, on peut séparer nos identifiants et classes par des « , ».

Fichier « index.css » simplifié (identifiants) :

#Italique, #Copyrights { font-style: italic; }
#Gras { font-weight: bold; }

Les identifiants « Italique » et « Copyrights » auront désormais le même style appliqué, sans réécrire sans cesse la même chose. Plutôt pratique, n’est-ce pas ?

Attribuer une classe à un élément HTML précis

Autre chose que nous pouvons faire, c’est attribuer des classes à des éléments HTML spécifiques. La syntaxe est « élément.class { attributs; }« .

Exemple :
span.Italique, p.Copyrights { font-style: italic; }
span.Gras { font-weight: bold; }

Si on prend ce code CSS et qu’on le met dans notre premier fichier d’exemple, on aura une fois de plus le même résultat, mais écrit différemment.

La magie des CSS

On peut appliquer plusieurs styles différents en fonction de l’élément, de la classe, de son identifiant. On peut très bien utiliser plusieurs classes pour un même élément HTML, en les séparant par des  » « . Mettons tout cela en pratique et faisons quelque chose d’un peu plus poussé.

Fichier « index.html » :
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma seconde feuille de styles</title>

    <link rel="stylesheet" type="text/css" href="index.css">
  </head>
  <body>
    <h3>Ma seconde feuille de styles</h3>
    <p>Petit paragraphe d'<span class="Italique Gras">exemple</span> avec des <span class="Gras">classes</span>.</p>
    <p class="Italique">Copyrights Zebra's</p>
  </body>
</html>
Fichier « index.css » :
.Italique { font-style: italic; }
.Gras { font-weight: bold; }

Cette fois, le résultat est qu’on a le mot « exemple » en gras et italique, le <span> ayant hérité des deux classes CSS, en prenant bien soin de séparer le nom des classes par un espace. On appelle cela la cascade.

Les priorités

Que se passerait il si on utilisait à la fois l’identifiant HTML, la classe CSS, l’attribut HTML « style », du code dans les balises <style>, et tant qu’à faire, qu’on utilise deux classes en même temps ?

Tout est question de priorités. En premier style défini, on a celui du navigateur lui-même. Celui-ci présente déjà des styles prédéfinis par défaut, et ce n’est pas forcément le même d’un navigateur à l’autre. D’où l’importance cruciale de faire un nettoyage en début de feuilles de styles. En second, qui vient écraser les paramètres du navigateur, on a le fichier CSS que l’on a lié au document HTML via la balise <link>. Ensuite viennent les styles définis dans l’entête du document HTML. En dernier lieu, celui qui vient écraser tous les autres et aura sa plus forte priorité est celui de l’attribut « style ». Je n’ai pas parlé des identifiants contre les classes, c’est le dernier lu qui l’emporte.

Pour résumer  : <style> <– <link> <– CSS <– Navigateur.

Conclusion

Pour éviter toute confusion dans les styles, souvenez-vous bien des priorités, commencez par écrire les règles générales, puis les règles plus précises. Evitez de dédoubler les règles, évitez d’utiliser les identifiants le plus possible (réservez-les pour le JavaScript), pensez ) nettoyer les règles des navigateurs en début de feuille de styles, utilisez au plus possible les feuilles de styles externalisées que possible, définissez bien vos éléments, et ensuite vos classes.

CSS 3 – Introduction

Vous souhaitez mettre en couleurs une page web (et pas que) ? Vous êtes alors au bon endroit.

Qu’est ce que CSS ?

CSS signifie « Cascading Style Sheet », soit « Feuille de style en cascade » en français. Avec la magie des feuilles de styles, on peut mettre en forme un document HTML sans soucis.

Si vous ne savez pas comment faire une page web, direction l’introduction HTML dans la partie Code <>.

Mise en place de l’arsenal

Tout bon travailleur possède de bons outils. Il va nous falloir un bon éditeur de code CSS, qui nous mette le code en couleurs. Il en existe plein, cherchez avec un moteur de recherche aux mots clés « IDE CSS », vous en trouverez pléthore. Personnellement j’utiliserais PSPad disponible sur http://www.pspad.com.

Comment ça marche ?

Nous allons prendre l’exemple HTML 5 suivant pour notre première feuille de styles :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma première feuille de styles</title>
  </head>
  <body>
    <h3>Ma première feuille de styles</h3>
    <p>Petit paragraphe d'<span>exemple</span></p>
  </body>
</html>

Nous avons 3 méthodes pour styliser la page :

  1. Utiliser l’attribut « style » des balises HTML
  2. Programmer la feuille de style au sein du document HTML
  3. Lier une feuille de style au document HTML

Nous allons changer la couleur de fond de la page, la couleur des textes, et mettre le mot « exemple » en italique. Je vous montrerais les 3 méthodes utilisable pour styliser notre page.

Méthode #1 : L’attribut « style »
<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma première feuille de styles</title>
  </head>
  <body style="background-color: #dddddd; color: #550000;">
    <h3>Ma première feuille de styles</h3>
    <p style="color: #00aa00;">Petit paragraphe d'<span style="font-style: italic;">exemple</span></p>
  </body>
</html>

Allez-y, copiez ce code HTML dans un fichier (avec l’extension « html » bien sûr), et ouvrez-le. Le fond est devenu grisâtre, le titre dans un bordeaux plutôt foncé, le paragraphe est quant à lui devenu vert, et le mot « exemple » est vert + italique.

C’est une méthode plutôt lourde quand on développe un site web. Il faut tenir compte du poids du fichier que l’on envoie à nos visiteurs, et ce n’est guère pratique.

Notez qu’il y a « héritage » du vert du paragraphe <p> envers son enfant <span>. On parle ici d’héritage des attributs, d’un parent envers un enfant (« parent » et « child » en anglais).

Méthode #2: L’intégration au sein de la page web

Pour ce faire, on va utiliser la balise HTML <style> :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma première feuille de styles</title>
    
    <style type="text/css">
      body
      {
        background-color: #dddddd;
        color: #550000; 
      }
      
      p { color: #00aa00; }
      span { font-style: italic; }
    </style>
  </head>
  <body>
    <h3>Ma première feuille de styles</h3>
    <p>Petit paragraphe d'<span>exemple</span></p>
  </body>
</html>

Voila, c’est exactement la même chose que précédemment, mais j’ai deux petits trucs à dire là-dessus : la première, c’est que c’est plus lisible – on a séparé le style de la mise en forme, la seconde, c’est qu’on a stylisé ici toutes les balises de la même façon. C’est-à-dire que dans notre première méthode, il nous fallait définir l’attribut « style » à chaque paragraphe que l’on écrivait, à chaque <span>, … Désormais, à chaque fois qu’on utilisera le tag <p>, son texte se verra colorisé en vert, chaque <span> sera en italique … Autre petite chose, la balise HTML <style> se met dans l’entête du document, et pas ailleurs.

Vous noterez que dans mes deux exemples il y a un « ; » après chaque attribut. C’est normal. Lorsqu’on a qu’un attribut CSS dans l’attribut HTML « style », on peut se permettre de l’omettre, cependant, je vous conseille de prendre la bonne habitude de le rajouter à chaque fois, ce qui permettra de rajouter un attribut sans perdre de temps lorsque vous utiliserez cette méthode.

Méthode #3: La feuille de style

Avec PSPad, créez un fichier CSS (menu « Fichier », « Nouveau fichier », « CSS », « OK »). Enregistrez-le à côté de votre document html. Chez moi, le document HTML se nomme « index.html », j’ai donc nommé ma feuille de styles « index.css ».

Contenu du fichier « index.css » :

body
{
  background-color: #dddddd;
  color: #550000; 
}

p { color: #00aa00; }
span { font-style: italic; }

Contenu du fichier « index.html » :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8">
    <title>Ma première feuille de styles</title>

    <link rel="stylesheet" type="text/css" href="index.css">    
  </head>
  <body>
    <h3>Ma première feuille de styles</h3>
    <p>Petit paragraphe d'<span>exemple</span></p>
  </body>
</html>

Enregistrez le tout, et chargez votre document HTML dans votre navigateur favori. On a exactement le même résultat. C’est déjà plus élégant non ? On a complètement séparé le contenu de l’apparence graphique. Ca nous permet d’une, de mettre en cache la feuille de style par le navigateur internet du visiteur de la page, de deux de séparer les parties métiers. C’est-à-dire que pour un même contenu, on pourrait imaginer plusieurs designs différent, sans retoucher au contenu. C’est la méthode la plus pratique et la plus couramment utilisée sur le web.

Conclusions

Si vous voulez développer un site web, il vous faudra bien connaître d’une part le langage HTML, et d’autre part les feuilles de styles en cascade. Dans un prochain article, je développerais les possibilité des CSS, je n’ai fait qu’effleurer le sujet pour le moment.