AIDE-MEMOIRE PHP - GUIDINEE.COM
Reperes a garder sous la main pendant le projet fil rouge.

=== PRISE EN MAIN ===
- PHP = langage CÔTÉ SERVEUR : s'execute sur le serveur, GENERE du HTML envoye au navigateur. Le visiteur ne voit jamais le code PHP.
- Cycle : REQUETE -> PHP (execute) -> HTML (genere, affiche). Pages DYNAMIQUES et personnalisees. PHP moderne (8+) = performant, riche (WordPress, Laravel).
- Environnement local : PACK tout-en-un (XAMPP, Laragon) = serveur web (Apache) + PHP + base (MySQL). Fichiers .php dans le dossier racine (htdocs), acces via localhost. Verifier avec phpinfo().
- Balises <?php ... ?> (dedans = PHP, dehors = HTML). echo affiche (echo 'Bonjour';). POINT-VIRGULE ; termine chaque instruction (l'oublier = erreur n°1). Commentaires // /* */. Separer logique et affichage.

=== BASES DU LANGAGE ===
- Variables : toujours $ (>$nom), affectation =. Typage DYNAMIQUE. Types : string, int, float, bool, array, null, object.
- Concatenation avec le POINT . (pas +). == (conversion, surprenant) vs === (valeur ET type, strict) -> PRIVILEGIER ===. Guillemets doubles interpretent les variables, simples = litteral.
- Conditions : if/elseif/else, switch (aiguillage, ne pas oublier break), ternaire (? :), match (PHP 8). ?? = valeur par defaut. Attention aux valeurs FALSY (0, '', '0', null, []).
- Boucles : for (compteur), while (condition), FOREACH (parcourir un tableau - le plus utilise : foreach ($tab as $cle => $valeur)). Attention aux boucles infinies. break/continue.
- Fonctions : function nom($params) { return ... }. PORTEE : variables locales (passer les donnees en PARAMETRES, pas de globales). TYPER params/retour (PHP moderne). Centaines de fonctions natives.
- TABLEAUX (structure centrale) : indexes ($tab[0]), ASSOCIATIFS ($tab['nom']), multidimensionnels. Fonctions natives (count, array_map/filter, in_array, implode/explode ; strlen, str_replace, trim). Ne pas reinventer.

=== PHP & LE WEB ===
- FORMULAIRES -> SUPERGLOBALES $_GET (URL, recherches) / $_POST (corps, modifier/sensible). REFLEXE : ne JAMAIS faire confiance aux entrees -> VALIDER + ASSAINIR cote SERVEUR (filter_var, htmlspecialchars).
- Validation cote CLIENT (JS) = confort mais CONTOURNABLE ; validation cote SERVEUR (PHP) = OBLIGATOIRE (protege reellement).
- HTTP sans etat -> SESSIONS ($_SESSION, cote serveur, sur) pour l'etat sensible (qui est connecte) ; COOKIES ($_COOKIE, cote client) pour preferences non sensibles.
- AUTHENTIFICATION : mots de passe HACHES (password_hash / password_verify, JAMAIS en clair), session protegee (regenerer l'ID), cookies surs (HttpOnly/Secure/SameSite), HTTPS, AUTORISATION (droits).
- INCLUSIONS (include/require, header/footer/config). FAILLE : ne jamais inclure un chemin venant de l'utilisateur. UPLOADS ($_FILES) : verifier type/taille, RENOMMER, stocker sans execution PHP.
- DATES : classe DateTime (gerer le FUSEAU ; stocker en ISO, formater a l'affichage). VALIDER avec filter_var (pas de regex maison pour email/URL). E-MAILS : bibliotheque dediee (PHPMailer), pas mail().

=== BASES DE DONNEES & POO ===
- MySQL (relationnel : tables/lignes) + PDO (interface moderne). CRUD (SELECT/INSERT/UPDATE/DELETE).
- CENTRAL : REQUETES PREPAREES (marqueurs :nom / ?, donnees passees SEPAREMENT). Ne JAMAIS concatener des donnees dans le SQL -> INJECTION SQL (faille critique). Regle absolue.
- POO : penser en OBJETS (donnees + comportements). CLASSE (modele) -> OBJET (new User()). $this, __construct. ENCAPSULATION (private + getters/setters), HERITAGE (extends), polymorphisme, INTERFACES (contrats), traits.
- NAMESPACES (eviter les conflits de noms) + AUTOLOADING (PSR-4, charger les classes automatiquement) + COMPOSER (gestionnaire de dependances = npm de PHP : installer des bibliotheques, autoloader). Ne pas versionner vendor/.
- SECURITE : injection SQL (requetes preparees), XSS (echapper a l'affichage : htmlspecialchars), CSRF (jetons + SameSite), mots de passe (password_hash). « Ne jamais faire confiance aux entrees ». HTTPS, secrets hors du code, erreurs non affichees. OWASP Top 10.

=== FRAMEWORKS & API ===
- MVC (Modele-Vue-Controleur) : MODELE (donnees/logique metier), VUE (affichage HTML), CONTROLEUR (coordination). Le socle des frameworks. Le comprendre AVANT = utiliser le framework intelligemment.
- LARAVEL (le plus populaire) : routage, controleurs, BLADE (templates, echappement auto = anti-XSS), ELOQUENT (ORM : manipuler des objets au lieu de SQL, requetes preparees auto, relations), MIGRATIONS (versionner la base). Auth/validation/CSRF fournis.
- SYMFONY (l'autre grand, entreprise) : composants reutilisables, TWIG (templates), DOCTRINE (ORM). Laravel vs Symfony : memes concepts (transferables) - choisir selon le contexte/marche.
- Un ORM (Eloquent) dispense d'ecrire du SQL courant MAIS il faut connaitre le SQL (comprendre ce qu'il fait, eviter le N+1, requetes complexes). Ne pas le traiter en boite noire.
- API REST : exposer des DONNEES (JSON) aux fronts/mobiles/services. Ressources + methodes HTTP + codes de statut. AUTHENTIFICATION par JETONS (JWT, sans etat, en-tete Authorization). HTTPS obligatoire.
- TESTS (PHPUnit) : code qui teste le code. CONFIANCE + NON-REGRESSION (relancer apres chaque modif). Unitaires / integration. Indispensable pour du code serieux (separe un prototype d'une app pro).

=== NIVEAU PRO & DEPLOIEMENT ===
- DESIGN PATTERNS (Repository, Factory, Dependency Injection) + SOLID (responsabilite unique, dependre d'abstractions...) = code maintenable. A appliquer avec DISCERNEMENT (attention au SUR-INGENIERIE ; trouver le juste niveau).
- PERFORMANCE : OPCACHE (cache du bytecode compile - gain majeur, activer en prod). CACHE (Redis) des resultats couteux. Optimiser la BASE (indexation, eviter le N+1). PROFILER avant d'optimiser. NE PAS optimiser prematurement.
- DOCKER (conteneurisation) : fin du « ca marche sur ma machine » (frequent en PHP). Dockerfile (image) -> conteneur. Docker Compose orchestre la STACK (PHP/Nginx + MySQL + Redis). Isolation (versions de PHP par projet).
- DEPLOIEMENT : hebergement MUTUALISE (simple, economique, ideal pour debuter), PaaS, VPS (controle + responsabilites), cloud. Deployer via GIT (pas de FTP manuel).
- CI/CD (GitHub Actions) : CI (a chaque push, tests PHPUnit) + CD (deployer si ca passe). Automatisation, fiabilite, tracabilite.
- PRODUCTION : SECRETS hors du code (variables d'environnement, .env hors depot), HTTPS, erreurs NON affichees (journalisees), OPcache active, autoloader Composer optimise, migrations, environnements separes (dev/staging/prod).

RAPPELS
- « Ne jamais faire confiance aux entrees » = LE reflexe de securite. Requetes preparees (injection SQL), htmlspecialchars (XSS), jetons (CSRF), password_hash (mots de passe).
- Privilegier === ; foreach pour les tableaux ; passer les donnees en parametres ; typer (PHP moderne).
- Comprendre les bases (langage, web, base, POO, MVC) AVANT le framework = l'utiliser intelligemment. Composer = socle du PHP moderne.
- Fiabiliser : tests (PHPUnit, non-regression). Concevoir proprement (SOLID, avec discernement). Optimiser methodiquement (mesurer d'abord).
- Savoir LIVRER (Docker, deploiement via Git, config de prod, CI/CD) acheve le developpeur autonome : de l'idee au service en ligne fiable.