TCH056 - Programmation Web
<Chapitre 05> Générer des pages dynamiquement côté serveur
Anis Boubaker, Ph.D.
Prof. Enseignant en informatique
Plan du chapitre
Introduction au Modèle Client/Serveur
Le modèle client/serveur est une architecture distribuée où les tâches et les charges de travail sont réparties entre les fournisseurs de ressources ou de services, appelés serveurs, et les demandeurs de service, appelés clients.
Rôle du Client
Le client est généralement un navigateur web qui envoie des requêtes au serveur et affiche les ressources reçues, comme les pages web.
- Envoie des requêtes HTTP au serveur
- Interprète les réponses du serveur (généralement des documents HTML, CSS, JavaScript)
- Peut demander des ressources statiques ou dynamiques
Rôle du Serveur
Le serveur traite les requêtes des clients et renvoie les réponses appropriées. Il peut s'agir de fichiers statiques, de documents générés dynamiquement, ou d'autres types de ressources.
- Traite les requêtes HTTP reçues
- Envoie des réponses aux clients
- Gère les ressources statiques et dynamiques
- Peut inclure des bases de données, des applications serveur, etc.
Architecture n-tiers
Communication via HTTP
HTTP (Hypertext Transfer Protocol) est le protocole utilisé pour la communication entre clients et serveurs dans le web.
- Protocole de communication client-serveur
- Utilise des méthodes telles que GET, POST, PUT, DELETE pour les requêtes
- Échange des données sous divers formats (HTML, JSON, XML, etc.)
- Les états de réponse (200 OK, 404 Not Found, etc.) indiquent le résultat des requêtes
Exemple de Communication HTTP
// Requête HTTP du client
GET /index.html HTTP/1.1
Host: www.exemple.com
// Réponse HTTP du serveur
HTTP/1.1 200 OK
Content-Type: text/html
<html>...</html>
Cet exemple montre une requête HTTP simple pour une page web et la réponse du serveur.
Introduction au Cycle de Vie d'une Requête HTTP
Le cycle de vie d'une requête HTTP décrit le processus complet depuis l'envoi d'une requête par un client jusqu'à la réception et l'affichage de la réponse.
Source: medium.com
Envoi de la Requête par le Client
Le processus commence lorsque le client (navigateur) envoie une requête HTTP au serveur. Cette requête peut être déclenchée par l'utilisateur en chargeant une page web, en soumettant un formulaire, etc.
GET /page.php HTTP/1.1
Host: www.exemple.com
Traitement par le Serveur (PHP)
Le serveur reçoit la requête et la traite. Si la requête demande une ressource PHP, le serveur exécute le script PHP correspondant.
<html lang="fr">
<head>...</head>
<body>
<?php
// Traitement PHP
echo "<h1>Bonjour, monde!</h1>";
?>
</body></html>
Ce script PHP pourrait générer du contenu dynamique en fonction de la requête (interrogation de la BD).
Réponse du Serveur
Après avoir traité la requête, le serveur envoie une réponse au client. Cette réponse inclut généralement un en-tête HTTP et un corps de message, qui peut être le HTML généré par le script PHP.
HTTP/1.1 200 OK
Content-Type: text/html
<html lang="fr">
<head>...</head>
<body>
<h1>Bonjour, monde!</h1>
</body></html>
Affichage sur le Client
Une fois la réponse reçue, le navigateur client l'interprète et affiche le contenu. Si la réponse est du HTML, le navigateur rend la page pour l'utilisateur.
Plan du chapitre
Introduction au PHP
PHP est un langage de script côté serveur utilisé pour développer des sites web dynamiques.
Structure d'un script PHP
<?php //Début d'un script PHP
/*
* Votre code PHP ici
*/
?> //Fin d'un script PHP
Entrelacement PHP/HTML
<html>
...
<p>
<?php
for($i=0; $i<10; $i++){
echo "Bonjour le monde ".$i." fois!<br />";
}
?>
</p>
<p>
<?= 'Ceci aussi est interprété en PHP'?>
</p>
</html>
Variables en PHP
<?php
$variable = "Hello, World!";
echo $variable;
?>
Les variables en PHP commencent par le signe $.
Typage dynamique
Comme en Javascript, les variables en PHP sont typées dynamiquement.
Types de données en PHP
- Entiers (integer)
- Flottants (double)
- Chaînes de caractères (string)
- Booléens (boolean)
- Tableaux (array)
- Objets (object)
Opérateurs en PHP
- Arithmétiques: +, -, *, /, %
- Comparaison: ==, !=, <, >, <=, >=
- Logiques: &&, ||, !
Structures de contrôle en PHP
<?php
// Structure if
if ($a > $b) {
echo "a est plus grand que b";
}
// Boucle for
for ($i = 0; $i < 10; $i++) {
echo $i;
}
// Boucle while
$i = 0;
while ($i < 10) {
echo $i;
$i++;
}
?>
Exercice 1: Générateur de Tableaux
Écrivez un script PHP qui génère un tableau HTML de 10x10 cellules, avec des numéros de 1 à 100. Coloriez les cellules en alternance pour créer un effet damier.
Introduction aux Fonctions en PHP
Les fonctions en PHP sont des blocs de code réutilisables conçus pour effectuer une tâche spécifique.
Déclaration d'une Fonction
Une fonction est déclarée avec le mot-clé
function suivi du nom de la fonction et des
parenthèses.
<?php
function saluer() {
echo "Bonjour, monde!";
}
?>
Cette fonction nommée saluer affiche un message.
Utilisation d'une Fonction
Une fonction est appelée en utilisant son nom suivi de parenthèses.
<?php
saluer(); // Affiche "Bonjour, monde!"
?>
Cet exemple montre comment appeler la fonction saluer.
Fonctions avec Paramètres
Les fonctions peuvent prendre des paramètres pour agir différemment selon les valeurs passées.
<?php
function salutation($nom) {
echo "Bonjour, " . $nom . "!";
}
salutation("Alice");
?>
Cette fonction utilise un paramètre $nom pour
personnaliser le message.
Portée des Variables
En PHP, les variables peuvent avoir différentes portées (globale, locale, statique).
<?php
$x = 5; // Variable globale
function tester() {
$y = 10; // Variable locale
echo $x; // Erreur: $x n'est pas accessible ici
}
?>
Cet exemple montre la différence entre les variables globales et locales.
Variables Globales et Locales
Les variables définies à l'extérieur d'une fonction ont une portée globale, tandis que celles définies à l'intérieur d'une fonction ont une portée locale.
<?php
$x = 5; // Variable globale
function tester() {
global $x; // Référence à la variable globale $x
$y = 10; // Variable locale
echo $x; // Affiche 5
}
tester();
?>
Cet exemple montre comment accéder à une variable globale à l'intérieur d'une fonction.
Variables Statiques
Les variables statiques conservent leur valeur entre les appels de fonction.
<?php
function compter() {
static $compte = 0;
$compte++;
echo $compte;
}
compter(); // 1
compter(); // 2
?>
Cet exemple montre comment une variable statique conserve sa valeur.
Exercice 2: Liste de produits
- Écrire une fonction produitsHTML dans un fichier fonctions.php qui reçoit un tableau de produits et qui génère le code HTML pour l'affichage du tableau.
-
Voici la structure du tableau de produits:
$produits = [ ["nom" => "Produit A", "prix" => 20.99, "categorie" => "Catégorie 1"], ["nom" => "Produit B", "prix" => 15.69, "categorie" => "Catégorie 2"], //... ]; - Modifiez votre page pour y inclure le tableau de produits.
Plan du chapitre
Introduction aux Variables Superglobales en PHP
Les variables superglobales en PHP sont des variables intégrées qui sont toujours disponibles dans tous les contextes du script.
La Variable $_SESSION
$_SESSION est une superglobale PHP qui stocke des informations de session qui peuvent être utilisées sur plusieurs pages.
<?php
session_start();
$_SESSION["utilisateur"] = "Alice";
echo $_SESSION["utilisateur"]; // Affiche "Alice"
?>
Cet exemple montre comment stocker et accéder à des données de session.
La Variable $_REQUEST
$_REQUEST est une superglobale PHP qui contient les données de $_GET, $_POST, et $_COOKIE.
<?php
// Supposons que le formulaire a été soumis avec
// une méthode GET ou POST
echo "Bonjour " . $_REQUEST["nom"];
?>
Cet exemple montre comment accéder aux données soumises via un formulaire.
La Variable $_GET
$_GET est une superglobale PHP qui contient les données envoyées via l'URL (méthode GET).
<?php
// URL: http://exemple.com?nom=Alice
echo "Bonjour " . $_GET["nom"]; // Affiche "Bonjour Alice"
?>
Cet exemple montre comment récupérer des données envoyées dans l'URL.
La Variable $_POST
$_POST est une superglobale PHP qui contient les données envoyées via un formulaire HTML (méthode POST).
<?php
// Supposons qu'un formulaire a été soumis avec ces données
echo "Bonjour " . $_POST["nom"];
?>
Cet exemple montre comment accéder aux données soumises par un formulaire POST.
Autres Variables Superglobales
- $_SERVER: Informations sur le serveur et l'environnement d'exécution.
- $_FILES: Informations sur les fichiers téléchargés via un formulaire.
- $_COOKIE: Données des cookies envoyées par le navigateur.
- $_ENV: Variables d'environnement.
- $_GLOBALS: Références à toutes les variables disponibles dans la portée globale.
Exercice 3: Compteur de visites
- En utilisant la super-globale $_SESSION, créez une page Web qui compte le nombre de fois qu'un utilisateur a visité la page.
- En rafraîchissant la page, le nombre de visites doit s'incrémenter.
Plan du chapitre
Cas d'étude: Babillard de PostIts
Le reste du cours sera vu autour du cas d'étude d'un Babillard de PostIts
- Téléchargez le code de départ du projet
- Téléchargez l'énoncé
Interrogation de Base de Données en PHP
PHP offre plusieurs moyens d'interagir avec les bases de données, notamment via MySQLi et PDO (PHP Data Objects).
Utilisation de MySQLi
MySQLi est une extension PHP qui permet l'interaction avec les bases de données MySQL.
<?php
$conn = new mysqli("hostname", "username", "password",
"database");
if ($conn->connect_error) {
die("Connexion échouée: " . $conn->connect_error);
}
echo "Connexion réussie";
?>
Cet exemple montre une connexion de base à une base de données MySQL avec MySQLi.
Gestion des Erreurs de Connexion MySQLi
La gestion des erreurs est cruciale pour déboguer et maintenir la sécurité de l'application.
// Exemple avec MySQLi
if ($conn->connect_error) {
die("Erreur de connexion: " . $conn->connect_error);
}
Utilisation de PDO
PDO offre une couche d'abstraction pour l'accès aux bases de données, permettant d'utiliser plusieurs types de bases de données.
<?php
try {
$conn = new PDO("mysql:host=hostname;dbname=database",
"username", "password");
$conn->setAttribute(PDO::ATTR_ERRMODE,
PDO::ERRMODE_EXCEPTION);
echo "Connexion réussie";
} catch(PDOException $e) {
echo "Connexion échouée: " . $e->getMessage();
}
?>
Cet exemple montre une connexion de base à une base de données en utilisant PDO.
Syntaxe de Base SQL
Rappels sur les commandes SQL de base pour interagir avec les bases de données.
- SELECT: Sélectionner des données
- INSERT: Insérer de nouvelles données
- UPDATE: Mettre à jour des données existantes
- DELETE: Supprimer des données
Exemple de Requête SELECT avec MySQLi
<?php
$result = $conn->query("SELECT * FROM table");
while($row = $result->fetch_assoc()) {
echo $row["colonne1"]." ".$row["colonne2"]."<br>";
}
?>
Cet exemple montre comment exécuter une requête SELECT et afficher les résultats avec MySQLi.
Exemple de Requête SELECT avec PDO
<?php
$stmt = $conn->query("SELECT * FROM table");
while($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
echo $row["colonne1"]." ".$row["colonne2"]."<br>";
}
?>
Cet exemple montre comment exécuter une requête SELECT et afficher les résultats avec PDO.
Les requêtes préparées
- Préparer une requête une seule fois pour l'exécuter à plusieurs reprises
- Améliorer l'efficacité
- Se protéger contre les injection SQL
$requete = $connexion->prepare(
"SELECT * FROM etudiants WHERE age > :age"
);
// Liaison des paramètres
$age = 30;
$requete->bindParam(':age', $age);
// Exécution de la requête
$requete->execute();
Les requêtes préparées:
bindParam
-
La méthode
bindParamrelie les paramètres à une variable par référence
$requete = $connexion->prepare(
"SELECT * FROM etudiants WHERE age > :age"
);
// Liaison des paramètres
$age = 30;
$requete->bindParam(':age', $age);
$requete->execute(); //exécution avec :age = 30
$age = 25
$requete->execute(); //exécution avec :age = 25
Les requêtes préparées:
bindValue
-
La méthode
bindValuerelie les paramètres à la valeur d'une variable
$requete = $connexion->prepare(
"SELECT * FROM etudiants WHERE age > :age"
);
// Liaison des paramètres
$age = 30;
$requete->bindValue(':age', $age);
$requete->execute(); //exécution avec :age = 30
$age = 25
$requete->execute();//Aucun changement
//exécution avec :age = 30
Les requêtes préparées:
Association des valeurs dans
execute
-
Permet d'éviter le
bindParamoubindValue
$requete = $connexion->prepare(
"SELECT * FROM etudiants
WHERE age > :ageMin AND age < :ageMax"
);
// Liaison des paramètres
$requete->execute([
'ageMin' => 20,
'ageMax' => 30
]);
Traitement du résultat de la requête
Méthode fetch 1/4
-
La méthode
fetchpermet de récupérer une ligne du résultat de la requête
// Exécution de la requête
$requete->execute();
// Récupération d'une seule ligne
$ligne = $requete->fetch(PDO::FETCH_ASSOC);
if ($ligne) {
print_r($ligne);
} else {
echo "Aucun résultat trouvé.";
}
Traitement du résultat de la requête
Méthode fetch 2/4
-
On peut itérer sur chacune des lignes résultantes en utilisant une
boucle
while:
// Exécution de la requête
$requete->execute();
// Boucle à travers chaque ligne de résultat
while ($ligne = $requete->fetch(PDO::FETCH_ASSOC)) {
print_r($ligne);
}
Traitement du résultat de la requête
Méthode fetch 2/4
-
Chaque ligne retournée est un tableau associatif, où les clés
correspondent aux noms des colonnes de la ligne retournée
(
PDO::FETCH_ASSOC):
$requete = $connexion->prepare(
"SELECT `nom`, `prenom`, `age` FROM etudiants"
);
// Liaison des paramètres
$requete->execute();
$ligne = $stmt->fetch(PDO::FETCH_ASSOC);
echo "Nom: ".$ligne['nom']." Prénom: ".$ligne['prenom'];
Options de récupération avec fetch
| Option | Chaque ligne est... |
|---|---|
| PDO::FETCH_ASSOC | Un tableau associatif, les clés correspondent aux noms de colonnes |
| PDO::FETCH_NUM | Un tableau indexé par numéro d'ordre des colonnes |
| PDO::FETCH_OBJ | Un objet anonyme, les noms des attributs qui correspondent aux noms des colonnes. |
Option par défaut de fetch
-
À spécifier lors de la connexion pour éviter de spécifier l'option
à chaque appel de
fetch
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
//mode par défaut: FETCH_ASSOC
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
];
try {
$pdo = new PDO($dsn, $user, $pass, $options);
} catch (\PDOException $e) {
die("Erreur de connexion BD: ".$e->getMessage);
}
Requêtes de modification des données
-
Les requêtes de modification (INSERT, UPDATE et DELETE) ne
retournent pas de résultat, il suffit de faire
execute$req = "INSERT INTO etudiants (`nom`, `prenom`) VALUES (:nom, :prenom)"; $req = $conn->prepare($sql); $req->bindParam(':nom', $leNom); $req->bindParam(':prenom', $lePrenom); $req->execute(); -
Après une insertion, la méthode
lastInsertIdpermet d'obtenir la dernière valeur d'une clé primaire auto-incrémentée$idEtudiantAjoute = $conn->lastInsertId();
Plan du chapitre
Traitement des Requêtes et Formulaires en PHP
PHP est fréquemment utilisé pour recueillir et traiter les données de formulaire, permettant une interaction dynamique avec les utilisateurs.
Structure de Base d'un Formulaire HTML
Les formulaires HTML sont utilisés pour collecter les entrées de l'utilisateur.
<form action="traitement.php" method="post">
Nom: <input type="text" name="nom"><br>
Email: <input type="email" name="email"><br>
<input type="submit" value="Soumettre">
</form>
Ce formulaire envoie les données à traitement.php via
POST.
Réception des Données en PHP (Méthode POST)
Les données soumises via POST sont accessibles via la superglobale $_POST en PHP.
<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$nom = $_POST['nom'];
$email = $_POST['email'];
// Traiter les données...
}
?>
Cet exemple montre comment accéder aux données de formulaire soumises.
Réception des Données en PHP (Méthode GET)
Les données soumises via GET sont accessibles via la superglobale $_GET en PHP.
<?php
if ($_SERVER["REQUEST_METHOD"] == "GET") {
$parametre = $_GET['parametre'];
// Traiter les données...
}
?>
Cet exemple montre comment accéder aux données envoyées via la méthode GET.
Validation des Données de Formulaire
Il est important de valider et de nettoyer les données reçues pour éviter les failles de sécurité.
<?php
$nom = $email = "";
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$nom = htmlspecialchars($_POST['nom']);
$email = filter_input(INPUT_POST, 'email',
FILTER_VALIDATE_EMAIL);
// Autres validations...
}
?>
Cet exemple montre une validation et un nettoyage des données reçues.
Nettoyage avec htmlspecialchars
-
La fonction
htmlspecialcharsremplace les caractères (&, ", ', < et >) par leurs entités HTML correspondantes - Ceci évite les attaques de type Cross Site Scripting (XSS) qui consiste à injecter du Javascript dans des données envoyées
- Devrait toujours être utilisée avant de stocker ou d'afficher des données reçues (autant par GET, POST ou autres)
Filtrage avec filter_var
- filter_var permet de valider et nettoyer le format des données reçues
-
La fonction reçoit:
- La valeur à filtrer
- Le type de filtre à appliquer
$email = $_POST['email'];
// Nettoyage
$emailNettoye = filter_var($email, FILTER_SANITIZE_EMAIL);
// Validation
if (!filter_var($emailNettoye, FILTER_VALIDATE_EMAIL)) {
echo "L'adresse email n'est pas valide.";
}