PHP Academy · Lektion

Eloquent-Beziehungen

Definieren Sie hasOne-, hasMany-, belongsTo- und Viele-zu-viele-Beziehungen.

Eloquent-Beziehungen ist eine kostenlose PHP Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des PHP Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Warum Beziehungen?

Mit Eloquent-Beziehungen können Sie verbundene Modelle mit ausdrucksstarkem PHP statt mit rohen SQL-JOINs abfragen.

hasOne

Ein User hat ein Profile. Definieren Sie dies im übergeordneten Model.

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

belongsTo

Ein Profile gehört zu einem User. Definieren Sie dies in dem Model, das den Fremdschlüssel enthält.

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

hasMany

Ein User hat viele Posts. Eine 1:n-Beziehung aus Sicht des übergeordneten Models.

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

belongsTo (viele Seite)

Jeder Post gehört zu einem User.

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

Viele-zu-viele (belongsToMany)

Ein Post hat viele Tags und ein Tag gehört zu vielen Posts – verbunden über eine Pivot-Tabelle.

<?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

Greifen Sie auf indirekt verbundene Modelle zu: Ein Country hat über Users viele Posts.

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

Polymorphe Beziehungen

Ein Comment-Model kann mithilfe polymorpher Beziehungen entweder zu einem Post oder zu einem Video gehören.

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

Abfragen zum Vorhandensein von Beziehungen

Fragen Sie Modelle anhand des Vorhandenseins einer Beziehung ab.

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

whereHas

Filtern Sie anhand von Bedingungen für Beziehungen.

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

Beziehungsmethoden vs. dynamische Eigenschaften

$user->posts() gibt den Query Builder zurück (Sie können ihn verketten). $user->posts gibt die geladene Collection zurück.

Zusammenfassung

Definieren Sie Beziehungen als Methoden, die hasOne, hasMany, belongsTo oder belongsToMany zurückgeben. Greifen Sie über dynamische Eigenschaften darauf zu oder verketten Sie Abfragen mit dem Methodenaufruf.

Schnelltest

Welcher Beziehungstyp verwendet eine Pivot-Tabelle?

Häufig gestellte Fragen

Ist die Lektion „Eloquent-Beziehungen“ kostenlos?

Ja — der vollständige Text von „Eloquent-Beziehungen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des PHP Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der PHP Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Eloquent-Beziehungen“?

Definieren Sie hasOne-, hasMany-, belongsTo- und Viele-zu-viele-Beziehungen. Du übst PHP Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um PHP Academy zu starten?

Keine Vorkenntnisse erforderlich. PHP Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Eloquent-Beziehungen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser PHP Academy-Lektion Code schreiben und ausführen?

Ja. Jede PHP Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu PHP Academy