Im Leben eines jeden Entwicklers gibt es oft einen Punkt, an dem du mit einer Datenbank interagieren musst. An dieser Stelle macht Eloquent, der objektrelationale Mapper (ORM) von Laravel, die Interaktion mit deinen Datenbanktabellen intuitiv und natürlich.

Es ist wichtig, dass du als Profi die sechs wichtigsten Beziehungstypen kennst und verstehst, die wir hier besprechen werden.

Was sind Beziehungen in Eloquent?

Wenn du mit Tabellen in einer relationalen Datenbank arbeitest, können wir Beziehungen als Verbindungen zwischen Tabellen bezeichnen. Sie helfen dir, Daten mühelos zu organisieren und zu strukturieren und sorgen für eine bessere Lesbarkeit und Handhabung der Daten. In der Praxis gibt es drei Arten von Datenbankbeziehungen:

  • one-to-one – Ein Datensatz in einer Tabelle ist mit einem, und nur einem, in einer anderen Tabelle verbunden. Zum Beispiel eine Person und eine Sozialversicherungsnummer.
  • one-to-many – Ein Datensatz ist mit mehreren Datensätzen in einer anderen Tabelle verknüpft. Zum Beispiel ein Autor und seine Blogs.
  • many-to-many – Mehrere Datensätze in einer Tabelle werden mit mehreren Datensätzen in einer anderen Tabelle verknüpft. Zum Beispiel Schüler und die Kurse, für die sie eingeschrieben sind.

Laravel macht die Interaktion und Verwaltung von Datenbankbeziehungen mithilfe der objektorientierten Syntax in Eloquent ganz einfach.

Zusätzlich zu diesen Definitionen führt Laravel weitere Beziehungen ein, nämlich:

  • Has Many Through
  • Polymorphe Beziehungen
  • Many-to-many Polymorphic

Nehmen wir zum Beispiel einen Laden, dessen Inventar eine Vielzahl von Artikeln enthält, jeder in seiner eigenen Kategorie. Deshalb ist es aus betriebswirtschaftlicher Sicht sinnvoll, die Datenbank in mehrere Tabellen aufzuteilen. Das bringt aber auch Probleme mit sich, denn du willst nicht jede einzelne Tabelle abfragen.

Wir können in Laravel ganz einfach eine simple One-to-many-Beziehung erstellen, die uns dabei hilft. Wenn wir z. B. die Produkte abfragen wollen, können wir das mit dem Produktmodell tun.

Datenbankschema mit drei Tabellen und einer gemeinsamen Tabelle, die eine polymorphe Beziehung darstellt
Datenbankschema mit drei Tabellen und einer gemeinsamen Tabelle, die eine polymorphe Beziehung darstellt

One-to-one-Beziehung

Als erste grundlegende Beziehung, die Laravel anbietet, verbindet sie zwei Tabellen so, dass eine Zeile der ersten Tabelle mit nur einer Zeile der anderen Tabelle korreliert.

Um dies in Aktion zu sehen, müssen wir zwei Modelle mit ihrer eigenen Migration erstellen:

php artisan make:model Tenant 
Php artisan make:model Rent

An dieser Stelle haben wir zwei Modelle, das eine ist der Mieter und das andere seine Miete.

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Tenant extends Model
{
    /**
    * Get the rent of a Tenant
    */
    public function rent() 
    {
        return $this->hasOne(Rent::class);
    }
}

Da eloquent die Fremdschlüsselbeziehung anhand des Namens des übergeordneten Modells (in diesem Fall Tenant) bestimmt, geht das Modell Rent davon aus, dass es einen Fremdschlüssel tenant_id gibt.

Wir können ihn einfach überschreiben, indem wir ein zusätzliches Argument für die hasOne-Methode angeben:

return $this- >hasOne(Rent::class, "custom_key");

Eloquent geht auch davon aus, dass es eine Übereinstimmung zwischen dem definierten Fremdschlüssel und dem Primärschlüssel des Elternmodells (Tenant) gibt. Standardmäßig wird die tenant_id mit dem id-Schlüssel des Tenant-Datensatzes abgeglichen. Wir können dies mit einem dritten Argument in der hasOne-Methode überschreiben, so dass es mit einem anderen Schlüssel übereinstimmt:

return $this->hasOne(Rent::class, "custom_key", "other_key");

Jetzt, da wir die One-to-one-Beziehung zwischen den Modellen definiert haben, können wir sie ganz einfach wie folgt verwenden:

$rent = Tenant::find(10)->rent;

Mit dieser Codezeile erhalten wir die Miete des Mieters mit der ID 10, falls sie existiert.

One-to-many-Beziehung

Wie bei der vorherigen Beziehung werden auch hier Beziehungen zwischen einem Elternmodell und mehreren Child-Modellen definiert. Es ist unwahrscheinlich, dass unser Mieter nur eine Mietzahlung hat, da es sich um eine wiederkehrende Zahlung handelt, also wird er mehrere Zahlungen haben.

In diesem Fall hat unsere vorherige Beziehung einen Fehler, den wir beheben können:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Tenant extends Model
{
    /**
    * Get the rents of a Tenant
    */
    public function rent() 
    {
        return $this->hasMany(Rent::class);
    }
}

Bevor wir die Methode zum Abrufen der Mieten aufrufen, sollten wir wissen, dass Beziehungen als Abfragebausteine dienen. Wir können also weitere Einschränkungen hinzufügen (z. B. Miete zwischen zwei Terminen, Mindestzahlung usw.) und sie verketten, um unser gewünschtes Ergebnis zu erhalten:

$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();

Und wie bei der vorherigen Beziehung können wir die Fremd- und Lokalschlüssel überschreiben, indem wir zusätzliche Argumente übergeben:

return $this->hasMany(Rent::class, "foreign_key");
return $this->hasMany(Rent::class, "foreign_key", "local_key");

Jetzt haben wir alle Mieten eines Mieters, aber was machen wir, wenn wir die Miete kennen und herausfinden wollen, zu wem sie gehört? Dazu können wir die Eigenschaft belongsTo verwenden:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Rent extends Model
{
    /**
    * Return the tenant for the rent
    */
    public function tenant() 
    {
        return $this->belongsTo(Tenant::class);
    }
}

Jetzt können wir den Mieter ganz einfach ermitteln:

$tenant = Rent::find(1)->tenant;

Bei der belongsTo-Methode können wir auch die Fremd- und Lokalschlüssel überschreiben, wie wir es zuvor getan haben.

Has-One-Of-Many-Beziehung

Da unser Tenant-Modell mit vielen Rent-Modellen verknüpft sein kann, wollen wir ganz einfach das neueste oder älteste Modell der Beziehungen abrufen.

Eine bequeme Möglichkeit, dies zu tun, ist die Kombination der Methoden hasOne und ofMany:

public function latestRent() {
    return $this->hasOne(Rent::class)->latestOfMany();
}

public function oldestRent() {
    return $this->hasOne(Rent::class)->oldestOfMany();
}

Standardmäßig erhalten wir die Daten auf der Grundlage des Primärschlüssels, der sortierbar ist, aber wir können unsere eigenen Filter für die ofMany-Methode erstellen:

return $this->hasOne(Rent::class)->ofMany('price', 'min');

HasOneThrough- und HasManyThrough-Beziehungen

Die -Through-Methoden legen nahe, dass unsere Modelle durch ein anderes Modell gehen müssen, um eine Beziehung zum gewünschten Modell herzustellen. Wir können zum Beispiel die Miete mit dem Vermieter verknüpfen, aber die Miete muss erst den Mieter durchlaufen, um den Vermieter zu erreichen.

Die Schlüssel der dafür notwendigen Tabellen würden wie folgt aussehen:

rent
    id - integer
    name - string
    value - double

tenants
    id - integer
    name - string
    rent_id - integer

landlord
    id - integer
    name - string
    tenant_id - integer

Nachdem wir uns vorgestellt haben, wie unsere Tabellen aussehen, können wir die Modelle erstellen:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Rent extends Model
{
    /**
    * Return the rents' landlord
    */
    public function rentLandlord() 
    {
        return $this->hasOneThrough(Landlord::class, Tenant::class);
    }
}

Das erste Argument der hasOneThrough-Methode ist das Modell, auf das du zugreifen willst, und das zweite Argument ist das Modell, durch das du gehen willst.

Und genau wie zuvor kannst du die fremden und lokalen Schlüssel überschreiben. Da wir nun zwei Modelle haben, müssen wir in dieser Reihenfolge jeweils zwei davon überschreiben:

public function rentLandlord() 
{
    return $this->hasOneThrough(
        Landlord::class,
        Tenant::class,
        "rent_id",    // Foreign key on the tenant table
        "tenant_id",  // Foreign key on the landlord table
        "id",         // Local key on the tenant class
        "id"          // Local key on the tenant table
    );
}

Die „Has Many Through“-Beziehung in Laravel Eloquent ist nützlich, wenn du auf Datensätze in einer entfernten Tabelle über eine Zwischentabelle zugreifen willst. Betrachten wir ein Beispiel mit drei Tabellen:

  • land
  • benutzer
  • spiele

Jedes Land hat viele Benutzer, und jeder Benutzer hat viele Spiele. Wir wollen alle Spiele, die zu einem Land gehören, über die Benutzertabelle abrufen.

Du würdest die Tabellen wie folgt definieren:

country
    id - integer
    name - string

user
    id - integer
    country_id - integer
    name - string

games
    id - integer
    user_id - integer
    title - string

Jetzt solltest du das Eloquent-Modell für jede einzelne Tabelle definieren:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Country extends Model
{
    protected $fillable = ['name'];

    public function users()
    {
        return $this->hasMany(User::class);
    }

    public function games()
    {
        return $this->hasManyThrough(Games::class, User::class);
    }
}
<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class User extends Model
{
    protected $fillable = [article_id, 'name'];

    public function country()
    {
        return $this->belongsTo(Country::class);
    }

    public function posts()
    {
        return $this->hasMany(Post::class);
    }
}
<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Game extends Model
{
    protected $fillable = ['user_id', 'title'];

    public function user()
    {
        return $this->belongsTo(User::class);
    }
}

Jetzt können wir die Methode spiele() des Ländermodells aufrufen, um alle Spiele zu erhalten, weil wir die Beziehung „Has many through“ zwischen Land und Spiel über das Benutzermodell hergestellt haben.

<?php

$country = Country::find(159);
            
// Retrieve all games for the country
$games = $country->games;

Many-To-Many-Beziehung

Die Many-To-Many-Beziehung ist komplizierter. Ein gutes Beispiel ist ein Mitarbeiter, der mehrere Rollen hat. Eine Rolle kann auch mehreren Mitarbeitern zugewiesen werden. Das ist die Grundlage der Many-to-Many-Beziehung.

Dafür brauchen wir die Tabellen employees, roles und role_employees .

Unsere Datenbanktabellenstruktur wird wie folgt aussehen:

employees
    id - integer
    name - string

roles 
    id - integer
    name - string

role_employees
    user_id - integer
    role_id - integer

Wenn wir die Struktur der Beziehungstabellen kennen, können wir unser Mitarbeitermodell ganz einfach als „belongToMany“ -Rollenmodell definieren.

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Employee extends Model
{
    public function roles() 
    {
        return $this- >belongsToMany(Role::class);
    }
}

Sobald wir dies definiert haben, können wir auf alle Rollen eines Mitarbeiters zugreifen und sie sogar filtern:

$employee = Employee::find(1);
$employee->roles->forEach(function($role) { // });

// OR 

$employee = Employee::find(1)->roles()->orderBy('name')->where('name', 'admin')->get();

Wie bei allen anderen Methoden können wir auch bei der belongsToMany-Methode die fremden und lokalen Schlüssel überschreiben.

Um die umgekehrte Beziehung der belongsToMany-Methode zu definieren, verwenden wir einfach dieselbe Methode, jetzt aber für die Child-Methode, mit dem Parent als Argument.

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Role extends Model
{
    public function employees() 
    {
        return $this->belongsToMany(Employee::class);
    }
}

Verwendungen der Zwischentabelle

Wie wir vielleicht schon bemerkt haben, wird bei der Verwendung der Many-to-Many-Beziehung immer eine Zwischentabelle verwendet. In diesem Fall verwenden wir die Tabelle role_employees.

Unsere Pivot-Tabelle enthält standardmäßig nur die Attribute id. Wenn wir andere Attribute wünschen, müssen wir sie wie folgt angeben:

return $this->belongsToMany(Employee::class)->withPivot("active", "created_at");

Wenn wir den Pivot für die Zeitstempel abkürzen wollen, können wir das tun:

return $this->belongsToMany(Employee::class)->withTimestamps();

Ein Trick ist, dass wir den Namen „Pivot“ so anpassen können, dass er besser zu unserer Anwendung passt:

return $this->belongsToMany(Employee::class)->as('subscription')->withPivot("active", "created_by");

Das Filtern der Ergebnisse einer eloquenten Abfrage ist ein Muss für jeden Entwickler, der seine Laravel-Anwendungen optimieren möchte.

Deshalb bietet Laravel mit den Pivots eine fantastische Funktion, mit der wir die Daten filtern können, die wir sammeln wollen. Anstatt also andere Funktionen wie Datenbanktransaktionen zu verwenden, um unsere Daten in Stücken zu erhalten, können wir sie mit nützlichen Methoden wie wherePivot, wherePivotIn, wherePivotNotIn, wherePivotBetween, wherePivotNotBetween, wherePivotNull, wherePivotNotNull filtern und sie bei der Definition von Beziehungen zwischen Tabellen verwenden!

return $this->belongsToMany(Employee::class)->wherePivot('promoted', 1);
return $this->belongsToMany(Employee::class)->wherePivotIn('level', [1, 2]);
return $this->belongsToMany(Employee::class)->wherePivotNotIn('level', [2, 3]);
return $this->belongsToMany(Employee::class)->wherePivotBetween('posted_at', ['2023-01-01 00:00:00', '2023-01-02 00:00:00']);
return $this->belongsToMany(Employee::class)->wherePivotNull('expired_at');
return $this->belongsToMany(Employee::class)->wherePivotNotNull('posted_at');

Eine letzte erstaunliche Funktion ist, dass wir nach Pivots sortieren können:

return $this->belongsToMany(Employee::class)
        ->where('promoted', true)
        ->orderByPivot('hired_at', 'desc');

Polymorphe Beziehungen

Das Wort Polymorph kommt aus dem Griechischen und bedeutet „viele Formen“ Das bedeutet, dass ein Modell in unserer Anwendung viele Formen annehmen kann, d.h. es kann mehr als eine Assoziation haben. Stell dir vor, wir bauen eine Anwendung mit Blogs, Videos, Umfragen usw. Ein Nutzer kann für jedes dieser Elemente einen Kommentar erstellen. Daher könnte ein Kommentar-Modell zu den Modellen Blogs, Videos und Umfragen gehören.

Polymorphes One-to-one

Diese Art von Beziehung ähnelt einer normalen One-to-one-Beziehung. Der einzige Unterschied besteht darin, dass das Child-Modell mit einer einzigen Assoziation zu mehr als einer Art von Modell gehören kann.

Zum Beispiel kann ein Mieter- und Vermieter-Modell eine polymorphe Beziehung zu einem WaterBill-Modell haben.

Die Tabellenstruktur kann folgendermaßen aussehen:

tenants
    id – integer
    name – string

landlords
    id – integer
    name – string

waterbills
    id – integer
    amount – double
    waterbillable_id
    waterbillable_type

Wir verwenden waterbillable_id für die ID des Vermieters oder Mieters , während die Spalte waterbillable_type den Klassennamen des übergeordneten Modells enthält. Die Spalte type wird von eloquent verwendet, um herauszufinden, welches übergeordnete Modell zurückgegeben werden soll.

Die Modelldefinition für eine solche Beziehung sieht wie folgt aus:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class WaterBill extends Model
{
    public function billable()
    {
        return $this->morphTo();
    }
}

class Tenant extends Model
{
    public function waterBill()    
    {
        return $this->morphOne(WaterBill::class, 'billable');
    }
}

class Landlord extends Model
{
    public function waterBill()    
    {
        return $this->morphOne(WaterBill::class, 'billable');
    }
}

Wenn wir das alles eingerichtet haben, können wir auf die Daten sowohl des Vermieter- als auch des Mieter-Modells zugreifen:

<?php

$tenant = Tenant::find(1)->waterBill;
$landlord = Landlord::find(1)->waterBill;

Polymorphes One-to-many

Der einzige Unterschied besteht darin, dass das untergeordnete Modell über eine einzige Assoziation zu mehr als einer Art von Modell gehören kann.

In einer Anwendung wie Facebook können die Nutzer/innen Beiträge, Videos, Umfragen, Live-Übertragungen usw. kommentieren. Mit einer polymorphen One-to-Many-Assoziation können wir eine einzige Kommentartabelle verwenden, um die Kommentare für alle Kategorien zu speichern, die wir haben. Unsere Tabellenstruktur würde etwa so aussehen:

posts 
    id – integer
    title – string
    body – text

videos
    id – integer
    title – string
    url – string

polls
    id – integer
    title – string

comments 
    id – integer
    body – text
    commentable_id – integer
    commentable_type – string

Die commentable_id ist die ID des Datensatzes und die commentable_type ist der Klassentyp, damit eloquent weiß, wonach es suchen muss. Die Struktur des Modells ist dem polymorphen One-to-Many-Modell sehr ähnlich:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Comment extends Model 
{
    public function commentable()
    {
        return $this->morphTo();
    }
}

class Poll extends Model
{
    public function comments()
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

class Live extends Model
{
    public function comments()
    {
        return $this->morphMany(Comments::class, 'commentable');
    }
}

Um die Kommentare eines Lives abzurufen, können wir einfach die Find-Methode mit der ID aufrufen und haben nun Zugriff auf die iterable Klasse comments:

<?php

use AppModelsLive;

$live = Live::find(1);

foreach ($live->comments as $comment) { }

// OR

Live::find(1)->comments()->each(function($comment) { // });
Live::find(1)->comments()->map(function($comment) { // });
Live::find(1)->comments()->filter(function($comment) { // });

// etc.

Und wenn wir den Kommentar haben und herausfinden wollen, zu wem er gehört, rufen wir die commentable-Methode auf:

<?php

use AppModelsComment;

$comment = Comment::find(10);
$commentable = $comment->commentable;

// commentable – type of Post, Video, Poll, Live

Polymorphes One-to-many

In vielen skalierbaren Anwendungen wollen wir eine einfache Möglichkeit haben, mit Modellen und zwischen ihnen zu interagieren. Wenn wir z. B. den ersten oder letzten Beitrag eines Nutzers wissen wollen, können wir dies mit einer Kombination aus den Methoden morphOne und ofMany erreichen:

<?php

public function latestPost()
{
    return $this->morphOne(Post::class, 'postable')->latestOfMany();
}

public function oldestPost()
{
    return $this->morphOne(Post::class, 'postable')->oldestOfMany();
}

Die Methoden latestOfMany und oldestOfMany ermitteln das neueste bzw. älteste Modell auf der Grundlage des Primärschlüssels des Modells, der die Voraussetzung dafür ist, dass es sortierbar ist.

In manchen Fällen wollen wir nicht nach der ID sortieren, z. B. wenn wir das Veröffentlichungsdatum einiger Beiträge geändert haben und sie in dieser Reihenfolge abrufen wollen, nicht nach ihrer ID.

Dazu können wir der ofMany-Methode 2 Parameter übergeben. Der erste Parameter ist der Schlüssel, nach dem wir filtern wollen, und der zweite ist die Sortiermethode:

<?php

public function latestPublishedPost()
{
    return $this->morphOne(Post::class, "postable")->ofMany("published_at", "max");
}

Mit diesem Wissen ist es möglich, fortschrittlichere Beziehungen zu konstruieren! Stell dir vor, wir haben folgendes Szenario. Wir sollen eine Liste mit allen aktuellen Beiträgen in der Reihenfolge erstellen, in der sie veröffentlicht worden sind. Das Problem entsteht, wenn wir 2 Beiträge mit demselben published_at-Wert haben und wenn die Beiträge in der Zukunft veröffentlicht werden sollen.

Hierfür können wir der ofMany-Methode die Reihenfolge übergeben, in der die Filter angewendet werden sollen. Auf diese Weise ordnen wir nach published_at und, wenn sie gleich sind, nach id. Zweitens können wir eine Abfragefunktion auf die ofMany-Methode anwenden, um alle Beiträge auszuschließen, die für die Veröffentlichung vorgesehen sind!

<?php

public function currentPosts()
{
    return $this->hasOne(Post::class)->ofMany([
        'published_at' => 'max',
        'id' => 'max',
    ], function ($query) {
        $query->where('published_at', '<', now());
    });
}

Polymorphes Many-to-Many

Die polymorphe Many-to-Many-Methode ist etwas komplexer als die normale Methode. Eine häufige Situation ist, dass Tags für mehrere Assets in deiner Anwendung gelten. Bei TikTok haben wir zum Beispiel Tags, die auf Videos, Shorts, Stories usw. angewendet werden können.

Die polymorphe Many-to-Many-Variante ermöglicht es uns, eine einzige Tabelle mit Tags zu haben, die den Videos, Shorts und Stories zugeordnet sind.

Die Struktur der Tabelle ist einfach:

videos
    id – integer
    description – string

stories 
    id – integer
    description – string

taggables 
    tag_id – integer
    taggable_id – integer
    taggable_type – string

Wenn die Tabellen fertig sind, können wir das Modell erstellen und die Methode morphToMany verwenden. Diese Methode akzeptiert den Namen der Modellklasse und den „Beziehungsnamen“:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Video extends Model
{
    public function tags()
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

Damit können wir ganz einfach die umgekehrte Beziehung definieren. Wir wissen, dass wir für jedes untergeordnete Modell die Methode morphedByMany aufrufen wollen:

<?php

namespace AppModels;
use IlluminateDatabaseEloquentModel;

class Tag extends Model
{
    public function stories()
    {
        return $this->morphedByMany(Story::class, 'taggable');
    }

    public function videos()
    {
        return $this->morphedByMany(Video::class, 'taggable');
    } 
}

Wenn wir nun einen Tag erhalten, können wir alle Videos und Geschichten abrufen, die mit diesem Tag zusammenhängen!

<?php
use AppModelTag;

$tag = Tag::find(10);
$posts = $tag->stories;
$videos = $tag->stories;

Optimiere Eloquent für Geschwindigkeit

Wenn du mit dem Eloquent ORM von Laravel arbeitest, ist es wichtig zu wissen, wie du Datenbankabfragen optimierst und den Zeit- und Speicherbedarf für das Abrufen von Daten minimierst. Eine Möglichkeit, dies zu tun, ist die Implementierung von Caching in deiner Anwendung.

Laravel bietet ein flexibles Caching-System, das verschiedene Backends unterstützt, z. B. Redis, Memcached und dateibasiertes Caching. Indem du die Ergebnisse von Eloquent-Abfragen zwischenspeicherst, kannst du die Anzahl der Datenbankabfragen reduzieren und deine Anwendung schneller und wertvoller machen.

Außerdem kannst du den Query Builder von Laravel nutzen, um zusätzliche komplexe Abfragen zu erstellen und so die Leistung deiner Anwendung weiter zu optimieren.

Zusammenfassung

Zusammenfassend lässt sich sagen, dass Eloquent-Beziehungen eine leistungsstarke Funktion von Laravel sind, die es Entwicklern ermöglicht, einfach mit zusammenhängenden Daten zu arbeiten. Von One-to-one- bis zu Many-to-many-Beziehungen bietet Eloquent eine einfache und intuitive Syntax, um diese Beziehungen zu definieren und abzufragen.

Wenn du als Laravel-Entwickler/in die Eloquent-Beziehungen beherrschst, kann das deinen Entwicklungsworkflow erheblich verbessern und deinen Code effizienter und lesbarer machen. Wenn du mehr über Laravel erfahren möchtest, findest du bei Kinsta verschiedene Ressourcen, darunter ein Tutorial über die ersten Schritte mit Laravel und einen Artikel über die Gehälter von Laravel-Entwicklern.

Kinsta bietet Managed-Hosting-Lösungen an, mit denen die Bereitstellung und Verwaltung von Laravel-Anwendungen ein Kinderspiel ist.

Coman Cosmin

Cosmin Coman is a technology writer and developer with over 3 years of experience. Apart from writing for Kinsta, he has assisted in research at nuclear physics facilities and universities. Tech-savvy and integrated into the community, he always comes up with innovative solutions.