Guide de Révision PHP – Préparation Entretien Technique

Préparation entretien technique PHP : OOP, frameworks, design patterns et bonnes pratiques.

backend

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é.

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

🔒 Sécurité PHP - Vulnérabilités Principales 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 HTTP Headers ✅ X-Frame-Options ✅ X-XSS-Protection ✅ HTTPS redirect 🛡️ 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

Intermédiaire Scénarios techniques

🏗️ Scénario : Architecture e-commerce

"Concevez les classes pour un panier d'achat. Quelles relations ?"

💡 Réponse attendue

Classes : Product, CartItem, Cart
Relations : Cart contient CartItem[]
CartItem référence Product + quantité
Méthodes : addProduct(), getTotal(), etc.

🔒 Scénario : Injection SQL

"Ce code est-il sécurisé ? Comment l'améliorer ?"

$sql = "SELECT * FROM users WHERE id = " . $_GET['id'];
💡 Réponse attendue

❌ Vulnérable aux injections SQL
✅ Utiliser requêtes préparées PDO
✅ Valider les entrées utilisateur

⚡ Scénario : Performance

"Votre page prend 5 secondes à charger. Où chercher ?"

💡 Réponse attendue

1. Profiler les requêtes SQL
2. Vérifier les boucles N+1
3. Implémenter du cache
4. Optimiser les images/assets

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.