PHP : Niveau Expert

Singleton, Factory et Injection de Dépendances

Apprenez à structurer vos applications pour qu'elles soient testables et maintenables.

<?php
// Injection de Dépendances (DI)
class Database { /* ... */ }

class UserRepository {
    public function __construct(private Database $db) {}
}

// Le conteneur de services s'occupera d'injecter $db dans UserRepository
$repo = new UserRepository(new Database());
?>

Protéger son application à 100%

• Hachage : password_hash() avec Argon2id.
• CSRF : Jetons uniques par session pour valider les formulaires.
• Sécurité des Entêtes : CSP, HSTS, X-Frame-Options.
• Validation : Utilisation stricte de filter_var et des expressions régulières.

Construire des services robustes

Apprenez à gérer les méthodes HTTP (GET, POST, PUT, DELETE), les codes de statut et le format JSON.

<?php
header('Content-Type: application/json');

if ($_SERVER['REQUEST_METHOD'] === 'GET') {
    echo json_encode(["status" => "success", "data" => $users]);
} else {
    http_response_code(405);
    echo json_encode(["error" => "Méthode non autorisée"]);
}
?>

Garantir la stabilité du code

Le Test-Driven Development (TDD) permet de s'assurer que chaque fonctionnalité répond aux besoins sans régression.

<?php
use PHPUnit\Framework\TestCase;

class CalculateurTest extends TestCase {
    public function testAddition() {
        $calc = new Calculateur();
        $this->assertEquals(4, $calc->add(2, 2));
    }
}
?>

Métaprogrammation et Introspection

Utilisez les attributs pour ajouter des méta-données directement dans vos classes (utilisé par Symfony/Doctrine).

<?php
#[Attribute]
class Route {
    public function __construct(public string $url) {}
}

class PageController {
    #[Route('/accueil')]
    public function index() { /* ... */ }
}

// Récupération via Reflection
$reflector = new ReflectionMethod(PageController::class, 'index');
$attr = $reflector->getAttributes(Route::class)[0];
echo $attr->newInstance()->url; // '/accueil'
?>

Caches et Profiling

Optimisez l'exécution avec OPcache et gérez les données massives avec Redis ou Memcached.

Utilisez Xdebug pour profiler votre code et trouver les fonctions les plus lentes.

Dernières innovations du langage

1. Property Hooks

Définissez des getters et setters directement sur la propriété.

class User {
    public string $name {
        set => strtolower($value);
        get => ucfirst($this->name);
    }
}

2. Asymmetric Visibility

Définissez une visibilité différente pour la lecture et l'écriture.

class Post {
    public private(set) string $title;

    public function __construct(string $title) {
        $this->title = $title;
    }
}

3. Readonly Classes (8.2+)

Toutes les propriétés de la classe deviennent readonly automatiquement.

readonly class Configuration {
    public function __construct(
        public string $apiUrl,
        public int $timeout
    ) {}
}

4. Enumerations (8.1+)

Gérez les états de manière type-safe.

enum Status: string {
    case Draft = 'draft';
    case Published = 'published';
}

Productivité et Standardisation

Apprenez à utiliser les leaders du marché pour créer des applications d'entreprise.

Symfony : Le choix de la flexibilité

Utilisé pour les projets complexes, Symfony repose sur des composants réutilisables.

// Exemple de contrôleur Symfony
namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Annotation\Route;

class HelloController {
    #[Route('/hello')]
    public function index(): Response {
        return new Response("Hello Symfony !");
    }
}

Laravel : L'élégance et la rapidité

Laravel simplifie les tâches courantes comme l'authentification, le routage et les sessions.

// Exemple de route Laravel
Route::get('/user', function () {
    return view('user.profile', ['name' => 'WinnyKing']);
});