Laravel eloquent Beziehungen liefert fünf Haupttypen: 1. Eins-zu-Eins-Verwendungszwecke Hader und Zuh?ren; 2. Ein-zu-Many verwendet Hasmany und hingohrsto; 3.. Viele zu viele Verwendungszwecke h?rerstoman und erzeugen Zwischentische; 4. Indirect Association verwendet HasmanyThrough; 5. Die polymorphe Assoziation verwendet Morphto und Morphmany. Jede Beziehung wird durch Definieren von Methoden im Modell erreicht. Eloquent verarbeitet automatisch die zugrunde liegenden Abfragen und macht den Datenzugriff intuitiver und effizienter.

Laravel eloquent Beziehungen: Ein praktischer Leitfaden

Laravels eloquentes ORM macht die Arbeit mit Datenbankbeziehungen in PHP sowohl intuitiv als auch leistungsstark. Wenn Sie eine Laravel -App erstellen und Modelle anschlie?en müssen - wie Benutzer zu Posts, Bestellungen für Produkte oder Kategorien zu Artikeln - sind eloquente Beziehungen der richtige Weg. Dieser Leitfaden unterteilt die h?ufigsten Beziehungstypen mit klaren Beispielen, die Sie sofort verwenden k?nnen.

1. Eins-zu-Eins-Beziehung

Verwenden Sie dies, wenn ein Datensatz in einer Tabelle mit genau einem Datensatz in einer anderen Tabelle verknüpft ist.

Beispiel: Ein User hat ein Profile .

Datenbank -Setup

 // Benutzer Tabelle
Schema :: Create ('Benutzer', Funktion (Blueprint $ Tabelle) {
    $ table-> id ();
    $ table-> string ('name');
    $ table-> String ('E-Mail');
    $ table-> timestemps ();
});

// Profiltabelle
Schema :: Create ('Profile', Funktion (Blueprint $ Tabelle) {
    $ table-> id ();
    $ table-> fremdId ('user_id')-> konstant ()-> ondelete ('cascade');
    $ table-> String ('Telefon')-> nullable ();
    $ table-> text ('bio')-> nullable ();
    $ table-> timestemps ();
});

Modelldefinition

 // user.php
?ffentliches Funktionsprofil ()
{
    $ this-> hasone zurückgeben (Profil :: Klasse);
}

// profil.php
Public Function User ()
{
    $ this->
}

Verwendung

 $ user = user :: find (1);
echo $ user-> profil-> bio;

// Profil für den Benutzer erstellen
$ user-> profil ()-> create ([
    'Telefon' => '123-456-7890',
    'bio' => 'Laravel Developer' '
]);

Hinweis: hasOne erwartet den Fremdschlüssel für das zugeh?rige Modell ( profiles.user_id ).

2. Eins-zu-Viele-Beziehung

Wird verwendet, wenn ein einzelner Datensatz mehrere zugeh?rige Datens?tze haben kann.

Beispiel: Ein User hat viele Posts .

Datenbank -Setup

 // Beitr?ge Tabelle
Schema :: Create ('Beitr?ge', Funktion (Blueprint $ Tabelle) {
    $ table-> id ();
    $ table-> fremdId ('user_id')-> conneNed ();
    $ table-> string ('title');
    $ table-> text ('K?rper');
    $ table-> timestemps ();
});

Modelldefinition

 // user.php
?ffentliche Funktion Posts ()
{
    $ this-> hasmany zurückgeben (Post :: class);
}

// post.php
Public Function User ()
{
    $ this->
}

Verwendung

 $ user = user :: find (1);
foreach ($ user-> posts als $ post) {
    echo $ post-> title;
}

// einen Beitrag erstellen
$ user-> posts ()-> create ([
    'title' => 'mein erster Beitrag',
    'K?rper' => 'Hallo Welt' '
]);

3. Viele zu viele Beziehung

Wird verwendet, wenn beide Seiten mehrere Datens?tze von der anderen Seite haben k?nnen. Ben?tigt einen Drehstab.

Beispiel: User geh?rt zu vielen Roles , und eine Role kann vielen Users geh?ren.

Datenbank -Setup

 // Rollentabelle
Schema :: Create ('Rollen', Funktion (Blueprint $ Tabelle) {
    $ table-> id ();
    $ table-> string ('name');
    $ table-> timestemps ();
});

// rollen_user pivot table (oder verwenden rollen_user)
Schema :: create ('rollen_user', function (Blueprint $ Tabelle) {
    $ table-> fremdId ('user_id')-> konstant ()-> ondelete ('cascade');
    $ table-> fremdId ('rol_id')-> conneted ()-> ontdelete ('Cascade');
    $ table-> prim?r (['user_id', 'rol_id']);
});

Modelldefinition

 // user.php
?ffentliche Funktionsrollen ()
{
    return $ this->
}

// rollen.php
Benutzer ?ffentliche Funktionen ()
{
    $ this-> hingaceStomany zurückgeben (Benutzer :: Klasse);
}

Verwendung

 $ user = user :: find (1);
foreach ($ user-> rollen als $ rollen) {
    echo $ rollen-> name;
}

// eine Rolle beibringen
$ user-> roles ()-> atat ($ rollen);

// Rollen synchronisieren (alle ersetzen)
$ user-> roles ()-> sync ([1, 2, 3]);

// mit Pivot -Daten (z. B. Zeitstempel oder zus?tzliche Felder)
$ user-> roles ()-> attach ($ rollenId, ['erstellt_at' => now ()]);

TIPP: Laravel f?rbt den Pivot -Tabellennamen automatisch aus den einzigartigen Modellen in alphabetischer Reihenfolge ( role_user ). Sie k?nnen es überschreiben, indem Sie ein zweites Argument übergeben:
belongsToMany(Role::class, 'user_roles')

4. hat viele durch

Verwenden Sie, wenn Sie über ein Zwischenmodell auf entfernte Beziehungen zugreifen m?chten.

Beispiel: Ein Country hat viele Posts über seine Users .

Modell -Setup

 // Country.php
?ffentliche Funktion Posts ()
{
    $ this-> hasManyThrough zurückgeben (Beitrag :: class, user :: class);
}

Angenommen:

• countries → users (Country_id) → posts (user_id)

Verwendung

 $ Country = Country :: Find (1);
foreach ($ Country-> Beitr?ge als $ post) {
    echo $ post-> title;
}

5. Polymorphe Beziehungen

Verwenden Sie, wenn ein Modell zu mehr als einem anderen Modell auf einer einzigen Assoziation geh?ren kann.

Beispiel: Sowohl Post als auch User k?nnen Image haben.

Datenbank -Setup

 // Bildertabelle
Schema :: Create ('Bilder', Funktion (Blueprint $ Tabelle) {
    $ table-> id ();
    $ table-> string ('url');
    $ table-> morphs ('imagelable'); // erstellt imagelable_type und bildable_id
    $ table-> timestemps ();
});

Modelldefinition

 // image.php
?ffentliche Funktionen imagelbar ()
{
    return $ this-> morphto ();
}

// post.php
?ffentliche Funktions Bilder ()
{
    return $ this-> morpmany (Image :: class, 'imagelable');
}

// user.php
?ffentliche Funktions Bilder ()
{
    return $ this-> morpmany (Image :: class, 'imagelable');
}

Verwendung

 $ post = post :: find (1);
$ image = $ post-> images ()-> create (['url' => 'foto.jpg']);

// Holen Sie sich den Besitzer des Bildes
$ image = Bild :: Find (1);
$ besitzer = $ image-> imagelbar; // Gibt die Post- oder Benutzerinstanz zurück

Bonus: Definieren von benutzerdefinierten ausl?ndischen Schlüssel

Manchmal folgen Ihre Spaltennamen Laravels Konvention nicht.

 // benutzerdefinierte Fremdschlüssel
return $ this->

// Benutzerdefinierte Prim?rschlüssel zum verwandten Modell
$ this->

Zusammenfassung der Beziehungsmethoden

Beredliche Beziehungen machen Ihren Laravel -Code sauberer und ausdrucksst?rker. Beginnen Sie mit den Grundlagen - hasOne , hasMany und belongsTo - und erweitern Sie dann belongsToMany wenn Ihre App w?chst.

Definieren Sie im Grunde die Beziehung einmal in Ihrem Modell, und eloquent verarbeitet die Verbindungen und Abfragen für Sie.

Das obige ist der detaillierte Inhalt vonLaravel eloquent Beziehungen Tutorial. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!