Cours sur la programmation PHP

Dans ce cours, nous passons en revue les éléments syntaxiques de PHP en parallèle avec le langage de description vu en cours d'algorithmique (variables, types, structures de contrôle, procédures et fonctions, etc.).

Puis nous nous intéressons à l'utilisation de PHP pour le web (production de code HTML, exploitation d'une base de données, etc.).

Instructions, expressions, variables et types PHP

Programmes, blocs d'instructions et instructions

Un programme PHP est encadré par les symboles <?php et ?>, avant et après peuvent se trouver des contenus textuels ou HTML. Un processeur aura la charge d'exécuter le code PHP et de le remplacer par le résultat de l'exécution. Dans le cas d'une application web, cette tâche incombera au serveur web.

En PHP, les blocs d'instructions sont délimités par des accolades : { est l'équivalent d'un Début, } d'une Fin.

Chaque instruction est impérativement suivie d'un point-virgule (;).

Types des variables

Même si aucune déclaration des variables et de leurs types n'est nécessaire, il existe en PHP trois types de données : les types scalaires, les tableaux classiques et les tableaux associatifs.

Les types scalaires regroupent les types de base : entiers, réels, caractères et chaîne de caractères, etc.

Variables, constantes, assignation

En PHP, toutes les variables commencent par le signe $.

Deux symboles à distinguer très vite :

symbole = pour l'affectation ;
symbole == pour le test d'égalité.

On pourra donc écrire :

$x = 2;
$y = 3.14;
$z = 'toto';

Comme son nom l'indique, une constante une fois définie ne changera plus de valeur. Elles sont donc bien distinguées des variables : elles ne commencent pas par le signe $ et sont définies à l'aide la fonction define.

define('NOM','toto');

Opérateurs

Nous disposons en PHP des opérateurs arithmétiques classiques : +, -, *, / et de l'opérateur de concaténation entre chaînes de caractères noté par un point.

$i = 10;
$i = $i + 1;
$i = $i + 9;
$texte = 'La variable i vaut '.$i;
$texte = $texte."\n";

Remarquez ici que PHP n'a pas de contrôle fort sur les types de variables : une même variable peut subir une opération arithmétique puis une opération propre aux chaînes de caractères sans provoquer d'erreur. Au final, la variable $texte contient donc La variable i vaut 20\n.

Il existe d'autres manières souvent pratiques d'exprimer ces opérations. Par exemple, les opérations ci-dessus sont strictement équivalentes à :

$i = 10;
$i++;
$i += 9;
$texte  = 'La variable i vaut '.$i;
$texte .= "\n";

Opérateurs booléens : ==, !=, >=, <=, &&, ||, !, etc.

Instruction de sortie et chaînes de caractères

L'affichage est réalisé à l'aide l'instruction echo. Cette instruction est particulièrement importante : c'est elle qui va produire le texte et les balises HTML du document final.

En PHP, les chaînes de caractères sont délimitées soit par des apostrophes, soit par des guillemets. Dans le premier cas, le contenu de la chaîne n'est pas interprété par PHP, dans le second une variable apparaissant dans la chaîne est remplacée par sa valeur.

$t = 'coucou';
$v = 5;
echo '$v fois $t\n';
echo "$v fois $t\n";

Dans ce cas, le premier affichage produira $v fois $t\n, le second lui affichera 5 fois coucou avec un passage à la ligne ensuite (codé par \n).

Fonctions et procédures en PHP

Définition

function nom_de_la_fonction (paramètres) {
  // des instructions ici
}

function EntetePage ($titre,$fond) {
  echo "<HTML>\n";
  echo "<HEAD>\n";
  echo "<TITLE>$titre</TITLE>\n";
  echo "</HEAD>\n";
  echo "<BODY BGCOLOR=\"$fond\">\n";
  echo "<H1>$titre</H1>\n";
}

function EntetePage ($titre,$fond='pink') {
  // corps de la fonction ici
}

Notons qu'en PHP les paramètres sont passés par valeur, c'est-à-dire que les procédures travaillent sur une copie des objets passés en paramètres. Si les objets donnés à une procédure sont susceptibles d'être modifiés et si nous souhaitons que ces modifications soient visibles de l'extérieur de la procédure, le passage doit se faire par référence, avec la syntaxe suivante :

function EntetePage (&$titre) { // notez le symbole &
  // corps de la fonction ici, qui peut modifier le titre
}

Utilisation

Entetepage('Ma première page','blue');

Entetepage($titre_page,$couleur_de_fond);

Entetepage($titre_page);

Bibliothèque de fonctions

Une manière élégante de programmer consiste à rassembler dans un même fichier PHP toutes les fonctions d'usage courant. Les différentes pages PHP peuvent ensuite utiliser ces fonctions en faisant appel à la bibliothèque de fonctions en utilisant la fonction require.

Ainsi, si l'on imagine que la fonction Entetepage se trouve dans un fichier nommé bibli.php, on pourra écrire dans un nouveau fichier :

require('bibli.php');
Entetepage('Ma première utilisation de bibliothèque');

Cet exemple illustre un moyen d'utiliser PHP pour maintenir la charte graphique d'un site.

Structures de contrôle en PHP

Modulo les conventions PHP, on retrouve les structures de contrôle classiques. Le si alors sinon :

if (une condition ici) {
  // des instructions ici
} else {
  // des instructions ici
}

La boucle tant que :

while (une condition ici) {
  // des instructions ici
}

Et la boucle pour :

for ($i=0 ; $i<10 ; $i++) {
  // des instructions ici
}

Un dernier type de boucle existe en PHP mais est dédié au parcours de tableaux.

Structures de données PHP : les tableaux

Deux types de tableaux :

les tableaux classiques : pas de contrainte sur le contenu des cases, celles-ci sont numérotées à partir de 0 ;
les tableaux associatifs dont la particularité est que les cases ne sont plus indicées par un numéro mais par un texte.

Manipulation des tableaux PHP

Tout d'abord l'affectation de valeurs aux cases des tableaux.

// définition d'un tableau vide et remplissage des cases
$t    = array();
$t[0] = 3.14;
$t[1] = 'coucou';
$t[]  = 10;

// syntaxe équivalente
$t = array(3.14,'coucou',10);

Cette dernière notation permet d'insérer une valeur dans la première case disponible (ici, la troisième) sans pour autant connaître la taille du tableau. À noter que cette taille peut être obtenue par la fonction sizeof.

Enfin, pour définir les tableaux associatifs, nous disposons de deux syntaxes :

$fiche1 = array();
$fiche1['prenom'] = 'Fabien';
$fiche1['nom']    = 'Torre';
$fiche1['mail']   = 'torre@univ.fr';
$fiche1['url']    = 'http://www.univ.fr/~toto/';
echo 'Mail de '.$fiche1['prenom'].' : '.$fiche1['mail'];

$fiche2 = array(
     'prenom' => 'Fabien',
     'nom'    => 'Torre',
     'mail'   => 'torre@univ.fr',
     'url'    => 'http://www.univ.fr/~toto/',
);
echo 'Mail de '.$fiche2['prenom'].' : '.$fiche2['mail'];

Parcours de tableaux PHP : la boucle foreach

Enfin, la boucle foreach est dédiée au parcours de tableaux, simples ou associatifs :

foreach ($tab as $val) {
  // des instructions ici portant sur $val
}

foreach ($tab as $clef => $val) {
  // des instructions ici portant sur $clef et $val
}

PHP et le web dynamique

Principes

La particularité des programmes PHP est qu'ils peuvent se trouver dans une page web, au milieu du code HTML : lorsque une telle page est demandée au serveur, celui-ci exécute le programme PHP qui s'y trouve et fournit le résultat.

Cela amène de nouvelles contraintes :

une telle page devra avoir l'extension .php pour indiquer au serveur qu'il y a du code à interpréter à l'intérieur ;
il faudra impérativement disposer d'un serveur web pour visualiser les pages PHP.

Du côté utilisateur par contre, le processus est totalement transparent : celui-ci ne recevra pas le code PHP mais un simple code HTML dont il ne pourra déterminer s'il a été écrit à la main ou généré par un programme.

Pour réaliser cette intégration on utilise une nouvelle balise pour signaler les blocs de code PHP. Le schéma général sera le suivant.

avant : du code HTML
<?php
  ici du code PHP !
  ici du code PHP !
  ici du code PHP !
?>
après : du code HTML

Transmission de paramètres

On regarde ici comment faire passer des valeurs à un script PHP.

URL

Une première méthode consiste à faire passer ces valeurs sur dans l'adresse du script PHP. Par exemple, on pourra écrire :

http://www.grappa.univ-lille3.fr/~torre/guide.php?id=coursphp

Dans guide.php, on disposera alors d'une variable $id qui contiendra ici la valeur coursphp. Il est possible de faire passer plusieurs valeurs en les séparant par le signe & :

http://www.grappa.univ-lille3.fr/~torre/guide.php?id=coursphp&lang=fr

Formulaires HTML

Cette fois les valeurs nous sont fournies par un utilisateur à travers un formulaire donc l'ACTION pointe sur un script PHP et la METHOD indique la valeur POST.

Ce script PHP pourra utiliser les valeurs venant du formulaire à travers des variables dont les noms correpondront aux NAME indiqués dans le formulaire.

Pour une question autorisant les réponses multiples, le NAME devra se terminer par des [], ce qui permettra dans le script PHP de manipuler une variable de type tableau.

PHP et les bases de données (MySQL)

Avertissement

Dans la suite, je ne présente qu'un échantillon minimal de fonctions PHP, échantillon qui doit déjà permettre à un programmeur débutant de dialoguer avec une base de données.

Dans la même idée, je ne fournis que l'utilisation la plus simple de ces fonctions. En particulier, je ne teste pas la réussite de chaque transaction avec la base.

Connexion

La connexion se fait en deux étapes : d'abord se connecter au serveur, puis à la base de données elle-même.

La première est réalisée par la fonction mysql_connect : on lui fournit le nom du serveur, notre nom d'utilisateur et le mot de passe correspondant. En retour, on reçoit un identifiant à utiliser ensuite à chaque échange avec la base.

La connexion à la base se fait elle grâce à la fonction mysql_select_db en lui passant le nom de la base de données et l'identifiant de connexion préalablement obtenu.

Ainsi, si l'on utilise EasyPHP, on écrira :

$connexion = mysql_connect('localhost','root','');
mysql_select_db('mabase',$connexion);

Par contre, chez Free, on utilisera les lignes suivantes (là, le nom d'utilisateur et le nom de la base sont les mêmes) :

$connexion = mysql_connect('sql.free.fr','fabien.torre','monmotdepasse');
mysql_select_db('fabien.torre',$connexion)

Déconnexion

Le déconnexion de la base se fait simplement avec la fonction mysql_close en indiquant l'identifiant de connexion :

mysql_close($connexion);

En pratique, il est possible d'oublier cette instruction sans conséquence grave : la connexion est automatiquement fermée avec la fin du script PHP.

Naturellement, l'intérêt de se connecter à une base de données n'est pas de se déconnecter aussi tôt... Voyons donc maintenant comment passer des requêtes à la base.

Exécution d'un INSERT

La requête la plus simple à réaliser est un INSERT, car nous n'attendons pas de valeur en retour. Il s'agit donc simplement de rédiger notre requête et de l'envoyer à la base. La foncion mysql_query est dédiée à cette transmission.

L'exemple suivant doit donc provoquer l'apparition d'une nouvelle ligne dans la table films de notre base :

$requete = "INSERT INTO films VALUES (1,'Rocky',1976)";
mysql_query($requete,$connexion);

Bien sûr, l'objectif n'est pas d'écrire de telles requêtes mais plutôt d'imaginer un schéma général dans lequel des informations extérieures viendront s'inscrire, comme par exemple :

$requete = "INSERT INTO films VALUES (2,'$titre',$annee)";
mysql_query($requete,$connexion);

Dans le cas où l'on a récupéré non pas une valeur mais un tableau de valeurs (en provenance d'un formulaire avec une question à choix multiple par exemple) , il conviendra d'écrire une boucle parcourant ce tableau et effectuant un INSERT pour chacune des cases :

for ($i=1 ; $i<=sizeof($acteurs) ; $i++) {
   $requete = "INSERT INTO jouedans VALUES ($acteurs[$i],$idfilm)";
   mysql_query($requete,$connexion);
}

cela peut aussi se faire avec un foreach au lieu d'un for :

foreach ($acteurs as $idacteur) {
   $requete = "INSERT INTO jouedans VALUES ($idacteur,$idfilm)";
   mysql_query($requete,$connexion);
}

Exécution d'un SELECT

L'écriture et la transmission d'une telle requête va se dérouler comme INSERT, la différence survenant lors de son exécution : une table intermédiaire est créée dans la base de données et un pointeur sur celle-ci nous est fourni pour récupérer ensuite les réponses.

$requete  = "SELECT * FROM films WHERE id=1";
$resultat = mysql_query($requete,$connexion);

Ici, nous venons d'exécuter une requête sur une table en précisant la valeur de sa clef primaire, nous n'aurons qu'une réponse dans notre table résultat.

Pour récupérer cette réponse, nous utilisons la fonctions mysql_fetch_array : à partir d'un pointeur vers une table intermédiaire, son rôle est de nous fournir une ligne de cette table sous forme de tableaux associatifs, les clefs du tableau correspondant aux noms de champs dans la base.

Ainsi, notre exemple complété pourra s'écrire :

$requete  = "SELECT * FROM films WHERE id=1";
$resultat = mysql_query($requete,$connexion);
$film     = mysql_fetch_array($resultat);
echo '<B>'.$film['titre'].'</B> ';
echo '('.$film['annee'].')';
echo "<BR>\n";

Considérons maintenant une requête amenant plusieurs réponses. Nous allons réaliser une boucle sur la table résultat, chaque passage dans la boucle traitant une ligne de la table résultat, toujours récupérée par la fonction mysql_fetch_array.

$requete  = "SELECT * FROM films";
$resultat = mysql_query($requete,$connexion);
echo "<UL>\n";
while ($film = mysql_fetch_array($resultat)) {
  echo '<LI><EM>'.$film['titre'].'</EM> ';
  echo '('.$film['annee'].')';
  echo "</LI>\n";
}
echo "</UL>\n";

Remarquons que si la requête n'a pas de réponse, une liste vide est produite. La fonction mysql_num_rows permet de connaître le nombre de réponses et d'agir en conséquence :

$requete  = "SELECT * FROM films";
$resultat = mysql_query($requete,$connexion);
$nb_films = mysql_num_rows($resultat);
if ($nb_films == 0) {
  echo "Il n'y a pas de film dans la base !";
} else {
  echo "<UL>\n";
  while ($film = mysql_fetch_array($resultat)) {
    echo '<LI><EM>'.$film['titre'].'</EM> ';
    echo '('.$film['annee'].')';
    echo "</LI>\n";
  }
  echo "</UL>\n";
}

Enfin, intéressons nous à un dernier cas, plus simple que les précédents, les cas où la requête ne ramène non seulement qu'une réponse mais où en plus cette réponse n'est constituée que d'une valeur. Dans ce cas, l'utilisation de la fonction mysql_fetch_array est exagérée et on lui préférera la fonction mysql_result à qui l'on fournit le pointeur sur la table résultat ainsi que la case à extraire repérée par son numéro de ligne et son numéro de colonne.

$requete  = "SELECT titre,annee FROM films WHERE id=12";
$resultat = mysql_query($requete,$connexion);
$titre    = mysql_result($resultat,0,0);
$annee    = mysql_result($resultat,0,1);

Récupérer un identifiant qui vient d'être auto-incrémenté

Imaginons que l'on vienne d'insérer une ligne dans une table sans préciser l'identifiant, celui-ci étant auto-incrémenté et que l'on ait besoin d'utiliser immédiatement cet identifiant.

La première solution qui vient à l'esprit est de récupérer l'identifiant ayant la plus grande valeur :

$requete = "INSERT INTO films VALUES ('','Rocky',1976)";
mysql_query($requete,$connexion);

$requete     = "SELECT MAX(id) FROM films";
$resultat    = mysql_query($requete,$connexion);
$identifiant = mysql_result($resultat,0,0);

echo "Le film que vous venez d'insérer a le numéro $identifiant.\n";

Cette méthode est risquée : par exemple, il peut survenir qu'un autre utilisateur exécutant le même script provoque un INSERT après le notre mais avant notre SELECT ; dans le cas, la valeur ramenée par MAX ne correspondra pas à notre insertion. Il est donc préférable de recourir à la fonction mysql_insert_id comme suit :

$requete = "INSERT INTO films VALUES ('','Rocky',1976)";
mysql_query($requete,$connexion);

$identifiant = mysql_insert_id();

echo "Le film que vous venez d'insérer a le numéro $identifiant.\n";

site de Fabien Torre

Notes de cours sur le langage PHP