SYLLABUS : PHP POUR DÉBUTANTS

📅 Durée : 4 à 6 semaines
🎯 Prérequis : Aucune connaissance en PHP requise, mais des bases en HTML et CSS sont
un plus.

Module 1 : Introduction à PHP et installation (Semaine 1)

 Présentation de PHP et son rôle dans le développement web
 Différences entre PHP et d’autres langages côté serveur
 Installation de PHP, Apache et MySQL (via XAMPP, WAMP ou MAMP)
 Configuration de l’environnement de travail (VS Code, PHPStorm, etc.)
 Structure d’un script PHP de base
 Premiers scripts et affichage avec echo et print

✍ Exercice : Écrire un script PHP qui affiche "Bonjour, PHP !"

Module 2 : Variables, Types et Opérations (Semaine 2)

 Déclaration et utilisation des variables
 Types de données en PHP (string, integer, float, boolean, array, object, NULL)
 Opérateurs arithmétiques, logiques et de comparaison
 Manipulation des chaînes de caractères (strlen(), substr(), str_replace(), etc.)
 Introduction aux tableaux (array(), tableaux associatifs et multidimensionnels)

✍ Exercice : Créer un programme qui prend deux nombres en entrée et affiche la somme, la
différence, le produit et le quotient.

Module 3 : Conditions et Boucles (Semaine 3)

 Les structures conditionnelles : if, else, elseif, switch
 Les boucles : for, while, do...while, foreach
 Utilisation des tableaux avec les boucles
 Introduction aux fonctions natives de PHP

✍ Exercice : Créer un programme qui génère une table de multiplication en utilisant une
boucle.

Module 4 : Fonctions et Superglobales (Semaine 4)

 Définition et utilisation des fonctions (function(), paramètres, valeurs de retour)
  Variables locales et globales
 Superglobales PHP : $_GET, $_POST, $_SESSION, $_COOKIE, $_SERVER, $_FILES
 Introduction à l’inclusion de fichiers (include et require)

✍ Exercice : Créer une fonction qui prend un nom et un âge en paramètre et retourne une
phrase comme : "Bonjour Alice, vous avez 25 ans."

Module 5 : Formulaires et Gestion des Données (Semaine

5)
 Création et validation de formulaires en PHP
 Méthodes GET et POST
 Sécurisation des entrées utilisateur (htmlspecialchars(), trim(), strip_tags())
 Gestion des fichiers ($_FILES, upload de fichiers)
 Sessions et cookies pour stocker des informations utilisateur

✍ Exercice : Créer un formulaire de connexion simple avec gestion de session.

Module 6 : PHP et Bases de Données MySQL (Semaine 6)

 Introduction à MySQL et connexion avec PHP (mysqli et PDO)
 CRUD (Create, Read, Update, Delete) avec MySQL
 Requêtes préparées pour la sécurité
 Gestion des erreurs et optimisation des requêtes
 Affichage dynamique des données depuis une base de données

✍ Exercice : Créer une petite application de gestion d’utilisateurs avec une base de données
MySQL.

Module 7 : Projet Final (Optionnel)

 Développement d’un mini-projet intégrant les concepts appris (ex : système de gestion
de tâches, blog simple, mini boutique en ligne).

✍ Projet : Réaliser une application CRUD complète avec connexion et sessions utilisateurs.

📌 Matériel et outils recommandés :

✅ Serveur local (XAMPP, WAMP, MAMP)
✅ Éditeur de code (VS Code, PHPStorm)
✅ Base de données MySQL (phpMyAdmin)
✅ Documentation PHP : https://www.php.net/manual/fr/
Module 1 : Introduction à PHP et
Installation (Semaine 1)
🎯 Objectifs d’apprentissage :

 Comprendre ce qu’est PHP et son rôle dans le développement web

 Installer un environnement de travail avec PHP, Apache et MySQL
 Écrire et exécuter un premier script PHP

1.1 Présentation de PHP

1.1.1 Qu'est-ce que PHP ?

PHP (Hypertext Preprocessor) est un langage de programmation côté serveur utilisé pour
développer des sites web dynamiques et des applications web.
✅ Points clés :

 PHP est interprété et s’exécute sur le serveur avant d’envoyer le résultat au navigateur.
 Il permet d’interagir avec des bases de données (MySQL, PostgreSQL, etc.).
 Il est compatible avec de nombreux serveurs web comme Apache et Nginx.

1.1.2 Différences entre PHP et d’autres langages

Langage Côté Serveur ou Client Usage principal
PHP Serveur Sites web dynamiques
JavaScript Client Interactions utilisateur
Python Serveur Web, Data Science, IA
HTML & CSS Client Structure et style du site

1.2 Installation de PHP et Configuration de

l’Environnement
Avant d’écrire du PHP, il faut installer un serveur local qui interprétera nos scripts.

1.2.1 Installation d’un serveur local

Nous allons utiliser XAMPP (Windows, macOS, Linux). D’autres alternatives sont WAMP
(Windows) ou MAMP (macOS).

✅ Étapes d’installation avec XAMPP :

1. Télécharger XAMPP depuis https://www.apachefriends.org/fr/index.html

2. Lancer l’installation et choisir les composants suivants :
o Apache (serveur web)
 o MySQL (base de données)
o PHP (interprète)
o phpMyAdmin (gestion des bases de données)
3. Ouvrir XAMPP et démarrer Apache et MySQL.
4. Vérifier l’installation en allant sur http://localhost.

1.2.2 Configuration de l’Environnement de Développement

✅ Choix d’un éditeur de code :

 Visual Studio Code (VS Code) (recommandé)

 PHPStorm (payant mais puissant)
 Sublime Text

✅ Configurer PHP dans VS Code :

 Installer l’extension PHP Intelephense pour l’autocomplétion.

 Ouvrir le dossier où seront stockés vos fichiers PHP.

1.3 Structure d’un Script PHP

Un script PHP s’écrit entre les balises suivantes :

<?php
// Code PHP ici
?>

✅ Règles de base :

 Le fichier doit avoir l’extension .php (ex: index.php).

 Les instructions se terminent par un point-virgule (;).
 PHP peut être intégré dans du HTML.

📌 Exemple d’un script PHP affichant "Bonjour, PHP !"

<?php
echo "Bonjour, PHP !";
?>

💡 Explication :

 echo permet d’afficher du texte.

 "Bonjour, PHP !" est une chaîne de caractères.

1.3.1 Utilisation de echo et print

Les deux fonctions permettent d’afficher du texte, mais echo est légèrement plus rapide.
<?php
echo "Hello, World!";
print "Bienvenue sur mon site !";
?>

1.4 Exécution d’un Script PHP

1.4.1 Où placer les fichiers PHP ?

Dans XAMPP, les fichiers PHP doivent être enregistrés dans le dossier :
📂 C:\xampp\htdocs (Windows)
📂 /Applications/XAMPP/htdocs/ (Mac)

Dans WAMP, les fichiers PHP doivent être enregistrés dans le dossier :
📂 C:\wamp64\www\ (Windows)

Créer un dossier mon_site dans htdocs ou www, puis un fichier index.php avec ce code :

<?php
echo "Bienvenue sur mon premier script PHP !";
?>
1.4.2 Accéder au script dans le navigateur

Ouvrir http://localhost/mon_site/index.php.

1.5 Exercice Pratique 🎯

📌 Objectif : Écrire un script PHP qui affiche votre prénom et votre âge.

Fichier : info.php

<?php
echo "Bonjour, je m'appelle Awa et j'ai 25 ans.";
?>

✅ Instructions :

1. Créer un fichier info.php dans htdocs/mon_site.

2. Modifier le script pour afficher votre propre prénom et âge.
3. Tester l'affichage sur http://localhost/mon_site/info.php.
1.6 Conclusion
À la fin de cette première semaine, vous êtes capable de :
✅ Comprendre le rôle de PHP dans le développement web
✅ Installer un environnement de développement avec XAMPP et VS Code
✅ Écrire et exécuter un premier script PHP

Prochaine étape : Module 2 - Variables, Types et Opérations 🚀.

Module 2 : Variables, Types et Opérations

(Semaine 2)
🎯 Objectifs d’apprentissage :
  Comprendre et utiliser les variables en PHP
 Identifier les différents types de données
 Effectuer des opérations arithmétiques et logiques
 Manipuler les chaînes de caractères et les tableaux

2.1 Introduction aux Variables en PHP

Une variable est un espace mémoire permettant de stocker une valeur. En PHP, une variable
commence toujours par $.

📌 Déclaration et affectation d’une variable :

<?php
$nom = "Yacine"; // Variable de type chaîne
$age = 25; // Variable de type entier
$prix = 10.5; // Variable de type flottant
?>

✅ Règles de nommage :

 Doit commencer par $ suivi d’une lettre ou _ (ex : $monNom).

 Ne doit pas contenir d’espaces ni de caractères spéciaux (sauf _).
 Sensible à la casse ($nom ≠ $Nom).

2.2 Types de Données en PHP

PHP est un langage faiblement typé, ce qui signifie que le type d’une variable est déterminé
automatiquement.

Type Exemple Description

String (Chaîne) "Bonjour" Texte entouré de guillemets
Integer (Entier) 42 Nombre entier
Float (Flottant) 3.14 Nombre à virgule
Boolean (Booléen) true / false Vrai ou Faux
Array (Tableau) ["Yacine", "Ndiaye"] Liste de valeurs
NULL NULL Absence de valeur

📌 Exemples :

<?php
$nom = "Jean"; // Chaîne de caractères
$age = 30; // Entier
$prix = 12.99; // Flottant
$estAdmin = true; // Booléen
 $langages = ["PHP", "Python", "Java"]; // Tableau
$valeur = NULL; // Variable nulle
?>

2.3 Opérateurs en PHP

Les opérateurs permettent d’effectuer des calculs et des comparaisons.

2.3.1 Opérateurs arithmétiques

Opérateur Signification Exemple
+ Addition $a + $b
- Soustraction $a - $b
* Multiplication $a * $b
/ Division $a / $b
% Modulo (reste de division) $a % $b

📌 Exemple d’opérations :

<?php
$a = 10;
$b = 3;
echo "Addition : " . ($a + $b); // 13
echo "Multiplication : " . ($a * $b); // 30
?>

2.3.2 Opérateurs de comparaison

Utilisés pour comparer deux valeurs.

Opérateur Signification Exemple Résultat

== Égal $a == $b true si $a et $b sont égaux
!= Différent $a != $b true si $a est différent de $b
> Supérieur $a > $b true si $a est supérieur à $b
< Inférieur $a < $b true si $a est inférieur à $b
>= Supérieur ou égal $a >= $b true si $a ≥ $b
<= Inférieur ou égal $a <= $b true si $a ≤ $b

📌 Exemple :

<?php
$x = 5;
$y = 10;
echo ($x < $y); // Affichera 1 (true)
?>

2.3.3 Opérateurs logiques

Utilisés pour combiner plusieurs conditions.

Opérateur Signification Exemple

&& (AND) Vrai si les deux conditions sont vraies $a > 5 && $b < 10
` ` (OR)
! (NOT) Inverse la condition !($a > 5)

📌 Exemple :

<?php
$age = 20;
$nationalite = "Français";

if ($age >= 18 && $nationalite == "Français") {

echo "Vous pouvez voter.";
}
?>

2.4 Manipulation des Chaînes de Caractères

2.4.1 Concaténation

En PHP, on utilise le point (.) pour assembler des chaînes.

<?php
$prenom = "Awa";
echo "Bonjour, " . $prenom . " !";
?>
2.4.2 Fonctions utiles
Fonction Utilisation
strlen($str) Retourne la longueur de $str
strtoupper($str) Met en majuscules
strtolower($str) Met en minuscules
substr($str, 0, 5) Extrait une partie de $str

📌 Exemple :

<?php
$message = "Bonjour PHP";
echo strtoupper($message); // "BONJOUR PHP"
?>
2.5 Manipulation des Tableaux
Il existe deux types de tableaux en PHP :

1. Tableaux indexés (avec des indices numériques).

2. Tableaux associatifs (avec des clés nommées).

2.5.1 Tableaux indexés

<?php
$fruits = ["Pomme", "Banane", "Cerise"];
echo $fruits[1]; // Affiche "Banane"
?>
2.5.2 Tableaux associatifs
<?php
$personne = ["nom" => "Alice", "age" => 25];
echo $personne["nom"]; // Affiche "Alice"
?>

2.6 Exercice Pratique 🎯

📌 Objectif :
Créer un script PHP qui :

 Déclare deux variables $a = 15 et $b = 4.

 Affiche leur somme, leur produit et leur division.
 Vérifie si $a est plus grand que $b et affiche un message.

📌 Correction :

<?php
$a = 15;
$b = 4;

echo "Somme : " . ($a + $b) . "<br>";

echo "Produit : " . ($a * $b) . "<br>";
echo "Division : " . ($a / $b) . "<br>";

if ($a > $b) {

echo "$a est plus grand que $b.";
} else {
echo "$a est plus petit ou égal à $b.";
}
?>
2.7 Conclusion
À la fin de cette semaine, vous êtes capable de :
✅ Déclarer et utiliser des variables en PHP
✅ Effectuer des opérations mathématiques et logiques
✅ Manipuler des chaînes et des tableaux

🔜 Prochain module : Les structures conditionnelles et boucles en PHP 🚀

Module 3 : Structures Conditionnelles et Boucles en PHP (Semaine 3)

🎯 Objectifs d’apprentissage :

 Comprendre et utiliser les structures conditionnelles (if, switch)

 Manipuler les boucles (for, while, foreach)
  Appliquer ces structures dans des cas pratiques

3.1 Introduction aux structures conditionnelles

Les structures conditionnelles permettent d’exécuter du code en fonction d’une condition
donnée.

3.2 La structure if...else...elseif

📌 Syntaxe de base :

<?php
if (condition) {
// Code exécuté si la condition est vraie
} elseif (autre_condition) {
// Code exécuté si l’autre condition est vraie
} else {
// Code exécuté si aucune condition n’est vraie
}
?>

📌 Exemple :

<?php
$age = 20;
if ($age < 18) {
echo "Vous êtes mineur.";
} elseif ($age >= 18 && $age < 60) {
echo "Vous êtes adulte.";
} else {
echo "Vous êtes senior.";
}
?>

📌 Utilisation avec les opérateurs logiques :

<?php
$score = 75;
if ($score >= 50 && $score < 75) {
echo "Note moyenne.";
} elseif ($score >= 75) {
echo "Bonne note.";
} else {
echo "Échec.";
}
?>

3.3 La structure switch...case

📌 Utilisation quand il y a plusieurs conditions sur une même variable

3.3.1 Syntaxe
<?php
switch (variable) {
case valeur1:
// Instructions si variable == valeur1
break;
case valeur2:
// Instructions si variable == valeur2
break;
default:
// Instructions si aucune correspondance
}
?>
3.3.2 Exemple
<?php
$jour = "mardi";

switch ($jour) {
case "lundi":
echo "Début de la semaine !";
break;
case "vendredi":
echo "Bientôt le week-end !";
break;
case "samedi":
case "dimanche":
echo "C'est le week-end !";
break;
default:
echo "Un jour comme les autres.";
}
?>

📌 Remarque :
Sans break, les instructions continuent d’être exécutées jusqu’au prochain break.

3.4 Les boucles en PHP

Les boucles permettent d’exécuter un bloc de code plusieurs fois.

3.4.1 La boucle while

📌 Exécute une instruction tant qu’une condition est vraie.

<?php
$nombre = 1;
while ($nombre <= 5) {
echo "Nombre : $nombre <br>";
$nombre++; // Incrémentation
}
?>

⚠️ Attention aux boucles infinies ! Toujours mettre une condition qui peut devenir fausse.

3.4.2 La boucle do...while

📌 Exécute au moins une fois le code avant de tester la condition.

<?php
$nombre = 1;
do {
echo "Valeur : $nombre <br>";
$nombre++;
} while ($nombre <= 5);
?>

3.4.3 La boucle for

📌 Idéale lorsque l’on connaît le nombre d’itérations.

<?php
for ($i = 1; $i <= 5; $i++) {
echo "Itération $i <br>";
}
?>

📌 Exemple : Afficher les nombres pairs entre 1 et 10

<?php
for ($i = 2; $i <= 10; $i += 2) {
echo "$i est pair <br>";
}
?>
3.4.4 La boucle foreach (pour les tableaux)

📌 Permet de parcourir un tableau sans utiliser d’index.

<?php
$couleurs = ["Rouge", "Vert", "Bleu"];
foreach ($couleurs as $couleur) {
echo "$couleur <br>";
}
?>

📌 Avec un tableau associatif :

<?php
$personne = ["nom" => "Alice", "âge" => 25, "ville" => "Dakar"];
foreach ($personne as $cle => $valeur) {
echo "$cle : $valeur <br>";
}
?>

3.5 Contrôle des boucles : break et continue

 break : Interrompt une boucle immédiatement.
 continue : Saute à l’itération suivante sans exécuter le reste du code.

📌 Exemple avec break (arrêter dès que $i atteint 3) :

<?php
for ($i = 1; $i <= 5; $i++) {
if ($i == 3) {
break;
}
echo "$i <br>";
}
?>

📌 Exemple avec continue (ignorer $i == 3) :

<?php
for ($i = 1; $i <= 5; $i++) {
if ($i == 3) {
continue;
}
echo "$i <br>";
}
?>

3.6 Exercice Pratique 🎯

📌 Exercice 1 : Écrire un programme qui vérifie si un nombre est positif, négatif ou nul.

📌 Correction :

<?php
$nombre = -5;

if ($nombre > 0) {
echo "Le nombre est positif.";
} elseif ($nombre < 0) {
echo "Le nombre est négatif.";
} else {
echo "Le nombre est nul.";
}
?>

📌 Exercice 2 : Afficher la table de multiplication de 5 de 1 à 10.

📌 Correction :

<?php
for ($i = 1; $i <= 10; $i++) {
echo "5 x $i = " . (5 * $i) . "<br>";
}
?>

📌 Exercice 3 : Parcourir un tableau d’étudiants et afficher leur nom et leur note.

📌 Correction :

<?php
$etudiants = [
"Alice" => 15,
"Bob" => 12,
"Charlie" => 18
];

foreach ($etudiants as $nom => $note) {

echo "$nom a obtenu $note/20. <br>";
}
?>
3.7 Conclusion
À la fin de ce module, vous êtes capable de :
✅ Utiliser if, switch, while, for, foreach
✅ Contrôler l’exécution des boucles avec break et continue
✅ Appliquer ces notions dans des cas concrets

🔜 Prochain module : Les fonctions en PHP 🚀

Module 4 : Les Fonctions en PHP (Semaine 4)
🎯 Objectifs d’apprentissage :

 Comprendre l’utilité des fonctions en PHP

 Définir et appeler des fonctions
 Utiliser des paramètres et des valeurs de retour
 Manipuler les fonctions prédéfinies et les fonctions anonymes

4.1 Introduction aux Fonctions

Une fonction est un bloc de code réutilisable qui permet d’exécuter une tâche spécifique.
Elle aide à éviter la redondance, rendre le code plus lisible et faciliter la maintenance.

📌 Exemple simple de fonction :

<?php
function direBonjour() {
echo "Bonjour, bienvenue sur mon site !";
}

direBonjour(); // Appel de la fonction

?>

4.2 Définition et Appel d’une Fonction

Une fonction se définit avec le mot-clé function suivi du nom de la fonction et des
parenthèses ().
Son code est contenu entre {}.

📌 Syntaxe de base :

<?php
function nomDeLaFonction() {
// Instructions à exécuter
}
?>
📌 Exemple d’une fonction qui affiche un message :

<?php
function afficherMessage() {
echo "Ceci est un message affiché depuis une fonction.";
}

afficherMessage(); // Appel de la fonction

?>

4.3 Les Paramètres d’une Fonction

Une fonction peut prendre des paramètres pour être plus dynamique.

📌 Exemple avec un paramètre :

<?php
function saluer($nom) {
echo "Bonjour, $nom !";
}

saluer("Alice"); // Affiche : Bonjour, Alice !

saluer("Bob"); // Affiche : Bonjour, Bob !
?>

📌 Exemple avec plusieurs paramètres :

<?php
function additionner($a, $b) {
echo "Le résultat de $a + $b est " . ($a + $b);
}

additionner(5, 10); // Affiche : Le résultat de 5 + 10 est 15

?>

4.4 Valeur de Retour d’une Fonction

Une fonction peut renvoyer une valeur à l’aide du mot-clé return.

📌 Exemple d’une fonction qui retourne un résultat :

<?php
function multiplier($x, $y) {
return $x * $y;
}

$resultat = multiplier(3, 4);

echo "Le produit est : " . $resultat; // Affiche : Le produit est : 12
?>

📌 Exemple d’une fonction qui retourne une chaîne de caractères :

<?php
function bienvenue($nom) {
return "Bienvenue, $nom !";
}

$message = bienvenue("Sophie");
echo $message; // Affiche : Bienvenue, Sophie !
?>

4.5 Paramètres avec Valeurs Par Défaut

On peut attribuer une valeur par défaut à un paramètre.

📌 Exemple d’une fonction avec une valeur par défaut :

<?php
function direBonjour($nom = "Visiteur") {
echo "Bonjour, $nom !";
}

direBonjour(); // Affiche : Bonjour, Visiteur !

direBonjour("Paul"); // Affiche : Bonjour, Paul !
?>

4.6 Les Fonctions avec un Nombre Variable de Paramètres

PHP permet d’accepter un nombre illimité d’arguments grâce à func_get_args() ou
...$args.
📌 Exemple avec ...$args :

<?php
function somme(...$nombres) {
return array_sum($nombres);
}

echo somme(1, 2, 3, 4, 5); // Affiche : 15

?>

4.7 Les Fonctions Anonymes (Fonctions Lambda)

Une fonction anonyme est une fonction sans nom. Elle est souvent utilisée avec des variables
ou comme argument d’une autre fonction.

📌 Exemple de fonction anonyme stockée dans une variable :

<?php
$square = function($n) {
return $n * $n;
};

echo $square(4); // Affiche : 16

?>

📌 Utilisation avec array_map() :

<?php
$nombres = [1, 2, 3, 4, 5];
$carres = array_map(function($n) { return $n * $n; }, $nombres);

print_r($carres); // Affiche : [1, 4, 9, 16, 25]

?>

4.8 Les Fonctions de Récursion

Une fonction récursive est une fonction qui s’appelle elle-même. Elle est utile pour résoudre
des problèmes comme le calcul factoriel ou le parcours d’un arbre.

📌 Exemple : Factorielle d’un nombre :

<?php
function factorielle($n) {
if ($n == 0) {
return 1;
 }
return $n * factorielle($n - 1);
}

echo factorielle(5); // Affiche : 120

?>

4.9 Les Fonctions Prédéfinies Utiles en PHP

PHP offre plusieurs fonctions prédéfinies très utiles :

📌 Manipulation des chaînes :

<?php
echo strlen("Bonjour"); // Affiche : 7 (longueur de la chaîne)
echo strtoupper("hello"); // Affiche : HELLO
?>

📌 Manipulation des tableaux :

<?php
$couleurs = ["Rouge", "Vert", "Bleu"];
echo count($couleurs); // Affiche : 3 (nombre d’éléments)
?>

📌 Fonctions mathématiques :

<?php
echo round(3.75); // Affiche : 4 (arrondi)
echo rand(1, 10); // Génère un nombre aléatoire entre 1 et 10
?>

4.10 Exercices Pratiques 🎯

📌 Exercice 1 :
Créer une fonction carre() qui prend un nombre en paramètre et retourne son carré.

📌 Correction :

<?php
function carre($n) {
return $n * $n;
}

echo carre(5); // Affiche : 25

?>

📌 Exercice 2 :
Créer une fonction convertirCelsiusEnFahrenheit() qui convertit une
température en Celsius en Fahrenheit.

📌 Correction :

<?php
function convertirCelsiusEnFahrenheit($celsius) {
return ($celsius * 9/5) + 32;
}

echo convertirCelsiusEnFahrenheit(0); // Affiche : 32

?>

📌 Exercice 3 :
Créer une fonction qui prend un tableau de nombres et retourne la somme des nombres pairs.

📌 Correction :

<?php
function sommePairs($nombres) {
$somme = 0;
foreach ($nombres as $n) {
if ($n % 2 == 0) {
$somme += $n;
}
}
return $somme;
}

echo sommePairs([1, 2, 3, 4, 5, 6]); // Affiche : 12

?>

4.11 Conclusion
À la fin de ce module, vous savez :
✅ Créer et utiliser des fonctions en PHP
✅ Passer des paramètres et récupérer des valeurs de retour
✅ Utiliser des fonctions anonymes et récursives
✅ Exploiter les fonctions prédéfinies de PHP

🔜 Prochain module : Les Tableaux en PHP 🚀

Module 5 : Les Tableaux en PHP (Semaine 5)
🎯 Objectifs d’apprentissage :

 Comprendre l’utilité des tableaux en PHP

 Déclarer et manipuler des tableaux indexés et associatifs
 Utiliser les principales fonctions de gestion des tableaux
 Parcourir un tableau avec différentes boucles

5.1 Introduction aux Tableaux

Un tableau (array) en PHP est une structure de données permettant de stocker plusieurs
valeurs sous une seule variable. Il peut contenir des nombres, chaînes de caractères,
booléens, voire d’autres tableaux (tableaux multidimensionnels).

5.2 Les Tableaux Indexés

Un tableau indexé utilise des indices numériques (commençant par 0) pour stocker les
éléments.

📌 Déclaration d’un tableau indexé :

<?php
$fruits = ["Pomme", "Banane", "Orange"];
?>

📌 Accéder aux éléments du tableau :

<?php
echo $fruits[0]; // Affiche : Pomme
echo $fruits[1]; // Affiche : Banane
?>

📌 Ajouter un élément au tableau :

<?php
$fruits[] = "Mangue"; // Ajoute un nouvel élément
print_r($fruits);
?>
📌 Compter le nombre d’éléments :

<?php
echo count($fruits); // Affiche : 4
?>

5.3 Les Tableaux Associatifs

Un tableau associatif utilise des clés personnalisées au lieu d’indices numériques.

📌 Déclaration d’un tableau associatif :

<?php
$personne = [
"nom" => "Dupont",
"age" => 30,
"ville" => "Paris"
];
?>

📌 Accéder aux éléments du tableau :

<?php
echo $personne["nom"]; // Affiche : Dupont
echo $personne["ville"]; // Affiche : Paris
?>

📌 Ajouter/modifier un élément :

<?php
$personne["profession"] = "Développeur"; // Ajout
$personne["ville"] = "Lyon"; // Modification
?>

5.4 Parcourir un Tableau

5.4.1 Avec une boucle for (tableaux indexés)
<?php
$fruits = ["Pomme", "Banane", "Orange"];
for ($i = 0; $i < count($fruits); $i++) {
echo $fruits[$i] . "<br>";
}
?>

5.4.2 Avec une boucle foreach (tableaux indexés et associatifs)

<?php
foreach ($fruits as $fruit) {
echo $fruit . "<br>";
}
?>

📌 Pour les tableaux associatifs :

<?php
foreach ($personne as $cle => $valeur) {
echo "$cle : $valeur <br>";
}
?>

5.5 Fonctions Utiles sur les Tableaux

📌 Vérifier si une clé existe (array_key_exists) :

<?php
if (array_key_exists("nom", $personne)) {
echo "Clé trouvée !";
}
?>

📌 Vérifier si une valeur existe (in_array) :

<?php
if (in_array("Paris", $personne)) {
echo "Valeur trouvée !";
}
?>

📌 Trouver la clé d’une valeur (array_search) :

<?php
$index = array_search("Banane", $fruits);
echo $index; // Affiche : 1
?>

📌 Supprimer un élément (unset) :

<?php
unset($personne["age"]);
?>
📌 Trier un tableau (sort, asort, ksort) :

<?php
sort($fruits); // Trie par ordre alphabétique
asort($personne); // Trie un tableau associatif par valeur
ksort($personne); // Trie un tableau associatif par clé
?>

5.6 Les Tableaux Multidimensionnels

Un tableau multidimensionnel est un tableau contenant un ou plusieurs tableaux.

📌 Exemple d’un tableau multidimensionnel :

<?php
$etudiants = [
["nom" => "Alice", "age" => 22, "note" => 15],
["nom" => "Bob", "age" => 24, "note" => 17],
["nom" => "Charlie", "age" => 21, "note" => 14]
];
?>

📌 Accéder aux valeurs d’un tableau multidimensionnel :

<?php
echo $etudiants[1]["nom"]; // Affiche : Bob
?>

📌 Parcourir un tableau multidimensionnel :

<?php
foreach ($etudiants as $etudiant) {
echo "Nom : " . $etudiant["nom"] . ", Age : " . $etudiant["age"] . ", Note
: " . $etudiant["note"] . "<br>";
}
?>

5.7 Exercices Pratiques 🎯

📌 Exercice 1 :
Créez un tableau associatif contenant le nom, l’âge et la ville d’une personne et affichez ces
informations avec une boucle foreach.

📌 Correction :

<?php
$personne = ["nom" => "Jean", "age" => 25, "ville" => "Marseille"];
foreach ($personne as $cle => $valeur) {
echo "$cle : $valeur <br>";
}
?>

📌 Exercice 2 :
Créez un tableau contenant les notes d’un étudiant et affichez la moyenne des notes.

📌 Correction :

<?php
$notes = [12, 15, 18, 10, 14];
$moyenne = array_sum($notes) / count($notes);
echo "Moyenne : " . $moyenne;
?>

📌 Exercice 3 :
Créez un tableau multidimensionnel avec une liste de produits (nom, prix, quantité) et
affichez les informations avec une boucle foreach.

📌 Correction :

<?php
$produits = [
["nom" => "Ordinateur", "prix" => 800, "quantité" => 10],
["nom" => "Téléphone", "prix" => 500, "quantité" => 20],
["nom" => "Casque", "prix" => 100, "quantité" => 15]
];

foreach ($produits as $produit) {

echo "Produit : " . $produit["nom"] . ", Prix : " . $produit["prix"] . "€,
Quantité : " . $produit["quantité"] . "<br>";
}
?>

5.8 Conclusion
À la fin de ce module, vous savez :
✅ Déclarer et manipuler des tableaux indexés et associatifs
✅ Parcourir un tableau avec for et foreach
✅ Utiliser les fonctions essentielles sur les tableaux
✅ Travailler avec des tableaux multidimensionnels

🔜 Prochain module : Les Superglobales et la Gestion des Formulaires en PHP 🚀

Module 6 : Les Superglobales et la Gestion
des Formulaires en PHP (Semaine 6)
🎯 Objectifs d’apprentissage :

 Comprendre le rôle des variables superglobales en PHP

 Manipuler les données envoyées via un formulaire (GET et POST)
 Sécuriser les entrées utilisateur
 Gérer les redirections et la persistance des données

6.1 Introduction aux Variables Superglobales

Les superglobales en PHP sont des variables prédéfinies accessibles à tout moment, sans
nécessiter une déclaration explicite.

📌 Liste des principales superglobales :

 $_GET → Récupère les données envoyées via l’URL

 $_POST → Récupère les données envoyées via un formulaire
 $_REQUEST → Combine $_GET, $_POST et $_COOKIE
 $_SESSION → Stocke des informations de session utilisateur
 $_COOKIE → Stocke des données persistantes sur le navigateur
 $_FILES → Gère l’upload de fichiers
 $_SERVER → Contient des informations sur le serveur et l’environnement
 $_ENV → Contient les variables d’environnement

6.2 Récupération des Données d’un Formulaire avec GET et POST

6.2.1 Méthode GET

La méthode GET envoie les données via l’URL. Elle est utilisée pour transmettre des
informations visibles et non sensibles.

📌 Exemple d’un formulaire GET :

<!-- form_get.php -->

<form action="traitement_get.php" method="GET">
<label>Nom :</label>
<input type="text" name="nom">
<button type="submit">Envoyer</button>
</form>
📌 Récupération des données (traitement_get.php) :

<?php
if (isset($_GET['nom'])) {
echo "Nom : " . htmlspecialchars($_GET['nom']);
} else {
echo "Aucun nom fourni.";
}
?>

🚨 Attention : Les données envoyées via GET sont visibles dans l’URL et peuvent être
interceptées.

6.2.2 Méthode POST

La méthode POST envoie les données dans le corps de la requête HTTP. Elle est plus sécurisée
que GET pour les informations sensibles.

📌 Exemple d’un formulaire POST :

<!-- form_post.php -->

<form action="traitement_post.php" method="POST">
<label>Nom :</label>
<input type="text" name="nom">
<button type="submit">Envoyer</button>
</form>

📌 Récupération des données (traitement_post.php) :

<?php
if (!empty($_POST['nom'])) {
echo "Nom : " . htmlspecialchars($_POST['nom']);
} else {
echo "Veuillez entrer un nom.";
}
?>

🚀 Avantage de POST : Les données ne sont pas visibles dans l’URL, ce qui améliore la
sécurité.

6.3 Sécurisation des Données du Formulaire

💡 Pourquoi sécuriser ?
Les données des utilisateurs peuvent contenir des scripts malveillants (XSS, injection SQL).
Voici quelques bonnes pratiques :
📌 1. Échapper les caractères spéciaux (htmlspecialchars)

<?php
$nom = htmlspecialchars($_POST['nom']);
?>

📌 2. Vérifier la présence des champs (isset et empty)

<?php
if (isset($_POST['nom']) && !empty($_POST['nom'])) {
echo "Nom : " . htmlspecialchars($_POST['nom']);
} else {
echo "Champ requis !";
}
?>

📌 3. Filtrer les entrées (filter_input)

<?php
$nom = filter_input(INPUT_POST, 'nom', FILTER_SANITIZE_STRING);
?>

📌 4. Utiliser trim() pour enlever les espaces inutiles

<?php
$nom = trim($_POST['nom']);
?>

6.4 Gestion des Redirections avec header()

Après soumission d’un formulaire, il est souvent utile de rediriger l’utilisateur.

📌 Exemple de redirection après soumission :

<?php
if (!empty($_POST['nom'])) {
header("Location: success.php");
exit();
} else {
header("Location: form_post.php?error=1");
exit();
}
?>
6.5 Stockage des Données avec SESSION et COOKIE
6.5.1 Les Sessions ($_SESSION)

Une session stocke temporairement des données pour un utilisateur sur le serveur. Elle est
utile pour maintenir une connexion utilisateur.

📌 Démarrer une session et stocker des données :

<?php
session_start();
$_SESSION['nom'] = "Jean";
?>

📌 Récupérer les données de session :

<?php
session_start();
echo $_SESSION['nom'];
?>

📌 Détruire une session :

<?php
session_start();
session_destroy();
?>

6.5.2 Les Cookies ($_COOKIE)

Un cookie stocke des informations sur le navigateur de l’utilisateur pour une durée
déterminée.

📌 Créer un cookie valable 1 jour :

<?php
setcookie("nom", "Jean", time() + 86400, "/");
?>

📌 Lire un cookie :

<?php
if (isset($_COOKIE['nom'])) {
echo "Nom stocké : " . $_COOKIE['nom'];
}
?>
📌 Supprimer un cookie :

<?php
setcookie("nom", "", time() - 3600, "/");
?>

6.6 Exercices Pratiques 🎯

📌 Exercice 1 :
Créer un formulaire de connexion avec POST qui affiche un message "Bienvenue, [nom]"
après soumission.

📌 Correction :

<!-- form_login.php -->

<form action="login.php" method="POST">
<label>Nom :</label>
<input type="text" name="nom">
<button type="submit">Se connecter</button>
</form>

<!-- login.php -->

<?php
if (!empty($_POST['nom'])) {
echo "Bienvenue, " . htmlspecialchars($_POST['nom']) . "!";
} else {
echo "Veuillez entrer un nom.";
}
?>

📌 Exercice 2 :
Créer une session qui stocke le nom de l’utilisateur et affiche un message "Session active pour
[nom]".

📌 Correction :

<?php
session_start();
$_SESSION['nom'] = $_POST['nom'] ?? "Utilisateur";
echo "Session active pour " . $_SESSION['nom'];
?>
📌 Exercice 3 :
Créer un cookie qui stocke la langue préférée de l’utilisateur et affiche un message "Langue
sélectionnée : [langue]".

📌 Correction :

<?php
setcookie("langue", "français", time() + 3600, "/");
if (isset($_COOKIE['langue'])) {
echo "Langue sélectionnée : " . $_COOKIE['langue'];
}
?>

6.7 Conclusion
À la fin de ce module, vous savez :
✅ Manipuler $_GET et $_POST pour récupérer les données utilisateur
✅ Sécuriser les entrées utilisateur contre les attaques
✅ Gérer les redirections après soumission
✅ Stocker des données avec SESSION et COOKIE

🔜 Prochain module : Manipulation des Fichiers en PHP 📂🚀

Module 7 : Manipulation des Fichiers en
PHP (Semaine 7)
🎯 Objectifs d’apprentissage :

 Lire et écrire dans des fichiers avec PHP

 Gérer l’upload de fichiers via un formulaire
 Sécuriser les opérations sur les fichiers
 Manipuler les fichiers et les répertoires

7.1 Introduction à la Manipulation des Fichiers en PHP

PHP permet de créer, lire, modifier et supprimer des fichiers sur le serveur grâce aux
fonctions intégrées. Ces fonctionnalités sont très utiles pour :
✅ Enregistrer des logs 📜
✅ Stocker des données sans base de données 💾
✅ Gérer l’upload d’images, de documents 📂

7.2 Ouvrir et Lire un Fichier

📌 Utilisation de fopen() et fread()

<?php
$handle = fopen("exemple.txt", "r"); // Ouvre le fichier en lecture
$contenu = fread($handle, filesize("exemple.txt")); // Lit tout le fichier
fclose($handle); // Ferme le fichier
echo $contenu;
?>

📌 Lecture ligne par ligne avec fgets()

<?php
$handle = fopen("exemple.txt", "r");
while (!feof($handle)) { // Vérifie s'il y a encore des lignes à lire
echo fgets($handle) . "<br>";
}
fclose($handle);
?>
📌 Lecture ligne par ligne avec file() (Retourne un tableau)

<?php
$lines = file("exemple.txt");
foreach ($lines as $line) {
echo $line . "<br>";
}
?>

7.3 Écrire dans un Fichier

📌 Créer un fichier et écrire du texte avec fwrite()

<?php
$handle = fopen("nouveau.txt", "w"); // Mode "w" (écrase le contenu existant)
fwrite($handle, "Hello World !\n");
fwrite($handle, "Bienvenue en PHP !");
fclose($handle);
?>

📌 Ajouter du texte à un fichier existant (a = append)

<?php
$handle = fopen("nouveau.txt", "a");
fwrite($handle, "\nLigne ajoutée !");
fclose($handle);
?>

📌 Écriture simplifiée avec file_put_contents()

<?php
file_put_contents("log.txt", "Nouvelle entrée de log.\n", FILE_APPEND);
?>

7.4 Suppression et Vérification d’un Fichier

📌 Vérifier si un fichier existe avec file_exists()

<?php
if (file_exists("test.txt")) {
echo "Le fichier existe.";
} else {
echo "Le fichier n'existe pas.";
}
?>
📌 Supprimer un fichier avec unlink()

<?php
if (file_exists("test.txt")) {
unlink("test.txt");
echo "Fichier supprimé.";
} else {
echo "Aucun fichier à supprimer.";
}
?>

7.5 Gestion des Répertoires

📌 Créer un dossier avec mkdir()

<?php
mkdir("nouveau_dossier");
?>

📌 Lister les fichiers d’un dossier avec scandir()

<?php
$files = scandir("mon_dossier");
foreach ($files as $file) {
echo $file . "<br>";
}
?>

📌 Supprimer un dossier avec rmdir()

<?php
rmdir("ancien_dossier");
?>

🚨 Attention : rmdir() ne fonctionne que si le dossier est vide.

7.6 Gestion de l’Upload de Fichiers

L’upload de fichiers est une fonctionnalité essentielle pour les images, les documents, etc. PHP
facilite cela via $_FILES.
7.6.1 Créer un formulaire d’upload
<!-- upload.html -->
<form action="upload.php" method="POST" enctype="multipart/form-data">
<input type="file" name="fichier">
<button type="submit">Envoyer</button>
</form>

7.6.2 Traiter l’upload en PHP

<?php
if (isset($_FILES['fichier'])) {
$destination = "uploads/" . basename($_FILES['fichier']['name']);
if (move_uploaded_file($_FILES['fichier']['tmp_name'], $destination)) {
echo "Fichier uploadé avec succès !";
} else {
echo "Erreur lors de l’upload.";
}
}
?>

7.7 Sécurisation de l’Upload

📌 1. Vérifier la taille du fichier

if ($_FILES['fichier']['size'] > 500000) { // Limite à 500 Ko

echo "Fichier trop volumineux.";
}

📌 2. Vérifier l’extension du fichier

$extensions_autorisees = ['jpg', 'png', 'pdf'];

$extension = pathinfo($_FILES['fichier']['name'], PATHINFO_EXTENSION);

if (!in_array($extension, $extensions_autorisees)) {
echo "Format non autorisé.";
}

📌 3. Vérifier le type MIME

$mime_types_autorises = ['image/jpeg', 'image/png', 'application/pdf'];

if (!in_array($_FILES['fichier']['type'], $mime_types_autorises)) {
echo "Type de fichier interdit.";
}
📌 4. Empêcher l’exécution de scripts malveillants

$nom_fichier = basename($_FILES['fichier']['name']);
$nom_fichier = preg_replace("/[^a-zA-Z0-9.\-_]/", "", $nom_fichier);
move_uploaded_file($_FILES['fichier']['tmp_name'], "uploads/" . $nom_fichier);

7.8 Exercices Pratiques 🎯

📌 Exercice 1 :
Créer un script qui lit un fichier donnees.txt et affiche son contenu ligne par ligne.

📌 Correction :

<?php
$handle = fopen("donnees.txt", "r");
while (!feof($handle)) {
echo fgets($handle) . "<br>";
}
fclose($handle);
?>

📌 Exercice 2 :
Créer un formulaire permettant d’écrire dans un fichier messages.txt.

📌 Correction :

<!-- form_message.html -->

<form action="message.php" method="POST">
<textarea name="message"></textarea>
<button type="submit">Enregistrer</button>
</form>

<!-- message.php -->

<?php
if (!empty($_POST['message'])) {
file_put_contents("messages.txt", $_POST['message'] . "\n", FILE_APPEND);
echo "Message enregistré !";
}
?>
📌 Exercice 3 :
Créer un script qui affiche tous les fichiers d’un dossier uploads.

📌 Correction :

<?php
$files = scandir("uploads");
foreach ($files as $file) {
if ($file != "." && $file != "..") {
echo "<a href='uploads/$file'>$file</a><br>";
}
}
?>

7.9 Conclusion
À la fin de ce module, vous savez :
✅ Lire et écrire dans des fichiers en PHP
✅ Vérifier et supprimer des fichiers
✅ Manipuler les répertoires
✅ Gérer l’upload de fichiers avec $_FILES
✅ Sécuriser les fichiers uploadés

🔜 Prochain module : Introduction aux Bases de Données avec MySQL 🗄️🚀

Module 8 : Introduction aux Bases de
Données avec MySQL (Semaine 8)
🎯 Objectifs d’apprentissage :

 Comprendre le rôle des bases de données dans le développement web

 Apprendre à interagir avec une base de données MySQL en PHP
 Utiliser MySQL pour stocker, récupérer, modifier et supprimer des données
 Exécuter des requêtes SQL avec PHP

8.1 Introduction aux Bases de Données et MySQL

Une base de données est un système permettant de stocker, organiser et gérer des données de
manière efficace.
🔹 MySQL est un SGBD (Système de Gestion de Base de Données) open source couramment utilisé
avec PHP.
🔹 Il permet de stocker, modifier et récupérer des données en utilisant le langage SQL (Structured
Query Language).

Pourquoi utiliser MySQL avec PHP ?

✅ Gestion efficace des données 📊

✅ Requêtes rapides et optimisées ⚡
✅ Sécurité des informations 🔒
✅ Utilisé dans les applications web modernes 🌍

8.2 Installation et Configuration de MySQL

📌 Installer MySQL :

 Télécharger et installer XAMPP ou WAMP

 Démarrer le serveur MySQL via le panneau de contrôle

📌 Accéder à MySQL avec phpMyAdmin :

1️⃣ Ouvrir http://localhost/phpmyadmin
2⃣ Créer une nouvelle base de données
3️⃣ Gérer les tables et les données facilement

8.3 Création d’une Base de Données et d’une Table

📌 Créer une base de données en SQL

CREATE DATABASE gestion_users;

📌 Sélectionner la base de données

USE gestion_users;

📌 Créer une table utilisateurs

CREATE TABLE utilisateurs (

id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(100) NOT NULL,
email VARCHAR(100) UNIQUE NOT NULL,
mot_de_passe VARCHAR(255) NOT NULL
);

8.4 Connexion de PHP à MySQL

📌 Connexion avec MySQLi (procédural)

<?php
$conn = mysqli_connect("localhost", "root", "", "gestion_users");

if (!$conn) {
die("Échec de connexion : " . mysqli_connect_error());
}
echo "Connexion réussie !";
?>

📌 Connexion avec PDO (orienté objet, recommandé)

<?php
try {
$pdo = new PDO("mysql:host=localhost;dbname=gestion_users", "root", "");
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "Connexion réussie !";
} catch (PDOException $e) {
die("Erreur : " . $e->getMessage());
}
?>

8.5 Insérer des Données dans une Table

📌 Méthode MySQLi (procédural)
<?php
$conn = mysqli_connect("localhost", "root", "", "gestion_users");

$sql = "INSERT INTO utilisateurs (nom, email, mot_de_passe) VALUES ('Alice',

'[email protected]', '12345')";
if (mysqli_query($conn, $sql)) {
echo "Utilisateur ajouté !";
} else {
echo "Erreur : " . mysqli_error($conn);
}
?>

📌 Méthode PDO (recommandée)

<?php
$pdo = new PDO("mysql:host=localhost;dbname=gestion_users", "root", "");

$sql = "INSERT INTO utilisateurs (nom, email, mot_de_passe) VALUES (:nom,

:email, :mdp)";
$stmt = $pdo->prepare($sql);
$stmt->execute([
'nom' => 'Alice',
'email' => '[email protected]',
'mdp' => password_hash('12345', PASSWORD_DEFAULT)
]);

echo "Utilisateur ajouté !";

?>

8.6 Lire des Données depuis MySQL

📌 Récupérer et afficher les utilisateurs (MySQLi)

<?php
$conn = mysqli_connect("localhost", "root", "", "gestion_users");

$sql = "SELECT * FROM utilisateurs";

$result = mysqli_query($conn, $sql);

while ($row = mysqli_fetch_assoc($result)) {

echo "ID: " . $row['id'] . " - Nom: " . $row['nom'] . " - Email: " .
$row['email'] . "<br>";
}
?>

📌 Récupérer et afficher les utilisateurs (PDO)

<?php
$pdo = new PDO("mysql:host=localhost;dbname=gestion_users", "root", "");

$sql = "SELECT * FROM utilisateurs";

$stmt = $pdo->query($sql);

while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {

echo "ID: {$row['id']} - Nom: {$row['nom']} - Email: {$row['email']}<br>";
}
?>

8.7 Mettre à Jour des Données

📌 Modifier un utilisateur (MySQLi)

<?php
$conn = mysqli_connect("localhost", "root", "", "gestion_users");

$sql = "UPDATE utilisateurs SET email = '[email protected]' WHERE id = 1";

mysqli_query($conn, $sql);
?>

📌 Modifier un utilisateur (PDO)

<?php
$pdo = new PDO("mysql:host=localhost;dbname=gestion_users", "root", "");

$sql = "UPDATE utilisateurs SET email = :email WHERE id = :id";

$stmt = $pdo->prepare($sql);
$stmt->execute(['email' => '[email protected]', 'id' => 1]);
?>

8.8 Supprimer des Données

📌 Supprimer un utilisateur (MySQLi)

<?php
$conn = mysqli_connect("localhost", "root", "", "gestion_users");

$sql = "DELETE FROM utilisateurs WHERE id = 1";

mysqli_query($conn, $sql);
?>
📌 Supprimer un utilisateur (PDO)

<?php
$pdo = new PDO("mysql:host=localhost;dbname=gestion_users", "root", "");

$sql = "DELETE FROM utilisateurs WHERE id = :id";

$stmt = $pdo->prepare($sql);
$stmt->execute(['id' => 1]);
?>

8.9 Sécuriser les Requêtes avec les Requêtes Préparées

Les requêtes préparées empêchent les attaques par injection SQL. Toujours utiliser PDO
avec prepare() et execute().
🚨 Mauvais exemple 🚨

$sql = "SELECT * FROM utilisateurs WHERE email = '".$_GET['email']."'";

✅ Bon exemple avec PDO

$sql = "SELECT * FROM utilisateurs WHERE email = :email";

$stmt = $pdo->prepare($sql);
$stmt->execute(['email' => $_GET['email']]);

8.10 Exercices Pratiques 🎯

📌 Exercice 1 : Créer un script qui affiche tous les utilisateurs d’une base de données.
📌 Exercice 2 : Créer un formulaire permettant d’ajouter un utilisateur en base de données.
📌 Exercice 3 : Modifier l’email d’un utilisateur à partir d’un formulaire.
📌 Exercice 4 : Ajouter un champ âge à la table utilisateurs et afficher les utilisateurs
âgés de plus de 25 ans.

8.11 Conclusion
À la fin de ce module, vous savez :
✅ Installer et configurer MySQL
✅ Se connecter à une base de données en PHP (MySQLi & PDO)
✅ Exécuter des requêtes SQL (SELECT, INSERT, UPDATE, DELETE)
✅ Sécuriser les requêtes avec PDO

🔜 Prochain module : Programmation Orientée Objet (POO) en PHP 🏗️🔍

Module 9 : Programmation Orientée Objet
(POO) en PHP (Semaine 9)
🎯 Objectifs d’apprentissage :

 Comprendre les principes de la programmation orientée objet (POO)

 Apprendre à créer et manipuler des classes et objets en PHP
 Maîtriser les concepts clés : constructeurs, héritage, encapsulation, polymorphisme
 Utiliser les interfaces et les traits pour une meilleure organisation du code

9.1 Introduction à la Programmation Orientée Objet

(POO)
📌 La programmation orientée objet (POO) est un paradigme qui permet de structurer le code en
utilisant des objets plutôt que des fonctions et variables globales.
📌 En PHP, un objet est une instance d’une classe, qui est un modèle définissant des propriétés
(attributs) et des comportements (méthodes).

Pourquoi utiliser la POO en PHP ?

✅ Code mieux organisé et réutilisable 🔄

✅ Maintenance et évolutivité améliorées 🔧
✅ Modélisation plus proche du monde réel 🌍

9.2 Déclaration d'une Classe et d'un Objet

📌 Créer une classe et un objet en PHP

<?php
class Voiture {
public $marque;
public $couleur;

public function rouler() {

return "La voiture roule 🚗💨";
}
}

// Instanciation d'un objet

$maVoiture = new Voiture();
$maVoiture->marque = "Toyota";
$maVoiture->couleur = "Rouge";

echo $maVoiture->marque . " " . $maVoiture->couleur . "<br>";

echo $maVoiture->rouler();
?>

9.3 Le Constructeur et le Destructeur

📌 Le constructeur (__construct()) est une méthode spéciale qui est appelée
automatiquement lors de la création d’un objet.
📌 Le destructeur (__destruct()) est exécuté lorsque l'objet est détruit ou en fin de script.

<?php
class Voiture {
public $marque;
public $couleur;

public function __construct($marque, $couleur) {

$this->marque = $marque;
$this->couleur = $couleur;
}

public function __destruct() {

echo "L'objet {$this->marque} est détruit.";
}
}

$maVoiture = new Voiture("Toyota", "Rouge");

echo "Ma voiture est une {$maVoiture->marque} de couleur {$maVoiture-
>couleur}.";
?>

9.4 Encapsulation et Modificateurs d’Accès

📌 L'encapsulation protège les données en limitant l'accès aux propriétés d'une classe.
📌 En PHP, il existe trois modificateurs d'accès :

 public : accessible partout

 protected : accessible uniquement dans la classe et ses classes dérivées
 private : accessible uniquement dans la classe
<?php
class CompteBancaire {
private $solde;

public function __construct($soldeInitial) {

$this->solde = $soldeInitial;
}

public function deposer($montant) {

$this->solde += $montant;
}

public function afficherSolde() {

return "Solde : {$this->solde}€";
}
}

$compte = new CompteBancaire(500);

$compte->deposer(200);
echo $compte->afficherSolde(); // Solde : 700€
?>

9.5 Héritage : Réutilisation du Code

📌 L'héritage permet à une classe de réutiliser les fonctionnalités d'une autre classe.
📌 Une classe enfant hérite des attributs et méthodes de la classe parent.

<?php
class Animal {
public function faireDuBruit() {
return "Un bruit d'animal 🐾";
}
}

class Chien extends Animal {

public function faireDuBruit() {
return "Woof Woof 🐶";
}
}

$monChien = new Chien();

echo $monChien->faireDuBruit(); // Woof Woof 🐶
?>
9.6 Polymorphisme : Adapter les Méthodes
📌 Le polymorphisme permet à une méthode d’avoir plusieurs formes dans des classes
différentes.

<?php
class Oiseau {
public function chanter() {
return "Piou Piou 🐦";
}
}

class Perroquet extends Oiseau {

public function chanter() {
return "Je parle comme un humain ! 🦜";
}
}

$perroquet = new Perroquet();

echo $perroquet->chanter(); // Je parle comme un humain ! 🦜
?>

9.7 Interfaces et Classes Abstraites

📌 Les interfaces définissent des méthodes obligatoires sans implémentation.
📌 Les classes abstraites sont des modèles que d’autres classes doivent compléter.

Interface
<?php
interface Volant {
public function voler();
}

class Avion implements Volant {

public function voler() {
return "L'avion vole dans le ciel ✈️";
}
}

$avion = new Avion();

echo $avion->voler();
?>

Classe Abstraite

<?php
abstract class Forme {
 abstract public function aire();
}

class Carre extends Forme {

private $cote;

public function __construct($cote) {

$this->cote = $cote;
}

public function aire() {

return $this->cote * $this->cote;
}
}

$carre = new Carre(4);

echo "Aire du carré : " . $carre->aire(); // 16
?>

9.8 Les Traits : Réutilisation de Code

📌 Les traits permettent d’ajouter des fonctionnalités à plusieurs classes sans utiliser
l’héritage.

<?php
trait Message {
public function direBonjour() {
return "Bonjour 👋";
}
}

class Utilisateur {
use Message;
}

$u = new Utilisateur();
echo $u->direBonjour(); // Bonjour 👋
?>

9.9 Exercices Pratiques 🎯

📌 Exercice 1 : Créez une classe Personne avec des propriétés nom et âge, et une méthode
sePresenter().
📌 Exercice 2 : Créez une classe Voiture qui hérite d’une classe Véhicule et redéfinit la
méthode deplacer().
📌 Exercice 3 : Implémentez une interface Calculable qui impose une méthode
calculerAire() dans une classe Rectangle.
📌 Exercice 4 : Utilisez un trait pour ajouter une fonctionnalité logAction() à plusieurs
classes.

9.10 Conclusion
À la fin de ce module, vous savez :
✅ Créer et manipuler des classes et objets en PHP
✅ Utiliser l’encapsulation pour protéger les données
✅ Appliquer l’héritage et le polymorphisme pour optimiser votre code
✅ Exploiter les interfaces, classes abstraites et traits pour mieux structurer votre projet

🔜 Prochain module : Gestion des Sessions et Sécurité en PHP 🔒

Module 10 : Gestion des Sessions et Sécurité
en PHP (Semaine 10)
🎯 Objectifs d’apprentissage :

 Comprendre le fonctionnement des sessions et cookies en PHP 🍪

 Sécuriser les données utilisateur et les authentifications 🔐
 Prévenir les principales failles de sécurité en PHP : SQL Injection, XSS, CSRF ⚠️
 Appliquer les bonnes pratiques pour un développement sécurisé

10.1 Introduction à la Sécurité en PHP

📌 En tant que langage côté serveur, PHP manipule des données sensibles : mots de passe,
identifiants, informations personnelles.
📌 Un manque de sécurité peut exposer votre application aux attaques et compromettre la
confidentialité des données.

🔎 Principales menaces en PHP :

✅ Injection SQL : Piratage des bases de données via des requêtes mal sécurisées
✅ Cross-Site Scripting (XSS) : Injection de scripts malveillants dans les pages web
✅ Cross-Site Request Forgery (CSRF) : Usurpation d'identité via des requêtes non sécurisées
✅ Fuites de données : Mauvaise gestion des sessions et accès non contrôlés

10.2 Gestion des Sessions en PHP

📌 Une session permet de conserver les informations d’un utilisateur d’une page à l’autre.
📌 Les sessions sont stockées côté serveur et identifiées par un ID unique (PHPSESSID).

Démarrer une session

<?php
session_start(); // Toujours appeler cette fonction en début de script

$_SESSION["utilisateur"] = "Jean";
$_SESSION["role"] = "admin";

echo "Utilisateur : " . $_SESSION["utilisateur"];

?>
Détruire une session

<?php
session_start();
session_destroy(); // Supprime toutes les données de session
?>

🔎 Bonnes pratiques :
✅ Toujours appeler session_start(); avant d'utiliser $_SESSION
✅ Détruire les sessions (session_destroy()) après la déconnexion
✅ Régénérer les identifiants de session pour éviter le session hijacking

10.3 Gestion des Cookies en PHP 🍪

📌 Un cookie est un fichier stocké sur l’ordinateur du client, utile pour retenir des préférences ou
suivre un utilisateur.
📌 Contrairement aux sessions, les cookies sont gérés côté client.

Créer un cookie
<?php
setcookie("langue", "francais", time() + 3600, "/"); // Expire après 1 heure
?>

Lire un cookie

<?php
if (isset($_COOKIE["langue"])) {
echo "Langue sélectionnée : " . $_COOKIE["langue"];
}
?>

Supprimer un cookie

<?php
setcookie("langue", "", time() - 3600, "/"); // Date d'expiration passée
?>

🔎 Bonnes pratiques :
✅ Ne stockez jamais de données sensibles dans un cookie
✅ Toujours utiliser le paramètre httponly (setcookie(name, value, expire, path,
domain, secure, httponly)) pour éviter le vol de cookies

10.4 Sécuriser les Données Utilisateur

📌 Un site PHP doit valider et filtrer toutes les entrées utilisateur pour éviter les attaques.

Validation des données

<?php
$nom = filter_input(INPUT_POST, "nom", FILTER_SANITIZE_STRING);
$email = filter_input(INPUT_POST, "email", FILTER_VALIDATE_EMAIL);

if ($email === false) {

echo "Adresse email invalide !";
}
?>
Éviter l’injection SQL (SQL Injection)

❌ Code vulnérable :

<?php
$pdo = new PDO("mysql:host=localhost;dbname=test", "root", "");
$user = $_GET["user"];
$result = $pdo->query("SELECT * FROM utilisateurs WHERE username = '$user'");
?>

✅ Solution avec requêtes préparées :

<?php
$pdo = new PDO("mysql:host=localhost;dbname=test", "root", "");
$stmt = $pdo->prepare("SELECT * FROM utilisateurs WHERE username = :user");
$stmt->execute(["user" => $_GET["user"]]);
?>

10.5 Protection contre les Attaques XSS (Cross-Site

Scripting)
📌 Une attaque XSS consiste à injecter du JavaScript malveillant dans un site web.

🔎 Exemple d'attaque XSS :

L'utilisateur entre <script>alert('Hacked!')</script> dans un formulaire, et le script
s’exécute chez tous les visiteurs.

✅ Solution : Échapper les caractères dangereux avec htmlspecialchars()

<?php
$nom = htmlspecialchars($_POST["nom"], ENT_QUOTES, "UTF-8");
echo "Bienvenue, " . $nom;
?>
10.6 Protection contre les Attaques CSRF (Cross-Site
Request Forgery)
📌 Une attaque CSRF pousse un utilisateur à envoyer une requête non désirée (ex : transfert
d’argent, modification de mot de passe).
📌 Solution : Utiliser un token CSRF unique dans les formulaires.

✅ Ajout d’un token CSRF

<?php
session_start();
$_SESSION["csrf_token"] = bin2hex(random_bytes(32));
?>

<form method="POST" action="process.php">

<input type="hidden" name="csrf_token" value="<?php echo
$_SESSION["csrf_token"]; ?>">
<input type="submit" value="Envoyer">
</form>

✅ Vérification du token côté serveur

<?php
session_start();
if ($_POST["csrf_token"] !== $_SESSION["csrf_token"]) {
die("Requête non autorisée !");
}
?>

10.7 Sécurisation des Mots de Passe

📌 Ne jamais stocker les mots de passe en clair !
📌 PHP fournit password_hash() et password_verify() pour un stockage sécurisé.

Hachage d’un mot de passe

<?php
$motDePasse = "monSuperMotDePasse123";
$hash = password_hash($motDePasse, PASSWORD_DEFAULT);

echo $hash;
?>
Vérification du mot de passe

<?php
$motDePasseEntre = "monSuperMotDePasse123";
if (password_verify($motDePasseEntre, $hash)) {
echo "Mot de passe valide";
} else {
echo "Mot de passe incorrect";
}
?>

🔎 Bonnes pratiques :
✅ Toujours utiliser password_hash() au lieu de md5() ou sha1()
✅ Ne pas stocker de mots de passe en clair dans la base de données

10.8 Exercices Pratiques 🎯

📌 Exercice 1 : Créez un système de connexion utilisant sessions et cookies.
📌 Exercice 2 : Implémentez un formulaire sécurisé contre l’injection SQL et les attaques XSS.
📌 Exercice 3 : Ajoutez une protection CSRF dans un formulaire de contact.
📌 Exercice 4 : Hachez et vérifiez un mot de passe sécurisé avec password_hash().

10.9 Conclusion
✅ Vous savez maintenant :

 Gérer les sessions et cookies en PHP

 Sécuriser les données utilisateur
 Protéger un site contre SQL Injection, XSS, CSRF
 Utiliser des mots de passe sécurisés

🔜 Prochain module : Programmation Web avec PHP et MySQL 🛠️

Module 11 : Programmation Web avec PHP
et MySQL (Semaine 11)
🎯 Objectifs d’apprentissage :

 Comprendre le fonctionnement des bases de données avec MySQL et PHP

 Savoir connecter PHP à MySQL avec PDO
 Effectuer des opérations CRUD (Create, Read, Update, Delete)
 Sécuriser les interactions avec la base de données

11.1 Introduction aux Bases de Données et MySQL

📌 Une base de données est un ensemble structuré d’informations stockées de manière organisée.
📌 MySQL est un Système de Gestion de Base de Données (SGBD) très utilisé avec PHP.

🔎 Concepts de base :
✅ Table : Contient les données sous forme de lignes et colonnes
✅ Enregistrement (ligne) : Une donnée spécifique dans une table
✅ Champ (colonne) : Une information d’un enregistrement
✅ Clé primaire : Identifiant unique d’un enregistrement

11.2 Installation de MySQL et Configuration

🔹 Télécharger et installer XAMPP ou WAMP
🔹 Lancer MySQL et accéder à phpMyAdmin
🔹 Créer une base de données :

CREATE DATABASE gestion_utilisateurs;

🔹 Sélectionner la base de données :

USE gestion_utilisateurs;

🔹 Créer une table utilisateurs :

CREATE TABLE utilisateurs (

id INT AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(50) NOT NULL,
email VARCHAR(100) UNIQUE NOT NULL,
mot_de_passe VARCHAR(255) NOT NULL
);
11.3 Connexion PHP et MySQL avec PDO
📌 PDO (PHP Data Objects) est une méthode sécurisée pour interagir avec MySQL.

🔹 Connexion à la base de données