Guide complet pour réviser PHP moderne et réussir votre entretien technique. Concepts essentiels, exercices pratiques et questions d'entretien organisés par niveau de difficulté.
📋 Sommaire
Points essentiels à retenir:
Syntaxe moderne : Types, opérateurs nullsafe, match, attributs
POO avancée : Classes, interfaces, traits, namespaces, autoloading
Sécurité : Validation, échappement, authentification, PDO
Bonnes pratiques : PSR standards, tests, injection de dépendances
Outils modernes : Composer, frameworks, nouveautés PHP 8+
1. Syntaxe et concepts de base
Écosystème PHP - Vue d'ensemble
Core PHP
• Variables, types
• Fonctions, boucles
POO
• Classes, objets
• Héritage, interfaces
Web
• HTTP, formulaires
• Sessions, cookies
Base de données
• PDO, SQL
• Requêtes, sécurité
Sécurité
• Validation, filtres
• XSS, CSRF
Outils
• Composer
• Tests, PSR
Frameworks
• Laravel, Symfony
• CMS : WordPress
Progression recommandée : de gauche à droite, puis vers le bas
Types PHP - Guide simple
Types Scalaires (simples)
string
int
float
bool
Se convertissent automatiquement avec ==
Types Composés (complexes)
array
object
callable
Contiennent plusieurs valeurs
Types Spéciaux
null
resource
mixed
Règles importantes
== : conversion automatique
=== : même type ET valeur
Exemple : "5" == 5 ✓
"5" === 5 ✗
Variables Superglobales
$_GET
$_POST
$_SESSION
$_COOKIE
$_SERVER
$_FILES
$GLOBALS
🔍 Opérateur Nullsafe (PHP 8.0+)
$user?->profile?->name
Évite les erreurs si $user ou $profile sont null
🔍 Null Coalescing
$name = $_GET['name'] ?? 'Anonyme';
Utilise la valeur de droite si celle de gauche est null
🔍 Match Expression
$result = match($status) {
'active' => 'Actif',
'inactive' => 'Inactif',
default => 'Inconnu'
};
Alternative moderne à switch avec return automatique
🔍 Spaceship Operator
$a <=> $b
// Retourne -1, 0, ou 1
Comparaison à trois voies pour les tris
POO PHP 8+ - Exemple concis et moderne
<?php
declare(strict_types=1);
// ✅ Enum avec méthodes (PHP 8.1+)
enum Status: string
{
case ACTIVE = 'active';
case INACTIVE = 'inactive';
public function getLabel(): string
{
return match($this) {
self::ACTIVE => 'Actif',
self::INACTIVE => 'Inactif'
};
}
}
// ✅ Interface simple
interface UserRepositoryInterface
{
public function save(User $user): int;
public function findById(int $id): ?User;
}
// ✅ Trait réutilisable
trait Timestampable
{
private readonly DateTime $createdAt;
private function initTimestamp(): void
{
$this->createdAt = new DateTime();
}
public function getCreatedAt(): DateTime
{
return $this->createdAt;
}
}
// ✅ Classe moderne avec promoted properties
class User
{
use Timestampable;
public function __construct(
public readonly int $id,
public readonly string $email,
private string $name,
private Status $status = Status::ACTIVE
) {
$this->initTimestamp();
}
public function getName(): string
{
return $this->name;
}
public function changeName(string $newName): void
{
if (strlen(trim($newName)) < 2) {
throw new InvalidArgumentException('Nom trop court');
}
$this->name = trim($newName);
}
public function isActive(): bool
{
return $this->status === Status::ACTIVE;
}
public function toArray(): array
{
return [
'id' => $this->id,
'email' => $this->email,
'name' => $this->name,
'status' => $this->status->value,
'created_at' => $this->createdAt->format('Y-m-d H:i:s')
];
}
}
// ✅ Service avec injection de dépendance
class UserService
{
public function __construct(
private UserRepositoryInterface $repository
) {}
public function createUser(string $email, string $name): User
{
// Validation simple
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('Email invalide');
}
$user = new User(0, $email, $name);
$id = $this->repository->save($user);
return new User($id, $email, $name);
}
}
// ✅ Usage simple
try {
$userService = new UserService(new DatabaseUserRepository());
$user = $userService->createUser('alice@example.com', 'Alice');
echo "Utilisateur créé : " . $user->getName();
echo " - Statut : " . $user->isActive() ? 'Actif' : 'Inactif';
} catch (Exception $e) {
echo "Erreur : " . $e->getMessage();
}
2. Programmation orientée objet
POO PHP - Relations et Héritage
Interface
PaymentInterface
+ processPayment()
+ refund()
Trait
Timestampable
+ touch()
+ getCreatedAt()
Abstract Class
AbstractPayment
+ setCurrency()
# validateAmount()
Enum
Status
ACTIVE
INACTIVE
Classe Concrète
StripePayment
- apiKey: string
+ __construct()
+ processPayment()
+ refund()
implements
use
extends
🔒 Visibilité des Propriétés et Méthodes
+
public
Accessible partout
#
protected
Classe + héritiers
-
private
Classe uniquement
🆕 Nouveautés POO PHP 8+
Évolution POO : PHP 7 → PHP 8+
❌ PHP 7 - Verbeux
class User {
private $name;
private $email;
public function __construct(
$name, $email) {
$this->name = $name;
$this->email = $email;
}
}
✅ PHP 8+ - Concis
readonly class User {
public function __construct(
public string $name,
public string $email
) {}
}
• Promoted properties
• Readonly class
• Types explicites
ÉVOLUTION
Classes et objets modernes
Promoted properties (PHP 8.0) - Déclaration raccourcie dans le constructeur
Readonly properties (PHP 8.1) - Propriétés immutables
Typed properties - Déclaration explicite des types
Constantes typées (PHP 8.3) - const int MAX = 100;
Interfaces et Traits
Interfaces - Contrats, méthodes publiques uniquement
Traits - Réutilisation de code, résolution de conflits
Intersection types (PHP 8.1) - A&B (objet implémentant A ET B)
Union types (PHP 8.0) - A|B (objet de type A OU B)
Autoloading et namespaces
PSR-4 - Standard d'autoloading moderne
Composer - Gestionnaire de dépendances et autoloading
Namespaces - Organisation logique du code
Use statements - Import et alias
🏗️ Interface vs Classe Abstraite
Interface : Contrat pur, méthodes publiques uniquement
Classe abstraite : Peut contenir logique concrète + méthodes abstraites
🧩 Trait
Réutilisation horizontale de code. Une classe peut utiliser plusieurs traits avec use
use Timestampable, Loggable;
🎯 Promoted Properties
Déclaration raccourcie dans le constructeur (PHP 8.0+)
public function __construct(
public string $name
) {}
🔒 Readonly
Propriétés immutables après initialisation (PHP 8.1+)
readonly class User {}
🏷️ Enums
Types énumérés avec méthodes (PHP 8.1+)
enum Status: string {
case ACTIVE = 'active';
public function isActive(): bool {
return $this === self::ACTIVE;
}
}
📋 Attributs
Métadonnées pour classes/méthodes (PHP 8.0+)
#[Route('/api/users')]
#[Cache(300)]
public function getUsers() {}
3. Base de données et PDO
PDO - Cycle de vie d'une requête sécurisée
1. Connexion
new PDO($dsn)
Options sécurisées
ERRMODE_EXCEPTION
2. Préparation
$pdo->prepare()
Placeholders :param
ou ? positionnels
3. Exécution
$stmt->execute()
Paramètres liés
Protection injection
4. Récupération
fetch() / fetchAll()
FETCH_ASSOC
FETCH_OBJ
❌ DANGEREUX - Requête native
$sql = "SELECT * FROM users
WHERE id = " . $_GET['id'];
$result = mysql_query($sql);
🚨 Vulnérable aux injections SQL
✅ SÉCURISÉ - PDO
$stmt = $pdo->prepare(
"SELECT * FROM users WHERE id = ?");
$stmt->execute([$_GET['id']]);
✅ Protection automatique
🔄 Transactions ACID
beginTransaction() → execute() → commit()
En cas d'erreur : rollback() automatique
Atomicité garantie
Configuration PDO sécurisée
DSN - Configuration de connexion (host, dbname, charset)
Options sécurisées - ERRMODE_EXCEPTION, EMULATE_PREPARES = false
Singleton pattern - Une seule instance de connexion
Gestion d'erreurs - Try/catch, logging approprié
Requêtes préparées et CRUD
Prepare/Execute - Protection contre l'injection SQL
Paramètres nommés - :param vs ? positionnels
Types de fetch - FETCH_ASSOC, FETCH_OBJ, FETCH_CLASS
Repository pattern - Encapsulation des requêtes
Transactions et performance
ACID - Atomicité, Cohérence, Isolation, Durabilité
Rollback automatique - En cas d'exception
Connection pooling - Réutilisation des connexions
Requêtes optimisées - Index, EXPLAIN, pagination
🎯 Types de récupération PDO
Modes de récupération des données
fetch()
• Une seule ligne
• false si fin
• Économe mémoire
fetchAll()
• Toutes les lignes
• Array complet
• + mémoire
fetchColumn()
• Une colonne
• Valeur directe
• COUNT(), etc.
fetchObject()
• Objet stdClass
• ou classe custom
• ORM léger
Modes par défaut
FETCH_ASSOC: ['name' => 'Alice']
FETCH_NUM: [0 => 'Alice']
FETCH_OBJ: $obj->name
PDO - Configuration et Repository pattern complet
<?php
declare(strict_types=1);
namespace App\Infrastructure\Database;
use PDO;
use PDOException;
use Exception;
// ✅ Singleton Database Connection
class DatabaseConnection
{
private static ?PDO $instance = null;
public static function getInstance(): PDO
{
if (self::$instance === null) {
$dsn = sprintf(
'mysql:host=%s;dbname=%s;charset=utf8mb4',
$_ENV['DB_HOST'] ?? 'localhost',
$_ENV['DB_NAME'] ?? 'myapp'
);
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
PDO::ATTR_EMULATE_PREPARES => false, // Vraies requêtes préparées
PDO::ATTR_PERSISTENT => true, // Connection persistante
PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8mb4 COLLATE utf8mb4_unicode_ci"
];
try {
self::$instance = new PDO(
$dsn,
$_ENV['DB_USER'] ?? 'root',
$_ENV['DB_PASS'] ?? '',
$options
);
} catch (PDOException $e) {
error_log("Database connection failed: " . $e->getMessage());
throw new Exception("Database connection failed");
}
}
return self::$instance;
}
// Empêcher l'instanciation directe
private function __construct() {}
private function __clone() {}
public function __wakeup() {}
}
// ✅ Abstract Repository avec fonctionnalités communes
abstract class AbstractRepository
{
protected PDO $pdo;
protected string $table;
public function __construct()
{
$this->pdo = DatabaseConnection::getInstance();
}
protected function executeQuery(string $sql, array $params = []): \PDOStatement
{
try {
$stmt = $this->pdo->prepare($sql);
$stmt->execute($params);
return $stmt;
} catch (PDOException $e) {
error_log("Query failed: {$sql} - " . $e->getMessage());
throw new Exception("Database query failed");
}
}
public function findById(int $id): ?array
{
$stmt = $this->executeQuery(
"SELECT * FROM {$this->table} WHERE id = :id",
['id' => $id]
);
$result = $stmt->fetch();
return $result ?: null;
}
public function findAll(int $limit = 100, int $offset = 0): array
{
$stmt = $this->executeQuery(
"SELECT * FROM {$this->table} ORDER BY id DESC LIMIT :limit OFFSET :offset",
['limit' => $limit, 'offset' => $offset]
);
return $stmt->fetchAll();
}
public function delete(int $id): bool
{
$stmt = $this->executeQuery(
"DELETE FROM {$this->table} WHERE id = :id",
['id' => $id]
);
return $stmt->rowCount() > 0;
}
public function count(): int
{
$stmt = $this->executeQuery("SELECT COUNT(*) FROM {$this->table}");
return (int) $stmt->fetchColumn();
}
}
// ✅ Repository spécialisé pour les utilisateurs
class UserRepository extends AbstractRepository
{
protected string $table = 'users';
public function findByEmail(string $email): ?array
{
$stmt = $this->executeQuery(
'SELECT * FROM users WHERE email = :email',
['email' => $email]
);
$result = $stmt->fetch();
return $result ?: null;
}
public function create(array $data): int
{
$sql = 'INSERT INTO users (name, email, password, created_at, updated_at)
VALUES (:name, :email, :password, NOW(), NOW())';
$this->executeQuery($sql, [
'name' => $data['name'],
'email' => $data['email'],
'password' => password_hash($data['password'], PASSWORD_DEFAULT)
]);
return (int) $this->pdo->lastInsertId();
}
public function update(int $id, array $data): bool
{
$sql = 'UPDATE users SET name = :name, email = :email, updated_at = NOW()
WHERE id = :id';
$stmt = $this->executeQuery($sql, [
'id' => $id,
'name' => $data['name'],
'email' => $data['email']
]);
return $stmt->rowCount() > 0;
}
// ✅ Recherche avec pagination
public function search(string $term, int $page = 1, int $perPage = 20): array
{
$offset = ($page - 1) * $perPage;
$sql = 'SELECT id, name, email, created_at FROM users
WHERE name LIKE :term OR email LIKE :term
ORDER BY name
LIMIT :limit OFFSET :offset';
$stmt = $this->pdo->prepare($sql);
$stmt->bindValue(':term', "%{$term}%", PDO::PARAM_STR);
$stmt->bindValue(':limit', $perPage, PDO::PARAM_INT);
$stmt->bindValue(':offset', $offset, PDO::PARAM_INT);
$stmt->execute();
return [
'data' => $stmt->fetchAll(),
'page' => $page,
'per_page' => $perPage,
'total' => $this->searchCount($term)
];
}
private function searchCount(string $term): int
{
$stmt = $this->executeQuery(
'SELECT COUNT(*) FROM users WHERE name LIKE :term OR email LIKE :term',
['term' => "%{$term}%"]
);
return (int) $stmt->fetchColumn();
}
// ✅ Transaction complexe - transfert de crédits
public function transferCredits(int $fromUserId, int $toUserId, int $amount): bool
{
try {
$this->pdo->beginTransaction();
// Vérifier et débiter le compte source
$stmt = $this->executeQuery(
'UPDATE users SET credits = credits - :amount
WHERE id = :id AND credits >= :amount',
['amount' => $amount, 'id' => $fromUserId]
);
if ($stmt->rowCount() === 0) {
throw new Exception('Crédits insuffisants');
}
// Créditer le compte destination
$this->executeQuery(
'UPDATE users SET credits = credits + :amount WHERE id = :id',
['amount' => $amount, 'id' => $toUserId]
);
// Logger la transaction
$this->executeQuery(
'INSERT INTO credit_transfers (from_user_id, to_user_id, amount, created_at)
VALUES (:from_id, :to_id, :amount, NOW())',
['from_id' => $fromUserId, 'to_id' => $toUserId, 'amount' => $amount]
);
$this->pdo->commit();
return true;
} catch (Exception $e) {
$this->pdo->rollback();
error_log("Transfer failed: " . $e->getMessage());
throw $e;
}
}
// ✅ Requête avec jointure optimisée
public function getUsersWithProfiles(int $limit = 50): array
{
$sql = 'SELECT u.id, u.name, u.email, p.bio, p.avatar_url
FROM users u
LEFT JOIN profiles p ON u.id = p.user_id
WHERE u.deleted_at IS NULL
ORDER BY u.created_at DESC
LIMIT :limit';
$stmt = $this->pdo->prepare($sql);
$stmt->bindValue(':limit', $limit, PDO::PARAM_INT);
$stmt->execute();
return $stmt->fetchAll(PDO::FETCH_ASSOC);
}
}
// ✅ Utilisation avec gestion d'erreurs complète
class UserService
{
public function __construct(
private UserRepository $userRepository
) {}
public function createUser(array $userData): array
{
// Validation
if (!filter_var($userData['email'], FILTER_VALIDATE_EMAIL)) {
throw new InvalidArgumentException('Email invalide');
}
// Vérifier l'unicité
if ($this->userRepository->findByEmail($userData['email'])) {
throw new DomainException('Cet email est déjà utilisé');
}
try {
$userId = $this->userRepository->create($userData);
// Récupérer l'utilisateur créé
$user = $this->userRepository->findById($userId);
// Logger l'événement
error_log("New user created: {$userData['email']} (ID: {$userId})");
return $user;
} catch (Exception $e) {
error_log("User creation failed: " . $e->getMessage());
throw new Exception('Impossible de créer l\'utilisateur');
}
}
}
// Usage
try {
$userRepository = new UserRepository();
$userService = new UserService($userRepository);
$newUser = $userService->createUser([
'name' => 'Alice Dupont',
'email' => 'alice@example.com',
'password' => 'SecurePass123!'
]);
echo "Utilisateur créé avec l'ID : " . $newUser['id'];
} catch (InvalidArgumentException|DomainException $e) {
echo "Erreur de validation : " . $e->getMessage();
} catch (Exception $e) {
echo "Erreur système : " . $e->getMessage();
}
Syntaxe moderne PHP 8+ - Exemples essentiels
<?php
declare(strict_types=1); // Typage strict
// ✅ Types scalaires et union types
function processData(string|int $value, ?array $options = null): bool|string
{
// Null coalescing assignment
$options ??= ['format' => 'json'];
// Match expression (PHP 8.0+)
return match (gettype($value)) {
'string' => strtoupper($value),
'integer' => $value > 0,
default => throw new InvalidArgumentException('Type non supporté')
};
}
// ✅ Arrow functions (PHP 7.4+)
$numbers = [1, 2, 3, 4, 5];
$squared = array_map(fn($n) => $n ** 2, $numbers);
// ✅ Null safe operator (PHP 8.0+)
class User {
public function __construct(
public readonly string $name, // PHP 8.1+ promoted properties
public ?Profile $profile = null
) {}
}
class Profile {
public function __construct(public string $bio) {}
}
$user = new User('Alice');
$bio = $user?->profile?->bio ?? 'Pas de bio'; // Safe navigation
// ✅ Enums (PHP 8.1+)
enum Status: string
{
case DRAFT = 'draft';
case PUBLISHED = 'published';
case ARCHIVED = 'archived';
public function isPublic(): bool
{
return $this === self::PUBLISHED;
}
}
// ✅ Attributes (PHP 8.0+)
#[Route('/api/users')]
class UserController
{
#[Get, Cache(300)]
public function index(): array
{
return ['users' => []];
}
}
// ✅ Gestion d'erreurs moderne
try {
$result = processData('test');
} catch (InvalidArgumentException $e) {
error_log($e->getMessage());
throw new DomainException('Données invalides', 0, $e);
} finally {
// Cleanup
}
🔒 Protection SQL Injection
Requêtes préparées : Séparent structure et données
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ?");
$stmt->execute([$userId]);
⚙️ Options PDO essentielles
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
PDO::ATTR_EMULATE_PREPARES => false
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
🔄 Transactions
Garantissent l'atomicité des opérations multiples
$pdo->beginTransaction();
// opérations...
$pdo->commit(); // ou rollback()
📊 Repository Pattern
Encapsule l'accès aux données dans des classes dédiées
class UserRepository {
public function findById(int $id): ?User
}
4. Sécurité et bonnes pratiques
SQL Injection
❌ Concaténation SQL
✅ Requêtes préparées
✅ Validation stricte
XSS
❌ echo $_POST['data']
✅ htmlspecialchars()
✅ CSP Headers
CSRF
❌ Pas de token
✅ CSRF tokens
✅ SameSite cookies
File Upload
❌ Pas de validation
✅ Type MIME check
✅ Rename files
Sessions
✅ session_regenerate_id
✅ Secure cookies
✅ HTTPOnly flag
Validation
✅ filter_var()
✅ Whitelist approach
✅ Type checking
Mots de passe
✅ password_hash()
✅ password_verify()
✅ Strong policies
🛡️ Defense in Depth (Défense en profondeur)
1. Validation côté client ET serveur
2. Échappement à la sortie selon le contexte
3. Principe du moindre privilège
4. Logs et monitoring
5. Chiffrement données sensibles
6. Mise à jour régulière
🛡️ Flux d'attaque vs Protection
Cycle d'une attaque et ses protections
👤 Attaquant
Payload malicieux
⚠️ Input
Non validé
💥 Traitement
Vulnérable
💀 Dégâts
Données volées
🛡️ Couche de Protection (Defense in Depth)
✅ Validation
✅ Échappement
✅ Auth
✅ Permissions
🔍 Monitoring & Logs
❌ BLOQUÉ
🏆 OWASP Top 5 pour PHP
Vulnérabilités critiques et leurs protections
1️⃣ Injection
SQL, NoSQL, LDAP
🛡️ Requêtes préparées
🛡️ Validation stricte
🛡️ Principe moindre
privilège
2️⃣ Auth cassée
Sessions faibles
🛡️ Sessions sécurisées
🛡️ 2FA obligatoire
🛡️ Rate limiting
3️⃣ Données sensibles
Mots de passe en clair
🛡️ password_hash()
🛡️ HTTPS obligatoire
🛡️ Chiffrement BDD
4️⃣ XSS
Scripts malicieux
🛡️ htmlspecialchars()
🛡️ CSP headers
🛡️ Validation E/S
5️⃣ CSRF
(Cross-Site Request Forgery)
Actions non autorisées via sites tiers
🛡️ Tokens CSRF uniques par session
🛡️ SameSite cookies + validation Origin
💡 Ces 5 vulnérabilités représentent ~80% des failles de sécurité web
La défense en profondeur combine plusieurs protections • Tests réguliers • Formation équipe
🔐 Mots de passe sécurisés
// ✅ Correct
$hash = password_hash($password, PASSWORD_DEFAULT);
if (password_verify($input, $hash)) { ... }
// ❌ Dangereux
if (md5($password) === $stored) { ... }
🛡️ Protection XSS
// ✅ Correct
echo htmlspecialchars($userInput, ENT_QUOTES, 'UTF-8');
// ❌ Dangereux
echo $_POST['comment']; // Script injecté
🎫 Tokens CSRF
// ✅ Génération
$token = bin2hex(random_bytes(32));
$_SESSION['csrf_token'] = $token;
// ✅ Vérification
hash_equals($_SESSION['csrf_token'], $_POST['token'])
🔒 Sessions sécurisées
// Configuration sécurisée
ini_set('session.cookie_httponly', '1');
ini_set('session.cookie_secure', '1');
ini_set('session.cookie_samesite', 'Strict');
session_regenerate_id(true);
📁 Upload de fichiers
// Vérifications essentielles
$allowedTypes = ['image/jpeg', 'image/png'];
$finfo = finfo_open(FILEINFO_MIME_TYPE);
$mimeType = finfo_file($finfo, $file['tmp_name']);
if (!in_array($mimeType, $allowedTypes)) { ... }
🌐 Headers de sécurité
header('X-Frame-Options: DENY');
header('X-XSS-Protection: 1; mode=block');
header('X-Content-Type-Options: nosniff');
header('Strict-Transport-Security: max-age=31536000');
5. Frameworks et outils modernes
Écosystème PHP Moderne - Frameworks et Outils
🏗️ Full-Stack
Laravel
CodeIgniter
✅ Tout inclus
✅ Rapide à démarrer
🧩 Modulaires
Symfony
Laminas
✅ Composants réutilisables
✅ Enterprise ready
⚡ Micro
Slim
Lumen
✅ APIs rapides
✅ Léger
🛠️ Outils Développement
Composer
PHPUnit
PHPStan
Dépendances • Tests • Analyse statique
🗄️ Base de Données
Eloquent
Doctrine
PDO
ORM avancé • ORM enterprise • SQL natif
🏛️ Architecture Moderne PHP
• Dependency Injection
• PSR Standards (4, 7, 11, 12...)
• Containerisation (Docker)
• API-First design
• Event-Driven
• Microservices
🏗️ Architecture Application PHP Moderne
Structure Moderne avec Dependency Injection
Controllers
HTTP Layer
Services
Business Logic
Repositories
Data Access
Database
MySQL/Postgres
🔌 Dependency Injection Container
• Auto-wiring des dépendances
• Configuration centralisée
• Interfaces vs implémentations
• Testabilité améliorée
📋 Standards PSR
PSR-4: Autoloading
PSR-7: HTTP Message
PSR-11: Container
PSR-12: Code Style
Structure de projet moderne avec Composer
// ✅ composer.json essentiel
{
"require": {
"php": "^8.1",
"symfony/http-foundation": "^6.0",
"monolog/monolog": "^3.0"
},
"autoload": {
"psr-4": {
"App\\": "src/"
}
},
"scripts": {
"test": "phpunit",
"analyse": "phpstan analyse src --level=8"
}
}
// ✅ Structure claire avec DI
// src/Application/Controllers/UserController.php
class UserController
{
public function __construct(
private UserService $userService,
private LoggerInterface $logger
) {}
public function create(Request $request): JsonResponse
{
try {
$user = $this->userService->createUser($request->toArray());
return new JsonResponse(['user' => $user], 201);
} catch (ValidationException $e) {
return new JsonResponse(['errors' => $e->getErrors()], 400);
}
}
}
// ✅ Service avec injection
// src/Domain/Services/UserService.php
class UserService
{
public function __construct(
private UserRepositoryInterface $repository,
private ValidatorInterface $validator
) {}
public function createUser(array $data): User
{
$this->validator->validate($data);
return $this->repository->create($data);
}
}
// ✅ Point d'entrée moderne
// public/index.php
require_once __DIR__ . '/../vendor/autoload.php';
$container = new Container();
$container->loadServices(__DIR__ . '/../config/services.php');
$request = Request::createFromGlobals();
$response = $container->get(Router::class)->handle($request);
$response->send();
📦 Composer - Gestionnaire de dépendances
composer require vendor/package
composer install
composer dump-autoload
Gère les dépendances et l'autoloading PSR-4
🏗️ Laravel vs Symfony
Laravel : Convention over configuration, full-stack
Symfony : Composants modulaires, enterprise
🔌 Dependency Injection
// Au lieu de
$service = new UserService(new UserRepository());
// DI Container fait
$service = $container->get(UserService::class);
🧪 PHPUnit - Tests
class UserTest extends TestCase {
public function testCreateUser() {
$user = $this->userService->create([...]);
$this->assertInstanceOf(User::class, $user);
}
}
6. Nouveautés PHP 8.3 / 8.4
🚀 Évolution PHP : 8.0 → 8.4
8.0
Nov 2020
• Union types
• Match expression
• Attributes
8.1
Nov 2021
• Enums
• Readonly properties
• Intersection types
8.2
Dec 2022
• Readonly classes
• DNF types
• Constants in traits
8.3
Nov 2023
• #[Override]
• json_validate()
• Anonymous classes
8.4
Nov 2024
• Typed constants
• Property hooks
• Asymmetric visibility
📊 Priorités d'adoption
🔥 Priorité haute
• Union types • Match • Enums
• Readonly • #[Override]
⚡ Priorité moyenne
• Attributes • json_validate()
• Intersection types
📚 À explorer
• Property hooks • DNF types
• Asymmetric visibility
🎯 Chemin de migration recommandé
PHP 7.4 → 8.0 → 8.1 → 8.2+ (adoption progressive)
🔥 Nouveautés les plus impactantes
Transformation du code PHP moderne
❌ PHP 7 - Types complexes
/**
* @param string|int|null $value
*/
✅ PHP 8+ - Union types
function process(string|int|null $value) {
// Type safety native
}
❌ Switch verbeux
switch ($status) {
case 'active': return 'Actif'; break;
default: return 'Inconnu';
✅ Match concis
$result = match($status) {
'active' => 'Actif',
default => 'Inconnu'
❌ Constantes dispersées
const STATUS_ACTIVE = 'active';
const STATUS_INACTIVE = 'inactive';
// Pas de méthodes, pas de validation
✅ Enums avec méthodes
enum Status: string {
case ACTIVE = 'active';
public function isActive(): bool {...}
Nouveautés PHP 8+ en action - Guide pratique
<?php
declare(strict_types=1);
// ✅ PHP 8.4 - Constantes typées
class Config
{
public const int MAX_USERS = 1000;
public const string APP_NAME = 'MyApp';
}
// ✅ PHP 8.3 - Attribut #[Override]
interface PaymentInterface
{
public function process(float $amount): bool;
}
class StripePayment implements PaymentInterface
{
#[Override] // Vérifie que la méthode existe dans l'interface
public function process(float $amount): bool
{
return $amount > 0;
}
}
// ✅ PHP 8.1 - Enums avec méthodes
enum Status: string
{
case ACTIVE = 'active';
case INACTIVE = 'inactive';
public function getLabel(): string
{
return match($this) {
self::ACTIVE => 'Actif',
self::INACTIVE => 'Inactif'
};
}
}
// ✅ PHP 8.2 - Readonly classes
readonly class UserProfile
{
public function __construct(
public string $name,
public string $email,
public Status $status = Status::ACTIVE
) {}
}
// ✅ PHP 8.0 - Union types + Match
function formatValue(string|int|float $value): string
{
return match (true) {
is_string($value) => "Texte: $value",
is_int($value) => "Entier: $value",
is_float($value) => "Décimal: " . number_format($value, 2),
default => "Type inconnu"
};
}
// ✅ PHP 8.3 - json_validate() pour validation rapide
function validateJsonPayload(string $json): bool
{
// Plus rapide que json_decode() pour juste valider
return json_validate($json);
}
// ✅ Usage moderne
$profile = new UserProfile('Alice', 'alice@example.com');
echo $profile->status->getLabel(); // "Actif"
$values = ['hello', 42, 3.14];
foreach ($values as $value) {
echo formatValue($value) . "\n";
}
$jsonData = '{"name": "test"}';
if (validateJsonPayload($jsonData)) {
echo "JSON valide !";
}
🎯 Union Types (8.0)
function process(string|int $value): string|null
{
return is_string($value) ? strtoupper($value) : (string) $value;
}
Types multiples sans @param DocBlock
⚡ Match Expression (8.0)
$result = match($status) {
'pending' => 'En attente',
'approved', 'validated' => 'Validé',
default => 'Inconnu'
};
Plus concis que switch, retourne une valeur
🏷️ Enums avec méthodes (8.1)
enum Priority: int {
case LOW = 1;
case HIGH = 5;
public function getColor(): string {
return match($this) {
self::LOW => 'green',
self::HIGH => 'red'
};
}
}
🔒 Readonly Classes (8.2)
readonly class Point {
public function __construct(
public float $x,
public float $y
) {}
}
// Toutes les propriétés sont readonly
✅ #[Override] (8.3)
class Child extends Parent {
#[Override]
public function method(): void {
// Vérifie à la compilation que
// Parent::method() existe
}
}
📊 json_validate() (8.3)
// Plus rapide que json_decode() pour validation
if (json_validate($jsonString)) {
$data = json_decode($jsonString, true);
}
// Économise la mémoire pour gros JSON
7. Questions d'entretien par niveau
📋 Questions organisées par difficulté
🎯 Pyramide des Compétences PHP - Entretiens
Expert
Intermédiaire
Junior
👶 Junior (0-2 ans)
• Syntaxe PHP de base
• Variables, boucles, fonctions
• HTML/CSS intégration
• Debugging simple
⏱️ Questions: 2-5 min
⚡ Intermédiaire (2-5 ans)
• POO avancée
• PDO et sécurité
• Frameworks (Laravel/Symfony)
• APIs REST
⏱️ Questions: 5-15 min
🚀 Expert (5+ ans)
• Architecture système
• Performance optimization
• Design patterns
• Leadership technique
⏱️ Questions: 15-30 min
💡 Questions par scénarios pratiques
Junior Scénarios de base
🧩 Scénario : Formulaire de contact
"Comment récupérer et valider les données d'un formulaire ?"
💡 Réponse attendue
// Validation
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
$name = trim($_POST['name'] ?? '');
$email = filter_var($_POST['email'], FILTER_VALIDATE_EMAIL);
if (empty($name) || !$email) {
$errors[] = 'Données invalides';
}
}
🔄 Scénario : Affichage de données
"Comment afficher une liste d'utilisateurs depuis un array ?"
💡 Réponse attendue
$users = [...]; // Array d'utilisateurs
foreach ($users as $user) {
echo "<div>{$user['name']} - {$user['email']}</div>";
}
// Mentionner htmlspecialchars() pour la sécurité
🐛 Scénario : Debugging
"Votre script PHP affiche une page blanche. Comment débugger ?"
💡 Réponse attendue
1. Vérifier les logs d'erreur
2. Activer error_reporting
3. Utiliser var_dump() / print_r()
4. Vérifier la syntaxe PHP
Expert Scénarios architecture
🏛️ Scénario : Microservices
"Comment migrer un monolithe vers des microservices ?"
💡 Réponse attendue
1. Identifier les bounded contexts
2. Strangler Fig pattern
3. API Gateway + Event sourcing
4. Monitoring distribué
📊 Scénario : Scalabilité
"1M d'utilisateurs simultanés. Architecture ?"
💡 Réponse attendue
Load balancing, cache Redis
Database sharding, CDN
Queue workers, monitoring
Auto-scaling, failover
🔧 Scénario : Legacy code
"Refactorer du code PHP 5.6 vers 8+. Strategy ?"
💡 Réponse attendue
1. Tests de régression d'abord
2. Migration progressive
3. Typing + modern syntax
4. Dependency injection
8. Exercices pratiques
🎯 Parcours d'Exercices PHP - Progression
🟢 Niveau 1
Bases PHP
🟡 Niveau 2
POO & BDD
🔴 Niveau 3
API & Sécurité
🏆 Projet
Complet
🎓 Compétences acquises après le parcours
✅ Maîtrise syntaxe PHP moderne
✅ POO et design patterns
✅ Sécurité et bonnes pratiques
✅ APIs REST complètes
✅ Architecture MVC
✅ Prêt pour entretiens techniques
🎯 Exercices progressifs avec corrections
🟢 Exercice 1 : Calculateur simple
Objectif : Créer une classe Calculator avec les 4 opérations de base
Concepts testés : Classes, méthodes, validation des entrées, exceptions
📝 Énoncé détaillé
Classe Calculator avec méthodes add(), subtract(), multiply(), divide()
Gérer la division par zéro avec une exception
Valider que les paramètres sont des nombres
Bonus: Méthode pour calculer un pourcentage
💡 Solution
class Calculator
{
public function add(float $a, float $b): float
{
return $a + $b;
}
public function divide(float $a, float $b): float
{
if ($b === 0.0) {
throw new InvalidArgumentException('Division par zéro');
}
return $a / $b;
}
public function percentage(float $value, float $percent): float
{
return ($value * $percent) / 100;
}
}
// Usage
$calc = new Calculator();
echo $calc->add(10, 5); // 15
echo $calc->percentage(200, 15); // 30
🟡 Exercice 2 : Gestionnaire de tâches
Objectif : Système de TODO avec PDO et validation
Concepts testés : PDO, CRUD, validation, sécurité
📝 Énoncé détaillé
Table: tasks (id, title, description, completed, created_at)
Classe Task et TaskRepository
Méthodes: create(), findAll(), markComplete(), delete()
Validation: titre obligatoire (min 3 caractères)
Sécurité: requêtes préparées PDO
💡 Solution
class Task
{
public function __construct(
public readonly int $id,
public string $title,
public string $description = '',
public bool $completed = false
) {
if (strlen(trim($title)) < 3) {
throw new InvalidArgumentException('Titre trop court');
}
}
}
class TaskRepository
{
public function __construct(private PDO $pdo) {}
public function create(string $title, string $description = ''): int
{
$stmt = $this->pdo->prepare(
'INSERT INTO tasks (title, description, created_at) VALUES (?, ?, NOW())'
);
$stmt->execute([$title, $description]);
return (int) $this->pdo->lastInsertId();
}
public function findAll(): array
{
$stmt = $this->pdo->query('SELECT * FROM tasks ORDER BY created_at DESC');
return $stmt->fetchAll(PDO::FETCH_ASSOC);
}
public function markComplete(int $id): bool
{
$stmt = $this->pdo->prepare('UPDATE tasks SET completed = 1 WHERE id = ?');
return $stmt->execute([$id]);
}
}
🔴 Exercice 3 : API REST sécurisée
Objectif : API complète avec authentification JWT
Concepts testés : REST, JSON, JWT, sécurité, architecture
📝 Énoncé détaillé
Endpoints: POST /login, GET /users, POST /users, PUT /users/{id}
Authentification JWT sur toutes les routes sauf /login
Validation des données JSON d'entrée
Codes de statut HTTP appropriés
Gestion d'erreurs avec messages JSON
💡 Solution (structure)
class ApiRouter
{
private const ROUTES = [
'POST /login' => 'login',
'GET /users' => 'getUsers',
'POST /users' => 'createUser'
];
public function handle(string $method, string $path): void
{
$route = "$method $path";
if (!isset(self::ROUTES[$route])) {
$this->jsonResponse(['error' => 'Not found'], 404);
return;
}
if ($route !== 'POST /login' && !$this->isAuthenticated()) {
$this->jsonResponse(['error' => 'Unauthorized'], 401);
return;
}
$handler = self::ROUTES[$route];
$this->$handler();
}
private function jsonResponse(array $data, int $status = 200): void
{
http_response_code($status);
header('Content-Type: application/json');
echo json_encode($data);
}
}
À Retenir
Types et syntaxe moderne : Utilisez declare(strict_types=1), union types, match expressions pour un code plus robuste
POO avancée : Maîtrisez les interfaces, traits, promoted properties et readonly classes pour une architecture solide
Sécurité par défaut : Requêtes préparées PDO, validation stricte, CSRF tokens, échappement systématique des sorties
Architecture moderne : Repository pattern, dependency injection, séparation des responsabilités (SRP)
Gestion d'erreurs : Exceptions typées, logging approprié, codes HTTP corrects pour les APIs
Performance : Cache intelligent, lazy loading, pagination, optimisation des requêtes SQL
Standards PSR : Autoloading PSR-4, structure de projet cohérente, code style PSR-12
Nouveautés 8+ : Enums, attributs, constantes typées, #[Override] pour un développement moderne
Tests et qualité : PHPUnit, analyse statique (PHPStan), validation continue du code
Écosystème : Composer pour les dépendances, frameworks modernes, outils de développement
🚀 PHP moderne privilégie la sécurité, la performance et la maintenabilité. Maîtriser ces concepts vous permettra de créer des applications robustes et évolutives. La clé est de pratiquer les patterns modernes et de rester à jour avec les évolutions du langage. PHP 8+ n'est plus le PHP des années 2000 - c'est un langage mature avec un typage fort et des outils professionnels.