Laravel Astuces Outils
3 min de lecture 68 vues

Maîtrisez les relations entre modèles Eloquent dans Laravel 11.x

lesage

wanzoou

@lesage

Maîtrisez les relations entre modèles Eloquent dans Laravel 11.x

Introduction

  • Les relations Eloquent : fondamentales pour une gestion efficace des données
  • Nouveautés et améliorations dans Laravel 11.x
  • Objectif : comprendre et implémenter les différents types de relations

@lesage | wanzoou.lovestoblog.com


One-to-One Relation

  • Définition : Un modèle est associé à un seul autre modèle.

  • Exemple : Un utilisateur a un seul profil détaillé.

  • Méthodes Eloquent : hasOne(), belongsTo()

  • Code :

    // Dans le modèle User
    public function profile()
    {
    return $this->hasOne(Profile::class);
    }
     
    // Dans le modèle Profile
    public function user()
    {
    return $this->belongsTo(User::class);
    }
     
    // Utilisation
    $user = User::find(1);
    $profile = $user->profile;

One-to-Many Relation

  • Définition : Un modèle peut avoir plusieurs modèles associés.

  • Exemple : Un auteur peut avoir écrit plusieurs livres.

  • Méthodes Eloquent : hasMany(), belongsTo()

  • Code :

    // Dans le modèle Author
    public function books()
    {
    return $this->hasMany(Book::class);
    }
     
    // Dans le modèle Book
    public function author()
    {
    return $this->belongsTo(Author::class);
    }
     
    // Utilisation
    $author = Author::find(1);
    $books = $author->books;
     
    foreach ($books as $book) {
    echo $book->title;
    }

Many-to-Many Relation

  • Définition : Plusieurs modèles peuvent être associés à plusieurs autres modèles.

  • Exemple : Un étudiant peut s'inscrire à plusieurs cours, et un cours peut avoir plusieurs étudiants.

  • Méthodes Eloquent : belongsToMany()

  • Code :

    // Dans le modèle Student
    public function courses()
    {
    return $this->belongsToMany(Course::class);
    }
     
    // Dans le modèle Course
    public function students()
    {
    return $this->belongsToMany(Student::class);
    }
     
    // Utilisation
    $student = Student::find(1);
    $courses = $student->courses;
     
    // Ajouter un étudiant à un cours
    $course = Course::find(1);
    $course->students()->attach($student->id);

Has-One-Through Relation

  • Définition : Un modèle est relié à un autre via un modèle intermédiaire.

  • Exemple : Un pays a une capitale via une ville.

  • Méthodes Eloquent : hasOneThrough()

  • Code :

    // Dans le modèle Country
    public function capital()
    {
    return $this->hasOneThrough(
    Capital::class,
    City::class,
    'country_id', // Clé étrangère sur City
    'city_id', // Clé étrangère sur Capital
    'id', // Clé locale sur Country
    'id' // Clé locale sur City
    );
    }
     
    // Utilisation
    $country = Country::find(1);
    $capital = $country->capital;

Has-Many-Through Relation

  • Définition : Un modèle est relié à plusieurs autres via un modèle intermédiaire.

  • Exemple : Un médecin a plusieurs patients via des rendez-vous.

  • Méthodes Eloquent : hasManyThrough()

  • Code :

    // Dans le modèle Doctor
    public function patients()
    {
    return $this->hasManyThrough(
    Patient::class,
    Appointment::class,
    'doctor_id', // Clé étrangère sur Appointment
    'id', // Clé étrangère sur Patient
    'id', // Clé locale sur Doctor
    'patient_id' // Clé locale sur Appointment
    );
    }
     
    // Utilisation
    $doctor = Doctor::find(1);
    $patients = $doctor->patients;

Polymorphic Relations

  • Définition : Un modèle peut appartenir à plus d'un type de modèle.

  • Exemple : Un commentaire peut être associé à un post ou à une vidéo.

  • Méthodes Eloquent : morphTo(), morphMany(), morphToMany()

  • Code :

    // Dans le modèle Comment
    public function commentable()
    {
    return $this->morphTo();
    }
     
    // Dans les modèles Post et Video
    public function comments()
    {
    return $this->morphMany(Comment::class, 'commentable');
    }
     
    // Utilisation
    $post = Post::find(1);
    $comments = $post->comments;
     
    $video = Video::find(1);
    $videoComments = $video->comments;

Eager Loading

  • Définition : Chargement anticipé des relations pour éviter le problème N+1.

  • Exemple : Charger tous les posts avec leurs auteurs.

  • Méthodes Eloquent : with(), load()

  • Code :

    // Eager loading lors de la requête
    $posts = Post::with('author')->get();
     
    foreach ($posts as $post) {
    echo $post->author->name;
    }
     
    // Lazy eager loading
    $books = Book::all();
    $books->load('author');

Conclusion et Bonnes Pratiques

  • Utilisez les relations Eloquent pour une meilleure organisation du code
  • Optimisez les performances avec l'eager loading
  • Exploitez les contraintes de clés étrangères dans vos migrations
  • Utilisez les événements de modèle pour maintenir l'intégrité des relations
  • Consultez régulièrement la documentation Laravel pour les mises à jour!
lesage

wanzoou

@lesage

🚀 Développeur Web passionné par l’innovation et les défis technologiques | Expertise en PHP (Laravel), JavaEE, JavaScript | Enthousiaste du Machine Learning

Vous aimez cet article ? Faite le savoir en partageant