Laravel
Laravel 11 & 10 • Chapitre 4 : Fonctionnalités Avancées

Relations Eloquent & Optimisation Eager Loading

Les relations Eloquent connectent vos modèles entre eux avec une clarté remarquable. Découvrez comment concevoir des relations 1:N, N:N, et surtout comment éliminer le redouté problème de requêtes N+1 grâce à with().

🌿
One to Many (1:N)

La relation reine : hasMany() dans Category et sa réciproque belongsTo() dans Product.

🔄
Many to Many (N:N)

Table pivot intermédiaire : belongsToMany() avec méthodes fluides attach(), detach() et sync().

🚀
Eager Loading with()

Chargez toutes les entités liées en seulement 2 requêtes SQL au lieu de dizaines de requêtes dans une boucle.

🧩
HasManyThrough & Morph

Accédez aux données distantes via un modèle intermédiaire ou associez des commentaires à plusieurs entités.

Category.php, Product.php & Requête Optimisée
// 1. Modèle Category.php : Une catégorie a plusieurs produits
namespace AppModels;

use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsHasMany;

class Category extends Model
{
    public function products(): HasMany
    {
        return $this->hasMany(Product::class);
    }
}

// 2. Modèle Product.php : Un produit appartient à une catégorie et a plusieurs tags
namespace AppModels;

use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentRelationsBelongsTo;
use IlluminateDatabaseEloquentRelationsBelongsToMany;

class Product extends Model
{
    public function category(): BelongsTo
    {
        return $this->belongsTo(Category::class);
    }

    public function tags(): BelongsToMany
    {
        return $this->belongsToMany(Tag::class)->withTimestamps();
    }
}

// 3. Contrôleur : Éviter le piège N+1 grâce au chargement préalable (Eager Loading)
// ✅ BONNE PRATIQUE : 2 requêtes SQL au total (optimisé)
$products = Product::with(['category', 'tags'])->latest()->get();

// Gestion de la table pivot Many-to-Many :
$product->tags()->sync([1, 4, 7]); // Associe les tags 1, 4, 7 et retire les autres !

Simulateur Comparateur de Performance : Lazy Loading (N+1) vs Eager Loading

Audit Requêtes SQL

Comparez l'impact spectaculaire entre une boucle naïve sans with() (le fameux problème N+1) et l'utilisation de l'Eager Loading dans Laravel.

Nombre d'articles simulés : 5 produits 2 Requêtes SQL • ~1.8 ms
// Requête 1 (pour charger tous les produits) :
SELECT * FROM products;
// Requête 2 (chargement groupé de toutes les catégories en 1 coup) :
SELECT * FROM categories WHERE id IN (1, 2, 3);
// Fini les requêtes dans la boucle ! Eloquent associe les objets en mémoire.
Clavier Mécanique RGB
belongsTo : Category #1
Périphériques
MacBook Air M2
belongsTo : Category #2
Ordinateurs
Souris Ergonomique Sans Fil
belongsTo : Category #1
Périphériques
Écran 4K Gaming 144Hz
belongsTo : Category #3
Écrans
Dell XPS 15
belongsTo : Category #2
Ordinateurs
Synthèse des Relations Eloquent dans Laravel
Méthode EloquentType de CardinalitéExemple TypiqueClé Étrangère par Défaut
hasOne() / belongsTo()Un à Un (1:1)User hasOne Profileuser_id sur profiles
hasMany() / belongsTo()Un à Plusieurs (1:N)Category hasMany Productcategory_id sur products
belongsToMany()Plusieurs à Plusieurs (N:N)Product belongsToMany TagTable pivot product_tag
hasManyThrough()1:N via Modèle TiersCountry hasMany Post through UserClés intermédiaires
morphMany()Polymorphique (1:N)Comment morphTo Post/Videocommentable_id, commentable_type