PHP Academy · Leçon

Relations Eloquent

Définir des relations hasOne, hasMany, belongsTo et plusieurs-à-plusieurs.

Relations Eloquent est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.

Pourquoi utiliser des relations ?

Les relations Eloquent vous permettent d’interroger des modèles associés avec du PHP expressif plutôt qu’avec des jointures SQL brutes.

hasOne

Un User possède un Profile. Définissez cette relation dans le modèle propriétaire.

<?php
class User extends Model {
    public function profile(): \Illuminate\Database\Eloquent\Relations\HasOne {
        return $this->hasOne(Profile::class);
    }
}
// Access:
$profile = $user->profile;

belongsTo

Un Profile appartient à un User. Définissez cette relation dans le modèle qui contient la clé étrangère.

<?php
class Profile extends Model {
    public function user(): \Illuminate\Database\Eloquent\Relations\BelongsTo {
        return $this->belongsTo(User::class);
    }
}
// Access:
$user = $profile->user;

hasMany

Un User possède plusieurs Posts. Relation un-à-plusieurs du côté parent.

<?php
class User extends Model {
    public function posts(): \Illuminate\Database\Eloquent\Relations\HasMany {
        return $this->hasMany(Post::class);
    }
}
// Access:
$posts = $user->posts; // Collection

belongsTo (côté plusieurs)

Chaque Post appartient à un User.

<?php
class Post extends Model {
    public function author(): \Illuminate\Database\Eloquent\Relations\BelongsTo {
        return $this->belongsTo(User::class, "user_id");
    }
}

Plusieurs-à-plusieurs (belongsToMany)

Un Post possède plusieurs Tags, et un Tag appartient à plusieurs Posts — ils sont liés par une table pivot.

<?php
class Post extends Model {
    public function tags() {
        return $this->belongsToMany(Tag::class);
    }
}
// Pivot table: post_tag (post_id, tag_id)
$tags = $post->tags;
$post->tags()->attach($tagId);
$post->tags()->detach($tagId);
$post->tags()->sync([1, 2, 3]);

hasManyThrough

Accédez à des modèles liés indirectement : un Country possède plusieurs Posts par l’intermédiaire de Users.

<?php
class Country extends Model {
    public function posts() {
        return $this->hasManyThrough(Post::class, User::class);
    }
}

Relations polymorphes

Un modèle Comment peut appartenir à un Post ou à un Video grâce aux relations polymorphes.

<?php
class Comment extends Model {
    public function commentable() {
        return $this->morphTo();
    }
}
class Post extends Model {
    public function comments() {
        return $this->morphMany(Comment::class, "commentable");
    }
}

Requêtes sur l’existence d’une relation

Interrogez les modèles en fonction de l’existence d’une relation.

<?php
// Posts that have at least one comment:
$commented = Post::has("comments")->get();
// Posts with >= 3 comments:
$popular = Post::has("comments", ">=", 3)->get();

whereHas

Filtrez selon des conditions appliquées à une relation.

<?php
$phpPosts = Post::whereHas("tags", function ($q) {
    $q->where("name", "PHP");
})->get();

Méthodes de relation contre propriétés dynamiques

$user->posts() renvoie le générateur de requêtes, que vous pouvez enchaîner. $user->posts renvoie la collection chargée.

Résumé

Définissez les relations sous forme de méthodes renvoyant hasOne, hasMany, belongsTo ou belongsToMany. Accédez-y comme à des propriétés dynamiques ou enchaînez des requêtes à partir de l’appel de méthode.

Vérification rapide

Quel type de relation utilise une table pivot ?

Questions Fréquemment Posées

La leçon « Relations Eloquent » est-elle gratuite ?

Oui — le texte complet de « Relations Eloquent » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Relations Eloquent » ?

Définir des relations hasOne, hasMany, belongsTo et plusieurs-à-plusieurs. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer PHP Academy ?

Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Relations Eloquent » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?

Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Modèles Eloquent et migrations
CRUD avec Eloquent
Relations Eloquent
Chargement anticipé et portées de requête

← Retour à PHP Academy