Laravel-FAQ

Fragen und Antworten rund um Laravel.

Wer ist Taylor Otwell?

Taylor Otwell ist ein Softwareentwickler, der sich auf Webentwicklung spezialisiert hat und als Erfinder und Hauptentwickler des Laravel-Frameworks bekannt ist. Er hat eine Reihe von Büchern über PHP-Frameworks veröffentlicht.

Warum hat Taylor Otwell Laravel erfunden?

Taylor Otwell entwickelte Laravel, um ein modernes, schnelles und dynamisches Framework für Web-Entwickler zu schaffen, mit dem sie leicht zu warten und zu erweiternde Anwendungen erstellen können. Um dies zu erreichen, hat er eine Reihe von Funktionen integriert, darunter ein leistungsstarkes ORM (Object Relational Mapper), eine vollständige Routing-Lösung, ein verständliches Templating-System (Blade), ein einfaches Queue System, eine vollständige Authentication-Lösung und viele andere. Die einfache Handhabung und die große Leistungsfähigkeit von Laravel machen es zu einem sehr beliebten Tool für Entwickler.

Welche Vorteile bietet Laravel?

Laravel bietet Web-Entwicklern eine Reihe von Vorteilen. Sein flexibles Authorization-System, einfaches ORM-System und benutzerfreundliche Blade-Vorlagenengine erleichtern die Entwicklung. Es verfügt auch über eine integrierte Dependency Injection, die die Wartung von Anwendungen vereinfacht, sowie eine integrierte Abfragesprache, die Entwicklern hilft, Datenbanken effizienter zu überprüfen. Zusätzlich bietet Laravel eine Reihe von Funktionen, die die Implementierung von Funktionen wie Formularvalidierung, Routing und Sessions ermöglichen.

Wie lange dauert es, bis man Laravel versteht?

Es kommt auf die Erfahrung im Bereich der Webentwicklung an. In ein paar Tagen kann man aber schon ein grundlegendes Verständnis für Laravel erlangen. Einige Entwickler behaupten, dass sie nach ein paar Wochen, in denen sie sich mit Routing, Blade-Templates und Eloquent-ORM beschäftigt haben, Erfahrungen mit Laravel gesammelt haben.

Was ist Eloquent?

Eloquent ist ein leistungsstarker Abfrage- und Mappungsbuilder für Laravel, der Entwicklern das Arbeiten mit relationalen Datenbanken erheblich erleichtert. Es ermöglicht die Definition von Modellen, die in einer relationalen Datenbank gespeichert werden, sodass sie leicht abgerufen und verarbeitet werden können. Eloquent bietet eine Reihe von Funktionen, darunter eine Query-Builder-API, ein Eager-Loading-System, eine leistungsstarke ORM und ein Modell-Caching-System..

Laravel Beispiel-Code-Snippets für Eloquent:

// Abrufen aller Modelle
$models = Model::all();

// Abrufen eines bestimmten Modells
$model = Model::find($id);

// Abrufen mehrerer Modelle anhand bestimmter Eigenschaften
$models = Model::where('property', 'value')->get();

Was ist Eager-Loading?

Eager-Loading ist eine Technik, die es Entwicklern ermöglicht, die Datenbankzugriffe eines Anwendungsprozesses zu optimieren. Anstatt mehrere Abfragen an die Datenbank zu stellen, um eine Liste von Daten abzurufen, können Entwickler mit Eager-Loading alle benötigten Daten mit nur einem Abruf abrufen. Dadurch wird der Prozesszeit und der Datenbankzugriff effizienter. Ein Laravel Code-Snippet zur Verwendung von Eager-Loading:

// Lade alle Modelle mit ihren Beziehungen 

$models = App\Model::with('relationOne', 'relationTwo')->get();

Was ist eine Relation?

Eine Relation ist eine Verbindung zwischen zwei oder mehr Tabellen in einer Datenbank. Diese Beziehung legt fest, wie die Daten in den verschiedenen Tabellen miteinander verbunden sind. Mit Eloquent, dem ORM (Object-Relational Mapping) von Laravel, können Entwickler Modelle erstellen, die diese Relationen verwalten. Dadurch kann man einfach auf Daten aus verschiedenen Tabellen zugreifen und diese bei Bedarf ebenso einfach ändern.

Welche Relationen gibt es?

In Laravel gibt es 3 Arten von Beziehungen: eins-zu-eins, eins-zu-viele und viele-zu-viele. Eins-zu-eins-Beziehungen stellen eine Verbindung zwischen zwei Modellen her, wobei jedes Modell eine einzelne Kopie des anderen hat. Eins-zu-viele-Beziehungen ermöglichen es einem Modell, mehrere Kopien des anderen zu besitzen. Viele-zu-viele-Beziehungen erlauben es beiden Modellen, mehrere Kopien des jeweils anderen zu haben.

1:1 Relation Beispiel

Eine 1:1-Beziehung wird in Laravel verwendet, wenn ein Objekt in einer Datenbank einem anderen Objekt zugeordnet ist. Jedes Objekt hat nur ein anderes, verknüpftes Objekt. In Laravel kannst du eine 1:1-Beziehung mit Hilfe der folgenden Schritte erstellen:

// Model
class User extends Model
{
    public function profile()
    {
        return $this->hasOne('App\Profile');
    }
}

// Profile Model
class Profile extends Model
{
    public function user()
    {
        return $this->belongsTo('App\User');
    }
}

// Blade Template
@foreach ($users as $user)
    <h2>{{ $user->name }}</h2>
    <p>{{ $user->profile->description }}</p>
@endforeach

1:n Relation Beispiel

Um eine 1:n-Beziehung zu definieren, kann man folgenden Code verwenden:

// Model

Model1::hasMany('Model2');
Model2::belongsTo('Model1');

// Route:

Route::get('Model1/{id}/Model2', 'Model2Controller@index');

// Controller

public function index($id)
{
    $model1 = Model1::findOrFail($id);

    return view('Model2.index', compact('model1'));
}

// Blade

@foreach($model1->model2 as $model2)
    <p>{{ $model2->name }}</p>
@endforeach

m:n Relation Beispiel

Um eine m:n-Beziehung zwischen Models in Laravel zu definieren, müssen wir ein „Pivot“ Model und eine Migration erstellen.

// Model

class User extends Model
{
    public function roles() 
    {
        return $this->belongsToMany('App\Role', 'user_roles');
    }
}

class Role extends Model
{
    public function users()
    {
        return $this->belongsToMany('App\User', 'user_roles');
    }
}

// Migration

Schema::create('user_roles', function (Blueprint $table) {
    $table->integer('user_id')->unsigned();
    $table->integer('role_id')->unsigned();

    $table->foreign('user_id')->references('id')->on('users')
        ->onUpdate('cascade')->onDelete('cascade');
    $table->foreign('role_id')->references('id')->on('roles')
        ->onUpdate('cascade')->onDelete('cascade');
});

// Blade

@foreach ($users as $user)
    <p>{{ $user->name }} hat folgende Rollen:</p>
    @foreach ($user->roles as $role)
        <p>{{ $role->name }}</p>
    @endforeach
@endforeach

Eloquent-Tipps

// Verwende Pluck, um einzelne Werte aus einem Satz zu extrahieren:
$names = User::where('active', 1)->pluck('name');

// Verwende Select, um die angeforderten Spalten zu wählen:
$users = User::select('name', 'age')->get();

// Verwende WhereBetween, um Werte zwischen einem Bereich zu filtern:
$users = User::whereBetween('age', [20, 30])->get();

// Verwende die Methode "scope" des Models, um eine Abfrage mit dem Namen "scopeName" zu erstellen:

public function scopeName($query)
{
    return $query->where('name', 'like', '%name%');
}

// Verwende die Methode "with" des Models, um eine Abfrage mit dem Namen "withName" zu erstellen:

public function withName()
{
    return $this->with('name');
}

Was ist Artisan?

Artisan ist ein Befehlszeilenprogramm, das für die Verwendung mit dem PHP-Framework Laravel entwickelt wurde. Es erlaubt es dir, eine Vielzahl von Aufgaben auszuführen, wie z.B. das Erstellen von Migrationen und Controllern, das Installieren von Paketen und das Generieren von Code-Schnipseln.

Was ist ein Model in Laravel?

Das Model in Laravel ist ein Objekt, das als Verbindung zwischen der Datenbank und dem Rest der Anwendung fungiert. Es ist ein Teil des Eloquent ORM (Object Relational Mapping) -Frameworks, das in Laravel verwendet wird. Mit Models können Sie Datenbank-Operationen wie Abfragen, Einfügen, Aktualisieren und Löschen ausführen.

<?php
namespace App;
 
use Illuminate\Database\Eloquent\Model;
 
class YourModel extends Model
{
    // Define your model's fillable attributes
    protected $fillable = [
        'attribute1',
        'attribute2',
        // ...
    ];
}

// Um Datenbankeinträge abzufragen:

$records = YourModel::where('attribute1', 'value1')->get();

// Um Einträge zu erstellen:

YourModel::create([
    'attribute1' => 'value1',
    'attribute2' => 'value2',
    // ...
]);

// Um Einträge zu aktualisieren:

YourModel::where('id', $id)->update([
    'attribute1' => 'value1',
    'attribute2' => 'value2',
    // ...
]);

// Um Einträge zu löschen:

YourModel::where('id', $id)->delete(); 

// Blade-Code-Snippets:
// Um Datenbankeinträge anzuzeigen:

@foreach($records as $record)
    <p>{{ $record->attribute1 }}</p>
    <p>{{ $record->attribute2 }}</p>
    // ...
@endforeach

Object Relational Mapping?

Object Relational Mapping (ORM) ist eine Programmiermethode, die es Entwicklern ermöglicht, Daten aus einer relationalen Datenbank als Objekte in einer objektorientierten Programmiersprache abzurufen, zu bearbeiten und als objektorientierte Strukturen zu betrachten. Dadurch wird der Prozess, Daten zwischen einer relationalen Datenbank und einer objektorientierten Programmiersprache wie PHP zu übertragen, erheblich vereinfacht, was das Debugging und die Verwaltung von Datenbank-Abfragen ebenfalls erleichtert.