Formation PHP

Développez des applications web dynamiques côté serveur

Créez un compte gratuitement

Suivez votre progression, sauvegardez vos avancées et obtenez des certificats de complétion. Rejoignez des milliers d'apprenants qui développent leurs compétences avec nous !

Suivi de progression détaillé

Certificats téléchargeables

Badges et accomplissements

Créer mon compte gratuit J'ai déjà un compte

Introduction à PHP

PHP (Hypertext Preprocessor) est un langage de script serveur open-source conçu spécifiquement pour le développement web. Créé en 1994 par Rasmus Lerdorf, PHP est aujourd'hui l'un des langages les plus utilisés pour créer des sites web dynamiques et interactifs.

🌐 Qu'est-ce que PHP ?

PHP est un langage de programmation qui s'exécute côté serveur, contrairement à JavaScript qui s'exécute dans le navigateur. Cela signifie que le code PHP est traité sur le serveur web avant que la page ne soit envoyée au navigateur de l'utilisateur.

💡 Comment fonctionne PHP ?

L'utilisateur demande une page web (ex: mon-site.com/page.php)
Le serveur web (Apache/Nginx) reçoit la requête
Le serveur exécute le code PHP contenu dans le fichier
PHP génère du HTML dynamique
Le serveur envoie le HTML au navigateur de l'utilisateur
Le navigateur affiche la page web

🚀 Pourquoi apprendre PHP ?

PHP est un choix excellent pour débuter en développement web pour plusieurs raisons :

✅ Populaire - Utilisé par 77% des sites web dans le monde, y compris des géants comme WordPress, Facebook, Wikipedia, et Yahoo
✅ Facile à apprendre - Syntaxe simple et intuitive, similaire à C et Java
✅ Puissant - Permet de créer des applications web complètes : sites e-commerce, réseaux sociaux, systèmes de gestion de contenu
✅ Gratuit et Open-Source - Aucun coût de licence, multiplateforme (Windows, Linux, macOS)
✅ Vaste communauté - Des millions de développeurs, documentation complète, nombreuses ressources d'apprentissage
✅ Intégration facile - Fonctionne parfaitement avec MySQL, HTML, CSS, JavaScript
✅ Frameworks modernes - Laravel, Symfony, CodeIgniter pour développer rapidement

📋 Prérequis pour apprendre PHP

Avant de commencer avec PHP, il est recommandé d'avoir des connaissances de base en :

✅ HTML - Pour structurer le contenu des pages web
✅ CSS - Pour styliser les pages web
⚠️ JavaScript - Utile mais pas obligatoire au début

💡 Note importante : PHP nécessite un serveur web pour fonctionner. Vous pouvez installer un environnement de développement local comme XAMPP, WAMP (Windows), MAMP (Mac), ou LAMP (Linux) qui incluent Apache, MySQL et PHP.

🎯 Cas d'usage de PHP

PHP est utilisé pour créer de nombreux types d'applications web :

🌐 Sites web dynamiques - Pages qui changent selon les données
🛒 E-commerce - Boutiques en ligne, paniers d'achat
📝 Systèmes de gestion de contenu - WordPress, Drupal, Joomla
👥 Réseaux sociaux - Forums, blogs, plateformes communautaires
📧 Envoi d'emails - Formulaires de contact, newsletters

📝 Syntaxe PHP

La syntaxe PHP est simple et intuitive. Tout code PHP doit être placé entre les balises d'ouverture <?php et de fermeture ?>. Le code est ensuite exécuté sur le serveur et le résultat est envoyé au navigateur sous forme de HTML.

🔤 Balises PHP

PHP utilise des balises spéciales pour délimiter le code :

<?php ?> - Balises standard (recommandées)
<? ?> - Balises courtes (nécessitent une configuration)
<?= ?> - Équivalent à echo (depuis PHP 5.4)

Exemple basique :


                        <?php

                          // Ceci est un commentaire sur une ligne

                          /* Ceci est un commentaire

                            sur plusieurs lignes */

                          echo "Hello World!"; // Affiche "Hello World!"

                        ?>

📤 Affichage de contenu

PHP offre plusieurs façons d'afficher du contenu :

echo - Affiche une ou plusieurs chaînes (le plus utilisé)
print - Affiche une seule chaîne (retourne 1 en cas de succès)
var_dump() - Affiche des informations détaillées sur une variable (débogage)
print_r() - Affiche une variable de manière lisible (débogage)

Exemples d'affichage :


                        <?php

                        // echo - le plus utilisé

                        echo "Bonjour"; // Affiche: Bonjour

                        echo "Bonjour ", "Monde"; // Affiche: Bonjour Monde


                        // print - similaire à echo

                        print "Hello"; // Affiche: Hello


                        // var_dump - pour déboguer

                        $age = 25;

                        var_dump($age); // Affiche: int(25)

                        ?>

📝 Règles de syntaxe importantes

✅ Les instructions se terminent par un point-virgule (;)
✅ PHP est sensible à la casse pour les noms de variables ($Nom ≠ $nom)
✅ Les noms de fonctions ne sont pas sensibles à la casse (ECHO = echo)
✅ Les espaces et retours à la ligne sont généralement ignorés
✅ Les commentaires ne sont pas exécutés

💡 Note importante : Les fichiers PHP doivent avoir l'extension .php et être exécutés sur un serveur web (Apache, Nginx). Vous ne pouvez pas simplement ouvrir un fichier PHP dans votre navigateur comme un fichier HTML. Il faut passer par un serveur web local ou distant.

📦 Variables

Les variables en PHP sont des conteneurs qui stockent des données. Elles sont essentielles pour créer des applications dynamiques. Contrairement à d'autres langages, PHP détermine automatiquement le type de variable selon la valeur assignée.

📝 Règles de nommage

✅ Doivent commencer par le symbole $ suivi d'une lettre ou d'un underscore
✅ Peuvent contenir des lettres, chiffres et underscores
✅ Sont sensibles à la casse ($nom ≠ $Nom ≠ $NOM)
❌ Ne peuvent pas commencer par un chiffre
❌ Ne peuvent pas contenir d'espaces ou de caractères spéciaux (sauf underscore)

Exemples de variables valides et invalides :


                        <?php

                        // ✅ Variables valides

                        $nom = "Jean";

                        $age = 25;

                        $_prix = 19.99;

                        $nomUtilisateur = "admin"; // camelCase recommandé

                        $est_actif = true; // snake_case aussi valide


                        // ❌ Variables invalides (généreraient des erreurs)

                        // $2nom = "Jean"; // Erreur: ne peut pas commencer par un chiffre

                        // $nom utilisateur = "admin"; // Erreur: espace interdit

                        // $nom-utilisateur = "admin"; // Erreur: tiret interdit

                        ?>

💾 Assignation de valeurs

L'assignation se fait avec l'opérateur =. PHP détermine automatiquement le type de la variable.

Exemples pratiques :


                        <?php

                        // Variables de différents types

                        $nom = "Jean"; // String (chaîne de caractères)

                        $age = 25; // Integer (entier)

                        $prix = 19.99; // Float (décimal)

                        $estActif = true; // Boolean (booléen)

                        $ville = NULL; // NULL (vide)


                        // Utilisation des variables

                        echo "Bonjour " . $nom; // Affiche: Bonjour Jean

                        echo "Vous avez " . $age . " ans"; // Affiche: Vous avez 25 ans


                        // Réassignation (changement de valeur)

                        $age = 26; // La variable $age vaut maintenant 26

                        ?>

🔄 Variables de variables

PHP permet d'utiliser le contenu d'une variable comme nom d'une autre variable. C'est ce qu'on appelle des "variables de variables".

app.formations.php.variables_variable_example_title


                        <?php

                        $nom = "age"; // $nom contient la chaîne "age"

                        $$nom = 25; // Crée $age = 25

                        echo $age; // Affiche: 25

                        ?>

💡 Bonne pratique : Utilisez des noms de variables descriptifs et cohérents. Préférez $nomUtilisateur plutôt que $n ou $x. Cela rend votre code plus lisible et maintenable.

🔢 Types de données

PHP est un langage à typage dynamique et faible. Cela signifie que vous n'avez pas besoin de déclarer le type d'une variable avant de l'utiliser, et PHP peut changer automatiquement le type d'une variable selon le contexte. PHP supporte 8 types de données primitifs.

📝 String (Chaîne de caractères)

Une chaîne est une séquence de caractères, comme du texte. Les chaînes peuvent être délimitées par des guillemets simples (') ou doubles (").

Exemples de chaînes :


                        <?php

                        // Guillemets simples (littéral)

                        $nom = 'Jean'; // String

                        echo 'Bonjour $nom'; // Affiche: Bonjour $nom (pas d'interpolation)


                        // Guillemets doubles (avec interpolation)

                        $prenom = "Marie";

                        echo "Bonjour $prenom"; // Affiche: Bonjour Marie

                        echo "Bonjour {$prenom}"; // Même résultat (syntaxe recommandée)


                        // Concaténation

                        $message = "Bonjour " . $prenom . " !"; // Utilise le point (.)

                        ?>

🔢 Integer (Entier)

Un entier est un nombre sans partie décimale. Il peut être positif, négatif ou zéro.

Exemples d'entiers :


                        <?php

                        $age = 25; // Integer positif

                        $temperature = -10; // Integer négatif

                        $zero = 0; // Zéro

                        $grand = 2147483647; // Maximum sur 32 bits


                        // Opérations arithmétiques

                        $somme = 10 + 5; // 15

                        $produit = 4 * 7; // 28

                        ?>

🔢 Float (Nombre décimal)

Un float (ou double) est un nombre avec une partie décimale. Utilisé pour les calculs nécessitant une précision décimale.

Exemples de décimaux :


                        <?php

                        $prix = 19.99; // Float

                        $pi = 3.14159; // Float

                        $pourcentage = 0.15; // 15%

                        $scientifique = 1.5e3; // 1500 (notation scientifique)


                        // Calcul avec décimaux

                        $total = 19.99 + 5.50; // 25.49

                        ?>

✅ Boolean (Booléen)

Un booléen représente une valeur de vérité. Il ne peut avoir que deux valeurs : true (vrai) ou false (faux).

Exemples de booléens :


                        <?php

                        $estActif = true; // Boolean true

                        $estConnecte = false; // Boolean false


                        // Utilisation dans les conditions

                        if ($estActif) {

                          echo "Le compte est actif";

                        }


                        // Conversion en booléen

                        $valeur = 1; // true en contexte booléen

                        $valeur = 0; // false en contexte booléen

                        $valeur = ""; // false (chaîne vide)

                        ?>

📚 Array (Tableau)

Un tableau stocke plusieurs valeurs dans une seule variable. PHP supporte les tableaux indexés et associatifs.

Exemples de tableaux :


                        <?php

                        // Tableau indexé (ancienne syntaxe)

                        $fruits = array("Pomme", "Banane", "Orange");


                        // Tableau indexé (syntaxe courte PHP 5.4+)

                        $legumes = ["Carotte", "Tomate", "Salade"];


                        // Tableau associatif

                        $personne = [

                          "nom" => "Jean",

                          "age" => 30,

                          "ville" => "Paris"

                        ];


                        // Accès aux éléments

                        echo $fruits[0]; // "Pomme"

                        echo $personne["nom"]; // "Jean"

                        ?>

🎯 Object (Objet)

Un objet est une instance d'une classe. Nous verrons les objets en détail dans la section POO.

❌ NULL

NULL représente une variable sans valeur. Une variable est NULL si elle a été assignée à NULL ou n'a jamais été assignée.

app.formations.php.null_examples_title


                        <?php

                        $ville = NULL; // NULL explicite

                        $nom; // NULL (non initialisée)


                        // Vérifier si une variable est NULL

                        if (is_null($ville)) {

                          echo "La variable est NULL";

                        }

                        ?>

🔍 Vérification de type

PHP fournit plusieurs fonctions pour vérifier le type d'une variable :

Fonctions de vérification de type :


                        <?php

                        $texte = "Hello";

                        $nombre = 42;

                        $decimal = 3.14;

                        $tableau = [1, 2, 3];


                        // Vérifications

                        is_string($texte); // true

                        is_int($nombre); // true

                        is_float($decimal); // true

                        is_array($tableau); // true

                        is_bool(true); // true

                        is_null(NULL); // true


                        // Obtenir le type

                        gettype($texte); // "string"

                        var_dump($nombre); // int(42)

                        ?>

💡 Conversion de types : PHP peut convertir automatiquement les types selon le contexte. Par exemple, <code>"5" + 3</code> donnera <code>8</code> (entier) car PHP convertit la chaîne en nombre. Vous pouvez aussi forcer une conversion avec <code>(int)</code>, <code>(string)</code>, <code>(float)</code>, <code>(bool)</code>, <code>(array)</code>.

➕ Opérateurs

Les opérateurs sont des symboles qui permettent d'effectuer des opérations sur des valeurs. PHP dispose de plusieurs catégories d'opérateurs : arithmétiques, de comparaison, logiques, d'affectation, et plus encore.

🔢 Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent des opérations mathématiques de base.

app.formations.php.operators_arithmetic_example_title


                        <?php

                        $a = 10;

                        $b = 3;


                        // Addition

                        $somme = $a + $b; // 13


                        // Soustraction

                        $difference = $a - $b; // 7


                        // Multiplication

                        $produit = $a * $b; // 30


                        // Division

                        $quotient = $a / $b; // 3.333...


                        // Modulo (reste de la division)

                        $reste = $a % $b; // 1 (10 ÷ 3 = 3 reste 1)


                        // Exponentiation (PHP 5.6+)

                        $puissance = $a ** $b; // 1000 (10³)

                        ?>

🔀 Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et retournent true ou false.

app.formations.php.operators_comparison_example_title


                        <?php

                        $a = 5;

                        $b = "5"; // Chaîne "5"

                        $c = 10;


                        // Égalité (valeur seulement)

                        $egal = ($a == $b); // true (5 == "5")


                        // Identité (valeur ET type)

                        $identique = ($a === $b); // false (int !== string)


                        // Différent

                        $different = ($a != $c); // true

                        $different = ($a <> $c); // true (même chose)


                        // Non identique

                        $nonIdentique = ($a !== $b); // true


                        // Supérieur / Inférieur

                        $superieur = ($c > $a); // true (10 > 5)

                        $inferieur = ($a < $c); // true (5 < 10)

                        $superieurEgal = ($a >= 5); // true

                        $inferieurEgal = ($a <= 5); // true

                        ?>

app.formations.php.operators_comparison_note

🔗 Opérateurs logiques

Les opérateurs logiques combinent des conditions booléennes.

app.formations.php.operators_logical_example_title


                        <?php

                        $age = 25;

                        $estActif = true;

                        $aPermis = false;


                        // ET logique (&& ou and)

                        if ($age >= 18 && $estActif) {

                          echo "Majeur et actif";

                        }


                        // OU logique (|| ou or)

                        if ($estActif || $aPermis) {

                          echo "Actif ou a permis";

                        }


                        // NON logique (!)

                        if (!$aPermis) {

                          echo "Pas de permis";

                        }

                        ?>

📝 Opérateurs d'affectation

Les opérateurs d'affectation assignent des valeurs aux variables. PHP offre des opérateurs d'affectation combinés pour simplifier le code.

app.formations.php.operators_assignment_example_title


                        <?php

                        $x = 10; // Affectation simple


                        // Affectation combinée

                        $x += 5; // Équivaut à: $x = $x + 5 (résultat: 15)

                        $x -= 3; // Équivaut à: $x = $x - 3 (résultat: 12)

                        $x *= 2; // Équivaut à: $x = $x * 2 (résultat: 24)

                        $x /= 4; // Équivaut à: $x = $x / 4 (résultat: 6)

                        $x %= 5; // Équivaut à: $x = $x % 5 (résultat: 1)


                        // Concaténation avec affectation

                        $texte = "Hello";

                        $texte .= " World"; // Équivaut à: $texte = $texte . " World"

                        echo $texte; // "Hello World"

                        ?>

app.formations.php.operators_concat_title

app.formations.php.operators_concat_text

app.formations.php.operators_concat_examples_title


                        <?php

                        $prenom = "Jean";

                        $nom = "Dupont";

                        $age = 30;


                        // Concaténation simple

                        $nomComplet = $prenom . " " . $nom; // "Jean Dupont"


                        // Concaténation avec variables

                        $message = "Bonjour " . $prenom . ", vous avez " . $age . " ans";

                        // "Bonjour Jean, vous avez 30 ans"


                        // Avec guillemets doubles (interpolation)

                        $message2 = "Bonjour $prenom, vous avez $age ans"; // Plus simple !

                        ?>

➕ Opérateurs d'incrémentation et décrémentation

Ces opérateurs augmentent ou diminuent une variable de 1.

app.formations.php.operators_increment_example_title


                        <?php

                        $x = 5;


                        // Pré-incrémentation (incrémente puis retourne)

                        echo ++$x; // Affiche: 6 (x vaut maintenant 6)


                        // Post-incrémentation (retourne puis incrémente)

                        $x = 5;

                        echo $x++; // Affiche: 5 (mais x vaut maintenant 6)

                        echo $x; // Affiche: 6


                        // Décrémentation

                        $x = 5;

                        echo --$x; // Affiche: 4

                        echo $x--; // Affiche: 4 (mais x vaut maintenant 3)

                        ?>

🔀 Conditions

Les structures conditionnelles permettent d'exécuter du code uniquement si certaines conditions sont remplies. C'est l'un des concepts fondamentaux de la programmation, permettant de créer des applications qui réagissent différemment selon les situations.

app.formations.php.conditions_if_title

app.formations.php.conditions_if_text

app.formations.php.conditions_if_example_title


                        <?php

                        $age = 18;


                        // Structure if simple

                        if ($age >= 18) {

                          echo "Vous êtes majeur";

                        }


                        // Structure if / else

                        if ($age < 18) {

                          echo "Vous êtes mineur";

                        } else {

                          echo "Vous êtes majeur";

                        }


                        // Structure if / elseif / else (conditions multiples)

                        if ($age < 18) {

                          echo "Mineur";

                        } elseif ($age == 18) {

                          echo "Tout juste majeur";

                        } elseif ($age < 65) {

                          echo "Majeur";

                        } else {

                          echo "Senior";

                        }

                        ?>

app.formations.php.operators_ternary_title

app.formations.php.operators_ternary_text

app.formations.php.operators_ternary_syntax_title


                        <?php

                        $age = 20;


                        // Syntaxe: (condition) ? valeur_si_vrai : valeur_si_faux

                        $statut = ($age >= 18) ? "Majeur" : "Mineur";

                        echo $statut; // "Majeur"


                        // Équivalent à:

                        if ($age >= 18) {

                          $statut = "Majeur";

                        } else {

                          $statut = "Mineur";

                        }


                        // Ternaire imbriqué (à utiliser avec modération)

                        $note = 85;

                        $resultat = ($note >= 90) ? "Excellent" : ($note >= 70) ? "Bien" : "À améliorer";

                        ?>

app.formations.php.conditions_switch_title

La structure switch est utile quand vous avez plusieurs conditions à vérifier sur la même variable. Elle est souvent plus lisible qu'une série de if/elseif.

app.formations.php.conditions_switch_example_title


                        <?php

                        $jour = "lundi";


                        switch ($jour) {

                          case "lundi":

                            echo "Premier jour de la semaine";

                            break; // Important: arrête l'exécution

                          case "vendredi":

                            echo "Dernier jour de travail";

                            break;

                          case "samedi":

                          case "dimanche":

                            echo "Week-end !";

                            break;

                          default:

                            echo "Jour de semaine";

                        }


                        // Exemple avec nombres

                        $note = 85;

                        switch (true) {

                          case ($note >= 90):

                            echo "Excellent";

                            break;

                          case ($note >= 70):

                            echo "Bien";

                            break;

                          default:

                            echo "À améliorer";

                        }

                        ?>

⚠️ Important : N'oubliez jamais le <code>break</code> dans un <code>switch</code> ! Sans <code>break</code>, PHP continuera à exécuter les cases suivantes (c'est ce qu'on appelle "fall-through"). C'est parfois voulu (comme dans l'exemple samedi/dimanche), mais généralement c'est une erreur.

✅ Conditions avec opérateurs logiques

Vous pouvez combiner plusieurs conditions avec les opérateurs logiques && (ET), || (OU), et ! (NON).

app.formations.php.operators_logical_examples_title


                        <?php

                        $age = 25;

                        $estActif = true;

                        $aPermis = true;


                        // ET logique (les deux conditions doivent être vraies)

                        if ($age >= 18 && $estActif) {

                          echo "Majeur et actif";

                        }


                        // OU logique (au moins une condition doit être vraie)

                        if ($age >= 18 || $aPermis) {

                          echo "Majeur ou a permis";

                        }


                        // NON logique (inverse la condition)

                        if (!$estActif) {

                          echo "Compte inactif";

                        }


                        // Conditions complexes

                        if (($age >= 18 && $estActif) || $aPermis) {

                          echo "Accès autorisé";

                        }

                        ?>

🎯 Cas d'usage pratiques

Voici quelques exemples concrets d'utilisation des conditions dans des situations réelles :

Exemple 1 : Vérification d'authentification


                        <?php

                        $estConnecte = true;

                        $estAdmin = false;


                        if ($estConnecte) {

                          if ($estAdmin) {

                            echo "Bienvenue administrateur";

                          } else {

                            echo "Bienvenue utilisateur";

                          }

                        } else {

                          echo "Veuillez vous connecter";

                        }

                        ?>

Exemple 2 : Calcul de remise


                        <?php

                        $montant = 150; // Montant d'achat

                        $remise = 0; // Remise en pourcentage


                        if ($montant >= 200) {

                          $remise = 20; // 20% de remise

                        } elseif ($montant >= 100) {

                          $remise = 10; // 10% de remise

                        } elseif ($montant >= 50) {

                          $remise = 5; // 5% de remise

                        }


                        $montantFinal = $montant - ($montant * $remise / 100);

                        echo "Montant: $montant€, Remise: $remise%, Total: $montantFinal€";

                        ?>

🔁 Boucles

Les boucles permettent de répéter des instructions plusieurs fois sans avoir à réécrire le même code. C'est un concept fondamental qui permet d'automatiser des tâches répétitives et de traiter des collections de données.

app.formations.php.loops_for_title

app.formations.php.loops_for_text

app.formations.php.loops_for_syntax_title


                        <?php

                        // Syntaxe: for (initialisation; condition; incrémentation)

                        // Exemple simple: compter de 0 à 4

                        for ($i = 0; $i < 5; $i++) {

                          echo $i . " "; // Affiche: 0 1 2 3 4

                        }


                        // Compter de 1 à 10

                        for ($i = 1; $i <= 10; $i++) {

                          echo $i . " ";

                        }


                        // Compter à rebours de 10 à 1

                        for ($i = 10; $i >= 1; $i--) {

                          echo $i . " "; // Affiche: 10 9 8 7 6 5 4 3 2 1

                        }


                        // Compter par pas de 2

                        for ($i = 0; $i <= 10; $i += 2) {

                          echo $i . " "; // Affiche: 0 2 4 6 8 10

                        }

                        ?>

app.formations.php.loops_while_title

app.formations.php.loops_while_text

Exemples avec while :


                        <?php

                        // Exemple simple

                        $i = 0;

                        while ($i < 5) {

                          echo $i . " ";

                          $i++; // Important: incrémenter pour éviter la boucle infinie

                        }


                        // Exemple pratique: générer des nombres jusqu'à atteindre 100

                        $nombre = 1;

                        while ($nombre <= 100) {

                          echo $nombre . " ";

                          $nombre *= 2; // Multiplier par 2 à chaque itération

                        } // Affiche: 1 2 4 8 16 32 64

                        ?>

app.formations.php.loops_dowhile_title

app.formations.php.loops_dowhile_text

app.formations.php.loops_dowhile_example_title


                        <?php

                        $i = 0;

                        do {

                          echo $i . " ";

                          $i++;

                        } while ($i < 5);


                        // Même si la condition est fausse au début, le code s'exécute une fois

                        $x = 10;

                        do {

                          echo "Exécuté au moins une fois";

                        } while ($x < 5); // Condition fausse, mais s'exécute quand même

                        ?>

🔄 Boucle foreach

La boucle foreach est spécialement conçue pour parcourir les tableaux et les objets. C'est la boucle la plus utilisée en PHP pour traiter des collections de données.

foreach avec tableaux indexés :


                        <?php

                        $fruits = ["Pomme", "Banane", "Orange"];


                        // Syntaxe simple (valeur seulement)

                        foreach ($fruits as $fruit) {

                          echo $fruit . "<br>";

                        }

                        // Affiche: Pomme, Banane, Orange


                        // Syntaxe avec clé et valeur

                        foreach ($fruits as $index => $fruit) {

                          echo "Index $index: $fruit<br>";

                        }

                        // Affiche: Index 0: Pomme, Index 1: Banane, Index 2: Orange

                        ?>

foreach avec tableaux associatifs :


                        <?php

                        $personne = [

                          "nom" => "Jean",

                          "age" => 30,

                          "ville" => "Paris"

                        ];


                        foreach ($personne as $cle => $valeur) {

                          echo "$cle: $valeur<br>";

                        }

                        // Affiche: nom: Jean, age: 30, ville: Paris

                        ?>

⏹️ Contrôle des boucles : break et continue

Les mots-clés break et continue permettent de contrôler l'exécution des boucles.

break et continue :


                        <?php

                        // break - arrête complètement la boucle

                        for ($i = 0; $i < 10; $i++) {

                          if ($i == 5) {

                            break; // Arrête la boucle quand i = 5

                          }

                          echo $i . " "; // Affiche: 0 1 2 3 4

                        }


                        // continue - passe à l'itération suivante

                        for ($i = 0; $i < 10; $i++) {

                          if ($i % 2 == 0) { // Si i est pair

                            continue; // Passe au suivant sans exécuter le reste

                          }

                          echo $i . " "; // Affiche seulement les impairs: 1 3 5 7 9

                        }

                        ?>

🎯 Cas d'usage pratiques

Voici des exemples concrets d'utilisation des boucles dans des situations réelles :

app.formations.php.loops_example1_title


                        <?php

                        $utilisateurs = ["Jean", "Marie", "Pierre", "Sophie"];


                        echo "<ul>";

                        foreach ($utilisateurs as $utilisateur) {

                          echo "<li>$utilisateur</li>";

                        }

                        echo "</ul>";

                        // Génère une liste HTML avec tous les utilisateurs

                        ?>

app.formations.php.loops_example2_title


                        <?php

                        $nombres = [10, 20, 30, 40, 50];

                        $somme = 0;


                        foreach ($nombres as $nombre) {

                          $somme += $nombre; // Ajoute chaque nombre à la somme

                        }


                        echo "La somme est: $somme"; // Affiche: La somme est: 150

                        ?>

💡 Bonne pratique : Utilisez foreach pour parcourir les tableaux plutôt que for quand c'est possible. C'est plus lisible, plus sûr (pas de risque d'erreur d'index), et plus performant.

⚡ Fonctions

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique. Elles permettent d'organiser votre code, d'éviter la répétition, et de faciliter la maintenance. PHP dispose de milliers de fonctions intégrées, mais vous pouvez aussi créer vos propres fonctions.

📝 Créer une fonction

Pour créer une fonction, utilisez le mot-clé function suivi du nom de la fonction et de parenthèses contenant les paramètres (optionnels).

Syntaxe de base :


                        <?php

                        // Fonction simple sans paramètres

                        function direBonjour() {

                          echo "Bonjour !";

                        }


                        direBonjour(); // Appelle la fonction


                        // Fonction avec paramètres

                        function saluer($nom) {

                          return "Bonjour " . $nom;

                        }


                        echo saluer("Marie"); // Affiche: "Bonjour Marie"

                        ?>

📤 return vs echo

Il y a une différence importante entre return et echo dans une fonction :

echo - Affiche directement le résultat (ne peut pas être récupéré)
return - Retourne une valeur que vous pouvez utiliser ailleurs (recommandé)

Différence entre return et echo :


                        <?php

                        // Avec echo (affiche directement)

                        function afficherNom($nom) {

                          echo $nom; // Affiche immédiatement

                        }

                        afficherNom("Jean"); // Affiche: Jean

                        $resultat = afficherNom("Jean"); // $resultat vaut NULL


                        // Avec return (retourne une valeur)

                        function obtenirNom($nom) {

                          return $nom; // Retourne la valeur

                        }

                        $resultat = obtenirNom("Jean"); // $resultat vaut "Jean"

                        echo $resultat; // Affiche: Jean

                        ?>

📥 Paramètres de fonction

Les fonctions peuvent accepter plusieurs paramètres, avec ou sans valeurs par défaut.

Fonctions avec plusieurs paramètres :


                        <?php

                        // Fonction avec plusieurs paramètres

                        function presenter($prenom, $nom, $age) {

                          return "Je m'appelle $prenom $nom et j'ai $age ans";

                        }


                        echo presenter("Jean", "Dupont", 30);

                        // Affiche: "Je m'appelle Jean Dupont et j'ai 30 ans"


                        // Paramètres avec valeurs par défaut

                        function saluer($nom, $langue = "fr") {

                          if ($langue == "en") {

                            return "Hello $nom";

                          } else {

                            return "Bonjour $nom";

                          }

                        }


                        echo saluer("Marie"); // "Bonjour Marie" (utilise la valeur par défaut)

                        echo saluer("John", "en"); // "Hello John"

                        ?>

🔢 Type hints et return types

Depuis PHP 7, vous pouvez spécifier les types de paramètres et de retour pour une meilleure sécurité et lisibilité.

Fonctions avec types :


                        <?php

                        // Spécifier le type des paramètres

                        function additionner(int $a, int $b): int {

                          return $a + $b;

                        }


                        echo additionner(5, 3); // 8


                        // Fonction avec type string

                        function majuscules(string $texte): string {

                          return strtoupper($texte);

                        }


                        echo majuscules("bonjour"); // "BONJOUR"

                        ?>

📚 Portée des variables (scope)

Les variables définies dans une fonction sont locales à cette fonction. Pour utiliser une variable globale, utilisez le mot-clé global.

Portée des variables :


                        <?php

                        $nom = "Jean"; // Variable globale


                        function afficherNom() {

                          // $nom n'est pas accessible ici par défaut

                          $nomLocal = "Marie"; // Variable locale

                          echo $nomLocal; // "Marie"

                        }


                        // Utiliser une variable globale

                        function afficherNomGlobal() {

                          global $nom; // Accède à la variable globale

                          echo $nom; // "Jean"

                        }


                        // Meilleure pratique: passer en paramètre

                        function afficherNomParam($nom) {

                          echo $nom; // Utilise le paramètre

                        }

                        afficherNomParam($nom); // "Jean"

                        ?>

🎯 Fonctions intégrées de PHP

PHP dispose de milliers de fonctions intégrées pour manipuler les chaînes, les tableaux, les dates, les fichiers, etc.

Exemples de fonctions intégrées :


                        <?php

                        // Fonctions pour chaînes

                        $texte = "  Bonjour Monde  ";

                        strlen($texte); // Longueur: 15

                        strtoupper($texte); // "  BONJOUR MONDE  "

                        trim($texte); // "Bonjour Monde" (enlève espaces)

                        substr($texte, 0, 7); // "Bonjour"


                        // Fonctions pour tableaux

                        $tableau = [3, 1, 4, 2];

                        count($tableau); // Nombre d'éléments: 4

                        sort($tableau); // Trie le tableau

                        array_reverse($tableau); // Inverse l'ordre


                        // Fonctions mathématiques

                        abs(-5); // Valeur absolue: 5

                        round(3.7); // Arrondi: 4

                        max(1, 5, 3); // Maximum: 5

                        min(1, 5, 3); // Minimum: 1

                        ?>

🎯 Cas d'usage pratiques

Voici des exemples de fonctions utiles dans des situations réelles :

Exemple 1 : Calculer le prix TTC


                        <?php

                        function calculerTTC(float $prixHT, float $tauxTVA = 20.0): float {

                          $montantTVA = $prixHT * ($tauxTVA / 100);

                          return $prixHT + $montantTVA;

                        }


                        echo calculerTTC(100); // 120 (TVA 20% par défaut)

                        echo calculerTTC(100, 10); // 110 (TVA 10%)

                        ?>

Exemple 2 : Valider un email


                        <?php

                        function validerEmail(string $email): bool {

                          return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;

                        }


                        if (validerEmail("test@example.com")) {

                          echo "Email valide";

                        } else {

                          echo "Email invalide";

                        }

                        ?>

💡 Bonne pratique : Donnez des noms descriptifs à vos fonctions. Préférez calculerPrixTTC() plutôt que calc(). Cela rend votre code auto-documenté et plus facile à comprendre.

📚 Tableaux

Les tableaux (arrays) sont des structures de données qui permettent de stocker plusieurs valeurs dans une seule variable. Ils sont essentiels en PHP et sont utilisés partout : pour stocker des listes d'utilisateurs, des données de formulaires, des résultats de base de données, etc.

📋 Types de tableaux

PHP supporte deux types de tableaux :

Tableaux indexés - Les éléments sont accessibles par un index numérique (0, 1, 2, ...)
Tableaux associatifs - Les éléments sont accessibles par des clés nommées ("nom", "age", etc.)

🔢 Tableaux indexés

Les tableaux indexés utilisent des indices numériques commençant à 0.

Créer et utiliser un tableau indexé :


                        <?php

                        // Syntaxe ancienne (PHP 5.3 et antérieur)

                        $fruits = array("Pomme", "Banane", "Orange");


                        // Syntaxe courte (PHP 5.4+) - RECOMMANDÉE

                        $legumes = ["Carotte", "Tomate", "Salade"];


                        // Accéder aux éléments (indices commencent à 0)

                        echo $fruits[0]; // "Pomme"

                        echo $fruits[1]; // "Banane"

                        echo $fruits[2]; // "Orange"


                        // Modifier un élément

                        $fruits[1] = "Kiwi"; // Remplace "Banane" par "Kiwi"


                        // Ajouter un élément

                        $fruits[] = "Fraise"; // Ajoute à la fin

                        $fruits[10] = "Mangue"; // Ajoute à l'index 10

                        ?>

🔑 Tableaux associatifs

Les tableaux associatifs utilisent des clés nommées au lieu d'indices numériques. C'est très utile pour représenter des données structurées.

Créer et utiliser un tableau associatif :


                        <?php

                        // Syntaxe avec array()

                        $personne = array(

                          "nom" => "Jean",

                          "prenom" => "Dupont",

                          "age" => 30,

                          "ville" => "Paris"

                        );


                        // Syntaxe courte (recommandée)

                        $etudiant = [

                          "nom" => "Marie",

                          "age" => 25,

                          "note" => 18.5

                        ];


                        // Accéder aux éléments

                        echo $personne["nom"]; // "Jean"

                        echo $personne["age"]; // 30


                        // Modifier un élément

                        $personne["age"] = 31; // Met à jour l'âge


                        // Ajouter un élément

                        $personne["email"] = "jean@example.com";

                        ?>

🔄 Parcourir les tableaux

Il existe plusieurs façons de parcourir un tableau en PHP.

Méthodes pour parcourir un tableau :


                        <?php

                        $fruits = ["Pomme", "Banane", "Orange"];


                        // Méthode 1: foreach (RECOMMANDÉE)

                        foreach ($fruits as $fruit) {

                          echo $fruit . "<br>";

                        }


                        // Méthode 2: foreach avec index

                        foreach ($fruits as $index => $fruit) {

                          echo "$index: $fruit<br>";

                        }


                        // Méthode 3: for (pour tableaux indexés)

                        for ($i = 0; $i < count($fruits); $i++) {

                          echo $fruits[$i] . "<br>";

                        }

                        ?>

🛠️ Fonctions utiles pour les tableaux

PHP offre de nombreuses fonctions pour manipuler les tableaux.

Fonctions courantes pour tableaux :


                        <?php

                        $nombres = [3, 1, 4, 2, 5];


                        // Compter les éléments

                        count($nombres); // 5

                        sizeof($nombres); // 5 (identique à count)


                        // Vérifier si un élément existe

                        in_array(3, $nombres); // true

                        array_key_exists(0, $nombres); // true


                        // Trier

                        sort($nombres); // [1, 2, 3, 4, 5] (modifie le tableau original)

                        rsort($nombres); // Tri décroissant

                        asort($personne); // Trie un tableau associatif par valeur

                        ksort($personne); // Trie par clé


                        // Ajouter/Supprimer des éléments

                        array_push($nombres, 6); // Ajoute à la fin

                        array_pop($nombres); // Retire le dernier

                        array_unshift($nombres, 0); // Ajoute au début

                        array_shift($nombres); // Retire le premier


                        // Rechercher

                        array_search(3, $nombres); // Retourne l'index de 3

                        array_keys($personne); // Retourne toutes les clés

                        array_values($personne); // Retourne toutes les valeurs

                        ?>

📊 Tableaux multidimensionnels

Un tableau peut contenir d'autres tableaux, créant ainsi des tableaux multidimensionnels. C'est très utile pour représenter des structures de données complexes.

app.formations.php.arrays_multidimensional_example_title


                        <?php

                        // Tableau de personnes

                        $personnes = [

                          [

                            "nom" => "Jean",

                            "age" => 30,

                            "ville" => "Paris"

                          ],

                          [

                            "nom" => "Marie",

                            "age" => 25,

                            "ville" => "Lyon"

                          ],

                          [

                            "nom" => "Pierre",

                            "age" => 35,

                            "ville" => "Marseille"

                          ]

                        ];


                        // Accéder aux éléments

                        echo $personnes[0]["nom"]; // "Jean"

                        echo $personnes[1]["age"]; // 25


                        // Parcourir un tableau multidimensionnel

                        foreach ($personnes as $personne) {

                          echo "{$personne['nom']} a {$personne['age']} ans et habite à {$personne['ville']}<br>";

                        }

                        ?>

🎯 Cas d'usage pratiques

Voici des exemples concrets d'utilisation des tableaux :

Exemple 1 : Stocker des données de formulaire


                        <?php

                        // Données d'un formulaire

                        $formulaire = [

                          "nom" => "Jean",

                          "email" => "jean@example.com",

                          "age" => 30,

                          "hobbies" => ["Lecture", "Sport", "Musique"]

                        ];


                        // Traiter les données

                        foreach ($formulaire as $cle => $valeur) {

                          if (is_array($valeur)) {

                            echo "$cle: " . implode(", ", $valeur) . "<br>";

                          } else {

                            echo "$cle: $valeur<br>";

                          }

                        }

                        ?>

Exemple 2 : Manipuler des listes


                        <?php

                        $produits = ["Laptop", "Souris", "Clavier"];


                        // Ajouter un produit

                        $produits[] = "Écran";


                        // Supprimer un produit

                        $index = array_search("Souris", $produits);

                        if ($index !== false) {

                          unset($produits[$index]);

                        }


                        // Réindexer le tableau après suppression

                        $produits = array_values($produits);


                        // Afficher tous les produits

                        foreach ($produits as $produit) {

                          echo "- $produit<br>";

                        }

                        ?>

💡 Bonne pratique : Utilisez la syntaxe courte [] plutôt que array() pour créer des tableaux. C'est plus moderne, plus lisible, et c'est la syntaxe recommandée depuis PHP 5.4.

📋 Formulaires

app.formations.php.forms_text

📤 Méthodes GET et POST

Il existe deux méthodes principales pour envoyer des données depuis un formulaire :

GET - Les données sont visibles dans l'URL (limité à ~2000 caractères). Utilisé pour les recherches, filtres, etc.
POST - Les données sont envoyées de manière sécurisée (non visibles dans l'URL). Utilisé pour les formulaires de connexion, d'inscription, etc.

📥 Récupérer les données POST

Les données envoyées via POST sont accessibles via le superglobal $_POST.

Exemple de formulaire avec POST :


                        <!-- Formulaire HTML -->

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

                          <input type="text" name="nom" placeholder="Votre nom" required>

                          <input type="email" name="email" placeholder="Votre email" required>

                          <button type="submit">Envoyer</button>

                        </form>


                        // traitement.php - Récupérer les données

                        <?php

                        if ($_SERVER["REQUEST_METHOD"] == "POST") {

                          // Récupérer les données

                          $nom = $_POST["nom"] ?? ''; // Utilise ?? pour valeur par défaut

                          $email = $_POST["email"] ?? '';


                          // Valider les données

                          if (!empty($nom) && !empty($email)) {

                            echo "Bonjour $nom, votre email est $email";

                          } else {

                            echo "Veuillez remplir tous les champs";

                          }

                        }

                        ?>

📥 Récupérer les données GET

Les données envoyées via GET sont accessibles via le superglobal $_GET et apparaissent dans l'URL.

Exemple avec GET :


                        // URL: recherche.php?q=php&categorie=web

                        <?php

                        // Récupérer les paramètres GET

                        $recherche = $_GET["q"] ?? ''; // "php"

                        $categorie = $_GET["categorie"] ?? ''; // "web"


                        if (!empty($recherche)) {

                          echo "Résultats pour: $recherche dans la catégorie $categorie";

                        }

                        ?>

app.formations.php.forms_security_title

Il est crucial de valider et sécuriser les données des formulaires pour éviter les attaques (XSS, injection SQL, etc.).

app.formations.php.forms_validation_example_title


                        <?php

                        if ($_SERVER["REQUEST_METHOD"] == "POST") {

                          // Récupérer et nettoyer les données

                          $nom = trim($_POST["nom"] ?? ''); // Enlève les espaces

                          $email = filter_var($_POST["email"] ?? '', FILTER_SANITIZE_EMAIL);

                          $message = htmlspecialchars($_POST["message"] ?? '', ENT_QUOTES, 'UTF-8');


                          // Valider

                          $erreurs = [];


                          if (empty($nom)) {

                            $erreurs[] = "Le nom est requis";

                        } elseif (strlen($nom) < 2) {

                            $erreurs[] = "Le nom doit contenir au moins 2 caractères";

                        }


                          if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {

                            $erreurs[] = "Email invalide";

                        }


                          if (empty($erreurs)) {

                            // Traiter les données (envoyer email, sauvegarder en BDD, etc.)

                            echo "Formulaire validé avec succès !";

                        } else {

                            // Afficher les erreurs

                            foreach ($erreurs as $erreur) {

                              echo "Erreur: $erreur<br>";

                            }

                          }

                        }

                        ?>

📋 Exemple complet de formulaire

Voici un exemple complet avec formulaire HTML et traitement PHP sur la même page :

Formulaire complet :


                        <?php

                        $message = '';

                        $erreur = '';


                        if ($_SERVER["REQUEST_METHOD"] == "POST") {

                          $nom = trim($_POST["nom"] ?? '');

                          $email = filter_var($_POST["email"] ?? '', FILTER_SANITIZE_EMAIL);


                          if (empty($nom)) {

                            $erreur = "Le nom est requis";

                        } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {

                            $erreur = "Email invalide";

                        } else {

                            $message = "Merci $nom, votre formulaire a été envoyé !";

                            // Ici vous pourriez envoyer un email, sauvegarder en BDD, etc.

                          }

                        }

                        ?>


                        <!DOCTYPE html>

                        <html>

                        <head>

                          <title>Formulaire de contact</title>

                        </head>

                        <body>

                          <?php if ($message): ?>

                            <p style="color: green;"><?php echo $message; ?></p>

                          <?php endif; ?>


                          <?php if ($erreur): ?>

                            <p style="color: red;"><?php echo $erreur; ?></p>

                          <?php endif; ?>


                          <form method="POST" action="">

                            <input type="text" name="nom" placeholder="Nom" required>

                            <input type="email" name="email" placeholder="Email" required>

                            <button type="submit">Envoyer</button>

                          </form>

                        </body>

                        </html>

⚠️ Sécurité importante : Toujours valider et nettoyer les données des formulaires ! Utilisez htmlspecialchars() pour éviter les attaques XSS, filter_var() pour valider les emails, et des requêtes préparées pour les bases de données (voir section PDO).

🔐 Sessions

Les sessions permettent de stocker des informations utilisateur entre les pages web. Contrairement aux cookies qui sont stockés côté client, les sessions sont stockées côté serveur, ce qui les rend plus sécurisées pour stocker des données sensibles.

🌐 Comment fonctionnent les sessions ?

Quand vous démarrez une session, PHP crée un identifiant unique (session ID) qui est envoyé au navigateur sous forme de cookie. Ce cookie permet au serveur de reconnaître l'utilisateur lors des requêtes suivantes et de récupérer ses données de session.

▶️ Démarrer une session

Avant d'utiliser les sessions, vous devez appeler session_start() au début de chaque page PHP qui utilise les sessions.

Démarrer et utiliser une session :


                        <?php

                        // Démarrer la session (doit être appelé avant tout output HTML)

                        session_start();


                        // Stocker des données dans la session

                        $_SESSION["username"] = "Jean";

                        $_SESSION["email"] = "jean@example.com";

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

                        $_SESSION["login_time"] = time(); // Timestamp actuel


                        // Récupérer des données de la session

                        echo "Bonjour " . $_SESSION["username"]; // "Bonjour Jean"


                        // Vérifier si une variable de session existe

                        if (isset($_SESSION["username"])) {

                          echo "Utilisateur connecté: " . $_SESSION["username"];

                        }

                        ?>

🗑️ Supprimer des données de session

Vous pouvez supprimer des variables individuelles ou détruire complètement la session.

Supprimer des données de session :


                        <?php

                        session_start();


                        // Supprimer une variable spécifique

                        unset($_SESSION["username");


                        // Supprimer toutes les variables de session

                        $_SESSION = []; // Vide le tableau


                        // Détruire complètement la session

                        session_destroy(); // Détruit la session côté serveur

                        // Note: session_destroy() ne supprime pas le cookie, il faut aussi:

                        if (ini_get("session.use_cookies")) {

                          $params = session_get_cookie_params();

                          setcookie(session_name(), '', time() - 42000,

                            $params["path"], $params["domain"],

                            $params["secure"], $params["httponly"]

                          );

                        }

                        ?>

🔐 Exemple : Système de connexion

Voici un exemple complet d'utilisation des sessions pour un système de connexion :

Système de connexion avec sessions :


                        // login.php - Page de connexion

                        <?php

                        session_start();


                        if ($_SERVER["REQUEST_METHOD"] == "POST") {

                          $username = $_POST["username"] ?? '';

                          $password = $_POST["password"] ?? '';


                          // Vérifier les identifiants (exemple simplifié)

                          if ($username == "admin" && $password == "secret123") {

                            // Créer la session

                            $_SESSION["logged_in"] = true;

                            $_SESSION["username"] = $username;

                            $_SESSION["login_time"] = time();


                            // Rediriger vers la page d'accueil

                            header("Location: index.php");

                            exit;

                          } else {

                            $erreur = "Identifiants incorrects";

                          }

                        }

                        ?>


                        // index.php - Page protégée

                        <?php

                        session_start();


                        // Vérifier si l'utilisateur est connecté

                        if (!isset($_SESSION["logged_in"]) || !$_SESSION["logged_in"]) {

                          // Rediriger vers la page de connexion

                          header("Location: login.php");

                          exit;

                        }


                        echo "Bienvenue " . $_SESSION["username"] . " !";

                        ?>


                        // logout.php - Déconnexion

                        <?php

                        session_start();

                        $_SESSION = []; // Vider la session

                        session_destroy(); // Détruire la session

                        header("Location: login.php");

                        exit;

                        ?>

⏱️ Durée de vie des sessions

Par défaut, une session PHP expire après 24 minutes d'inactivité. Vous pouvez modifier cette durée dans le fichier php.ini ou avec ini_set().

Configurer la durée de vie des sessions :


                        <?php

                        // Modifier la durée de vie de la session (en secondes)

                        ini_set('session.gc_maxlifetime', 3600); // 1 heure

                        session_set_cookie_params(3600); // Cookie expire après 1 heure

                        session_start();

                        ?>

⚠️ Important : <code>session_start()</code> doit être appelé avant tout output HTML (même un espace ou une ligne vide). Sinon, vous obtiendrez l'erreur "Headers already sent".

🗄️ MySQL

MySQL est l'un des systèmes de gestion de bases de données relationnelles (SGBDR) les plus populaires. PHP peut se connecter à MySQL pour stocker, récupérer, modifier et supprimer des données. Il existe deux extensions principales : MySQLi (améliorée) et PDO (plus moderne et recommandée).

🔌 Connexion à MySQL avec MySQLi

MySQLi (MySQL Improved) est l'extension améliorée de MySQL. Elle supporte les requêtes préparées et offre de meilleures performances.

Connexion et requêtes de base :


                        <?php

                        // Connexion à la base de données

                        $host = "localhost";

                        $username = "root";

                        $password = ""; // Mot de passe vide par défaut (XAMPP)

                        $database = "ma_base";


                        $conn = mysqli_connect($host, $username, $password, $database);


                        // Vérifier la connexion

                        if (!$conn) {

                          die("Connexion échouée: " . mysqli_connect_error());

                        }

                        echo "Connexion réussie !";


                        // Fermer la connexion

                        mysqli_close($conn);

                        ?>

📖 Requête SELECT (Lire des données)

La requête SELECT permet de récupérer des données de la base de données.

Exemple de requête SELECT :


                        <?php

                        $conn = mysqli_connect("localhost", "root", "", "ma_base");


                        // Requête SELECT

                        $sql = "SELECT id, nom, email FROM users";

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


                        if (mysqli_num_rows($result) > 0) {

                          // Parcourir les résultats

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

                            echo "ID: " . $row["id"] . ", Nom: " . $row["nom"] . ", Email: " . $row["email"] . "<br>";

                          }

                        } else {

                          echo "Aucun résultat trouvé";

                        }


                        mysqli_close($conn);

                        ?>

➕ Requête INSERT (Ajouter des données)

La requête INSERT permet d'ajouter de nouvelles données dans la base de données.

Exemple de requête INSERT :


                        <?php

                        $conn = mysqli_connect("localhost", "root", "", "ma_base");


                        // Données à insérer

                        $nom = "Jean Dupont";

                        $email = "jean@example.com";

                        $age = 30;


                        // Requête INSERT (⚠️ DANGEREUX - voir section PDO pour requêtes préparées)

                        $sql = "INSERT INTO users (nom, email, age) VALUES ('$nom', '$email', $age)";


                        if (mysqli_query($conn, $sql)) {

                          echo "Nouvel utilisateur créé avec succès. ID: " . mysqli_insert_id($conn);

                        } else {

                          echo "Erreur: " . mysqli_error($conn);

                        }


                        mysqli_close($conn);

                        ?>

✏️ Requête UPDATE (Modifier des données)

La requête UPDATE permet de modifier des données existantes.

Exemple de requête UPDATE :


                        <?php

                        $conn = mysqli_connect("localhost", "root", "", "ma_base");


                        $id = 1;

                        $nouveauNom = "Marie Martin";

                        $nouvelAge = 25;


                        $sql = "UPDATE users SET nom='$nouveauNom', age=$nouvelAge WHERE id=$id";


                        if (mysqli_query($conn, $sql)) {

                          echo "Utilisateur mis à jour. Lignes affectées: " . mysqli_affected_rows($conn);

                        } else {

                          echo "Erreur: " . mysqli_error($conn);

                        }


                        mysqli_close($conn);

                        ?>

🗑️ Requête DELETE (Supprimer des données)

La requête DELETE permet de supprimer des données de la base de données.

Exemple de requête DELETE :


                        <?php

                        $conn = mysqli_connect("localhost", "root", "", "ma_base");


                        $id = 1;

                        $sql = "DELETE FROM users WHERE id=$id";


                        if (mysqli_query($conn, $sql)) {

                          echo "Utilisateur supprimé avec succès";

                        } else {

                          echo "Erreur: " . mysqli_error($conn);

                        }


                        mysqli_close($conn);

                        ?>

⚠️ Sécurité CRITIQUE : Les exemples ci-dessus utilisent des requêtes directes qui sont vulnérables aux attaques par injection SQL ! NE JAMAIS utiliser cette méthode en production. Utilisez toujours des requêtes préparées (voir section PDO ci-dessous) pour protéger votre application.

🔌 PDO

PDO (PHP Data Objects) est une interface moderne et sécurisée pour accéder aux bases de données. C'est la méthode recommandée pour travailler avec des bases de données en PHP car elle offre :

✅ Sécurité - Protection contre les injections SQL via requêtes préparées
✅ Portabilité - Fonctionne avec MySQL, PostgreSQL, SQLite, etc.
✅ Simplicité - API cohérente pour toutes les bases de données
✅ Performance - Meilleures performances que MySQLi

🔌 Connexion avec PDO

La connexion PDO utilise un DSN (Data Source Name) pour spécifier la base de données.

Connexion PDO :


                        <?php

                        try {

                          // Connexion avec gestion d'erreurs

                          $pdo = new PDO(

                            "mysql:host=localhost;dbname=ma_base;charset=utf8mb4",

                            "root", // Username

                            "", // Password

                            [

                              PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,

                              PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC

                            ]

                          );

                          echo "Connexion réussie !";

                        } catch (PDOException $e) {

                          echo "Erreur de connexion: " . $e->getMessage();

                        }

                        ?>

🔒 Requêtes préparées (Sécurisées)

Les requêtes préparées sont la meilleure façon de protéger votre application contre les injections SQL. Les valeurs sont séparées de la requête SQL elle-même.

SELECT avec requête préparée :


                        <?php

                        $pdo = new PDO("mysql:host=localhost;dbname=ma_base", "root", "");


                        // Requête préparée avec paramètres nommés (recommandé)

                        $stmt = $pdo->prepare("SELECT * FROM users WHERE id = :id AND email = :email");

                        $stmt->execute([

                          'id' => 1,

                          'email' => 'jean@example.com'

                        ]);


                        // Récupérer les résultats

                        $user = $stmt->fetch(); // Un seul résultat

                        // ou

                        $users = $stmt->fetchAll(); // Tous les résultats


                        if ($user) {

                          echo "Nom: " . $user['nom'];

                        }

                        ?>

INSERT avec requête préparée :


                        <?php

                        $pdo = new PDO("mysql:host=localhost;dbname=ma_base", "root", "");


                        $nom = "Jean Dupont";

                        $email = "jean@example.com";

                        $age = 30;


                        // Requête préparée INSERT

                        $stmt = $pdo->prepare("INSERT INTO users (nom, email, age) VALUES (:nom, :email, :age)");

                        $stmt->execute([

                          'nom' => $nom,

                          'email' => $email,

                          'age' => $age

                        ]);


                        echo "Utilisateur créé. ID: " . $pdo->lastInsertId();

                        ?>

UPDATE et DELETE avec requêtes préparées :


                        <?php

                        $pdo = new PDO("mysql:host=localhost;dbname=ma_base", "root", "");


                        // UPDATE

                        $stmt = $pdo->prepare("UPDATE users SET nom = :nom, age = :age WHERE id = :id");

                        $stmt->execute([

                          'id' => 1,

                          'nom' => "Marie Martin",

                          'age' => 25

                        ]);

                        echo "Lignes modifiées: " . $stmt->rowCount();


                        // DELETE

                        $stmt = $pdo->prepare("DELETE FROM users WHERE id = :id");

                        $stmt->execute(['id' => 1]);

                        echo "Lignes supprimées: " . $stmt->rowCount();

                        ?>

🔄 Parcourir plusieurs résultats

Vous pouvez parcourir les résultats d'une requête de plusieurs façons.

Méthodes pour récupérer les résultats :


                        <?php

                        $pdo = new PDO("mysql:host=localhost;dbname=ma_base", "root", "");

                        $stmt = $pdo->prepare("SELECT * FROM users");

                        $stmt->execute();


                        // Méthode 1: fetchAll() - Récupère tous les résultats

                        $users = $stmt->fetchAll();

                        foreach ($users as $user) {

                          echo $user['nom'] . "<br>";

                        }


                        // Méthode 2: fetch() dans une boucle - Récupère un par un

                        while ($user = $stmt->fetch()) {

                          echo $user['nom'] . "<br>";

                        }

                        ?>

✅ Avantage des requêtes préparées : Les requêtes préparées protègent automatiquement contre les injections SQL. Les valeurs sont traitées comme des données, pas comme du code SQL. C'est la méthode obligatoire à utiliser en production !

🏗️ Programmation Orientée Objet (POO)

La Programmation Orientée Objet (POO) est un paradigme de programmation qui organise le code en classes et objets. Elle permet de créer des structures de code réutilisables, maintenables et modulaires. La POO est essentielle pour développer des applications PHP modernes et complexes.

📚 Concepts fondamentaux

La POO repose sur plusieurs concepts clés :

Classe - Un modèle ou un plan pour créer des objets (comme un moule)
Objet - Une instance concrète d'une classe (comme un gâteau fait avec le moule)
Propriété - Une variable appartenant à une classe ou un objet
Méthode - Une fonction appartenant à une classe ou un objet
Encapsulation - Le principe de cacher les détails internes et exposer seulement ce qui est nécessaire
Héritage - La capacité d'une classe à hériter des propriétés et méthodes d'une autre classe

🏗️ Créer une classe

Une classe est définie avec le mot-clé class suivi du nom de la classe.

Exemple de classe simple :


                        <?php

                        class Personne {

                          // Propriétés (variables de la classe)

                          public $nom;

                          public $prenom;

                          private $age; // private = accessible uniquement dans la classe


                          // Constructeur - appelé lors de la création d'un objet

                          public function __construct($nom, $prenom, $age) {

                            $this->nom = $nom;

                            $this->prenom = $prenom;

                            $this->age = $age;

                          }


                          // Méthode (fonction de la classe)

                          public function saluer() {

                            return "Bonjour, je suis $this->prenom $this->nom";

                          }


                          // Méthode pour accéder à une propriété privée

                          public function getAge() {

                            return $this->age;

                          }

                        }


                        // Créer un objet (instance de la classe)

                        $personne1 = new Personne("Dupont", "Jean", 30);

                        $personne2 = new Personne("Martin", "Marie", 25);


                        // Utiliser les méthodes

                        echo $personne1->saluer(); // "Bonjour, je suis Jean Dupont"

                        echo $personne1->nom; // "Dupont" (propriété publique)

                        echo $personne1->getAge(); // 30 (via méthode)

                        // echo $personne1->age; // ERREUR: propriété privée

                        ?>

🔒 Visibilité des propriétés et méthodes

PHP offre trois niveaux de visibilité pour contrôler l'accès aux propriétés et méthodes :

public - Accessible partout (dans la classe, dans les classes enfants, et depuis l'extérieur)
private - Accessible uniquement dans la classe elle-même
protected - Accessible dans la classe et ses classes enfants (héritage)

Exemple de visibilité :


                        <?php

                        class Exemple {

                          public $public = "Accessible partout";

                          private $private = "Accessible uniquement ici";

                          protected $protected = "Accessible ici et dans les enfants";


                          public function afficherPrivate() {

                            return $this->private; // OK: dans la classe

                          }

                        }


                        $obj = new Exemple();

                        echo $obj->public; // OK: public

                        // echo $obj->private; // ERREUR: private

                        // echo $obj->protected; // ERREUR: protected

                        echo $obj->afficherPrivate(); // OK: via méthode publique

                        ?>

🏗️ Constructeur et destructeur

Le constructeur (__construct) est appelé automatiquement lors de la création d'un objet. Le destructeur (__destruct) est appelé quand l'objet est détruit.

Constructeur et destructeur :


                        <?php

                        class Utilisateur {

                          private $nom;

                          private $email;


                          // Constructeur

                          public function __construct($nom, $email) {

                            $this->nom = $nom;

                            $this->email = $email;

                            echo "Utilisateur créé: $nom<br>";

                          }


                          // Destructeur

                          public function __destruct() {

                            echo "Utilisateur détruit: {$this->nom}<br>";

                          }


                          public function getNom() {

                            return $this->nom;

                          }

                        }


                        $user = new Utilisateur("Jean", "jean@example.com");

                        // Affiche: "Utilisateur créé: Jean"

                        echo $user->getNom(); // "Jean"

                        // Quand $user est détruit, affiche: "Utilisateur détruit: Jean"

                        ?>

🔧 Getters et Setters

Les getters et setters sont des méthodes pour accéder et modifier les propriétés privées. C'est une bonne pratique qui permet de contrôler l'accès aux données.

Getters et Setters :


                        <?php

                        class Produit {

                          private $nom;

                          private $prix;


                          public function __construct($nom, $prix) {

                            $this->setNom($nom);

                            $this->setPrix($prix);

                          }


                          // Getter pour nom

                          public function getNom() {

                            return $this->nom;

                          }


                          // Setter pour nom (avec validation)

                          public function setNom($nom) {

                            if (strlen($nom) < 2) {

                              throw new Exception("Le nom doit contenir au moins 2 caractères");

                            }

                            $this->nom = $nom;

                          }


                          // Getter pour prix

                          public function getPrix() {

                            return $this->prix;

                          }


                          // Setter pour prix (avec validation)

                          public function setPrix($prix) {

                            if ($prix < 0) {

                              throw new Exception("Le prix ne peut pas être négatif");

                            }

                            $this->prix = $prix;

                          }

                        }


                        $produit = new Produit("Laptop", 999.99);

                        echo $produit->getNom(); // "Laptop"

                        echo $produit->getPrix(); // 999.99

                        $produit->setPrix(899.99); // Modifier le prix

                        ?>

👨‍👩‍👧‍👦 Héritage

L'héritage permet à une classe (enfant) d'hériter des propriétés et méthodes d'une autre classe (parent). C'est très utile pour éviter la duplication de code.

Exemple d'héritage :


                        <?php

                        // Classe parent

                        class Animal {

                          protected $nom;

                          protected $espece;


                          public function __construct($nom, $espece) {

                            $this->nom = $nom;

                            $this->espece = $espece;

                          }


                          public function manger() {

                            return "{$this->nom} mange";

                          }


                          public function dormir() {

                            return "{$this->nom} dort";

                          }

                        }


                        // Classe enfant (hérite de Animal)

                        class Chien extends Animal {

                          public function __construct($nom) {

                            parent::__construct($nom, "Chien"); // Appeler le constructeur parent

                          }


                          // Méthode spécifique au chien

                          public function aboyer() {

                            return "{$this->nom} aboie: Wouf Wouf !";

                          }

                        }


                        // Classe enfant (hérite de Animal)

                        class Chat extends Animal {

                          public function __construct($nom) {

                            parent::__construct($nom, "Chat");

                          }


                          // Méthode spécifique au chat

                          public function miauler() {

                            return "{$this->nom} miaule: Miaou !";

                          }

                        }


                        // Utilisation

                        $chien = new Chien("Rex");

                        $chat = new Chat("Mimi");


                        echo $chien->manger(); // "Rex mange" (hérité)

                        echo $chien->aboyer(); // "Rex aboie: Wouf Wouf !" (spécifique)

                        echo $chat->dormir(); // "Mimi dort" (hérité)

                        echo $chat->miauler(); // "Mimi miaule: Miaou !" (spécifique)

                        ?>

🎯 Méthodes statiques

Les méthodes statiques appartiennent à la classe elle-même, pas à une instance. Elles sont appelées avec ClassName::methodName().

Méthodes statiques :


                        <?php

                        class Calculatrice {

                          // Méthode statique

                          public static function additionner($a, $b) {

                            return $a + $b;

                          }


                          public static function multiplier($a, $b) {

                            return $a * $b;

                          }

                        }


                        // Appeler sans créer d'objet

                        echo Calculatrice::additionner(5, 3); // 8

                        echo Calculatrice::multiplier(4, 7); // 28

                        ?>

🎯 Cas d'usage pratique : Gestion d'utilisateurs

Voici un exemple complet utilisant la POO pour gérer des utilisateurs :

Système de gestion d'utilisateurs :


                        <?php

                        class Utilisateur {

                          private $id;

                          private $nom;

                          private $email;

                          private $role;


                          public function __construct($nom, $email, $role = "user") {

                            $this->nom = $nom;

                            $this->email = $email;

                            $this->role = $role;

                          }


                          public function getNom() { return $this->nom; }

                          public function getEmail() { return $this->email; }

                          public function getRole() { return $this->role; }


                          public function estAdmin() {

                            return $this->role === "admin";

                          }


                          public function presenter() {

                            return "Je suis {$this->nom} ({$this->email}), rôle: {$this->role}";

                          }

                        }


                        $user1 = new Utilisateur("Jean", "jean@example.com");

                        $admin = new Utilisateur("Admin", "admin@example.com", "admin");


                        echo $user1->presenter(); // "Je suis Jean (jean@example.com), rôle: user"

                        echo $admin->estAdmin(); // true

                        ?>

💡 Bonne pratique : Utilisez la POO pour organiser votre code en structures logiques. Les classes permettent de regrouper des fonctionnalités liées, de réutiliser du code via l'héritage, et de protéger les données avec l'encapsulation. C'est essentiel pour développer des applications PHP professionnelles !

🎓 Prochaines étapes

Félicitations ! Vous avez maintenant une solide base en PHP.

✅ Ce que vous avez appris :

Syntaxe PHP et variables
Types de données
Opérateurs et expressions
Structures conditionnelles
Boucles
Fonctions
Tableaux
Traitement de formulaires
Sessions et cookies
Connexion MySQL
PDO et requêtes préparées
Programmation Orientée Objet

❮ Précédent: Bootstrap Suivant: Git ❯