Sechs Dinge, die du wissen musst, um Laravel Eloquent zu beherrschen

Laravel ist ein quelloffenes und einfach zu bedienendes PHP-Framework. Eine seiner leistungsstärksten Funktionen ist Eloquent, ein objektrelationaler Mapper (ORM), der die Bearbeitung von Datenbankeinträgen vereinfacht.

Eloquent beschleunigt das Erstellen, Lesen, Aktualisieren und Löschen von Datensätzen in einer Datenbank aus einer Anwendung heraus. Mit Eloquent erstellst du Modelle, die Datenbanktabellen widerspiegeln, und verwendest diese Modelle zur Erstellung deiner Abfragen.

Dieser Artikel befasst sich mit sechs Elementen der wichtigsten Funktionen von Eloquent: Abfragebereiche, Beziehungen, Mutatoren und Accessoren, Sammlungen, Modelllöschung und Factories. Anhand von praktischen Beispielen wird erläutert, was die einzelnen Funktionen bewirken. Wir hoffen, dass du diese Beispiele nutzen kannst, um Laravel Eloquent noch besser zu beherrschen.

1. Eloquent Abfragebereiche

Wenn du eine Anwendung erstellst, kommst du manchmal in Situationen, in denen du Bedingungen mehr als einmal verwendest. Wenn du den Code jedes Mal neu schreibst, kann das die Fehlerwahrscheinlichkeit erhöhen und deinen Code unordentlich machen. Laravel löst dieses Problem, indem es solche Bedingungen in wiederverwendbare Anweisungen, sogenannte Scopes, verpackt.

Abfragebereiche sind Methoden, um einem Modell Datenbanklogik hinzuzufügen und Abfragelogik wiederzuverwenden.

Im Folgenden findest du ein Beispiel für einen Abfragebereich. Angenommen, du möchtest eine Softwareentwicklungsplattform für dein Team erstellen, die abgeschlossene und laufende Funktionen verfolgt. Mit dieser Bedingung kannst du nur die laufenden Features abfragen:

$onGoing = Project::where('ongoing', 1)->get();

Möglicherweise brauchst du diese Bedingung auch auf anderen Anwendungsseiten, z. B. auf der Statistikseite. Mit Abfragebereichen kann eine Seite die obige Bedingung wiederverwenden, was deine Abfrage vereinfacht und deinen Code sauberer macht.

Hier siehst du, wie du einen Abfragebereich für dieses Szenario verwenden kannst:

class Features extends Model
{
    public function scopeOngoing($query)
    {
        return $query->where('ongoing', 0);
    }
}

Verwende dann den folgenden Code, um den Bereich auszuführen:

$onGoing = Feature::ongoing()->get();

Es gibt zwei Arten von Geltungsbereichen: globale und lokale.

Globale Bereiche

Globale Bereiche ermöglichen das Hinzufügen von Bedingungen zu allen Abfragen innerhalb eines Modells. Du kannst z. B. eine Bedingung hinzufügen, um Features nach dem Namen des Teamleiters in allen Abfragen innerhalb deines Modells zu filtern.

Lokale Geltungsbereiche

Lokale Bereiche ermöglichen die Definition gemeinsamer Beschränkungen für die Wiederverwendbarkeit. Du möchtest zum Beispiel, dass die Anwendung die Merkmale zurückgibt, die Bugs haben. Dein Code könnte einen lokalen Bereich wie diesen implementieren:

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class User extends Model
{
    public function scopeBugged($query)
    {
        return $query->where('bugged', '>', 1);
    }
}

Der obige Code gibt alle Merkmale zurück, die nicht behobene Fehler haben.

2. Eloquent-Beziehungen

Beziehungen in Eloquent ermöglichen es dir, verschiedene Tabellen einfach miteinander zu verknüpfen. Zum Beispiel kann ein Produkt auf einer E-Commerce-Website mit Bestand, Preis, Ansichten und Bewertungen aufgeführt sein. Mit Eloquent kannst du diese Beziehungen einfach verwalten, auch wenn sich die Datensätze in verschiedenen Tabellen befinden.

Du kannst Beziehungen als Methoden für Modellklassen definieren, genau wie bei einem Eloquent-Modell. Häufig verwendete Eloquent-Beziehungen sind eins-zu-eins, invers und polymorph.

Eins-zu-eins

Hier ist ein Beispiel für eine einfache Eins-zu-Eins-Beziehung, die ein Produktmodell mit einem Inventar verknüpft.

public function Inventory()
{
    return $this->hasOne('AppInventory');
}

Im obigen Code ruft die Methode Inventory() die Methode hasOne() für das Produktmodell auf. Diese prüft, ob das Produkt derzeit verfügbar ist.

Umgekehrt

Mit Eloquent kannst du auch eine umgekehrte Beziehung erstellen. Zum Beispiel, wenn du Produkte auf der Grundlage der Anzahl ihrer Ansichten abrufen möchtest. Inverse Beziehungen können dir die Produkte liefern, die bei den Besuchern einer Website das größte Interesse wecken. Du kannst die Methode belongsTo() verwenden, die die Umkehrung von hasOne() ist. Der folgende Code veranschaulicht dies.

public function product()
{
    return $this->belongsTo('AppProduct');
}

Im obigen Code gleicht Eloquent die product_id mit der Anzahl der übergebenen Views ab. Mit Hilfe von product_id können dann weitere Parameter, wie z. B. Preis und Bestand, abgefragt werden.

Polymorphe

In der Anwendungsentwicklung sind die Beziehungen nicht immer einfach. Manchmal gibt es ein Modell, das zu mehr als einem Modelltyp gehört. So können z. B. Produkt- und Bestandsmodell beide polymorphe Beziehungen zu einem Bildmodell haben.

Polymorphe Beziehungen würden es dir ermöglichen, dieselbe Liste von Bildern sowohl für das Inventar als auch für die Produkte zu verwenden. Nachfolgend findest du einen Codeschnipsel, der eine polymorphe Beziehung implementiert.

class Image extends Model
{
    /**
     * Getting the shared image.
     */
    public function myimage()
    {
        return $this->morphTo();
    }
}

class Product extends Model
{
    /**
     * Get the image to use on the product's page.
     */
    public function image()
    {
        return $this->morphOne(Image::class, 'myimage');
    }
}

class Inventory extends Model
{
    /**
     * Get the image to use on the inventory page.
     */
    public function image()
    {
        return $this->morphOne(Image::class, 'myimage');
    }
}

Der obige Code verwendet die Methode morphTo(), um das übergeordnete Modell des polymorphen Modells abzurufen.

Das ist nur die Spitze des Eisbergs zu diesem Thema. Mehr dazu erfährst du in unserem Leitfaden für Fortgeschrittene zu Laravel Eloquent-Beziehungen.

3. Eloquent Mutatoren und Accessoren

Mutatoren und Accessoren ermöglichen es dir, Daten zu verändern, während du sie speicherst und abrufst. Mutatoren ändern Daten, bevor sie gespeichert werden, während Accessoren Daten beim Abrufen ändern.

Wenn du in deiner Datenbank Namen in Kleinbuchstaben speichern willst, kannst du einen Mutator erstellen, der diese Änderung vornimmt. Wenn du den Vor- und Nachnamen des Nutzers auf deinen Anwendungs-Seiten als einen Namen anzeigen möchtest, kannst du einen Accessor erstellen, um dies zu erreichen.

Im Folgenden findest du ein Beispiel für einen Mutator, der Namen vor dem Speichern groß schreibt.

class User extends Model
{
    /**
     * Mutators capitalizing first and last name.
     */
    public function setFirstNameAttribute($value)
    {
        $this->attributes['first_name'] = ucfirst($value);
    }

    public function setLastNameAttribute($value)
    {
        $this->attributes['last_name'] = ucfirst($value);
    }
}

Nachfolgend ein Beispiel für einen Accessor, der den Vor- und Nachnamen des Nutzers kombiniert.

class User extends Model
{
    /**
     * Accessor combining both names.
     */
    public function getFullNameAttribute()
    {
        return ucfirst($this->first_name) . ' ' . ucfirst($this->last_name);
    }
}

4. Eloquent-Sammlungen

Eloquent Collections behandeln Methoden, die mehrere Modellergebnisse zurückgeben. Diese Klasse findest du unter IlluminateDatabaseEloquentCollection.

Wie bei Arrays ist es auch bei Collections möglich, durch sie zu iterieren. Nachfolgend siehst du eine einfache Iteration.

use AppModelsProduct;

$products = Product::where('availability', 1)->get();

foreach ($products as $product) {
   echo $product->name;
}

Sammlungen sind mächtiger als Arrays, weil du mit ihnen komplexere Operationen durchführen kannst. Du kannst dir zum Beispiel die Liste aller verfügbaren Produkte anzeigen lassen und alle auslassen, die nicht „aktiv“ sind

$names = Product::all()->reject(function ($product) {
   return $product->active === false;
})->map(function ($product) {
   return $product->name;
});

Im Folgenden findest du einige der Methoden, die die Klasse Collections bietet.

Enthält

Die Methode contains() prüft, ob der Code einen bestimmten Modus enthält, wie im folgenden Code gezeigt:

$products->contains(1);
$products->contains(Product::find(1));

Alle

Die Methode all() gibt die in der Sammlung enthaltenen Modelle zurück (siehe unten):

$collection = Product::all();

Viele andere Methoden werden von der Klasse Collections unterstützt.

5. Eloquent-Modelle löschen

In Eloquent erstellst du Modelle, die dir bei der Erstellung von Abfragen helfen. Manchmal musst du jedoch Modelle löschen, um eine Anwendung effizienter zu machen. Dazu rufst du delete für die Instanz des Modells auf.

use AppModelsStock;

$stock = Stock::find(1);
$stock->delete();

Mit dem obigen Code wird das Modell Stock aus einer Anwendung entfernt. Dies ist eine dauerhafte Entfernung, die nicht rückgängig gemacht werden kann.

Sanftes Löschen

Eine weitere Funktion von Eloquent ist das sanfte Löschen von Modellen. Wenn du ein Modell sanft löschst, entfernst du es nicht aus der Datenbank.

Du kennzeichnest es mit deleted_at, um die Zeit und das Datum des Löschvorgangs anzugeben. Dies ist wichtig, wenn du einen Teil der Datenbankeinträge ausschließen möchtest, z. B. unvollständige Einträge, ohne sie dauerhaft zu löschen. Es hilft dabei, die Abfrageergebnisse von Eloquent zu bereinigen, ohne zusätzliche Bedingungen hinzuzufügen.

Du aktivierst Soft Delete, indem du die Eigenschaft softDeletes zu einem Modell hinzufügst und eine Spalte deleted_at in der zugehörigen Datenbanktabelle einfügst.

Hinzufügen von Soft Delete zu einem Modell

Du aktivierst Soft Deletes im Modell, indem du die Eigenschaft IlluminateDatabaseEloquentSoftDeletes hinzufügst, wie unten gezeigt.

namespace AppModels;
use IlluminateDatabaseEloquentModel;
use IlluminateDatabaseEloquentSoftDeletes;

class Flight extends Model
{
   use SoftDeletes;
}

So fügst du eine delete_at-Spalte hinzu

Bevor du Soft Delete verwenden kannst, sollte deine Datenbank eine delete_at Spalte haben. Du fügst diese Spalte mit einer Hilfsmethode des Laravel Schema builders hinzu, wie unten gezeigt:

use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;

Schema::table('users', function (Blueprint $table) {
   $table->softDeletes();
});

Schema::table('users', function (Blueprint $table) {
   $table->dropSoftDeletes();
});

Dies fügt eine delete_at Spalte hinzu, die mit dem Datum und der Uhrzeit aktualisiert wird, wenn eine Soft Delete Aktion erfolgreich war.

Wie man sanft gelöschte Modelle einbezieht

Wenn du möchtest, dass die Abfrageergebnisse auch weich gelöschte Modelle enthalten, fügst du der Abfrage die Methode withTrashed() hinzu. Ein Beispiel ist unten abgebildet:

$stocks = Stock::withTrashed()->where('stock_id', 20)->get();

Die obige Abfrage enthält auch Modelle mit dem Attribut deleted_at.

Wie du nur sanft gelöschte Modelle abfragst

Eloquent ermöglicht es dir auch, nur weich gelöschte Modelle abzufragen. Dazu rufst du z. B. die Methode onlyTrashed() auf:

$Stock = Stock::onlyTrashed()->where('stock_id', 1)->get();

Wie man gelöschte Modelle wiederherstellt

Du kannst auch sanft gelöschte Modelle wiederherstellen, indem du die Methode restore() aufrufst.

$stocks = Stock::withTrashed()->where('stock_id', 20)->restore();

Diese ändert das Feld delete_at eines soft gelöschten Modells in null. Wenn das Modell nicht soft-gelöscht wurde, bleibt das Feld unverändert.

6. Eloquent Factories

Modellfabriken in Laravel erstellen Dummy-Daten, die du verwenden kannst, um deine Anwendung zu testen oder um deine Datenbank zu füllen. Um dies zu implementieren, erstellst du ein Modell in einer Factory-Klasse, wie im folgenden Beispiel gezeigt. Das Codeschnipsel erstellt eine Modellfabrik, die gefälschte Lieferanten eines Produkts und seiner Preise erzeugen kann.

namespace DatabaseFactories;
use IlluminateDatabaseEloquentFactoriesFactory;
use IlluminateSupportStr;

class StockFactory extends Factory
{
    public function definition()
    {
        return [
            'supplier_name' => fake()->name(),
            'price' => fake()->numberBetween($min = 1500, $max = 6000),
        ];
    }
}

Die Methode definition() im obigen Beispiel gibt eine Reihe von Attributwerten zurück, die Laravel beim Aufbau des Modells verwendet. Der Fake-Helper hilft der Factory, auf die PHP-Bibliothek Faker zuzugreifen.

Zusammenfassung

Eloquent macht die Entwicklung von Anwendungen in Laravel einfacher. Dank Implementierungen wie Beziehungen ist es bei der Erstellung einfacher und komplexer Abfragen gleichermaßen effektiv. Die einfache Erzeugung von funktionalen Dummy-Daten mit Hilfe von Factories macht es perfekt für Entwickler, die robuste Tests für ihre Anwendungen erstellen wollen. Außerdem helfen Eloquent Scopes dabei, komplexe Abfragen so zu vereinfachen, dass der Code aufgeräumt bleibt.

In diesem Artikel wurden nur sechs der wichtigsten Funktionen von Eloquent vorgestellt, aber Eloquent hat noch weitere leistungsstarke Funktionen. Die Verwendung von gemeinsam nutzbaren und wiederverwendbaren Modellen hat Eloquent zu einem beliebten Feature unter Entwicklern gemacht, und die Einfachheit der Eloquent-Abfragen macht Laravel zu einem entwicklerfreundlichen Framework – auch für Anfänger.

Egal, wie viel Erfahrung du hast, Kinstas Web Anwendungs-Hosting-Plattform unterstützt Entwickler wie dich. Unser Laravel-Schnellstart-Template zeigt, wie einfach es ist, deine Anwendung auf unseren Servern im Premium-Tier-Netzwerk von Google Cloud zum Laufen zu bringen.

Steve Bonisteel Kinsta

Steve Bonisteel is a Technical Editor at Kinsta who began his writing career as a print journalist, chasing ambulances and fire trucks. He has been covering Internet-related technology since the late 1990s.