Développement d'applications web : séance 2

Principe de PHP

La figure ci-dessous montre le principe de fonctionnement des scripts PHP.

Le client (navigateur) envoie une requête au serveur web (apache) afin de récupérer le contenu d’une URL avec l’extension .php.
Comme l’extension de l’URL est .php, le serveur exécute un interpréteur PHP en lui passant en paramètre le fichier .php correspondant à l’URL.
L’interpréteur exécute le code PHP et renvoie au serveur tout ce que ce dernier affiche. En principe, ces affichages forment le code HTML d’une page HTML mais on peut également afficher du JSON ou n’importe quel autre format.
Enfin, le serveur renvoie au client tous les affichages renvoyés par l’interpréteur. S’il s’agit de code HTML, le client (navigateur) l’affiche comme s’il s’agissait d’une page HTML classique.

Premiers pas en PHP

Comme vous le verrez, PHP n’est pas très différent de C ou de Python. Quand on maîtrise ces deux langages, on peut apprendre PHP très rapidement.

Les scripts PHP :

Les fichiers PHP sont appelés scripts PHP. Voici un script basique (les commentaires sont comme en C) :

script.php

<?php // balise de début de script PHP

// les expressions se terminent par des ;
// echo sert à faire les affichages
echo "hello\n";

// fin de script (optionnel):
?>

Suivant l’installation que vous avez faites de PHP, l’interpréteur peut être appelé à la ligne de commande :

php script.php

Ici, l’exécution de la commande ci-dessus affichera « hello ».

La balise <?php est obligatoire pour débuter le script. La balise de fin ?> est optionnelle et souvent omise.

Des scripts à l'intérieur de balises HTML :

On peut entrelacer du code PHP avec du code HTML dans un même fichier PHP, ce qui justifie l’utilisation des balises <?php et ?> :

script2.php

<html>
<header></header>
<body>
<h1>script PHP à l'intérieur d'une page html</h1>

<?php
echo "hello\n";
?>

<p>fin de la page web.</p>
</body>
</html>

Exercice 1 : La CLI des champs

Écrivez un script PHP qui fait quelques affichages (à vous de choisir ce que vous souhaitez afficher). Exécutez ce script via votre interpréteur PHP à la ligne de commande (CLI). A priori, sous Windows, la commande php.exe devrait être reconnue. Sous macOS ou Linux, la commande s’appelle plutôt php.

Les variables et leurs valeurs

Déclarer/utiliser des variables

Comme en Python, pour créer une variable en PHP, on ne déclare pas son type, on se contente de lui affecter une valeur. Celle-ci détermine son type, que l’on peut changer dynamiquement par la suite.

Règle

Toutes les variables sont préfixées par le signe « $ ».

Ainsi, la ligne 4 du script ci-dessous crée une nouvelle variable $x dont la valeur est la chaîne de caractères toto\n. Pour accéder à la valeur d’une variable, on utilise son nom sans mettre de signe =. Par exemple, la ligne 7 accède à la valeur de $x. C’est comme si on avait écrit echo "toto\n".

Rappel: l’instruction echo permet de faire des affichages. Sur la ligne 10, on affiche une chaîne avec les valeurs de $x et $y. Les contenus des chaînes de caractères entre guillemets sont interprétés. Ici, les accolades ne servent à rien. En revanche, elles sont utiles pour des expressions plus complexes comme le contenu d’une cellule d’un tableau ({$tab[0]}).

Comme en Python, si une variable contient une chaîne de caractères, on peut très bien lui affecter par la suite un entier (typage dynamique). C’est ce que fait la ligne 9.

var1.php

<?php

// déclarer une variable
$x = "toto\n";
$y = 3;

echo $x;
echo $y;
$x = 3 * sqrt(4);
echo "\nnouvel affichage: $x {$y}";

?>

toto
3
nouvel affichage: 6 3

Précisions sur des types standards des variables

Les chaînes de caractères :

Les chaînes entre guillemets sont interprétées, celles entre quotes ne le sont pas. L’opérateur de concaténation est le « . ».

var2.php

<?php
$x = 3;

// chaînes de caractères interprétées (entre guillemets) :
$y = "toto $x\n";
// chaînes non interprétées (entre quotes) :
$z = 'toto $x\n';

echo $y;
echo $z;
echo $x . $x; // '.' => concaténation de chaînes de caractères
?>

toto 3
toto $x\n33

Les nombres et les booléens :

PHP fait la différence entre un entier et un nombre réel.

number.php

<?php
$x = 3;     // ceci est un entier
$y = 4.65;  // ceci est un flottant
$z = true;  // ceci n'est pas une pipe

echo is_int($x);
echo "==============\n";
echo is_int($y);
echo "#####\n";
echo is_float($y);
?>

Le code ci-dessus produira l’affichage suivant :

1==============
#####
1

Attention

Les fonctions booléennes comme is_int() affichent 1 pour true et rien pour false (cf. is_int($x) et is_int($y) ci-dessus). Pour débugger, il est plus sûr d’utiliser echo (int) is_int($y) qui affichera 0 ou 1.

Les tableaux

Les tableaux se définissent et s’utilisent comme les list en Python. Il est déconseillé d’utiliser le mot-clef array, qui est obsolète (versions de PHP < 5.4).

array.php

<?php
// création de tableaux indexés par des nombres ou des clefs :
$tab1 = ['x', 'y'];                   // syntaxe depuis PHP 5.4
$tab2 = [3 => 'val1', 7 => 'val2'];

$tab3 = array ('x', 'y');             // syntaxe obsolète
$tab4 = array ('key1' => 'val1', 'key2' => 'val2');

// ajout/modification d'éléments :
$tab1[4] = 'z';
$tab1[] = 't'; // ajoute à la fin du tableau (équivalent à tab1[5] = 'z')

// accès aux éléments
echo $tab1[0] . ' ' . $tab4['key2'] . "\n";

// affichage du contenu de tout le tableau. Pratique pour débugguer
print_r($tab1);
?>

x val2
Array
(
    [0] => x
    [1] => y
    [4] => z
    [5] => t
)

Exercice 2 : Enregistrement...

En PHP, stockez les informations sur une personne (nom, prénom, âge, taille) dans un tableau indexé par des clefs puis affichez ces caractéristiques sous la forme suivante :

xxx yyy, dont l'âge est zzz, mesure ttt mètres.

où xxx et yyy sont, respectivement, le prénom et le nom de la personne, zzz est son âge, et ttt sa taille.

Affichez trois fois la phrase ci-dessus. Testez à la ligne de commande.

Les constantes

Les constantes se distinguent des variables par le fait qu’elles ne sont pas préfixées par le signe $ et, qu’en général (mais ce n’est pas obligatoire), elles sont en majuscules. Le code ci-dessous vous montre comment en créer. Leur utilisation est identique à celui des variables.

number.php

<?php
// déclarer une constante :
define ("MYCONST", "toto\n"); // l'ancienne manière (obsolète)
const CST2 = 3.4;             // la nouvelle manière

// utiliser une constante (pas de dollar) :
echo MYCONST;
echo CST2;
?>

Déclarer / appeler des fonctions

La syntaxe pour déclarer une fonction est similaire à Javascript et aux autres langages que vous connaissez.

function.php

<?php
// déclarer une fonction :
function f() {
    echo "toto\n";
}

function g($x, $y=4) { // 4 = valeur par défaut de $y
    return $x + $y;
}

// appeler une fonction :
f();
echo g(3,2) . "\n";
echo g(3);  // équivalent à echo g(3,4)
?>

Là où l’on a des différences par rapport aux autres langages, c’est dans la portée des variables.

La portée des variables

Comme dans la plupart des langages, les variables peuvent être globales, locales ou statiques.

On peut donc écrire avec confiance le code suivant :

scope1.php

<?php
// ici, scope = global :
$x = 4;

function f($y) {
    echo ($x + $y) . "\n";
}
f(2);
?>

qui devrait nous afficher la valeur 6… Mais voici ce qu’elle produit :

PHP Warning:  Undefined variable $x in scope1.php on line 8
2

Règle

En PHP, les variables globales ne sont pas visibles par défaut à l’intérieur des fonctions. Pour que ce soit le cas, il faut les déclarer comme globales à l’intérieur des fonctions.

scope2.php

<?php
// ici, scope = global :
$x = 4;
$z = 6;

function f($y) {
    // pour accéder à x ou z, qui ne sont pas définis dans la fonction :
    // soit utiliser $GLOBALS['x']  // lourd. à éviter
    // soit déclarer global $z;     // à préférer
    global $z;

    echo ($GLOBALS['x'] + $y) . "\n"; // $GLOBALS : tableau des variables globales
    echo ($z + $y) . "\n";
}
f(2);
?>

Attention : Si vous affectez une valeur à une variable à l’intérieur d’une fonction sans la déclarer global, vous créez une nouvelle variable locale. De plus, sa portée est limitée à l’intérieur de la fonction, et non pas aux blocs {} : la ligne $x = 6 ne crée pas une nouvelle variable.

scope3.php

<?php
$x = 4;  // variable globale
function f() {
    $x = 5; // variable locale à la fonction, différente de la variable globale
    {
        $x = 6; // même variable qu'au-dessus
    }
    echo $x . "\n";
}
f();
echo $x;
?>

6
4

Exercice 3 : C'est fonctionnel

Écrivez un script PHP qui déclare et initialise deux variables globales entières $x et $y et qui définit les fonctions suivantes :

une fonction f() ne prenant aucun paramètre qui incrémente $x et se termine sans rien retourner.
une fonction g($x) qui prend un paramètre $x (dont on suppose que c’est un entier), qui ajoute à $x la valeur de la variable globale $y et retourne la valeur ainsi calculée.
une fonction h($x, $y) dont les valeurs par défaut de ses paramètres sont respectivement 3 et 4. La fonction appelle d’abord la fonction g en lui passant le premier paramètre de h, puis la rappelle en lui passant le deuxième paramètre de h et, enfin, renvoie la somme des valeurs retournées par les appels à la fonction g.

Testez ces différentes fonctions et affichez les valeurs de $x et $y. Pour cela, vous pourrez avantageusement utiliser PHP à la ligne de commande. Vérifiez que ces valeurs correspondent à ce à quoi vous vous attendiez.

Les boucles et alternatives

PHP supporte les mêmes boucles et alternatives que celles que vous connaissez en C.

commeC.php

<?php

for ($i = 0; $i < 10; $i++) {
    if ($i % 2 == 0)
        echo "$i est pair\n";
    else
        echo "$i est impair\n";
}

?>

est pair
est impair
est pair
est impair
est pair
est impair
est pair
est impair
est pair
est impair

Il existe toutefois quelques différences avec le C.

Une boucle range-for :

PHP possède une boucle permettant d’itérer les éléments de collections : la boucle foreach.

boucles.php

<?php
$tab = ['x', 'y', 'z'];

// boucle pour itérer sur les éléments de $tab :
foreach ($tab as $val) {
    echo "$val  ";
}
echo "\n";

// si on a besoin des clefs en plus de la valeur des cellules :
foreach ($tab as $key => $val) {
    echo "$key = $val  ";
}
echo "\n";

// boucle à la C (pas forcément très utile en PHP) :
for ($i = 0; $i < count($tab); $i++) { echo "${tab[$i]}  "; }
?>

x  y  z
0 = x  1 = y  2 = z
x  y  z

L'instruction elseif :

En plus des if/else ou des switch, PHP supporte l’instruction elseif.

ifelse.php

<?php
$x = 3;

// if then else :
if ( $x == 4 )
    echo "x vaut 4\n";
elseif ($x == 3)
    echo "x vaut 3\n";
else
    echo "x est différent\n";

switch ($x) {  // switch : similaire au langage C
    case 3:
        echo "x = 3\n"; break;
    default:
        echo "x != 3\n";
}
?>

x vaut 3
x = 3

Exercice 4 : La boucle des lapins

Écrivez un script PHP qui, à l’aide d’une boucle for, affiche les 10 premiers nombres de la suite de Fibonacci.

Exercice 5 : Ackermann

Le fonction d’Ackermann est un classique en informatique, cf. la page wikipedia :

https://fr.wikipedia.org/wiki/Fonction_d%27Ackermann

Écrivez un script PHP qui permet de calculer Ack(3,4), qui vaut 125 si votre programme est correct.

Les importations

Dans vos programmes, vous avez été amené(e) à importer du code d’autres programmes. Par exemple, en Java, vous avez fait des import, en C des #include. En PHP, vous avez 4 possibilités pour réaliser de telles importations :

import : importe le fichier comme le ferait un #include. Si celui-ci n’existe pas, un warning est émis mais le programme continue à s’exécuter. Notez que, lorsqu’on importe un fichier, on exécute toutes les instructions qu’il contient.
import_once : c’est comme un import à ceci près que, si on demande à importer plusieurs fois le même fichier, il ne le sera en réalité qu’une seule fois. Par exemple, un fichier a.php peut faire un import_once de deux fichiers b.php et c.php, et le fichier b.php peut lui-même faire un import_once de c.php. Ainsi, on a deux directives d’import du fichier c.php mais, comme on a fait des import_once plutôt que des import, c.php ne sera importé qu’une seule fois. En C, ce mécanisme est assuré par le fait que, quand on inclut des headers, ceux-ci débutent par des #ifndef XXX #define XXX.
require : c’est comme l’instruction import à ceci près que, si le fichier que l’on souhaite importer n’existe pas, cela fait « planter » le script PHP.
require_once : c’est comme un require mais avec la garantie que l’on importera le fichier qu’une seule fois.

Vous disposez de 4 possibilités pour importer du code d’autres programmes en PHP :

import : importe le fichier comme le ferait un #include en C. Il émet un warning si le fichier n’existe pas, mais le programme continue son exécution. Notez que, lorsqu’on importe un fichier, on exécute toutes les instructions qu’il contient.
import_once : garantit que le fichier ne sera effectivement importé qu’une seule fois, même si on exécute plusieurs import_once de ce fichier. En C, cette propriété est assurée par le fait que, quand on inclut des fichiers .h, ceux-ci débutent par des #ifndef XXX #define XXX.
require : similaire à import mais fait « planter » le script (erreur fatale) si le fichier est introuvable.
require_once : combine require et l’importation unique (once).

Règle

Je vous suggère de toujours utiliser require_once. En effet, si vous essayez d’importer des fichiers qui n’existent pas, cela arrêtera tout de suite votre script, ce qui sera plus simple pour débugger. Pourquoi le fichier n’existerait-il pas me direz-vous ? Souvent, c’est parce que l’on se trompe dans son chemin d’accès. Le _once est également utile pour éviter que certaines variables (par exemple, des handlers sur des bases de données) ne soient créées plusieurs fois.

Voici un exemple :

myscript.php

<?php
echo "je suis dans myscript\n";
?>

import.php

<?php
// importation d'un script php dans un autre :
// require_once : importe exactement 1 fois
require_once 'myscript.php';
echo "fin\n";
require_once 'myscript.php';
?>

je suis dans myscript
fin

Quelques astuces

La Documentation de PHP est très bien faite, n’hésitez pas à l’utiliser :

https://www.php.net/manual/fr/funcref.php

Pour des raisons de sécurité, PHP ne montre pas par défaut les erreurs et warnings de votre code, ce qui n’est pas pratique lorsque l’on débuggue. Voici comment faire pour les visualiser. Il faut rajouter dans vos scripts les instructions suivantes :

ini_set('display_errors', 'On');
error_reporting(E_ALL);