Comment définir les relations Eloquent?

Question

Accepted Answer

**Les relations Eloquent** modélisent la façon dont les tables de base de données sont liées, définies comme des méthodes sur les modèles. Laravel supporte tous les types de relations courants — one-to-many, many-to-many, one-to-one, et plus — vous donnant un accès élégant et orienté objet aux données associées.

## One-to-many (hasMany / belongsTo)

```php
class User extends Model {
    public function posts() {              // a user HAS MANY posts
        return $this->hasMany(Post::class);
    }
}
class Post extends Model {
    public function author() {              // a post BELONGS TO a user (inverse)
        return $this->belongsTo(User::class);
    }
}

// access related data as properties (lazy-loaded)
$user->posts;          // a Collection of the user's Posts
$post->author;          // the Post's User
$user->posts()->where('published', true)->get();   // query the relationship
```

La relation la plus courante : un parent `hasMany` enfants, et chaque enfant `belongsTo` au parent. Accéder à la relation en tant que propriété retourne le(s) modèle(s) associé(s).

## Many-to-many (belongsToMany)

```php
class Post extends Model {
    public function tags() {                // posts and tags — many-to-many
        return $this->belongsToMany(Tag::class);   // uses a pivot table (post_tag)
    }
}
$post->tags;                    // the post's tags
$post->tags()->attach($tagId);   // add an association
$post->tags()->detach($tagId);   // remove
$post->tags()->sync([1, 2, 3]);  // set exactly these
```

**Many-to-many** utilise une table pivot (gérée automatiquement), avec `attach`/`detach`/`sync` pour gérer les associations.

## Autres types de relations

```php
$this->hasOne(Profile::class);          // one-to-one
$this->hasManyThrough(...);              // has-many through an intermediate model
$this->morphMany(Comment::class, 'commentable');   // POLYMORPHIC (comments on posts OR videos)
```

## Eager loading (éviter N+1!)

```php
// ❌ N+1: a query per post to get each author
$posts = Post::all();
foreach ($posts as $post) { echo $post->author->name; }

// ✅ eager load with with() — fetches authors in ONE extra query
$posts = Post::with('author')->get();
```

Utilisez `with()` pour **eager-loader** les relations et prévenir le problème de requête N+1.

## Pourquoi c'est important

Les relations Eloquent sont essentielles pour travailler avec des données relationnelles dans Laravel — presque chaque application a des entités associées (utilisateurs et messages, messages et étiquettes, commandes et articles), donc comprendre comment définir et utiliser les relations est une connaissance fondamentale quotidienne.

Connaître les types de relations et quand utiliser chacun — **`hasMany`/`belongsTo`** pour one-to-many (le plus courant), **`belongsToMany`** pour many-to-many (avec la table pivot et `attach`/`detach`/`sync`), `hasOne` pour one-to-one, et les relations polymorphes pour des associations flexibles — est nécessaire pour modéliser toute donnée non triviale et est l'une des fonctionnalités les plus puissantes et élégantes d'Eloquent.

Les relations vous donnent un accès intuitif et orienté objet aux données associées (`$user->posts`, `$post->author`) sans écrire manuellement les jointures, ce qui est un avantage majeur de productivité.

Critiquement, comprendre l'**eager loading avec `with()`** pour prévenir le **problème N+1** (où accéder aux relations dans une boucle déclenche une requête par enregistrement — un problème de performance grave) est essentiel, car les relations rendent les problèmes N+1 faciles à introduire.

Maîtriser les relations Eloquent — les définir, accéder aux données associées, et eager-loader pour éviter N+1 — est une connaissance centrale et fréquemment utilisée qui sous-tend la modélisation efficace des données et la performance dans les applications Laravel.