Laravel ist ein beliebtes PHP-Framework für die Entwicklung moderner und dynamischer Webanwendungen in der heutigen schnelllebigen und sich ständig weiterentwickelnden Webentwicklungslandschaft. Eine seiner Kernfunktionen ist Laravel Eloquent, ein objektrelationaler Mapper (ORM), der es Entwicklern ermöglicht, effizient CRUD-Operationen (Create, Read, Update und Delete) in einer Datenbank durchzuführen.
Dieses Tutorial zeigt dir, wie du diese Operationen in deiner Laravel-Anwendung mit dem Eloquent ORM von Laravel durchführst und wie du deine Laravel CRUD-Anwendung mit MyKinsta bereitstellst.
CRUD-Funktionalität in Laravel
CRUD-Operationen sind das Rückgrat einer jeden datenbankgestützten Anwendung. Sie ermöglichen es dir, die grundlegendsten und wichtigsten Datenbankoperationen auszuführen, z. B. neue Datensätze zu erstellen, bestehende Datensätze zu lesen, sie zu aktualisieren und zu löschen. Diese Operationen sind entscheidend für die Funktionalität jeder Laravel-Anwendung, die mit einer Datenbank interagiert.
Eloquent bietet eine einfache und intuitive Möglichkeit, mit der Datenbank zu interagieren, indem es die Komplexität der Datenbankverwaltung reduziert, damit du dich auf die Entwicklung deiner Anwendung konzentrieren kannst. Die eingebauten Methoden und Klassen ermöglichen dir ein einfaches CRUD von Datensätzen in der Datenbank.
Voraussetzungen
Um diesem Tutorial folgen zu können, musst du folgende Voraussetzungen erfüllen:
- XAMPP
- Composer
- Ein MyKinsta-Konto
- Ein Konto bei GitHub, GitLab oder Bitbucket, um deinen Code zu veröffentlichen
- Bootstrap Version 5
Schritte
- Installiere Laravel und erstelle eine neue Anwendung
- Erstelle eine Datenbank
- Erstelle eine Tabelle
- Erstelle einen Controller
- Richte das Modell ein
- Füge eine Route hinzu
- Blade-Dateien generieren
- Einsetzen und Testen deiner CRUD-Anwendung
Der vollständige Code des Tutorials hilft dir bei der Umsetzung.
Laravel installieren und eine neue Anwendung erstellen
Öffne dein Terminal, in dem du deine Laravel-Anwendung erstellen möchtest, und befolge die folgenden Schritte.
- Um Laravel zu installieren, führe aus:
composer global require laravel/installer- Um eine neue Laravel-Anwendung zu erstellen, führe aus:
laravel new crudpostsDatenbank erstellen
Um eine neue Datenbank für deine Anwendung zu erstellen:
- Starte den Apache- und den MySQL-Server im XAMPP-Kontrollpanel und besuche
http://localhost/phpmyadminin deinem Browser.
- Klicke in der linken Seitenleiste auf Neu. Du solltest das Folgende sehen:
- Füge einen Datenbanknamen hinzu und klicke auf Erstellen.
- Bearbeite die .env-Datei deiner Anwendung im Stammverzeichnis deiner Laravel-Anwendung. Sie enthält alle Umgebungsvariablen, die von der Anwendung verwendet werden. Finde die Variablen mit dem Präfix
DB_und bearbeite sie mit deinen Datenbankzugangsdaten:
DB_CONNECTION=
DB_HOST=
DB_PORT=
DB_DATABASE=
DB_USERNAME=
DB_PASSWORD=Eine Tabelle erstellen
Die Datenzeilen in deiner Anwendung werden in Tabellen gespeichert. Für diese Anwendung brauchst du nur eine Tabelle, die du mit Laravel-Migrationen erstellst.
- Um eine Tabelle zu erstellen und eine Migrationsdatei mit Laravels Kommandozeilenschnittstelle Artisan zu erzeugen, führe aus:
php artisan make:migration create_posts_tableDer obige Befehl erstellt eine neue Datei,
yyyy_mm_dd_hhmmss_create_posts_table.php, in database/migrations.
- Öffne die Datei yyyy_mm_dd_hhmmss_create_posts_table.php und definiere in der Funktion up die Spalten, die du in deiner Datenbanktabelle haben möchtest:
public function up()
{
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('body');
$table->timestamps();
});
}Dieser Code legt fest, was die Tabelle posts enthält. Sie hat vier Spalten: id, title, body, und timestamps.
- Führe die Migrationsdateien im Ordner database/migrations aus, um Tabellen in der Datenbank zu erstellen:
php artisan migrateDie Ausgabe sieht wie folgt aus:
- Gehe zu der Datenbank, die du zuvor erstellt hast, um zu bestätigen, dass du die Tabellen erstellt hast:
Erstelle einen Controller
Der Controller enthält alle Funktionen zum CRUD von Beiträgen aus der Datenbank.
Erstelle eine Controller-Datei innerhalb deiner Laravel-Anwendung mit Artisan:
php artisan make:controller PostController --apiWenn du diesen Befehl ausführst, wird eine Datei PostController.php in app/Http/Controllers erstellt, mit Boilerplate-Code und leeren Funktionsdeklarationen index, store, show, update und destroy.
Funktionen erstellen
Als nächstes erstellst du die Funktionen, die die Daten speichern, indizieren, aktualisieren, zerstören, erstellen, anzeigen und bearbeiten.
Du kannst sie in der Datei app/Http/Controller/PostController.php einfügen (siehe unten).
Die Funktion store
Die Funktion store fügt einen Beitrag in die Datenbank ein.
Scrolle zur Funktion store und füge den folgenden Code innerhalb der leeren geschweiften Klammern ein:
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
Post::create($request->all());
return redirect()->route('posts.index')
->with('success','Post created successfully.');Dieser Code nimmt ein Objekt, das den Titel und den Text des Beitrags enthält, prüft die Daten, fügt einen neuen Beitrag zur Datenbank hinzu, wenn die Daten gültig sind, und leitet den Benutzer mit einer Erfolgsmeldung zur Homepage weiter.
Die Funktion index
Die Funktion index holt alle Beiträge aus der Datenbank und sendet die Daten an den posts.index seite.
Die update Funktion
Die <update Funktion enthält die id des zu aktualisierenden Beitrags, den neuen Beitrag title und die body. Nach der Validierung der Daten findet sie den Beitrag mit der gleichen id. Wenn er gefunden wird, aktualisiert die Funktion update den Beitrag in der Datenbank mit den neuen title und body. Dann leitet sie den Nutzer mit einer Erfolgsmeldung zur Startseite weiter.
Die destroy Funktion
Die Funktion destroy findet einen Beitrag mit dem angegebenen id, löscht ihn aus der Datenbank und leitet den Benutzer mit einer Erfolgsmeldung auf die Startseite weiter.
Die oben genannten Funktionen sind die Funktionen, die zum CRUD von Beiträgen aus der Datenbank verwendet werden. Du musst jedoch weitere Funktionen innerhalb des Controllers definieren, um die benötigten Seiten in resources/views/posts/ zu rendern.
Die Funktion create
Die Funktion create rendert die resources/views/posts/create.blade.php seite, die das Formular zum Hinzufügen von Beiträgen zur Datenbank enthält.
Die show Funktion
Die Funktion show findet einen Beitrag mit dem angegebenen id in der Datenbank und zeigt die Seite resources/views/posts/show.blade.php datei mit dem Beitrag.
Die edit Funktion
Die Funktion edit findet einen Beitrag mit der angegebenen id in der Datenbank und rendert die Datei resources/views/posts/edit.blade.php datei mit den Beitragsdetails in einem Formular.
Das Modell einrichten
Das Modell Post interagiert mit der Tabelle posts in der Datenbank.
- Um ein Modell mit Artisan zu erstellen, führe aus:
php artisan make:model PostDieser Code erstellt eine Datei Post.php im Ordner App/Models.
- Erstelle ein Array
<fillable. Füge den folgenden Code innerhalb der KlassePostund unterhalb der Zeileuse HasFactory;ein
protected $fillable = [
'title',
'body',
];Dieser Code erstellt ein fillable Array, mit dem du von deiner Laravel-Anwendung aus Elemente zur Datenbank hinzufügen kannst.
- Verbinde das Modell
Postmit der Datei PostController.php. Öffne die Datei PostController.php und füge die folgende Zeile unteruse IlluminateHttpRequest;ein. Sie sieht wie folgt aus:
use IlluminateHttpRequest;
use AppModelsPost;Die Datei PostController.php sollte jetzt wie folgt aussehen:
<?php
namespace AppHttpControllers;
use IlluminateHttpRequest;
use AppModelsPost;
class PostController extends Controller
{
/**
* Display a listing of the resource.
*
* @return IlluminateHttpResponse
*/
public function index()
{
$posts = Post::all();
return view('posts.index', compact('posts'));
}
/**
* Store a newly created resource in storage.
*
* @param IlluminateHttpRequest $request
* @return IlluminateHttpResponse
*/
public function store(Request $request)
{
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
Post::create($request->all());
return redirect()->route('posts.index')
->with('success', 'Post created successfully.');
}
/**
* Update the specified resource in storage.
*
* @param IlluminateHttpRequest $request
* @param int $id
* @return IlluminateHttpResponse
*/
public function update(Request $request, $id)
{
$request->validate([
'title' => 'required|max:255',
'body' => 'required',
]);
$post = Post::find($id);
$post->update($request->all());
return redirect()->route('posts.index')
->with('success', 'Post updated successfully.');
}
/**
* Remove the specified resource from storage.
*
* @param int $id
* @return IlluminateHttpResponse
*/
public function destroy($id)
{
$post = Post::find($id);
$post->delete();
return redirect()->route('posts.index')
->with('success', 'Post deleted successfully');
}
// routes functions
/**
* Show the form for creating a new post.
*
* @return IlluminateHttpResponse
*/
public function create()
{
return view('posts.create');
}
/**
* Display the specified resource.
*
* @param int $id
* @return IlluminateHttpResponse
*/
public function show($id)
{
$post = Post::find($id);
return view('posts.show', compact('post'));
}
/**
* Show the form for editing the specified post.
*
* @param int $id
* @return IlluminateHttpResponse
*/
public function edit($id)
{
$post = Post::find($id);
return view('posts.edit', compact('post'));
}
}Routes hinzufügen
Nachdem du die Controller-Funktionen und das Post Modell erstellt hast, musst du Routen für deine Controller-Funktionen hinzufügen.
- Öffne routes/web.php und lösche die Boilerplate-Route, die die Anwendung erstellt hat. Ersetze sie durch den folgenden Code, um die Controller-Funktionen mit ihren jeweiligen Routen zu verbinden:
// returns the home page with all posts
Route::get('/', PostController::class .'@index')->name('posts.index');
// returns the form for adding a post
Route::get('/posts/create', PostController::class . '@create')->name('posts.create');
// adds a post to the database
Route::post('/posts', PostController::class .'@store')->name('posts.store');
// returns a page that shows a full post
Route::get('/posts/{post}', PostController::class .'@show')->name('posts.show');
// returns the form for editing a post
Route::get('/posts/{post}/edit', PostController::class .'@edit')->name('posts.edit');
// updates a post
Route::put('/posts/{post}', PostController::class .'@update')->name('posts.update');
// deletes a post
Route::delete('/posts/{post}', PostController::class .'@destroy')->name('posts.destroy');- Um die Routen zu verbinden, öffne app/Http/Controllers/PostController.php und füge die folgende Zeile unter der Zeile
use IlluminateSupportFacadesRoute;ein:
use IlluminateSupportFacadesRoute;
use AppHttpControllersPostController;Die Datei routes/web.php sollte jetzt wie folgt aussehen:
<?php
use IlluminateSupportFacadesRoute;
use AppHttpControllersPostController;
// returns the home page with all posts
Route::get('/', PostController::class .'@index')->name('posts.index');
// returns the form for adding a post
Route::get('/posts/create', PostController::class . '@create')->name('posts.create');
// adds a post to the database
Route::post('/posts', PostController::class .'@store')->name('posts.store');
// returns a page that shows a full post
Route::get('/posts/{post}', PostController::class .'@show')->name('posts.show');
// returns the form for editing a post
Route::get('/posts/{post}/edit', PostController::class .'@edit')->name('posts.edit');
// updates a post
Route::put('/posts/{post}', PostController::class .'@update')->name('posts.update');
// deletes a post
Route::delete('/posts/{post}', PostController::class .'@destroy')->name('posts.destroy');Blade-Dateien generieren
Jetzt, wo du die Routen hast, kannst du die Laravel-Blade-Dateien erstellen. Bevor du Artisan verwendest, um die Blade-Dateien zu erzeugen, musst du den Befehl make:view erstellen, mit dem du die Blade.php-Dateien erzeugen kannst.
- Führe den folgenden Code in der CLI aus, um eine MakeViewCommand-Befehlsdatei im Ordner app/Console/Commands zu erstellen:
php artisan make:command MakeViewCommand- Erstelle einen Befehl zum Erzeugen von .blade.php-Dateien aus der CLI, indem du den Code in der MakeViewCommand-Datei durch den folgenden ersetzst:
<?php
namespace AppConsoleCommands;
use IlluminateConsoleCommand;
use File;
class MakeViewCommand extends Command
{
/**
* The name and signature of the console command.
*
* @var string
*/
protected $signature = 'make:view {view}';
/**
* The console command description.
*
* @var string
*/
protected $description = 'Create a new blade template.';
/**
* Execute the console command.
*
* @return mixed
*/
public function handle()
{
$view = $this->argument('view');
$path = $this->viewPath($view);
$this->createDir($path);
if (File::exists($path))
{
$this->error("File {$path} already exists!");
return;
}
File::put($path, $path);
$this->info("File {$path} created.");
}
/**
* Get the view full path.
*
* @param string $view
*
* @return string
*/
public function viewPath($view)
{
$view = str_replace('.', '/', $view) . '.blade.php';
$path = "resources/views/{$view}";
return $path;
}
/**
* Create a view directory if it does not exist.
*
* @param $path
*/
public function createDir($path)
{
$dir = dirname($path);
if (!file_exists($dir))
{
mkdir($dir, 0777, true);
}
}
}Eine Startseite erstellen
Als nächstes erstellst du deine Startseite. Die Homepage ist die Datei index.blade.php, in der alle Beiträge aufgelistet sind.
- Um die Startseite zu erstellen, führe aus:
php artisan make:view posts.indexDadurch wird ein Ordner “ posts“ im Ordner “ /resources/views“ und eine Datei “ index.blade.php “ darunter erstellt. Der resultierende Pfad ist /resources/views/posts/index.blade.php.
- Füge den folgenden Code in die Datei index.blade.php ein:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet"
integrity="sha384-GLhlTQ8iRABdZLl6O3oVMWSktQOp6b7In1Zl3/Jr59b6EGGoI1aFkw7cmDA6j6gD" crossorigin="anonymous">
<title>Posts</title>
</head>
<body>
<nav class="navbar navbar-expand-lg navbar-light bg-warning">
<div class="container-fluid">
<a class="navbar-brand h1" href={{ route('posts.index') }}>CRUDPosts</a>
<div class="justify-end ">
<div class="col ">
<a class="btn btn-sm btn-success" href={{ route('posts.create') }}>Add Post</a>
</div>
</div>
</div>
</nav>
<div class="container mt-5">
<div class="row">
@foreach ($posts as $post)
<div class="col-sm">
<div class="card">
<div class="card-header">
<h5 class="card-title">{{ $post->title }}</h5>
</div>
<div class="card-body">
<p class="card-text">{{ $post->body }}</p>
</div>
<div class="card-footer">
<div class="row">
<div class="col-sm">
<a href="{{ route('posts.edit', $post->id) }}"
class="btn btn-primary btn-sm">Edit</a>
</div>
<div class="col-sm">
<form action="{{ route('posts.destroy', $post->id) }}" method="post">
@csrf
@method('DELETE')
<button type="submit" class="btn btn-danger btn-sm">Delete</button>
</form>
</div>
</div>
</div>
</div>
</div>
@endforeach
</div>
</div>
</body>
</html>Der obige Code erstellt eine einfache HTML-Seite, die Bootstrap für das Styling verwendet. Er richtet eine Navigationsleiste und eine Gittervorlage ein, die alle Beiträge in der Datenbank mit Details und zwei Aktionsschaltflächen – Bearbeiten und Löschen – auflistet, indem er den @foreach Blade-Helper verwendet.
Die Schaltfläche Bearbeiten bringt den Nutzer zur Seite Beitrag bearbeiten, wo er den Beitrag bearbeiten kann. Die Schaltfläche Löschen löscht den Beitrag aus der Datenbank mithilfe von {{ route('posts.destroy', $post->id) }} und der Methode DELETE.
Hinweis: Der Navbar-Code für alle Dateien ist derselbe wie in der vorherigen Datei.
- Erstelle die Seite create.blade.php. Die Blade-Datei namens create fügt Beiträge zur Datenbank hinzu. Verwende den folgenden Befehl, um die Datei zu erstellen:
php artisan make:view posts.createDies erzeugt eine Datei create.blade.php im Ordner /resources/views/posts .
- Füge den folgenden Code in die Datei create.blade.php ein:
// same as the previous file. Add the following after the nav tag and before the closing body tag.
<div class="container h-100 mt-5">
<div class="row h-100 justify-content-center align-items-center">
<div class="col-10 col-md-8 col-lg-6">
<h3>Add a Post</h3>
<form action="{{ route('posts.store') }}" method="post">
@csrf
<div class="form-group">
<label for="title">Title</label>
<input type="text" class="form-control" id="title" name="title" required>
</div>
<div class="form-group">
<label for="body">Body</label>
<textarea class="form-control" id="body" name="body" rows="3" required></textarea>
</div>
<br>
<button type="submit" class="btn btn-primary">Create Post</button>
</form>
</div>
</div>
</div>Der obige Code erstellt ein Formular mit den Feldern title und body sowie einer Schaltfläche submit, mit der du über die Aktion {{ route('posts.store') }} mit der Methode POST einen Beitrag zur Datenbank hinzufügen kannst.
- Erstelle die Seite Beitrag bearbeiten, um Beiträge in der Datenbank zu bearbeiten. Verwende den folgenden Befehl, um die Datei zu erstellen:
php artisan make:view posts.editDadurch wird eine Datei edit.blade.php im Ordner /resources/views/posts erstellt.
- Füge den folgenden Code in die Datei edit.blade.php ein:
<div class="container h-100 mt-5">
<div class="row h-100 justify-content-center align-items-center">
<div class="col-10 col-md-8 col-lg-6">
<h3>Update Post</h3>
<form action="{{ route('posts.update', $post->id) }}" method="post">
@csrf
@method('PUT')
<div class="form-group">
<label for="title">Title</label>
<input type="text" class="form-control" id="title" name="title"
value="{{ $post->title }}" required>
</div>
<div class="form-group">
<label for="body">Body</label>
<textarea class="form-control" id="body" name="body" rows="3" required>{{ $post->body }}</textarea>
</div>
<button type="submit" class="btn mt-3 btn-primary">Update Post</button>
</form>
</div>
</div>
</div>Der obige Code erstellt ein Formular mit den Feldern title und body und einem Submit-Button zum Bearbeiten eines Beitrags mit dem angegebenen id in der Datenbank über die Aktion {{ route('posts.update') }} mit einer Methode PUT.
- Starte dann deinen Anwendungsserver mit dem unten stehenden Code neu:
php artisan serveBesuche http://127.0.0.1:8000 in deinem Browser, um deinen neuen Blog zu sehen. Klicke auf die Schaltfläche Beitrag hinzufügen, um neue Beiträge hinzuzufügen.
Einsetzen und Testen deiner CRUD-Anwendung
Bereite deine Anwendung wie folgt für den Einsatz vor.
- Sorge für eine reibungslose und unkomplizierte Bereitstellung, indem du den öffentlichen Ordner deklarierst. Füge im Stammverzeichnis des Anwendungsordners eine .htaccess-Datei mit dem folgenden Code hinzu:
<IfModule mod_rewrite.c >
RewriteEngine On
RewriteRule ^(.*)$ public/$1 [L]
</IfModule >- Zwinge deine Anwendung,
HTTPSzu verwenden, indem du den folgenden Code über deinen Routen in der Datei routes/web.php einfügst:
use IlluminateSupportFacadesURL;
URL::forceScheme('https');- Pushe deinen Code in ein Git-Repository. Kinsta unterstützt Bereitstellungen von GitHub, GitLab oder Bitbucket.
Ein Projekt auf MyKinsta einrichten
- Erstelle ein MyKinsta-Konto, wenn du noch keins hast.
- Logge dich in dein Konto ein und klicke im Dashboard auf die Schaltfläche Dienst hinzufügen, um eine neue Anwendung zu erstellen.
- Wenn du neu in der Anwendung bist, verbinde dich mit deinem GitHub-, GitLab- oder Bitbucket-Konto und erteile bestimmte Berechtigungen.
- Fülle das Formular aus und füge die
APP_KEYhinzu. Du findest den entsprechenden Wert in deiner .env-Datei.
- Wähle deine Build-Ressourcen aus und entscheide, ob du den Build-Pfad deiner Anwendung verwenden oder deine Anwendung mit einer Dockerdatei bauen möchtest. Für diese Demonstration lässt du MyKinsta die Anwendung auf der Grundlage deines Repositorys bauen.
- Gib die verschiedenen Prozesse an, die du während der Bereitstellung ausführen möchtest. Du kannst sie an dieser Stelle leer lassen.
- Zum Schluss fügst du deine Zahlungsmethode hinzu.
Nachdem du deine Zahlungsmethode bestätigt hast, stellt MyKinsta deine Anwendung bereit und weist dir eine URL zu (siehe unten):
Du kannst den Link besuchen, aber du bekommst eine 500 | Server Error Seite, weil die Anwendung eine gültige Datenbankverbindung benötigt, um zu funktionieren. Der folgende Abschnitt behebt dieses Problem.
Erstelle eine Datenbank über MyKinsta
- Um eine Datenbank zu erstellen, gehe zu deinem MyKinsta-Dashboard und klicke auf Dienst hinzufügen.
- Wähle Datenbank und fülle das Formular mit dem gewünschten Datenbanknamen, -typ, Benutzernamen und Passwort aus. Füge einen Standort für das Rechenzentrum und eine Datenbankgröße hinzu, die zu deiner Anwendung passt.
- Auf der nächsten Seite werden die Kostenübersicht und deine Zahlungsmethode angezeigt. Klicke auf Datenbank erstellen, um den Vorgang abzuschließen.
- Nachdem du die Datenbank erstellt hast, leitet dich MyKinsta zu deiner Dienstleistungsliste weiter. Klicke auf die Datenbank, die du gerade erstellt hast, und scrolle nach unten zu Externe Verbindungen. Kopiere die Anmeldedaten der Datenbank.
- Gehe zurück zur Verteilungsseite der Anwendung und klicke auf Einstellungen. Scrolle dann nach unten zu Umgebungsvariablen und klicke auf Umgebungsvariablen hinzufügen. Füge die Datenbankanmeldeinformationen in der folgenden Reihenfolge als Umgebungsvariablen hinzu:
DB_CONNECTION=mysql
DB_HOST=External hostname
DB_PORT=External port
DB_DATABASE=Database name
DB_USERNAME=Username
DB_PASSWORD=PasswordDie Liste der Umgebungsvariablen der Anwendung sollte jetzt wie folgt aussehen:
- Gehe auf die Seite Bereitstellungen deiner Anwendung und setze deine Anwendung manuell ein, indem du auf Jetzt einsetzen klickst, um die Änderungen zu übernehmen. Bis jetzt hast du eine Datenbank erstellt und sie mit deiner Anwendung verbunden.
- Um nun die Datenbanktabellen in deiner MyKinsta-Datenbank zu erstellen, verbindest du die Datenbank mit deiner lokalen Anwendung, indem du deine .env-Datei mit denselben Anmeldedaten aktualisierst, die du in deiner Anwendung bei MyKinsta eingegeben hast, und den folgenden Befehl ausführst:
php artisan migrateDieser Befehl führt alle Migrationsdateien aus. Er erstellt alle definierten Tabellen in deiner MyKinsta-Anwendung.
Jetzt kannst du deine Anwendung mit der URL testen, die dir nach der ersten Bereitstellung zugewiesen wurde.
Zusammenfassung
Laravel ist ein umfassendes Framework für die Erstellung robuster und skalierbarer Webanwendungen, die CRUD-Funktionen erfordern. Mit seiner intuitiven Syntax und seinen leistungsstarken Funktionen macht es Laravel einfach, CRUD-Operationen in deine Anwendung einzubauen.
In diesem Artikel wurden die grundlegenden Konzepte von CRUD-Operationen behandelt und wie man sie mit den eingebauten Funktionen von Laravel implementiert. Außerdem wird erklärt:
- Wie du eine Datenbank in MyKinsta erstellst und sie mit deiner Anwendung verbindest
- Wie du die Migrationen von Laravel nutzt, um die Datenbanktabelle zu definieren und die Controller-Datei und ihre Funktionen zu erstellen
- Definiere ein Modell und verbinde es mit dem Controller. Laravels Routing generiert Blade-Dateien, um entsprechende Seiten und Formulare zu erstellen und die Anwendung mit MyKinsta einzusetzen und zu testen
Nachdem du nun gesehen hast, wie einfach es ist, CRUD-Operationen in Laravel durchzuführen, solltest du dir MyKinsta für die Entwicklung und das Hosting von Webanwendungen ansehen.
Ik ben de Editorial Team Lead bij Kinsta. Ik ben een open source liefhebber en ik houd van coderen. Met meer dan 7 jaar ervaring in technisch schrijven en redactiewerk voor de tech-industrie, werk ik graag samen met mensen om duidelijke en beknopte content te creëren en workflows te verbeteren.
Schreibe einen Kommentar