Wie man mit Laravel CRUD (Create, Read, Update und Delete) durchführt

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

1. Installiere Laravel und erstelle eine neue Anwendung
2. Erstelle eine Datenbank
3. Erstelle eine Tabelle
4. Erstelle einen Controller
5. Richte das Modell ein
6. Füge eine Route hinzu
7. Blade-Dateien generieren
8. 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.

1. Um Laravel zu installieren, führe aus:

composer global require laravel/installer

2. Um eine neue Laravel-Anwendung zu erstellen, führe aus:

laravel new crudposts

Datenbank erstellen

Um eine neue Datenbank für deine Anwendung zu erstellen:

1. Starte den Apache- und den MySQL-Server im XAMPP-Kontrollpanel und besuche http://localhost/phpmyadmin in deinem Browser.

2. Klicke in der linken Seitenleiste auf Neu. Du solltest das Folgende sehen:

3. Füge einen Datenbanknamen hinzu und klicke auf Erstellen.

4. 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.

1. Um eine Tabelle zu erstellen und eine Migrationsdatei mit Laravels Kommandozeilenschnittstelle Artisan zu erzeugen, führe aus:

php artisan make:migration create_posts_table

Der obige Befehl erstellt eine neue Datei,

yyyy_mm_dd_hhmmss_create_posts_table.php, in database/migrations.

2. Ö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.

3. Führe die Migrationsdateien im Ordner database/migrations aus, um Tabellen in der Datenbank zu erstellen:

php artisan migrate

Die Ausgabe sieht wie folgt aus:

4. 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 --api

Wenn 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.

1. Um ein Modell mit Artisan zu erstellen, führe aus:

php artisan make:model Post

Dieser Code erstellt eine Datei Post.php im Ordner App/Models.

2. Erstelle ein Array <fillable. Füge den folgenden Code innerhalb der Klasse Post und unterhalb der Zeile use 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.

3. Verbinde das Modell Post mit der Datei PostController.php. Öffne die Datei PostController.php und füge die folgende Zeile unter use 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.

1. Ö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');

2. 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.

1. 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

2. 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.

1. Um die Startseite zu erstellen, führe aus:

php artisan make:view posts.index

Dadurch 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.

2. 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.

3. 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.create

Dies erzeugt eine Datei create.blade.php im Ordner /resources/views/posts .

4. 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.

5. 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.edit

Dadurch wird eine Datei edit.blade.php im Ordner /resources/views/posts erstellt.

6. 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.

7. Starte dann deinen Anwendungsserver mit dem unten stehenden Code neu:

php artisan serve

Besuche 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.

1. 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 >

2. Zwinge deine Anwendung, HTTPS zu verwenden, indem du den folgenden Code über deinen Routen in der Datei routes/web.php einfügst:

use IlluminateSupportFacadesURL;
URL::forceScheme('https');

3. Pushe deinen Code in ein Git-Repository. Kinsta unterstützt Bereitstellungen von GitHub, GitLab oder Bitbucket.

Ein Projekt auf MyKinsta einrichten

1. Erstelle ein MyKinsta-Konto, wenn du noch keins hast.

2. Logge dich in dein Konto ein und klicke im Dashboard auf die Schaltfläche Dienst hinzufügen, um eine neue Anwendung zu erstellen.

3. Wenn du neu in der Anwendung bist, verbinde dich mit deinem GitHub-, GitLab- oder Bitbucket-Konto und erteile bestimmte Berechtigungen.

4. Fülle das Formular aus und füge die APP_KEY hinzu. Du findest den entsprechenden Wert in deiner .env-Datei.

5. 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.

6. Gib die verschiedenen Prozesse an, die du während der Bereitstellung ausführen möchtest. Du kannst sie an dieser Stelle leer lassen.

7. 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

1. Um eine Datenbank zu erstellen, gehe zu deinem MyKinsta-Dashboard und klicke auf Dienst hinzufügen.

2. 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.

3. Auf der nächsten Seite werden die Kostenübersicht und deine Zahlungsmethode angezeigt. Klicke auf Datenbank erstellen, um den Vorgang abzuschließen.

4. 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.

5. 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=Password

Die Liste der Umgebungsvariablen der Anwendung sollte jetzt wie folgt aussehen:

6. 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.

7. 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 migrate

Dieser 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.

Marcia Ramos Kinsta

I'm the Editorial Team Lead at Kinsta. I'm a open source enthusiast and I love coding. With more than 7 years of technical writing and editing for the tech industry, I love collaborating with people to create clear and concise pieces of content and improve workflows.

• LinkedIn