Classe qui ne peut pas etre instanciee directement et qui sert de modele. Elle peut contenir des methodes abstraites (sans corps) et des methodes concretes.
Comme un plan d'architecte : il definit la structure mais on ne peut pas y habiter, il faut d'abord construire la maison.
abstract class Shape {
abstract public function area(): float;
public function describe(): string {
return get_class($this) . ': ' . $this->area();
}
}Cas d'usage : Quand plusieurs classes partagent une logique commune mais doivent chacune implementer certains comportements specifiques.
Pattern qui fournit une interface pour creer des familles d'objets lies sans specifier leurs classes concretes. Etend le Factory Method a plusieurs produits.
Comme un concessionnaire de marque : Peugeot produit berlines ET SUV, Toyota aussi, mais dans leur propre style.
interface UIFactory {
public function createButton(): Button;
public function createInput(): Input;
}
class DarkThemeFactory implements UIFactory {
public function createButton(): Button { return new DarkButton(); }
public function createInput(): Input { return new DarkInput(); }
}Cas d'usage : Quand on doit creer des familles d'objets coherents (theme UI, drivers de base de donnees).
Deux patterns ORM opposes. Active Record (Eloquent) : l'objet connait sa persistence. Data Mapper (Doctrine) : un mapper externe gere la persistence, l'entite reste pure.
Active Record : un employe qui classe lui-meme ses dossiers. Data Mapper : un archiviste independant qui gere le classement.
// Active Record (Eloquent)
$user = User::find(1);
$user->name = 'Alice';
$user->save();
// Data Mapper (Doctrine)
$user = $em->find(User::class, 1);
$user->setName('Alice');
$em->flush();Cas d'usage : Active Record pour les projets simples/rapides, Data Mapper pour les domaines complexes avec logique metier riche.
Classes sans nom definies a la volee avec new class. Utiles pour creer des implementations jetables d'interfaces, surtout dans les tests.
Comme un figurant dans un film : il joue son role une seule fois sans avoir besoin d'un nom au generique.
$mock = new class implements Logger {
public array $logs = [];
public function log(string $msg): void {
$this->logs[] = $msg;
}
};Cas d'usage : Pour les tests unitaires (mocks rapides) ou les implementations uniques dans des factories.
Syntaxe courte fn() => pour les closures a une seule expression, avec capture automatique des variables du scope parent par valeur.
Comme un post-it avec une instruction rapide au lieu d'ecrire une lettre complete.
$prices = [10, 20, 30];
$tax = 0.2;
$withTax = array_map(
fn($price) => $price * (1 + $tax),
$prices
);Cas d'usage : Pour les callbacks courts dans array_map, array_filter et autres fonctions d'ordre superieur.
Metadonnees structurees ajoutees au code via #[...], introduites en PHP 8.0. Remplacent les annotations en commentaires par une syntaxe native.
Comme des etiquettes collees sur des boites : elles decrivent le contenu sans le modifier.
#[Route('/api/users', methods: ['GET'])]
class UserController {
#[Cache(ttl: 3600)]
public function list(): Response {
// ...
}
}Cas d'usage : Pour la configuration declarative : routes, validation, serialisation, ORM mapping.
Gestionnaire de dependances standard de PHP. Gere les packages, l'autoloading PSR-4, les scripts et le versioning semantique via composer.json.
Comme un chef de chantier qui commande les bons materiaux dans les bonnes versions et s'assure que tout est compatible.
// composer.json
{
"require": {
"php": "^8.2",
"laravel/framework": "^11.0"
},
"autoload": {
"psr-4": { "App\\": "src/" }
}
}Cas d'usage : Dans tout projet PHP moderne pour gerer les dependances et l'autoloading.
Principe de design qui favorise l'assemblage d'objets (a un) plutot que l'heritage (est un) pour la reutilisation de code. Produit des architectures plus flexibles.
Comme des briques LEGO : on assemble des pieces pour construire ce qu'on veut, plutot que d'heriter d'un modele fixe.
class OrderService {
public function __construct(
private PaymentGateway $payment,
private Mailer $mailer,
private Logger $logger,
) {}
}Cas d'usage : Dans la majorite des cas ou on est tente d'heriter pour reutiliser du code.
Syntaxe PHP 8.0 qui declare et assigne les proprietes directement dans la signature du constructeur, eliminant le code repetitif.
Comme remplir un formulaire qui cree automatiquement le dossier, au lieu de recopier chaque champ a la main.
class Product {
public function __construct(
private string $name,
private float $price,
private int $stock = 0,
) {}
}Cas d'usage : Pour tout constructeur PHP : reduit le boilerplate et rend le code plus lisible.
Attaque qui force un utilisateur authentifie a executer des actions non voulues sur un site ou il est connecte, via un lien ou formulaire piege.
Comme quelqu'un qui imite ta signature pour envoyer une lettre en ton nom.
// Generation du token
$_SESSION['csrf'] = bin2hex(random_bytes(32));
echo '<input type="hidden" name="csrf" value="'
. $_SESSION['csrf'] . '">';
// Verification
if (!hash_equals($_SESSION['csrf'], $_POST['csrf']))
throw new SecurityException();Cas d'usage : Sur tout formulaire ou action modifiant des donnees (POST, PUT, DELETE).
Les modules de haut niveau ne doivent pas dependre de modules de bas niveau. Les deux doivent dependre d'abstractions (interfaces). L'abstraction ne depend pas des details.
Comme un chef qui commande 'du poisson frais' sans se soucier du fournisseur specifique.
// Haut niveau depend de l'abstraction
class OrderService {
public function __construct(
private PaymentGateway $gateway // interface
) {}
}
// Bas niveau implemente l'abstraction
class StripePayment implements PaymentGateway { }Cas d'usage : Pour decouvrir les couches de l'application et permettre le remplacement des implementations (tests, refactoring).
Container d'injection de dependances qui instancie automatiquement les objets et leurs dependances. Realisation concrete du principe d'inversion de dependances.
Comme une agence d'interim : tu decris le profil recherche, elle fournit la personne qualifiee.
// Symfony DI
services:
App\Service\Mailer:
arguments:
$transport: '@mailer.transport'
// Auto-wiring resout les types automatiquementCas d'usage : Pour eliminer les new manuels et centraliser la configuration des services.
Principe OOP qui restreint l'acces direct aux donnees internes d'un objet via des modificateurs de visibilite (public, protected, private).
Comme un distributeur de billets : tu interagis via l'ecran et le clavier, pas en ouvrant le coffre.
class BankAccount {
private float $balance = 0;
public function deposit(float $amount): void {
if ($amount <= 0) throw new \InvalidArgumentException();
$this->balance += $amount;
}
public function getBalance(): float { return $this->balance; }
}Cas d'usage : Pour proteger l'etat interne des objets et garantir que les modifications passent par des methodes controlees.
Type introduit en PHP 8.1 qui represente un ensemble fini de valeurs possibles. Les enums peuvent etre pures ou backed (avec valeur string/int).
Comme les feux de signalisation : il n'existe que rouge, orange et vert, rien d'autre.
enum Status: string {
case Draft = 'draft';
case Published = 'published';
case Archived = 'archived';
}
$post->status = Status::Published;Cas d'usage : Pour remplacer les constantes de classe et garantir qu'une valeur appartient a un ensemble defini.
Pattern de creation qui delegue l'instanciation d'objets a une methode ou classe dediee, plutot que d'appeler new directement.
Comme une commande au restaurant : tu choisis le plat, la cuisine decide comment le preparer.
class NotificationFactory {
public static function create(string $type): Notifier {
return match($type) {
'email' => new EmailNotifier(),
'sms' => new SmsNotifier(),
'push' => new PushNotifier(),
};
}
}Cas d'usage : Pour centraliser la logique de creation et decoupler le code appelant des classes concretes.
Primitive de concurrence introduite en PHP 8.1 permettant de suspendre et reprendre l'execution d'un bloc de code. Base des frameworks asynchrones comme Revolt.
Comme mettre un livre en pause avec un marque-page pour en lire un autre, puis reprendre exactement ou on s'etait arrete.
$fiber = new Fiber(function (): void {
$value = Fiber::suspend('paused');
echo "Repris avec: $value";
});
$result = $fiber->start(); // 'paused'
$fiber->resume('hello');Cas d'usage : Pour construire des bibliotheques asynchrones ou des event loops sans callbacks imbriques.
Mecanisme OOP permettant a une classe enfant d'heriter des proprietes et methodes d'une classe parente. PHP ne supporte que l'heritage simple.
Comme un enfant qui herite des caracteristiques de ses parents mais peut developper les siennes.
class Animal {
public function breathe(): string { return 'respire'; }
}
class Dog extends Animal {
public function bark(): string { return 'wouf'; }
}
// Dog peut breathe() ET bark()Cas d'usage : Quand il existe une vraie relation 'est un' entre deux classes (un Chien EST un Animal).
Verification systematique des donnees entrantes (formulaires, API, fichiers) contre un format attendu. Premiere ligne de defense contre les attaques.
Comme le controle de securite a l'aeroport : on verifie tout ce qui entre avant de laisser passer.
$email = filter_input(
INPUT_POST, 'email', FILTER_VALIDATE_EMAIL
);
if ($email === false) {
throw new ValidationException('Email invalide');
}Cas d'usage : A chaque point d'entree de donnees externes : formulaires, API, imports de fichiers.
Contrat qui definit les methodes qu'une classe doit implementer, sans fournir d'implementation. Permet le polymorphisme et le decouplage.
Comme une prise electrique standard : tout appareil qui respecte le format peut se brancher.
interface PaymentGateway {
public function charge(float $amount): bool;
public function refund(string $txId): bool;
}
class StripeGateway implements PaymentGateway {
public function charge(float $amount): bool { /* ... */ }
public function refund(string $txId): bool { /* ... */ }
}Cas d'usage : Pour definir des contrats entre composants et permettre de changer d'implementation sans modifier le code appelant.
Les clients ne doivent pas etre forces d'implementer des interfaces qu'ils n'utilisent pas. Privilegier plusieurs petites interfaces a une grande interface generale.
Comme un menu a la carte vs un menu fixe : on choisit uniquement ce qu'on veut manger.
// Mauvais: interface grasse
// interface Worker { work(); eat(); sleep(); }
// Bon: interfaces segregees
interface Workable { public function work(): void; }
interface Feedable { public function eat(): void; }
class Robot implements Workable {
public function work(): void { /* ... */ }
}Cas d'usage : Quand differentes classes n'ont besoin que d'un sous-ensemble du comportement d'une interface.
Compilation Just-In-Time ajoutee en PHP 8.0 qui compile le bytecode en code machine natif a l'execution. Ameliore surtout les taches CPU-intensives.
Comme un traducteur simultane qui finit par parler directement dans la langue cible sans passer par la traduction.
; php.ini
opcache.jit=1255
opcache.jit_buffer_size=256MCas d'usage : Pour les applications CPU-bound (calculs, traitement d'images). Peu d'impact sur les apps web classiques IO-bound.
Mecanisme (static:: vs self::) qui resout la reference a la classe au moment de l'execution, pas de la definition. Permet aux methodes heritees de referencer la classe enfant.
Comme un formulaire generique qui s'adapte au logo de l'entreprise qui l'utilise, pas celle qui l'a cree.
class Model {
public static function create(array $data): static {
return new static($data); // static = classe enfant
}
}
class User extends Model {}
$user = User::create(['name' => 'Alice']); // retourne UserCas d'usage : Dans les classes de base (ORM, factories) ou les methodes heritees doivent retourner le type de la sous-classe.
Toute instance d'une classe parente doit pouvoir etre remplacee par une instance de classe enfant sans casser le programme. Les sous-types doivent respecter le contrat du parent.
Comme un remplacant au football : il doit pouvoir jouer au meme poste sans changer les regles du jeu.
class Rectangle {
public function setWidth(int $w): void { $this->w = $w; }
public function setHeight(int $h): void { $this->h = $h; }
public function area(): int { return $this->w * $this->h; }
}
// Square qui override setWidth/setHeight viole LSP
// car le comportement change de facon inattendueCas d'usage : Lors de la conception de hierarchies d'heritage pour eviter les bugs subtils lies aux sous-classes.
Methodes speciales prefixees par __ (__construct, __get, __set, __toString, etc.) appelees automatiquement par PHP dans certaines situations.
Comme les reflexes du corps : ils se declenchent automatiquement en reaction a un stimulus, sans y penser.
class Config {
private array $data = [];
public function __get(string $key): mixed {
return $this->data[$key] ?? null;
}
public function __set(string $key, mixed $val): void {
$this->data[$key] = $val;
}
}Cas d'usage : Pour creer des APIs fluides, du lazy loading ou des wrappers dynamiques.
Expression PHP 8.0 similaire a switch mais avec comparaison stricte, pas de fall-through, et qui retourne une valeur. Plus sure et concise que switch.
Comme un distributeur automatique : tu inseres le code exact, tu recois le produit correspondant, pas d'ambiguite.
$label = match($status) {
'draft' => 'Brouillon',
'published' => 'Publie',
'archived' => 'Archive',
default => 'Inconnu',
};Cas d'usage : Pour remplacer les switch/case simples qui retournent une valeur en fonction d'une condition.
Pattern architectural separant Model (donnees/logique), View (affichage) et Controller (orchestration). Base de la majorite des frameworks PHP.
Comme un restaurant : le cuisinier (Model), la presentation du plat (View), le serveur (Controller) qui coordonne.
class UserController {
public function show(int $id): Response {
$user = $this->userRepo->find($id); // Model
return $this->render('user/show', [
'user' => $user // View
]);
}
}Cas d'usage : Structure de base pour toute application web PHP avec separation des responsabilites.
Fonctionnalite PHP 8.0 permettant de passer des arguments par nom plutot que par position. Ameliore la lisibilite et permet de sauter les parametres optionnels.
Comme remplir un formulaire ou chaque champ a une etiquette, au lieu de deviner l'ordre des cases.
function createUser(
string $name,
string $email,
string $role = 'user'
): User { /* ... */ }
createUser(name: 'Alice', email: 'a@b.com');Cas d'usage : Pour les fonctions avec beaucoup de parametres optionnels, ou la lisibilite est cruciale.
Espace de noms qui organise le code en groupes logiques et evite les collisions de noms entre classes. Introduit en PHP 5.3, c'est la base de l'autoloading moderne.
Comme les noms de famille : deux personnes peuvent s'appeler Marie, mais Marie Dupont et Marie Martin sont distinctes.
namespace App\Services;
use App\Models\User;
class UserService {
public function find(int $id): User {
return User::findOrFail($id);
}
}Cas d'usage : Dans tout projet PHP moderne pour organiser le code et permettre l'autoloading PSR-4 via Composer.
Operateur ?-> de PHP 8.0 qui court-circuite la chaine d'appels si une valeur intermediaire est null, retournant null au lieu de lancer une erreur.
Comme un GPS qui s'arrete de calculer l'itineraire si la destination n'existe pas, au lieu de planter.
// Avant
$country = $user->getAddress()
? $user->getAddress()->getCountry()
: null;
// Apres
$country = $user?->getAddress()?->getCountry();Cas d'usage : Pour naviguer dans des chaines d'objets potentiellement null sans multiples verifications if/null.
Pattern ou un sujet notifie automatiquement ses observateurs quand son etat change. Base du systeme d'evenements en PHP et du Hook System WordPress.
Comme une chaine YouTube : quand une video est publiee, tous les abonnes sont notifies automatiquement.
interface Observer {
public function update(Event $event): void;
}
class EventDispatcher {
public function dispatch(Event $event): void {
foreach ($this->listeners[$event::class] as $listener) {
$listener->update($event);
}
}
}Cas d'usage : Pour decoupler les actions : apres la creation d'un compte, envoyer un email, creer un log, notifier l'admin.
Extension native qui met en cache le bytecode compile des scripts PHP en memoire partagee, eliminant la recompilation a chaque requete. Gain de 30-70% de performance.
Comme memoriser une recette au lieu de la relire a chaque fois qu'on cuisine le meme plat.
; php.ini
opcache.enable=1
opcache.memory_consumption=256
opcache.max_accelerated_files=20000
opcache.validate_timestamps=0 ; prod onlyCas d'usage : Obligatoire en production, c'est le premier levier de performance PHP.
Les entites logicielles doivent etre ouvertes a l'extension mais fermees a la modification. On ajoute du comportement sans toucher au code existant.
Comme une multiprise : on peut brancher de nouveaux appareils sans modifier l'installation electrique.
interface Discount {
public function calculate(float $price): float;
}
class StudentDiscount implements Discount {
public function calculate(float $price): float {
return $price * 0.8;
}
}
// Ajout sans modifier le code existantCas d'usage : Quand un systeme doit evoluer frequemment : nouveaux types de paiement, nouvelles regles metier.
Echappement des donnees au moment de l'affichage selon le contexte (HTML, attribut, URL, JS). Derniere ligne de defense contre le XSS.
Comme emballer un colis fragile avant l'envoi : on protege le contenu en fonction de la destination.
// Contexte HTML
echo htmlspecialchars($data, ENT_QUOTES, 'UTF-8');
// Contexte URL
echo urlencode($data);
// Contexte JS
echo json_encode($data);Cas d'usage : A chaque affichage de donnees dynamiques, adapte au contexte de sortie.
Fonctions natives PHP pour hasher et verifier des mots de passe de maniere securisee. Utilise bcrypt par defaut avec salt automatique.
Comme une empreinte digitale : on peut verifier que c'est la bonne personne sans stocker son doigt.
// Stockage
$hash = password_hash($password, PASSWORD_DEFAULT);
// Verification
if (password_verify($inputPassword, $hash)) {
echo 'Mot de passe correct';
}Cas d'usage : Pour tout systeme d'authentification qui stocke des mots de passe.
Framework de test PHP moderne construit sur PHPUnit, avec une syntaxe expressive inspiree de Jest. Offre arch testing, parallel testing et une DX superieure.
Comme PHPUnit avec un lifting : meme moteur puissant, mais un interieur plus agreable et moderne.
test('cart total applies discount', function () {
$cart = new Cart();
$cart->add(new Product(price: 100));
$cart->applyDiscount(10);
expect($cart->total())->toBe(90);
});Cas d'usage : Pour les equipes qui veulent une syntaxe de test plus lisible et productive.
Analyseur statique qui detecte les bugs sans executer le code. Verifie les types, les appels de methodes, les proprietes inexistantes et plus selon le niveau configure (0-9).
Comme un correcteur orthographique pour le code : il repere les erreurs avant la publication.
# phpstan.neon
parameters:
level: 8
paths:
- src
# Commande
# vendor/bin/phpstan analyseCas d'usage : En CI/CD pour detecter les bugs de type et les erreurs logiques avant le deploiement.
Framework de tests unitaires standard en PHP. Fournit assertions, mocks, data providers, couverture de code et integration CI.
Comme un laboratoire de controle qualite qui verifie chaque piece avant l'assemblage final.
class CartTest extends TestCase {
public function test_total_with_discount(): void {
$cart = new Cart();
$cart->add(new Product(price: 100));
$cart->applyDiscount(10);
$this->assertEquals(90, $cart->total());
}
}Cas d'usage : Pour tester toute logique metier et garantir la non-regression a chaque changement.
Capacite d'objets de types differents a repondre au meme message (methode). Permet de traiter des objets differents de maniere uniforme via une interface commune.
Comme la touche Play : que ce soit Spotify, YouTube ou un CD, le resultat est de la musique.
interface Notifier {
public function send(string $msg): void;
}
class EmailNotifier implements Notifier { /* ... */ }
class SmsNotifier implements Notifier { /* ... */ }
function notify(Notifier $n, string $msg): void {
$n->send($msg); // fonctionne pour tout Notifier
}Cas d'usage : Pour ecrire du code generique qui fonctionne avec n'importe quelle implementation d'une interface.
Requetes SQL parametrees ou les valeurs sont envoyees separement du code SQL. Protection native contre les injections SQL.
Comme un formulaire pre-imprime avec des cases vides : la structure est fixe, seules les donnees changent.
$stmt = $pdo->prepare(
'INSERT INTO users (name, email) VALUES (:name, :email)'
);
$stmt->execute([
'name' => $name,
'email' => $email,
]);Cas d'usage : Pour CHAQUE requete SQL qui inclut des donnees variables, sans exception.
PHP Standards Recommendations : normes communautaires du PHP-FIG definissant autoloading (PSR-4), coding style (PSR-12), logging (PSR-3), HTTP (PSR-7/15), container (PSR-11).
Comme le code de la route : des regles communes pour que tous les developpeurs circulent dans le meme sens.
// PSR-4 : App\Models\User -> src/Models/User.php
// PSR-12 : coding style
// PSR-3 : LoggerInterface
// PSR-7 : RequestInterface / ResponseInterface
// PSR-11 : ContainerInterfaceCas d'usage : Pour l'interoperabilite entre frameworks et libraries, et un code lisible par tous.
Proprietes PHP 8.1 qui ne peuvent etre initialisees qu'une seule fois, puis deviennent immutables. PHP 8.2 etend cela aux classes entieres avec readonly class.
Comme un tatouage : une fois fait, on ne peut plus le modifier.
readonly class UserDTO {
public function __construct(
public string $name,
public string $email,
) {}
}Cas d'usage : Pour les DTOs et Value Objects ou l'immutabilite garantit l'integrite des donnees.
Outil de refactoring automatique qui modernise le code PHP en appliquant des regles de transformation. Peut migrer entre versions PHP et frameworks.
Comme un traducteur automatique qui met a jour un vieux livre dans un langage moderne.
// rector.php
return RectorConfig::configure()
->withPhpSets(php83: true)
->withPreparedSets(
deadCode: true,
codeQuality: true,
);Cas d'usage : Pour migrer un projet vers PHP 8.x ou moderniser du code legacy automatiquement.
Couche d'abstraction entre la logique metier et l'acces aux donnees. Le repository expose des methodes metier et masque les details de persistence.
Comme un bibliothecaire : tu lui demandes un livre par titre, il sait ou le trouver dans les rayons.
interface UserRepository {
public function findByEmail(string $email): ?User;
public function save(User $user): void;
}
class DoctrineUserRepository implements UserRepository {
// Implementation avec Doctrine ORM
}Cas d'usage : Pour decoupler la logique metier de la base de donnees et faciliter les tests unitaires.
Registre central qui gere la creation et la resolution des dependances. C'est le coeur des frameworks modernes (Laravel, Symfony) pour l'injection de dependances.
Comme un annuaire d'entreprise : quand tu as besoin d'un service, tu demandes au standard qui te met en relation.
// Enregistrement
$container->bind(Logger::class, FileLogger::class);
// Resolution automatique
$service = $container->make(OrderService::class);
// Les dependances sont resolues automatiquementCas d'usage : Dans tout framework PHP moderne pour gerer les dependances et leur cycle de vie.
Attaque ou l'attaquant fixe l'ID de session d'un utilisateur avant qu'il se connecte, puis utilise cet ID pour usurper sa session.
Comme donner une cle de chambre d'hotel a quelqu'un et attendre qu'il s'y installe pour entrer apres lui.
// Apres login reussi, TOUJOURS regenerer
session_regenerate_id(true);
// Configuration stricte
ini_set('session.use_strict_mode', 1);
ini_set('session.use_only_cookies', 1);Cas d'usage : Apres chaque changement de niveau de privilege (login, elevation de droits).
Une classe ne doit avoir qu'une seule raison de changer. Chaque classe se concentre sur une seule responsabilite metier.
Comme un employe specialise : le cuisinier cuisine, le serveur sert, le caissier encaisse.
// Mauvais: une classe qui fait tout
// class User { save(), sendEmail(), generatePDF() }
// Bon: responsabilites separees
class UserRepository { public function save(User $u) {} }
class UserMailer { public function welcome(User $u) {} }
class UserExporter { public function toPDF(User $u) {} }Cas d'usage : Toujours : chaque classe creee doit avoir une responsabilite claire et unique.
Pattern qui garantit qu'une classe n'a qu'une seule instance et fournit un point d'acces global. Souvent considere comme un anti-pattern en PHP moderne.
Comme le president d'un pays : il n'y en a qu'un seul a la fois, accessible par tous.
class Database {
private static ?self $instance = null;
private function __construct() {}
public static function getInstance(): self {
return self::$instance ??= new self();
}
}Cas d'usage : Rarement justifie en PHP moderne : le service container gere deja les instances uniques.
Vulnerabilite ou un attaquant injecte du code SQL malveillant via des entrees utilisateur non assainies. L'une des failles les plus critiques et frequentes.
Comme un intrus qui ajoute des instructions sur un bon de commande pour se faire livrer gratuitement.
// DANGEREUX
$sql = "SELECT * FROM users WHERE id = $id";
// SECURISE
$stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id');
$stmt->execute(['id' => $id]);Cas d'usage : Prevention obligatoire sur TOUTE requete SQL utilisant des donnees externes.
Pattern qui definit une famille d'algorithmes interchangeables. Le client choisit la strategie a utiliser a l'execution sans modifier le code consommateur.
Comme choisir son moyen de transport : bus, velo ou taxi, la destination reste la meme.
interface ShippingStrategy {
public function calculate(Order $order): float;
}
class ExpressShipping implements ShippingStrategy { }
class StandardShipping implements ShippingStrategy { }
$order->setShipping(new ExpressShipping());Cas d'usage : Quand un comportement peut varier selon le contexte : calcul de prix, tri, notification.
Mecanisme de reutilisation de code dans les langages a heritage simple. Un trait permet d'injecter des methodes dans plusieurs classes sans heritage.
Comme un kit d'accessoires qu'on peut ajouter a n'importe quelle voiture, peu importe la marque.
trait Timestampable {
public function getCreatedAt(): DateTime {
return $this->createdAt;
}
}
class Article {
use Timestampable;
}Cas d'usage : Pour partager du comportement commun (logging, timestamps, soft delete) entre classes non liees par heritage.
Union (A|B) accepte l'un OU l'autre type (PHP 8.0). Intersection (A&B) exige que la valeur implemente TOUS les types (PHP 8.1). Renforce le typage statique.
Union : un billet accepte en euros OU en dollars. Intersection : un candidat qui parle francais ET anglais.
// Union
function parse(string|int $input): string { }
// Intersection
function save(Countable&Iterator $items): void { }Cas d'usage : Pour exprimer des contraintes de type precises et reduire les erreurs a l'execution.
Extension PHP de debugging et profilage. Permet le step debugging, le stack trace detaille, la couverture de code et le profilage de performance.
Comme une camera au ralenti qui permet de voir chaque etape de l'execution en detail.
; php.ini
zend_extension=xdebug
xdebug.mode=debug
xdebug.start_with_request=yes
xdebug.client_host=127.0.0.1
xdebug.client_port=9003Cas d'usage : En developpement pour debugger pas-a-pas, analyser les performances et generer la couverture de code.
Vulnerabilite permettant l'injection de scripts malveillants dans une page web vue par d'autres utilisateurs. Vole des sessions, redirige, defigure.
Comme quelqu'un qui colle un faux panneau dans un magasin pour tromper les clients.
// DANGEREUX
echo "Bonjour $username";
// SECURISE
echo 'Bonjour ' . htmlspecialchars($username, ENT_QUOTES, 'UTF-8');Cas d'usage : A chaque affichage de donnees dynamiques dans du HTML, sans exception.
Autres stacks