Glossaire PHP de A à Z — PHP

Glossaire PHP — 124 définitions

Tous les termes définis dans les 25 sections du guide, classés par ordre alphabétique.
Astuce : Ctrl + F pour chercher un terme dans la page.

« Ça marche sur ma machine »: Le problème que Docker résout (fréquent en PHP : versions, extensions, config, casse Windows/Linux) : le conteneur embarque son environnement, tournant partout à l'identique.
== vs === / guillemets: `==` compare avec conversion de type (lâche, surprenant) ; `===` compare valeur ET type (strict, à privilégier). Guillemets doubles interprètent les variables, simples = littéral.
$_GET vs $_POST: GET : données dans l'URL (visibles, pour recherches/filtres/liens). POST : données dans le corps (non visibles, pour formulaires qui modifient, données sensibles).
API REST: Interface exposant des données (en JSON) consommées par d'autres programmes (front, mobile, services) ; ressources via URL, méthodes HTTP sémantiques, codes de statut.
Architecture propre: Séparation des couches, découplage, dépendre d'abstractions, code lisible ; produit un code maintenable, flexible, testable, évolutif.
Assertions: Vérifications qu'un test effectue : assertEquals(attendu, résultat), assertTrue, assertNull… ; elles échouent si la réalité ne correspond pas à l'attendu.
Authentification par jetons: Pour les API (sans état, front séparé/mobile) : après connexion, le serveur émet un JETON que le client renvoie à chaque requête (en-tête Authorization) et que le serveur vérifie.
Authentification par session: Connexion : vérifier identifiant + mot de passe, stocker l'identité en session ; pages protégées : vérifier la session ; déconnexion : détruire la session.
Autoloading (PSR-4): Charge AUTOMATIQUEMENT le fichier d'une classe à son usage (fini les inclusions manuelles), via une convention (PSR-4) associant namespaces et structure de dossiers.
Balises PHP: Le code PHP se place entre `` ; hors des balises = HTML (envoyé tel quel), dedans = code PHP (exécuté). Permet de mélanger PHP et HTML.
Base de données / MySQL: Système stockant durablement les données (utilisateurs, produits…). MySQL/MariaDB : base RELATIONNELLE (tables, lignes, colonnes) interrogée en SQL (SELECT/INSERT/UPDATE/DELETE = CRUD).
Bénéfices de Docker: Reproductibilité (identique partout), isolation (versions de PHP différentes sans conflit), portabilité, facilité de déploiement, onboarding rapide (docker compose up).
Bénéfices des tests: Confiance (le code fait ce qu'il doit), NON-RÉGRESSION (détecter ce qu'une modif casse), documentation (comportement attendu), meilleure conception (code testable = mieux structuré), détection précoce des bugs.
Blade (templates): Le moteur de templates de Laravel : syntaxe propre ({{ }}, @foreach, @if) avec ÉCHAPPEMENT AUTOMATIQUE (protection XSS par défaut) et layouts réutilisables (héritage).
Boucle: Répète un traitement plutôt que de dupliquer le code ; indispensable pour manipuler des collections ou répéter une action.
break / continue: break : SORT de la boucle immédiatement. continue : PASSE à l'itération suivante. Attention aux boucles INFINIES (condition qui ne devient jamais fausse).
CI/CD (GitHub Actions): Automatiser code → production : CI (à chaque push, tester/vérifier — PHPUnit), CD (déployer automatiquement si les vérifications passent). GitHub Actions/GitLab CI créent ces pipelines.
Closures / fonctions natives: Fonctions anonymes (closures) et fléchées : sans nom, stockables/passables (callbacks). PHP a des centaines de fonctions natives (strlen, array_map…) — consulter la doc.
Commentaires: Texte ignoré par PHP pour expliquer le code : `//` ou `#` (une ligne), `/* ... */` (plusieurs lignes) ; essentiels à la lisibilité.
Composants Symfony: Symfony est fait de composants indépendants (routage, formulaires, sécurité, console…) utilisables séparément ; de nombreux projets (dont Laravel) en utilisent sous le capot.
Composer: Gestionnaire de DÉPENDANCES de PHP (équivalent de npm) : installer des bibliothèques externes et gérer leurs versions ; a transformé l'écosystème PHP.
composer.json / vendor: composer.json déclare les dépendances ; `composer install` les télécharge (dossier vendor/, non versionné, régénérable) et génère l'autoloader (vendor/autoload.php). composer.lock fige les versions.
Concaténation (.): En PHP, on assemble les chaînes avec le POINT `.` (pas `+`) : `'Bonjour ' . $nom`.
Configuration & secrets: Paramètres et SECRETS (identifiants base, clés) fournis par l'environnement de production, JAMAIS dans le code/dépôt Git (variables d'environnement, .env hors dépôt).
Contrôleur (Controller): Fait le LIEN : reçoit la requête, appelle le Modèle pour les données, choisit la Vue à afficher avec ces données ; orchestre modèle et vue.
Cookies ($_COOKIE): Petites données stockées dans le NAVIGATEUR, renvoyées à chaque requête (setcookie / $_COOKIE) ; côté client (modifiables) — options de sécurité HttpOnly, Secure, SameSite.
Côté serveur vs côté client: Serveur (PHP) : exécute la logique (formulaires, base, authentification) et génère les pages. Client (navigateur) : affiche le HTML/CSS et exécute le JavaScript.
CRUD: Les quatre opérations de base : Create (INSERT), Read (SELECT), Update (UPDATE), Delete (DELETE) ; réalisées avec PDO et des requêtes préparées, avec récupération (fetch/fetchAll).
CSRF → jetons: Forcer un utilisateur connecté à exécuter une action à son insu (requête forgée) ; protection : jetons CSRF (unique par formulaire, vérifié) et cookie SameSite.
Cycle requête → PHP → HTML: L'utilisateur demande une page → le serveur exécute le code PHP → PHP génère du HTML → le navigateur l'affiche. Ce cycle se rejoue à chaque requête.
Dates (DateTime): PHP moderne manipule les dates avec la classe DateTime/DateTimeImmutable : créer, FORMATER pour l'affichage (->format), calculer des différences (->diff), ajouter/soustraire.
Déploiement / hébergement: Faire tourner l'application PHP sur un serveur accessible sur Internet. Options : hébergement mutualisé (simple, économique), PaaS (simplifié), VPS (contrôle + responsabilités), cloud.
Design patterns: Solutions ÉPROUVÉES à des problèmes de conception récurrents (recettes d'organisation validées) ; donnent un vocabulaire commun. Ex. Factory, Repository, Strategy, Observer, Dependency Injection.
Discernement (vs sur-ingénierie): Appliquer patterns et SOLID avec MESURE selon le problème ; le sur-ingénierie (structure excessive inutile) est un piège comme le sous-ingénierie (désordre). Trouver le juste niveau.
Docker / conteneurisation: Outil empaquetant une application AVEC tout son environnement (PHP, extensions, config, dépendances) dans un conteneur isolé et portable, qui tourne identiquement partout.
Docker Compose (stack PHP): Fichier docker-compose.yml définissant plusieurs conteneurs (PHP/Nginx + MySQL + Redis…) et leurs relations, lancés ensemble (docker compose up) ; décrit toute la stack PHP.
Doctrine (ORM): L'ORM associé à Symfony : manipuler des ENTITÉS (objets) au lieu de SQL, requêtes préparées auto, relations, migrations ; approche « Data Mapper » (vs Active Record d'Eloquent).
Dossier racine web / localhost: Dossier où placer ses fichiers .php (htdocs, www) pour qu'ils soient servis ; on y accède via http://localhost (sa propre machine).
echo: Construction pour AFFICHER (produire de la sortie) : `echo 'Bonjour';` génère du texte/HTML dans la page. L'outil fondamental de sortie (aussi `print`).
Eloquent (ORM): L'ORM de Laravel : tables ↔ classes (modèles), lignes ↔ objets ; manipuler la base via des objets/méthodes (Produit::all()) au lieu de SQL, avec requêtes préparées auto et gestion des relations.
Encapsulation / visibilité: Regrouper données et comportements, et contrôler l'accès via la visibilité : public (partout), private (classe seule), protected (classe + descendantes). Propriétés private + getters/setters pour protéger l'état.
Environnement local (AMP): De quoi exécuter PHP et une base sur sa machine pour développer/tester. AMP = serveur web (Apache), PHP, base (MySQL) — souvent installés ensemble via un pack.
Envoi d'e-mails: La fonction native mail() est basique/peu fiable ; utiliser des bibliothèques dédiées (PHPMailer, Symfony Mailer) pour la fiabilité. Ne jamais injecter de données non contrôlées dans les en-têtes.
Essentiels de production PHP: HTTPS, erreurs NON affichées (journalisées), OPcache activé, autoloader Composer optimisé, migrations exécutées au déploiement, environnements séparés (dev/staging/prod).
Expressions régulières (regex): Mini-langage décrivant des motifs dans du texte ; preg_match (correspond ?), preg_replace (remplacer). Puissantes mais difficiles.
filter_var pour valider: Pour les validations courantes (email, URL…), préférer filter_var (FILTER_VALIDATE_EMAIL…) à une regex maison — plus fiable. Réserver les regex aux motifs spécifiques.
Fonction: Bloc de code réutilisable accomplissant une tâche : `function saluer($nom) { return ... }`, appelée par son nom. Évite la duplication, améliore lisibilité et maintenance.
Fonctions de tableaux/chaînes: Centaines de fonctions natives : tableaux (count, in_array, array_map/filter/reduce, sort, implode/explode…), chaînes (strlen, str_replace, substr, trim, str_contains…).
Fonctions multi-octets (mb_): Pour traiter correctement l'Unicode (caractères accentués/non-latins) : mb_strlen, mb_substr… ; les fonctions classiques travaillent sur des octets (problème en UTF-8).
for: Boucle avec compteur, quand on connaît le nombre de répétitions : `for ($i = 0; $i < 10; $i++) { ... }` (initialisation ; condition ; incrément).
foreach: Boucle pour PARCOURIR un tableau (la plus utilisée) : `foreach ($tab as $valeur)` (chaque valeur) ou `foreach ($tab as $cle => $valeur)` (paires clé → valeur).
Formulaire / superglobales: Les formulaires envoient des données au serveur, que PHP récupère via des superglobales (tableaux spéciaux disponibles partout) : $_GET, $_POST, $_FILES, $_SESSION…
Fuseau & format de stockage: Points de vigilance : configurer le FUSEAU horaire (sinon heures fausses) ; STOCKER les dates dans un format standard (ISO AAAA-MM-JJ) et les FORMATER seulement à l'affichage.
Gestion de fichiers: Lire/écrire des fichiers serveur : file_get_contents, file_put_contents, fopen/fread/fwrite, file_exists, unlink (supprimer).
Git pour déployer: Déployer via Git (le serveur récupère le code depuis le dépôt) plutôt que de transférer les fichiers à la main (FTP) — plus fiable et traçable.
Hachage / HTTPS / secrets: Mots de passe HACHÉS (password_hash/verify, jamais en clair) ; HTTPS (chiffrer) ; secrets hors du code (variables d'environnement) ; erreurs non affichées en production ; dépendances à jour.
Héritage: Une classe hérite d'une autre (`class Admin extends User`) : elle obtient ses propriétés/méthodes, peut en ajouter ou REDÉFINIR ; permet réutilisation et spécialisation.
HTTP sans état (stateless): Chaque requête HTTP est indépendante, le serveur ne se souvient pas des précédentes ; cookies et sessions ajoutent une « mémoire » entre les pages.
if / elseif / else: Exécute un bloc SI une condition est vraie ; else (sinon), elseif (sinon si, plusieurs conditions en cascade). La condition s'évalue à true/false.
Image / Dockerfile / conteneur: Image : modèle figé de l'app + environnement, défini par un Dockerfile (recette : image PHP de base, extensions, code, dépendances Composer). Conteneur : instance en exécution.
include / require: Insèrent le contenu d'un fichier dans un autre. require : erreur FATALE si introuvable (fichiers indispensables). include : avertissement et continue (optionnels).
Injection SQL: Faille CRITIQUE : concaténer des données utilisateur dans une requête SQL permet à un attaquant d'injecter du SQL malveillant (lire/modifier/détruire la base). À éviter absolument.
Injection SQL → requêtes préparées: Injecter du SQL via des données concaténées ; protection : TOUJOURS des requêtes préparées (PDO), jamais de concaténation dans le SQL.
Interfaces / traits: Interface : « contrat » de méthodes qu'une classe doit implémenter (programmer par contrat, découpler). Trait : réutiliser des méthodes dans plusieurs classes sans héritage (partage horizontal).
Interpréteur PHP: Le programme qui exécute le code PHP sur le serveur ; le visiteur ne voit jamais le code PHP, seulement le HTML résultant.
JWT (JSON Web Token): Jeton SIGNÉ cryptographiquement (auto-porteur, sans stockage serveur), très répandu pour les API ; renvoyé à chaque requête et vérifié. Adapté aux fronts séparés et au mobile.
Laravel: Le framework PHP le plus populaire (élégant, productif, vaste écosystème) ; implémente le MVC et fournit des outils puissants appliquant les bonnes pratiques. La référence du PHP moderne.
Laravel vs Symfony: Deux excellents frameworks matures : Laravel plus accessible/productif ; Symfony plus rigoureux/modulaire/entreprise. Mêmes concepts (MVC, ORM, templates) — transférables.
Migrations: Système versionnant la structure de la base (créer/modifier des tables via du code PHP versionné) : structure reproductible, évolution traçable — essentiel en équipe et au déploiement.
Mise en cache (Redis): Stocker des résultats coûteux (requêtes fréquentes, calculs, pages) pour ne pas les refaire ; Redis (ou Memcached) = stockage EN MÉMOIRE rapide servant de cache. Souvent le levier le plus impactant.
Modèle (Model): Gère les DONNÉES et la LOGIQUE MÉTIER : accès à la base, entités (Utilisateur, Produit), règles métier — indépendamment de l'affichage.
MVC (Modèle-Vue-Contrôleur): Pattern d'architecture séparant l'application en trois responsabilités : Modèle (données/logique métier), Vue (affichage), Contrôleur (coordination). Le socle des frameworks web.
Namespaces (espaces de noms): Organisent les classes en « espaces » logiques et évitent les CONFLITS de noms (deux `User` coexistent dans des namespaces différents). Déclaration `namespace App\Models;`, import avec `use`.
Ne jamais faire confiance aux entrées: Toute donnée utilisateur (formulaire, URL) est potentiellement erronée ou malveillante ; toujours valider et assainir côté SERVEUR avant de l'utiliser.
Ne pas optimiser prématurément: Code correct et clair d'abord, MESURER quand un problème survient, puis optimiser CIBLÉ. Optimiser trop tôt fait perdre du temps et complexifie inutilement.
Niveaux de tests: Unitaires (une fonction/classe isolée), d'intégration (plusieurs parties ensemble, ex. avec la base), fonctionnels/bout en bout (l'application comme un utilisateur).
Null coalescent ?? / match: `??` renvoie la gauche si elle existe et n'est pas null, sinon la droite (valeurs par défaut). `match` (PHP 8+) = switch moderne, strict, qui renvoie une valeur.
OPcache: Extension qui met en CACHE le bytecode PHP compilé : la compilation ne se fait qu'une fois (au lieu de chaque requête) — gain de performance MAJEUR quasi gratuit. À activer, surtout en production.
Opérateurs: Arithmétiques (+ - * / % **), affectation (=, +=…), comparaison (==, ===, !=, <, >…), logiques (&& || !).
Optimisation de la base: Souvent le vrai goulot : requêtes lentes/non indexées, problème N+1 (une requête par élément — à corriger par l'eager loading). Indexer, optimiser les requêtes a souvent le plus d'impact.
Organisation par inclusions: Séparer le code en fichiers logiques (config, fonctions, header/footer, pages) assemblés par inclusions ; premier pas vers une architecture propre (MVC, autoloading).
Pack tout-en-un: Installation regroupant serveur web + PHP + base de données : XAMPP (multiplateforme), Laragon, WampServer (Windows), MAMP (macOS) — le plus simple pour débuter.
Packagist / écosystème: Le dépôt de paquets PHP (via Composer) : un immense écosystème de bibliothèques réutilisables — installer des composants éprouvés au lieu de tout coder.
Page dynamique: Page générée par le serveur, souvent personnalisée (selon l'utilisateur, les données) ; par opposition à une page HTML statique toujours identique.
Paramètres / retour: Paramètres : données passées en entrée (avec valeurs par défaut possibles). Retour (via `return`) : le résultat renvoyé. Les entrées et sorties de la fonction.
Patterns courants (PHP): Singleton (une seule instance, à user avec parcimonie), Factory (créer des objets), Repository (centraliser l'accès aux données), Dependency Injection (fournir les dépendances de l'extérieur) — utilisés par les frameworks.
PDO: PHP Data Objects : interface moderne, unifiée et sûre pour se connecter aux bases et exécuter des requêtes ; fonctionne avec plusieurs types de bases (abstraction).
PHP: Langage de programmation côté serveur conçu pour le Web (PHP: Hypertext Preprocessor) ; il s'exécute sur le serveur et génère du HTML envoyé au navigateur.
phpinfo(): Fonction affichant les informations de configuration PHP ; un fichier info.php avec phpinfo() vérifie que l'environnement fonctionne et montre la version installée.
phpMyAdmin: Interface web (incluse dans les packs) pour créer et gérer des bases de données MySQL sans ligne de commande.
Point-virgule: Termine chaque instruction PHP (`;`) ; l'oublier provoque une erreur de syntaxe — l'erreur de débutant la plus fréquente.
Polymorphisme / abstraction: Polymorphisme : des objets de classes différentes répondent à la même méthode différemment. Abstraction : masquer la complexité derrière des interfaces simples.
POO / Classe / Objet: Paradigme organisant le code autour d'OBJETS (données + comportements). Une CLASSE est un modèle (propriétés + méthodes) ; un OBJET est une instance (`new User()`). $this = l'objet courant ; __construct = constructeur (initialisation).
Portée (scope): Une variable définie dans une fonction est LOCALE (invisible dehors) ; une variable externe n'est pas accessible dans la fonction. Isolation voulue — passer les données en PARAMÈTRES.
Profilage / mesurer avant d'optimiser: Identifier les vrais goulots par la MESURE (profilage) avant d'optimiser (règle d'or) ; éviter d'optimiser à l'aveugle ou prématurément.
Requête préparée: Requête avec des MARQUEURS (? ou :nom) où les données sont passées SÉPARÉMENT (prepare puis execute) ; la base les traite comme données pures — l'injection SQL devient impossible.
require_once / include_once: Garantissent qu'un fichier n'est inclus QU'UNE fois (évite les inclusions multiples et redéfinitions) — souvent à privilégier.
Ressources & méthodes (API): GET /api/produits (lister), GET /{id} (lire), POST (créer, 201), PUT/PATCH (modifier), DELETE (supprimer) ; réponses JSON avec les bons codes (200, 201, 400, 401, 404…).
Routage / contrôleurs / Artisan: Routage : associer des URL à des actions (Route::get). Contrôleurs : classes traitant les requêtes. Artisan : ligne de commande (générer du code, migrations…).
Routage / flux MVC: Le routage dirige la requête vers le bon contrôleur ; flux : requête → routage → contrôleur → modèle (données) → vue (affichage). Sépare données, affichage, coordination.
Sécurité d'API: Authentification par jetons sûrs, HTTPS (indispensable — les jetons circulent), validation des entrées, autorisation (droits), gestion d'erreurs propre (codes/JSON), rate limiting.
Sécurité de session: Mots de passe HACHÉS (password_hash/verify), régénérer l'ID à la connexion (contre la fixation), cookies sécurisés (HttpOnly/Secure/SameSite), HTTPS, et contrôle des accès (autorisation).
Sessions ($_SESSION): État stocké CÔTÉ SERVEUR (non modifiable par l'utilisateur), le navigateur ne gardant qu'un identifiant de session. session_start() puis $_SESSION. Le mécanisme sécurisé.
SOLID: Cinq principes de conception OO : Single Responsibility (une responsabilité), Open/Closed (extension sans modification), Liskov, Interface Segregation, Dependency Inversion (dépendre d'abstractions).
switch: Compare UNE variable à plusieurs valeurs (case), plus lisible qu'une cascade de elseif ; le `break` sort du switch (l'oublier fait tomber dans le case suivant) ; default pour les autres cas.
Symfony: L'autre grand framework PHP (avec Laravel), réputé rigoureux, modulaire, prisé en entreprise et sur les gros projets ; architecture en COMPOSANTS réutilisables.
Syntaxe courte: Équivalent de `` : `` affiche une variable, pratique dans les templates HTML. Les variables sont sensibles à la casse (mais pas les mots-clés).
Tableau associatif: Collection dont les éléments sont accessibles par une CLÉ textuelle : `$personne = ['nom' => 'Alice']; $personne['nom']`. Omniprésent (données structurées).
Tableau indexé: Collection dont les éléments sont accessibles par un INDEX numérique (à partir de 0) : `$fruits = ['pomme', 'banane']; $fruits[0]`.
Tableau multidimensionnel: Tableaux DANS des tableaux (ex. une liste d'utilisateurs, chacun un tableau associatif) ; représente des données complexes.
TDD (Test-Driven Development): Écrire les tests AVANT le code (le test définit ce que le code doit faire, puis on l'écrit pour le faire passer) ; une discipline qui améliore la conception.
Ternaire: Raccourci if/else renvoyant une valeur : `condition ? valeurSiVrai : valeurSiFaux`. Pratique pour les affectations conditionnelles courtes.
Tests automatisés / PHPUnit: Code qui TESTE votre code (relançable à volonté), au lieu de vérifier à la main. PHPUnit est le framework de test standard de PHP (installé via Composer).
Twig (templates): Le moteur de templates de Symfony : syntaxe propre et sûre ({{ }}, {% for %}, {% if %}) avec échappement automatique (XSS) et héritage ; apprécié au-delà de Symfony.
Typage des paramètres/retour: Déclarer les types (`function f(int $a): int`) documente, attrape des erreurs et rend le code robuste — fortement recommandé en PHP moderne.
Typage dynamique: PHP détermine le type selon la valeur (pas de déclaration préalable) ; une variable peut changer de type. Types : string, int, float, bool, array, null, object.
Uploads ($_FILES) — sécurité: Fichiers envoyés par l'utilisateur ($_FILES), à traiter avec précautions : vérifier type/taille, RENOMMER, stocker hors racine/sans exécution PHP, limiter les extensions. Source classique de failles.
Valeurs « falsy »: Valeurs considérées « fausses » par PHP dans une condition : false, 0, chaîne vide, '0', null, tableau vide ; le reste est « vrai ».
Validation serveur obligatoire: La validation côté client (JavaScript) améliore l'expérience mais est contournable ; la validation côté serveur (PHP) est obligatoire — c'est elle qui protège réellement.
Valider: Vérifier que les données ont le format attendu (email valide, nombre positif, champ requis) et rejeter sinon ; filter_var() aide (email, URL, entier…).
Variable ($): Stocke une donnée ; commence toujours par `$` (`$nom`), affectée avec `=` (`$age = 30;`). Nom sensible à la casse, à choisir clair et parlant.
Vue (View): Gère l'AFFICHAGE : le HTML, ce que voit l'utilisateur ; reçoit des données préparées et les présente, sans logique métier.
while / do...while: while : répète TANT QU'une condition est vraie (nombre inconnu). do...while : exécute au moins une fois (test à la fin).
XSS → htmlspecialchars: Injecter du JavaScript qui s'exécute chez d'autres utilisateurs (affichage de données non échappées) ; protection : ÉCHAPPER à l'affichage avec htmlspecialchars().