Skip to content

4. Die View und ihr Modell

Bis hierher haben Actions ihre Antworten selbst erzeugt: Text, JSON und einige als Zeichenkette geschriebene HTML-Tags. In einer MVC-Anwendung ist das die Aufgabe einer View: einer Datei, die die HTML-Seite beschreibt, mit Platzhaltern für die Daten, die die Action ihr übergibt – das Modell der View.

[Laravel] bringt eine eigene View-Engine mit, [Blade]. Eine [Blade]-View ist eine Datei, deren Name auf [.blade.php] endet und die im Ordner [resources/views] der Anwendung liegt. Es ist eine Textdatei – hier HTML –, in der drei Arten von Tags auf dem Server interpretiert werden:

  • [{{ expression }}]: der Wert eines [PHP]-Ausdrucks, der in die Seite eingefügt wird;
  • [@instruction]: eine Direktive: Bedingung ([@if]), Schleife ([@foreach]), Template-Vererbung ([@extends], [@section]), Einbindung ([@include]) ... Eine Direktive beginnt mit [@], gefolgt von ihrem Namen;
  • [{{-- commentaire --}}]: ein Kommentar, der auf der erzeugten Seite nicht erscheint.

Alles andere wird unverändert übernommen. Ausdrücke werden in [PHP] geschrieben: Es muss keine zweite Sprache gelernt werden. [Blade] ähnelt damit [Razor], der View-Engine von [ASP.NET Core MVC], die ebenfalls HTML und Code mischt und ebenfalls das Zeichen [@] verwendet; es unterscheidet sich von [Thymeleaf] ([Spring MVC]), dessen Views gültige HTML-Dateien sind, die um [th:]-Attribute erweitert wurden. Eine [Blade]-View wird nicht unverändert ausgeführt: Bei der ersten Verwendung [Blade] kompiliert es sie zu einer gewöhnlichen [PHP]-Datei, die in [storage/framework/views] gespeichert wird und die es wiederverwendet, solange die View unverändert bleibt. Wir werden sehen, wie diese Datei aussieht.

4.1. Beispiel 13: Eine erste View

13-first-view/
├── app/
│   ├── Http/
│   │   └── Controllers/
│   │       └── ViewsController.php
│   └── Models/
│       └── PageModel.php
├── resources/
│   └── views/
│       └── views/
│           ├── unknown.blade.php
│           └── index.blade.php
├── routes/
│   └── web.php
└── ...

4.1.1. Das Modell der View: app/Models/PageModel.php

<?php
// app/Models/PageModel.php: das Modell der View, die Daten, die die Action an die View übergibt

namespace App\Models;

readonly class PageModel
{
    public function __construct(
        public string $title,
        public string $message,
        public string $time,
    ) {
    }
}

Das Modell der View ist eine einfache unveränderliche Klasse (siehe Beispiel 03): die drei Informationen, die die View anzeigt. Es ist nicht zwingend, das Modell einer View als Klasse zu definieren: Man könnte der View auch drei einzelne Variablen übergeben. Eine Klasse dokumentiert jedoch, was die View erwartet, und ermöglicht es dem Editor, den Code der Action zu überprüfen. Diesen Ansatz verfolgt die Fallstudie, in der jede View ihre eigene Modellklasse hat.

4.1.2. Der Controller: app/Http/Controllers/ViewsController.php

<?php
// app/Http/Controllers/ViewsController.php: Actions, die eine VIEW zurückgeben

namespace App\Http\Controllers;

use App\Models\PageModel;
use Illuminate\Http\Response;
use Illuminate\View\View;

class ViewsController
{
    // view: die Blade-Engine baut die Seite aus der View
    // resources/views/views/index.blade.php und aus den im
    // Array übergebenen Variablen (hier nur eine, [model]); die erzeugte Seite ist die Antwort der Action
    public function index(): View
    {
        $model = new PageModel(
            'My first view',
            'This page was built by Blade, on the server.',
            date('H:i:s'));
        return view('views.index', ['model' => $model]);
    }

    // dieselbe View mit einem anderen Modell; oder eine andere View, mit dem Code 404
    public function hello(string $name): View|Response
    {
        if ($name === 'unknown') {
            // die Seite, mit dem Code 404 gesendet
            return response()->view('views.unknown', ['name' => $name], 404);
        }
        $model = new PageModel(
            "Hello $name",
            'This time, the title of the page comes from the URL.',
            date('H:i:s'));
        return view('views.index', ['model' => $model]);
    }
}
  • Zeilen 17–20: Die Action baut das Modell der View auf. Die Funktion ***[date] von *[PHP] formatiert die aktuelle Uhrzeit: [H] für die Stunden, [i] für die Minuten und [s]** für die Sekunden;
  • Zeile 21: Die Funktion [view] veranlasst [Blade], die Seite zu erzeugen. Der erste Parameter ist der Name der View: der Dateipfad relativ zum Ordner [resources/views], in dem die [/] durch Punkte ersetzt sind und der ohne die Endung [.blade.php] angegeben wird: [views.index] bezeichnet die Datei [resources/views/views/index.blade.php]. Der zweite Parameter ist ein assoziatives Array, in dem jeder Schlüssel zu einer Variablen in der View wird – hier zu einer einzigen: [$model]. [view] gibt ein [View]-Objekt zurück, das [Laravel] durch Erzeugen der Seite in eine Antwort umwandelt (vom Typ [text/html]);
  • Zeile 29: eine weitere View mit einer anderen Variablen ([$name]). [response()->view(...)] erzeugt eine Antwort aus einer View mit dem angegebenen Code – hier 404 –, um eine eigene Fehlerseite anzuzeigen. Der Typ der Action [View|Response] bedeutet: entweder eine [View] oder eine [Response];
  • Zeilen 31–35: dieselbe View wie bei der Action [index], aber mit einem anderen Modell. Das ist der Vorteil der Trennung von Actions und Views: Eine einzige View kann von mehreren Actions verwendet werden.

4.1.3. Die View: resources/views/views/index.blade.php

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  {{-- {{ ... }}: the value of an expression, inserted into the page --}}
  <title>{{ $model->title }}</title>
</head>
<body>
  <h1>{{ $model->title }}</h1>
  <p>{{ $model->message }}</p>
  <p>Page built at {{ $model->time }}.</p>
</body>
</html>
  • Zeile 5: ein [Blade]-Kommentar;
  • Zeile 6: [{{ $model->title }}] fügt den Wert der Eigenschaft [title] der Variablen [$model] ein. Zwischen den geschweiften Klammern können Sie einen beliebigen [PHP]-Ausdruck schreiben.

Alles, was durch [{{ }}] eingefügt wird, wird maskiert: Die Zeichen [<], [>], [&], ["] und ['] werden durch ihre HTML-Entitäten ersetzt. Diese Aufgabe hatte in Beispiel 09 die Funktion [e] übernommen, nun aber geschieht sie automatisch: Eine View kann somit nicht versehentlich von einem Benutzer gelieferten HTML-Code in die Seite einfügen.

4.1.4. Die View: resources/views/views/unknown.blade.php

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Unknown</title>
</head>
<body>
  <h1>Nobody is called [{{ $name }}] here.</h1>
</body>
</html>

Eine View muss kein Objekt erhalten: Die Variable [$name] ist eine Zeichenkette.

4.1.5. Ausführung

Image

Image

Die angezeigte Uhrzeit ist die koordinierte Weltzeit (UTC), da die Standardzeitzone von [Laravel] so eingestellt ist; die Fallstudie zeigt, wie man sie ändert. Die unverarbeitete Ausgabe zeigt die Verarbeitung durch [Blade]: Die Tags [{{ }}] wurden durch ihre Werte ersetzt, und der Kommentar wurde entfernt (an seiner Stelle bleibt eine Leerzeile).

curl -i http://localhost:8000/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">

  <title>My first view</title>
</head>
<body>
  <h1>My first view</h1>
  <p>This page was built by Blade, on the server.</p>
  <p>Page built at 16:04:07.</p>
</body>
</html>

Die Fehlerseite „home“, gefolgt von einem Namen, der HTML enthält ([<b>martin], in der URL codiert):

curl -i http://localhost:8000/hello/unknown
curl http://localhost:8000/hello/%3Cb%3Emartin
HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Unknown</title>
</head>
<body>
  <h1>Nobody is called [unknown] here.</h1>
</body>
</html>
...
  <title>Hello &lt;b&gt;martin</title>
...
  <h1>Hello &lt;b&gt;martin</h1>
...

Das Tag [<b>] wurde maskiert, obwohl weder die Action noch die View sich darum gekümmert hat. Hier schließlich die von [Blade] kompilierte View, wie sie im Ordner [storage/framework/views] zu finden ist (unter einem berechneten Namen wie [bfadc851307fb914e48325630a6c9191.php]):

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">

  <title><?php echo e($model->title); ?></title>
</head>
<body>
  <h1><?php echo e($model->title); ?></h1>
  <p><?php echo e($model->message); ?></p>
  <p>Page built at <?php echo e($model->time); ?>.</p>
</body>
</html>
<?php /**PATH .../13-first-view/resources/views/views/index.blade.php ENDPATH**/ ?>

Jedes [{{ expression }}] ist zu [<?php echo e(expression); ?>] geworden: Die Umwandlung erfolgt durch die Funktion [e] aus Beispiel 09. Eine [Blade]-View ist also nur eine elegantere Art, eine [PHP]-Datei zu schreiben, die HTML erzeugt. [PHP] wurde ursprünglich als Seitensprache konzipiert, bei der der Code zwischen [<?php] und [?>] in die HTML-Datei eingefügt wird; [Blade] behält dessen Effizienz bei und behebt seine Schwächen (insbesondere das fehlende Escaping).

4.2. Beispiel 14: Die Sprache Blade

Dieses Beispiel vereint die wichtigsten Konstrukte von [Blade] in einer einzigen View.

4.2.1. Das Modell und die Action

Das Modell der View wird durch drei unveränderliche Klassen beschrieben, jede in einer eigenen Datei ([PHP] verlangt keine Klasse pro Datei, aber der Class Loader von [Composer] sucht die Klasse [App\Models\Product] in der Datei [app/Models/Product.php]):

<?php
// app/Models/Product.php: ein Produkt

namespace App\Models;

readonly class Product
{
    public function __construct(
        public string $name,
        public float $price,
        public bool $inStock,
    ) {
    }
}
<?php
// app/Models/Address.php: eine Adresse

namespace App\Models;

readonly class Address
{
    public function __construct(
        public string $street,
        public string $city,
    ) {
    }
}
<?php
// app/Models/BasicsModel.php: das Modell der View von Beispiel 14

namespace App\Models;

readonly class BasicsModel
{
    /**
     * @param list<Product> $products
     * @param list<Product> $cart
     */
    public function __construct(
        public string $title,
        public string $name,
        public ?string $nickname,
        public string $html,
        public bool $loggedIn,
        public string $currency,
        public array $products,
        public array $cart,
        public Address $address,
    ) {
    }
}

Das Modell enthält Werte verschiedener Typen: Zeichenketten, [null], Boolesche Werte, Arrays von Objekten, leere Arrays und Objekte, die andere Objekte enthalten. Die Preise sind hier vom Typ [float], um die Berechnungen in der View zu vereinfachen (Beispiel 06 hat gezeigt, warum eine exakte Dezimalzahl vorzuziehen ist).

<?php
// app/Http/Controllers/BasicsController.php: eine View, die die wichtigsten Konstrukte von Blade verwendet

namespace App\Http\Controllers;

use App\Models\Address;
use App\Models\BasicsModel;
use App\Models\Product;
use Illuminate\View\View;

class BasicsController
{
    public function index(): View
    {
        $model = new BasicsModel(
            title: 'Blade basics',
            name: 'Martin',
            nickname: null,
            html: '<b>this is HTML</b>',
            loggedIn: true,
            currency: '€',
            products: [
                new Product('Keyboard', 25, true),
                new Product('Mouse', 12.5, false),
                new Product('Screen', 149, true),
            ],
            cart: [],
            address: new Address('12 rue des Lilas', 'Angers'));
        return view('basics.index', ['model' => $model]);
    }
}

Die Action baut das Modell mit benannten Parametern auf (siehe Beispiel 01): Jedem Wert geht der Name des Parameters voraus, für den er bestimmt ist, was den Aufruf trotz der Parameteranzahl lesbar macht.

4.2.2. Die View: resources/views/basics/index.blade.php

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>{{ $model->title }}</title>
</head>
<body>
  {{-- PHP code in the view, between the two instructions that follow; here, two variables --}}
  @php
    $total = collect($model->products)->sum('price');
    $count = count($model->products);
  @endphp
  <h1>{{ $model->title }}</h1>
  {{-- 1. display a value of the model; null is displayed as an empty string;
       the ?? operator replaces a null value. This Blade comment does not appear
       in the produced page --}}
  <p>1. Name: {{ $model->name }} - nickname: [{{ $model->nickname }}] [{{ $model->nickname ?? 'none' }}]</p>
  {{-- 2. {{ }} escapes HTML; {!! !!} inserts it as is --}}
  <p>2a. {{ $model->html }}</p>
  <p>2b. {!! $model->html !!}</p>
  {{-- 3. a condition --}}
  @if ($model->loggedIn)
    <p>3. You are logged in.</p>
  @else
    <p>3. You are not logged in.</p>
  @endif
  {{-- 4. a loop: $loop describes the state of the loop --}}
  <p>4. Our products:</p>
  <ul>
    @foreach ($model->products as $product)
      <li>no. {{ $loop->index }}: {{ $product->name }}, {{ $product->price }} {{ $model->currency }}
        {{ $product->inStock ? '(in stock)' : '(sold out)' }}
        @if ($loop->first) - the first one @endif
        @if ($loop->last) - the last one, seen by {{ $model->name }} @endif
      </li>
    @endforeach
  </ul>
  {{-- 5. the empty list: @forelse ... @empty --}}
  <p>5. Your cart:
    @forelse ($model->cart as $p)<span>{{ $p->name }}</span>@empty it is empty. @endforelse
  </p>
  {{-- 6. computed expressions, the @php variables, and number_format --}}
  <p>6. {{ $count }} products, for a total of {{ $total }} {{ $model->currency }};
    average price: {{ number_format($total / $count, 2, '.', ',') }} {{ $model->currency }}</p>
  {{-- 7. an object inside an object, and a PHP function (mb_strtoupper) --}}
  <p>7. Address: {{ $model->address->street }}, {{ mb_strtoupper($model->address->city) }}</p>
  {{-- 8. @ is a Blade instruction only at the start of a word; @@ writes an @ --}}
  <p>8. An email address: contact@example.com; a displayed instruction: @@if</p>
</body>
</html>
  • Zeilen 9–12: Die Direktiven [@php] und [@endphp] begrenzen einen [PHP]-Codeblock, der an dieser Stelle der Seite ausgeführt wird. Dort werden zwei View-Variablen erstellt: der Gesamtpreis, berechnet mit der Methode [sum] einer Collection (Beispiel 03), die eine Eigenschaft jedes Elements summiert, und die Anzahl der Produkte. Der [@php]-Block sollte dieser Art von Vorbereitung vorbehalten bleiben: Die Berechnung gehört normalerweise in die Action;
  • Zeile 17: Ein [null]-Wert wird als leere Zeichenkette angezeigt. Der Operator [??] in [PHP] (Beispiel 08) ersetzt einen [null]-Wert durch einen Standardwert;
  • Zeilen 19–20: [{{ }}] maskiert HTML (2a); [{!! !!}] hingegen fügt den Wert unverändert und ohne Maskierung ein (2b). [{!! !!}] ist für HTML reserviert, das die Anwendung selbst erzeugt, niemals für Benutzereingaben;
  • Zeilen 22–26: eine Bedingung: [@if], [@elseif], [@else], [@endif], mit einer [PHP]-Bedingung in Klammern. Jeder Block wird durch eine Direktive [@end...] geschlossen;
  • Zeilen 30–36: eine Schleife [@foreach] ... [@endforeach], die wie die Schleife [foreach] von [PHP] geschrieben wird. Darin beschreibt die Spezialvariable [$loop] den Zustand der Schleife: [$loop->index] (die Nummer des Durchlaufs, beginnend bei 0), [$loop->iteration] (beginnend bei 1), [$loop->first], [$loop->last] (true beim ersten bzw. letzten Durchlauf), [$loop->count] (die Anzahl der Elemente). Variablen außerhalb der Schleife ([$model->name]) bleiben zugänglich;
  • Zeile 32: der ternäre Operator von [PHP], [condition ? a : b] (Beispiel 11);
  • Zeile 40: Die Direktive [@forelse] ... [@empty] ... [@endforelse] ist eine Schleife, in der der Block [@empty] ausgeführt wird, wenn die Liste leer ist. Das ist einfacher als ein [@if], das die Länge der Liste prüfen würde;
  • Zeilen 43–44: berechnete Ausdrücke ([$total / $count]) und die Variablen aus dem [@php]-Block. Die Funktion [number_format] von [PHP] formatiert eine Zahl: zwei Nachkommastellen, einen Punkt als Dezimaltrennzeichen und ein Komma als Tausendertrennzeichen. In Beispiel 16 sehen wir eine wesentlich bessere Möglichkeit, Zahlen und Beträge zu formatieren;
  • Zeile 46: Der Operator [->] durchläuft die Objekte ([$model->address->city]), und jede [PHP]-Funktion kann aufgerufen werden: [mb_strtoupper] wandelt eine Zeichenkette in Großbuchstaben um (die Funktionen [mb_...], für *multi-byte*, verarbeiten in UTF-8 codierte Umlaute und Akzentzeichen korrekt);
  • Zeile 48: Das Zeichen [@] wird von [Blade] nur am Wortanfang interpretiert; in einer E-Mail-Adresse wird es unverändert übernommen. Um ein [@] gefolgt vom Namen einer Direktive zu schreiben, wird es verdoppelt: [@@if] erzeugt [@if]. Ebenso erzeugt [@{{ ... }}] den Text [{{ ... }}], was nützlich ist, wenn eine Seite geschweifte Klammern enthält, die für ein [JavaScript]-Framework bestimmt sind.

Ein Hinweis zu Kommentaren: [Blade] verarbeitet [@php]-Blöcke vor den Kommentaren. Ein Kommentar, der das Wort [@php] enthält, würde daher als Beginn eines Code-Blocks interpretiert, mit unerwarteten Ergebnissen: Deshalb enthält der Kommentar in Zeile 8 es nicht.

4.2.3. Ausführung

Image

Die erzeugte Seite:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Blade basics</title>
</head>
<body>

    <h1>Blade basics</h1>

  <p>1. Name: Martin - nickname: [] [none]</p>

  <p>2a. &lt;b&gt;this is HTML&lt;/b&gt;</p>
  <p>2b. <b>this is HTML</b></p>

      <p>3. You are logged in.</p>

  <p>4. Our products:</p>
  <ul>
          <li>no. 0: Keyboard, 25 €
        (in stock)
         - the first one               </li>
          <li>no. 1: Mouse, 12.5 €
        (sold out)
                      </li>
          <li>no. 2: Screen, 149 €
        (in stock)
                 - the last one, seen by Martin       </li>
      </ul>

  <p>5. Your cart:
     it is empty.   </p>

  <p>6. 3 products, for a total of 186.5 €;
    average price: 62.17 €</p>

  <p>7. Address: 12 rue des Lilas, ANGERS</p>

  <p>8. An email address: contact@example.com; a displayed instruction: @if</p>
</body>
</html>

Die Kommentare und Direktiven sind verschwunden, hinterlassen aber ihre Leerzeichen und Zeilenumbrüche: [Blade] versucht nicht, sauber formatiertes HTML zu erzeugen. Das hat keine Folgen: Der Browser ignoriert diese Leerraumzeichen. Eine Zahl wie [float] wird beim Einfügen in eine Zeichenkette mit einem Dezimalpunkt geschrieben ([12.5]); [number_format] verwendet die ihm übergebenen Trennzeichen.

4.3. Beispiel 15: Templates, Fragmente, statische Dateien

Die Seiten einer Website haben meist dieselbe Struktur: eine Kopfzeile, eine Navigationsleiste, eine Fußzeile und dieselben Stylesheets. Statt diese Struktur in jeder View zu wiederholen, wird sie einmal in einem Template (*Layout*) geschrieben, das die Seiten erweitern. Dieses Beispiel verwendet außerdem [Bootstrap], das am weitesten verbreitete CSS-Framework, für das Layout.

15-layout/
├── app/
│   ├── Http/
│   │   └── Controllers/
│   │       └── PagesController.php
│   └── Models/
│       └── Member.php
├── bootstrap/
│   └── app.php
├── public/
│   └── css/
│       └── styles.css
├── resources/
│   └── views/
│       ├── components/
│       │   └── card.blade.php
│       ├── fragments/
│       │   └── navbar.blade.php
│       ├── layout.blade.php
│       └── pages/
│           ├── home.blade.php
│           ├── raw.blade.php
│           └── team.blade.php
├── routes/
│   └── web.php
└── ...

4.3.1. Statische Dateien

Eine HTML-Seite verweist auf weitere Dateien: Stylesheets, [JavaScript]-Skripte und Bilder. Diese Dateien, die der Server unverändert ausliefert, heißen statische Dateien. Bei [Laravel] liegen sie im Ordner [public], den der Webserver unverändert ausliefert (Beispiel 01): Die Datei [public/css/styles.css] ist unter der URL [/css/styles.css] verfügbar, ohne dass [Laravel] beteiligt ist.

/* ein paar Einstellungen zusätzlich zu Bootstrap */
body {
  background-color: #f5f7fa;
}

/* der Footer des Layouts */
.footer {
  margin-top: 2rem;
  font-size: 0.85rem;
  color: #6c757d;
}

/* die Fehlermeldungen am Seitenende auf hellrosa Hintergrund */
.error-area {
  margin-top: 1.5rem;
  padding: 0.75rem 1rem;
  background-color: #fdecef;
  border: 1px solid #f5c2c7;
  border-radius: 0.375rem;
  color: #842029;
}

Einige zusätzliche CSS-Regeln zu [Bootstrap]: ein hellgrauer Hintergrund, der Stil der Fußzeile und der Stil eines Fehlerbereichs, der in den folgenden Beispielen verwendet wird.

[Bootstrap] wird in den Beispielen 15 bis 28 verwendet. Statt in den Ordner [public] jedes Beispiels eine Kopie zu legen, teilen sich die Beispiele es: Es liegt im Ordner [examples/common/bootstrap]. Dieser Ordner wird nicht vom Webserver ausgeliefert: Eine allen diesen Beispielen gemeinsame Route liefert seine Dateien aus. Sie wird in der Datei [examples/common/bootstrap.php] beschrieben:

<?php
// common/bootstrap.php: eine Route, die die Bootstrap-Dateien ausliefert, gemeinsam genutzt von
// den Beispielen 15 bis 28 (Ordner examples/common/bootstrap), unter der URL /bootstrap/...

use Illuminate\Support\Facades\Route;

Route::get('bootstrap/{file}', function (string $file) {
    $folder = realpath(__DIR__.'/bootstrap');
    // realpath: der absolute Pfad der angeforderten Datei ohne . und .. ; false,
    // falls die Datei nicht existiert
    $path = realpath($folder.'/'.$file);
    // eine Datei, die existiert und tatsächlich IM Ordner liegt (kein ../, um ihn zu verlassen)
    abort_unless($path && str_starts_with($path, $folder.DIRECTORY_SEPARATOR)
        && is_file($path), 404);
    // der Typ der Datei, abgeleitet aus ihrer Endung
    $types = ['css' => 'text/css', 'js' => 'text/javascript', 'map' => 'application/json'];
    $type = $types[pathinfo($path, PATHINFO_EXTENSION)] ?? 'application/octet-stream';
    return response()->file($path, ['Content-Type' => $type]);
})->where('file', '.*')->name('bootstrap');
  • Zeile 7: eine Route, deren Aktion eine anonyme Funktion ist (Beispiel 01). Der Routenparameter [{file}] akzeptiert jedes Pfadende, auch mit Schrägstrichen (Constraint [.*], Zeile 19, siehe Beispiel 02): Die URL [/bootstrap/css/bootstrap.min.css] bezeichnet die Datei [css/bootstrap.min.css] im Ordner. Die Route heißt [bootstrap];
  • Zeilen 8–14: Das Ausliefern von Dateien, die über eine URL bezeichnet werden, erfordert eine Vorsichtsmaßnahme: Eine URL wie [/bootstrap/../../15-layout/.env] darf keinen Zugriff auf eine Datei außerhalb des Ordners gewähren. Die Funktion [realpath] von [PHP] berechnet den absoluten Pfad einer Datei ohne ihre Bestandteile [.] und [..] oder liefert [false] zurück, wenn die Datei nicht existiert. Wir prüfen, ob der erhaltene Pfad tatsächlich mit dem Ordnerpfad beginnt ([str_starts_with]) und ob er auf eine Datei verweist ([is_file]); andernfalls beendet [abort_unless] die Anfrage mit einem 404-Fehler. [abort_unless(condition, code)] entspricht [if (! condition) abort(code)]; ebenso gibt es [abort_if]. [DIRECTORY_SEPARATOR] ist das Pfadtrennzeichen des Systems: [\] unter [Windows], [/] anderswo;
  • Zeilen 16–18: [response()->file] erzeugt eine Antwort, die den Inhalt einer Datei sendet. Der Inhaltstyp wird anhand der Dateiendung gewählt (geliefert von [pathinfo]), sodass ein Stylesheet korrekt als [text/css] deklariert wird: Ein Browser lehnt ein Stylesheet ab, das als etwas anderes deklariert ist.

Die Route wird in jedem Beispiel von der Datei [bootstrap/app.php] deklariert:

<?php
// bootstrap/app.php: die Anwendung von Beispiel 15

use Illuminate\Foundation\Application;
use Illuminate\Support\Facades\View;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // then: Routen, die außerhalb der Gruppe web deklariert sind (ohne Session oder Cookies):
        // die, die Bootstrap ausliefert, gemeinsam genutzt von den Beispielen 15 bis 28
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware()
    ->withExceptions()
    // booted: Code, der ausgeführt wird, sobald die Anwendung gestartet ist
    ->booted(function () {
        // ein "View Composer": wird vor dem Aufbau JEDER View (*) ausgeführt,
        // er fügt allen Views seine Variablen hinzu
        View::composer('*', function ($view) {
            $view->with(['path' => request()->path(), 'year' => date('Y')]);
        });
    })
    ->create();
  • Zeilen 11–14: Der Parameter [then] von [withRouting] ist eine Funktion, die aufgerufen wird, nachdem die Routen in [routes/web.php] deklariert wurden, um zusätzliche Routen zu deklarieren. Diese gehören nicht zur Gruppe [web]: Sie haben weder eine Session noch Cookies, was für statische Dateien geeignet ist. Die Pfeilfunktion führt die Datei [common/bootstrap.php] aus;
  • Zeilen 18–24: Die Methode [booted] registriert eine Funktion, die ausgeführt wird, sobald die Anwendung gestartet ist;
  • Zeilen 21–23: Die Fassade [View] registriert einen View Composer: eine Funktion, die [Laravel] vor dem Rendern jeder View ausführt, deren Name dem angegebenen Muster entspricht, hier [*] (also alle). Sie erhält die View und kann ihr Variablen hinzufügen ([with]). Hier stehen [$path] (der Pfad der angeforderten URL, geliefert von [request()], der aktuellen Anfrage) und [$year] (das aktuelle Jahr) somit in allen Views zur Verfügung, ohne dass die Aktionen sie bereitstellen müssen. Das Template verwendet sie für seine Fußzeile. Die Methode [View::share('name', value)] würde in ähnlicher Weise einen festen Wert für alle Views freigeben.

4.3.2. Das Template: resources/views/layout.blade.php

<!doctype html>
{{-- the layout of the pages: the pages EXTEND it, and fill its sections --}}
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  {{-- @yield: a slot that the page can fill; here with a default content --}}
  <title>@yield('title', 'Home') - My site</title>
  {{-- route(): the URL of the [bootstrap] named route; asset(): the URL of a file of public/ --}}
  <link rel="stylesheet" href="{{ route('bootstrap', 'css/bootstrap.min.css') }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3">
    {{-- insertion of the fragments/navbar.blade.php file --}}
    @include('fragments.navbar')
    <main>
      {{-- the content of the page requested by the action is inserted here --}}
      @yield('content')
    </main>
    {{-- $path, $year: added to all the views (see bootstrap/app.php) --}}
    <footer class="footer">Page [{{ $path }}] - © {{ $year }}</footer>
  </div>
</body>
</html>
  • Zeile 6: Das Tag [viewport] weist mobile Browser an, die Seite in der Bildschirmbreite darzustellen, was [Bootstrap] erwartet;
  • Zeile 8: Die Direktive [@yield] kennzeichnet einen benannten Platzhalter – den Seiten, die das Template erweitern, füllen können – mit einem Abschnitt gleichen Namens. Der zweite Parameter ist der Standardinhalt des Platzhalters, den eine Seite verwendet, die den Abschnitt nicht bereitstellt;
  • Zeilen 10–11: [route('bootstrap', 'css/bootstrap.min.css')] erzeugt die URL der benannten Route [bootstrap] (Beispiel 04) mit dem Wert ihres Parameters [{file}]. Die Funktion [asset] erzeugt eine URL aus einer Datei im Ordner [public]. Die URL der Datei von Hand zu schreiben ([/css/styles.css]) würde ebenfalls funktionieren, aber [asset] funktioniert auch, wenn die Anwendung unter einem URL-Präfix installiert ist;
  • Zeile 16: [@include] fügt den Inhalt einer anderen View ein, hier die Navigationsleiste. Die eingebundene View hat Zugriff auf die Variablen der View, die sie einbindet;
  • Zeile 19: der Bereich, den jede Seite mit ihrem eigenen Inhalt füllt;
  • Zeile 22: Die Fußzeile verwendet die beiden Variablen des View Composers.

Die Klasse [container] von [Bootstrap] zentriert den Inhalt und begrenzt seine Breite; [py-3] fügt einen vertikalen Innenabstand hinzu: [Bootstrap] stellt Hunderte solcher Klassen bereit, die im Attribut [class] kombiniert werden.

4.3.3. Die Navigationsleiste: resources/views/fragments/navbar.blade.php

1
2
3
4
5
6
7
8
9
{{-- a fragment: a piece of page, inserted by @include --}}
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">My site</span>
  <div class="navbar-nav">
    <a class="nav-link" href="/">Home</a>
    <a class="nav-link" href="/team">Team</a>
    <a class="nav-link" href="/raw">Page without layout</a>
  </div>
</nav>

Ein Fragment: ein Teil einer Seite, der für sich allein keine Bedeutung hat. Die Klassen [navbar], [navbar-brand] und [nav-link] gehören zur Navigationsleiste von [Bootstrap].

4.3.4. Eine Komponente: resources/views/components/card.blade.php

1
2
3
4
5
6
7
8
{{-- a COMPONENT: a piece of page that has parameters, like a function --}}
@props(['name', 'role'])
<div class="card">
  <div class="card-body">
    <h5 class="card-title">{{ $name }}</h5>
    <p class="card-text">{{ $role }}</p>
  </div>
</div>
  • Zeile 2: Eine Komponente ist ein Teil einer Seite mit Parametern; das ist die Aufgabe von [Blade]. Eine anonyme Komponente ist eine einfache View aus dem Ordner [resources/views/components]; die Direktive [@props] deklariert ihre Parameter, die zu Variablen der View werden. Sie wird als HTML-Tag verwendet, dessen Name mit [x-] beginnt: [<x-card name="..." role="..." />] fügt das mit diesen Werten erzeugte Seitenfragment ein. Parameter können einen Standardwert haben: [@props(['name', 'role' => ''])]. Die Karte ([card]) ist eine Komponente von [Bootstrap].

4.3.5. Die Seiten

{{-- this page EXTENDS the layout: it only provides the content of its sections --}}
@extends('layout')

@section('content')
  <h1>Welcome</h1>
  <p>This page only contains its own content: the header, the navigation
    bar and the footer come from the <code>layout.blade.php</code> layout.</p>
  {{-- the [card] component, with two parameters written on the spot --}}
  <x-card name="A component" role="called with parameters written on the spot" />
@endsection
  • Zeile 2: Die Seite erweitert das Template: [Blade] erzeugt die Template-Seite und ersetzt ihre [@yield]-Platzhalter durch die von der Seite definierten Abschnitte. In einer View, die ein Template erweitert, erscheint Text, der außerhalb der Abschnitte steht, nicht in der erzeugten Seite;
  • Zeilen 4–10: der Abschnitt [content], der den gleichnamigen Platzhalter füllt. Den Abschnitt [title] definiert die Seite nicht: Der Platzhalter behält seinen Standardinhalt „Home“;
  • Zeile 9: die Verwendung der Komponente [card]. Die Parameter werden als HTML-Attribute geschrieben; ihre Werte sind Zeichenketten.
@extends('layout')

@section('title', 'Our team')

@section('content')
  <h1>Our team</h1>
  <div class="row g-3">
    @foreach ($members as $member)
      <div class="col-md-4">
        {{-- :name="...": the value of the parameter is a PHP EXPRESSION --}}
        <x-card :name="$member->name" :role="$member->role" />
      </div>
    @endforeach
  </div>
@endsection
  • Zeile 3: ein kurzer Abschnitt, dessen Inhalt als zweiter Parameter übergeben wird;
  • Zeilen 8–13: eine Karte pro Teammitglied in einem Raster von [Bootstrap] ([row], [col-md-4]: drei Spalten auf einem mittleren oder großen Bildschirm, eine Spalte auf einem schmalen Bildschirm);
  • Zeile 11: Einem Parameter, dessen Name mit [:] beginnt, wird der Wert eines [PHP]-Ausdrucks zugewiesen, keine Zeichenkette: [:name="$member->name"].

Der Controller führt keine neuen Funktionen ein:

<?php
// app/Http/Controllers/PagesController.php: drei Seiten

namespace App\Http\Controllers;

use App\Models\Member;
use Illuminate\View\View;

class PagesController
{
    public function home(): View
    {
        return view('pages.home');
    }

    public function team(): View
    {
        $members = [
            new Member('Marie Pélissier', 'Director'),
            new Member('Jacques Bromard', 'Developer'),
            new Member('Philippe Jandot', 'Graphic designer'),
        ];
        return view('pages.team', ['members' => $members]);
    }

    public function raw(): View
    {
        return view('pages.raw');
    }
}

Schließlich verwendet die dritte Seite das Template nicht:

<!doctype html>
{{-- this view does not use the layout: it is a complete page --}}
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Raw page</title>
</head>
<body>
  <p>This page does not use the layout: no Bootstrap, no navigation bar.</p>
  <p><a href="/">Back to home</a></p>
</body>
</html>

4.3.6. Ausführung

Image

Image

Image

Die Team-Seite, wie der Browser sie erhält (die von Kommentaren und Direktiven hinterlassenen Leerzeilen wurden entfernt):

curl http://localhost:8000/team
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Our team - My site</title>
  <link rel="stylesheet" href="http://localhost:8000/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="http://localhost:8000/css/styles.css">
</head>
<body>
  <div class="container py-3">
    <nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">My site</span>
  <div class="navbar-nav">
    <a class="nav-link" href="/">Home</a>
    <a class="nav-link" href="/team">Team</a>
    <a class="nav-link" href="/raw">Page without layout</a>
  </div>
</nav>
    <main>
        <h1>Our team</h1>
  <div class="row g-3">
          <div class="col-md-4">
        <div class="card">
  <div class="card-body">
    <h5 class="card-title">Marie Pélissier</h5>
    <p class="card-text">Director</p>
  </div>
</div>
      </div>
...
      </div>
    </main>
    <footer class="footer">Page [team] - © 2026</footer>
  </div>
</body>
</html>

Der Browser hat eine vollständige Seite erhalten: Template, Fragment, Seite und Komponenten wurden auf dem Server zusammengesetzt. Die URL-Werte in den Stylesheets wurden von [route] und [asset] berechnet: Es sind absolute URL-Werte. Der Pfad der Startseite lautet [/]; die Pfade der anderen Seiten werden ohne führenden Schrägstrich geschrieben ([team]): Das ist die Konvention von [request()->path()]. Sie können überprüfen, ob die Stylesheets korrekt angewendet werden (die Option [-I] von [curl] zeigt nur die Antwort-Header an):

curl -I http://localhost:8000/bootstrap/css/bootstrap.min.css
curl -I http://localhost:8000/css/styles.css
1
2
3
4
5
6
7
8
9
HTTP/1.1 200 OK
Content-Type: text/css; charset=utf-8
Last-Modified: Sat, 26 Sep 2026 16:04:06 GMT
Content-Length: 232111
Accept-Ranges: bytes
...
HTTP/1.1 200 OK
Content-Type: text/css; charset=UTF-8
Content-Length: 435

Die erste Datei wurde über unsere Route gesendet; die zweite wurde direkt vom Entwicklungsserver gesendet, ohne [Laravel] zu durchlaufen.

4.4. Beispiel 16: Helper

Eine View muss häufig Werte formatieren: einen Betrag mit seiner Währung, ein ausgeschriebenes Datum oder einen Text in Großbuchstaben. Dieser Code gehört nicht in die Aktion (die sich nicht um die Darstellung kümmert) und wäre in der View umständlich zu schreiben. Stattdessen wird er in [PHP] in Funktionen geschrieben, die die Views aufrufen: Das sind die Helper der View. [Blade] bietet mehrere Möglichkeiten, sie verfügbar zu machen: den Aufruf einer Funktion oder einer statischen Methode, das Schreiben eigener Direktiven ([@money($price)]) und die Verwendung von Komponenten, die wir bereits kennengelernt haben.

16-helpers/
├── app/
│   ├── Helpers/
│   │   └── Formats.php
│   ├── Http/
│   │   ├── Controllers/
│   │   │   └── PagesController.php
│   │   └── Middleware/
│   │       └── SetLanguage.php
│   └── Models/
│       └── Product.php
├── resources/
│   └── views/
│       ├── components/
│       │   ├── badge.blade.php
│       │   └── link.blade.php
│       ├── fragments/
│       │   └── navbar.blade.php
│       ├── layout.blade.php
│       └── pages/
│           ├── home.blade.php
│           └── products.blade.php
└── ...

4.4.1. Funktionen: app/Helpers/Formats.php

<?php
// app/Helpers/Formats.php: von den Views aufgerufene Funktionen

namespace App\Helpers;

use Brick\Math\BigDecimal;
use Carbon\CarbonInterface;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Number;

class Formats
{
    // "keyboard" -> "KEYBOARD"
    public static function uppercase(?string $text): string
    {
        return $text === null ? '' : mb_strtoupper($text);
    }

    // ein Betrag in einer Währung, im Format der Sprache der Anfrage (siehe die
    // Middleware SetLanguage): 1149.9 -> "€1,149.90" auf Englisch, "1 149,90 €" auf
    // Französisch. Die PHP-Erweiterung intl kennt die Konventionen jedes Landes
    public static function money(BigDecimal $amount, string $currency = 'EUR'): string
    {
        return Number::currency($amount->toFloat(), in: $currency, locale: App::getLocale());
    }

    // ein Datum in ausgeschriebenen Worten, in der Sprache der Anfrage: "Saturday 26 September 2026"
    public static function longDate(CarbonInterface $day): string
    {
        return $day->locale(App::getLocale())->isoFormat('dddd D MMMM YYYY');
    }
}
  • Zeilen 14–17: eine statische Methode ([static]): Sie wird auf der Klasse aufgerufen, ohne Objekt ([Formats::uppercase('keyboard')]). Sie akzeptiert [null];
  • Zeilen 22–24: die Formatierung eines Betrags. Sie hängt von der Sprache ab: Im Französischen [1 149,90 €] (Leerzeichen als Tausendertrennzeichen, Dezimalkomma, Symbol hinter dem Betrag); im Englischen [€1,149.90]. Die Klasse [Number] von [Laravel] basiert auf der Erweiterung [intl] von [PHP], die die Konventionen aller Länder unterstützt (sie verwendet die Daten des Unicode-Projekts *CLDR*): [Number::currency] formatiert einen Betrag, wobei die Währung durch ihren internationalen Code bezeichnet wird ([EUR], [USD]). [intl] kann nur Zahlen vom Typ [float] formatieren: Die Dezimalzahl wird konvertiert ([toFloat()]), was hier unbedenklich ist, da die Zahl nicht mehr für Berechnungen verwendet wird. Die Sprache ([fr], [en]) ist die der Anwendung für die aktuelle Anfrage, zurückgegeben von [App::getLocale()]; wir werden sehen, wer sie festlegt;
  • Zeilen 28–30: die Formatierung eines [Carbon] -Datums (Beispiel 12). [locale(...)] liefert eine Kopie des Datums, die auf eine bestimmte Sprache eingestellt ist; [isoFormat] formatiert es folgendermaßen: [dddd] schreibt den Wochentag aus, [D] den Tag des Monats, [MMMM] schreibt den Monat aus und [YYYY] das Jahr. [Carbon] bringt Übersetzungen dieser Namen in über zweihundert Sprachen mit. Der Typ [CarbonInterface] akzeptiert alle [Carbon]-Daten.

4.4.2. Die Sprache jeder Anfrage: app/Http/Middleware/SetLanguage.php

<?php
// app/Http/Middleware/SetLanguage.php: die Formatierungssprache jeder Anfrage

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\App;
use Symfony\Component\HttpFoundation\Response;

class SetLanguage
{
    // der URL-Parameter ?lang=fr, sonst Englisch
    public function handle(Request $request, Closure $next): Response
    {
        App::setLocale($request->query('lang') === 'fr' ? 'fr' : 'en');
        return $next($request);
    }
}

Die Formatierungssprache hängt von der Anfrage ab: Der URL-Parameter [?lang=fr] wählt Französisch; Englisch ist die Standardsprache. Eine Middleware (Beispiel 03) legt sie vor jeder Aktion über [App::setLocale] fest: Die Fassade [App] bezeichnet die Anwendung selbst. Die so festgelegte Sprache gilt nur für die aktuelle Anfrage: Die nächste Anfrage kehrt zur Sprache aus [.env] ([APP_LOCALE], mit Englisch als Standard) zurück. Das Kapitel zur Internationalisierung verwendet dieselbe Sprache, um die Texte zu übersetzen.

4.4.3. Konfiguration: bootstrap/app.php

<?php
// bootstrap/app.php: die Anwendung von Beispiel 16

use App\Http\Middleware\SetLanguage;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Support\Facades\Blade;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // then: Routen, die außerhalb der Gruppe web deklariert sind (ohne Session oder Cookies):
        // die, die Bootstrap ausliefert, gemeinsam genutzt von den Beispielen 15 bis 28
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // die Sprache jeder Anfrage (siehe app/Http/Middleware/SetLanguage.php)
        $middleware->web(append: SetLanguage::class);
    })
    ->withExceptions()
    ->booted(function () {
        // "selbstgeschriebene" DIREKTIVEN: @money($price), @longDate($day). Eine Direktive
        // erhält den TEXT ihres Parameters und gibt den PHP-Code zurück, der sie ersetzen wird
        Blade::directive('money', fn (string $expression) =>
            "<?php echo e(\\App\\Helpers\\Formats::money($expression)); ?>");
        Blade::directive('longDate', fn (string $expression) =>
            "<?php echo e(\\App\\Helpers\\Formats::longDate($expression)); ?>");
    })
    ->create();
  • Zeile 19: Die Middleware wird am Ende der Gruppe [web] hinzugefügt: Sie wird für alle Routen in [routes/web.php] ausgeführt, nach den Middlewares der Gruppe (Session, Cookies usw.). Beispiel 03 verwendete [append], das eine globale Middleware hinzufügt, die für alle Anfragen ausgeführt wird, auch für Routen außerhalb der Gruppe [web];
  • Zeilen 25–28: Die Fassade [Blade] registriert zwei „benutzerdefinierte“ Direktiven: [@money(...)] und [@longDate(...)]. Eine Direktive wird verarbeitet, wenn die View kompiliert wird (Beispiel 13): Ihre Funktion erhält den Text , der zwischen den Klammern steht (zum Beispiel [$product->price, 'USD']), und liefert den [PHP]-Code zurück, der die Direktive in der kompilierten View ersetzt. Hier erfolgt ein Aufruf der entsprechenden Methode von ***[Formats]***, deren Ergebnis maskiert ([e]***) und ausgegeben wird ([echo]***). In einer Zeichenkette in Anführungszeichen steht [\\] für einen einzelnen [\];
  • Die Direktiven werden in einer Funktion [booted] (Beispiel 15) abgelegt, sobald die Anwendung gestartet ist: Die Fassade [Blade] ist erst zu diesem Zeitpunkt nutzbar.

Da Direktiven kompilierten Code erzeugen, erfordern sie eine Vorsichtsmaßnahme: Nach dem Ändern einer Direktive müssen Sie die kompilierten Views löschen (Befehl [php artisan view:clear]), damit die Views mit der neuen Version neu kompiliert werden.

4.4.4. Der Controller: app/Http/Controllers/PagesController.php

<?php
// app/Http/Controllers/PagesController.php: zwei Seiten

namespace App\Http\Controllers;

use App\Models\Product;
use Brick\Math\BigDecimal;
use Carbon\CarbonImmutable;
use Illuminate\View\View;

class PagesController
{
    public function home(): View
    {
        return view('pages.home', ['today' => CarbonImmutable::today()]);
    }

    public function products(): View
    {
        return view('pages.products', ['products' => [
            new Product('keyboard', BigDecimal::of('25'), 12),
            new Product('mouse', BigDecimal::of('12.5'), 0),
            new Product('screen', BigDecimal::of('1149.9'), 3),
        ]]);
    }
}

Die Aktionen übergeben den Views Rohwerte: ein Datum ([CarbonImmutable::today()], das heutige Datum um Mitternacht) und Dezimalzahlen. Die Formatierung übernehmen die Views. Die Klasse [Product] vereint einen Namen, einen Preis (ein [BigDecimal], siehe Beispiel 06) und einen Lagerbestand. Die Routen heißen [home] und [products].

4.4.5. Die Views

1
2
3
4
5
6
{{-- a component: a link of the navigation bar, which receives the [active]
     class if the current page is under the [path] path. request(): the
     current request, available in all the views; $slot: the content placed
     between the tags of the component --}}
@props(['href', 'path'])
<a @class(['nav-link', 'active' => request()->is($path)]) href="{{ $href }}">{{ $slot }}</a>
  • Zeile 5: eine Komponente, die einen Link in der Navigationsleiste erzeugt. Dem Link der aktuellen Seite wird die Klasse [active] aus [Bootstrap] zugewiesen, die ihn hervorhebt;
  • Zeile 6: Die Direktive [@class] erzeugt aus einem Array das Attribut [class] für ein Tag: Eine für sich geschriebene Klasse (['nav-link']) ist immer vorhanden; eine als Schlüssel geschriebene Klasse (['active' => condition]) ist nur vorhanden, wenn die Bedingung wahr ist. Die Funktion [request()] liefert die aktuelle Anfrage; ihre Methode [is] vergleicht den Pfad der URL mit einem Muster, in dem [*] für eine beliebige Zeichenfolge steht. Die Variable [$slot] enthält den Inhalt zwischen dem öffnenden und dem schließenden Tag der Komponente ([<x-link ...>Products</x-link>]).
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">Helpers</span>
  <div class="navbar-nav">
    {{-- 1. a condition written in the view --}}
    <a class="nav-link{{ request()->is('/') ? ' active' : '' }}" href="/">Home</a>
    {{-- 2. the [link] component --}}
    <x-link href="/products" path="products*">Products</x-link>
    {{-- 3. route() builds the URL of a named route; a parameter that is not a
         parameter of the route is added at the end of the URL: /products?lang=fr --}}
    <a class="nav-link" href="{{ route('products', ['lang' => 'fr']) }}">Produits (fr)</a>
  </div>
</nav>
  • Zeile 5: dasselbe, direkt in der View geschrieben, ohne Komponente, mit dem ternären Operator. [request()->is('/')] erkennt nur die Startseite. Die Komponente erspart es, die Bedingung für jeden Link zu wiederholen;
  • Zeile 7: die Verwendung der Komponente;
  • Zeile 10: Ein Parameter von [route] , der kein Routenparameter ist, wird der URL als Parameter angehängt: [/products?lang=fr].
1
2
3
{{-- a Bootstrap badge: green if the product is in stock, red otherwise --}}
@props(['stock'])
<span @class(['badge', 'text-bg-success' => $stock > 0, 'text-bg-danger' => $stock <= 0])>{{ $stock > 0 ? "$stock in stock" : 'sold out' }}</span>
  • Zeile 3: ein Badge von [Bootstrap], grün ([text-bg-success]) oder rot ([text-bg-danger]) je nach Lagerbestand, mit [@class]. Der Text des Badges wird vom ternären Operator ausgewählt; ["$stock in stock"] ist eine interpolierte Zeichenkette.
@extends('layout')
@section('title', 'Home')

@section('content')
  <h1>Home</h1>
  {{-- the "home-made" @longDate directive --}}
  <p>Today is @longDate($today).</p>
  {{-- app()->getLocale(): the language of the request, set by the SetLanguage middleware --}}
  <p>Formatting language: {{ app()->getLocale() }}
    (<a href="/?lang=fr">in French</a>, <a href="/">in English</a>)</p>
@endsection
  • Zeile 7: der Aufruf der Direktive „home“;
  • Zeile 9: Die Funktion [app()] liefert die Anwendung, und [getLocale()] liefert deren Sprache für die aktuelle Anfrage.
@extends('layout')
{{-- @use: the equivalent, in a view, of PHP's use instruction --}}
@use('App\Helpers\Formats')
@section('title', 'Products')

@section('content')
  <h1>Products</h1>
  <table class="table table-sm w-auto">
    <thead><tr><th>Product</th><th>Price</th><th>Price in dollars</th><th>Stock</th></tr></thead>
    <tbody>
      @foreach ($products as $product)
        <tr>
          {{-- a static method, then a directive, without then with a parameter --}}
          <td>{{ Formats::uppercase($product->name) }}</td>
          <td>@money($product->price)</td>
          <td>@money($product->price, 'USD')</td>
          {{-- the [badge] component builds the HTML of the badge --}}
          <td><x-badge :stock="$product->stock" /></td>
        </tr>
      @endforeach
    </tbody>
  </table>
@endsection
  • Zeile 3: Die Direktive [@use] importiert eine Klasse in die View, genau wie die Anweisung [use] in einer [PHP]-Datei;
  • Zeile 14: ein Aufruf einer statischen Methode, die wie eine Funktion wirkt;
  • Zeilen 15–16: die Direktive [@money], zuerst mit ihrer Standardwährung, dann mit einem Parameter;
  • Zeile 18: die Verwendung der Komponente [badge].

Das Template [layout.blade.php] ist eine vereinfachte Version des Templates aus Beispiel 15.

4.4.6. Ausführung

Image

Image

Dieselbe Seite mit dem Parameter [?lang=fr]. Nur die Formatierung der Zahlen ändert sich; der Text selbst ist fest in den Views codiert. Das Kapitel zur Internationalisierung übersetzt auch den Text.

Image

Ein Auszug aus dem erzeugten HTML:

curl "http://localhost:8000/products?lang=en"
1
2
3
4
5
6
7
8
9
...
              <tr>
          <td>KEYBOARD</td>
          <td>€25.00</td>
          <td>$25.00</td>
          <td><span class="badge text-bg-success">12 in stock</span>
</td>
        </tr>
...

4.5. Beispiel 17: Ein GET-Formular

Ein HTML-Formular sendet seine Felder auf eine von zwei Arten an den Server, je nach seinem Attribut [method]:

  • [method="get"]: Die Felder werden der URL als Parameter angehängt ([/search?keyword=le&genre=novel]). Diese Methode verwendet ein Formular, das eine Abfrage durchführt: eine Suche oder einen Filter. Die URL mit den Ergebnissen kann als Lesezeichen gespeichert, geteilt oder gefahrlos neu geladen werden;
  • [method="post"]: Die Felder sind im Anfragekörper enthalten (siehe Beispiel 11). Diese Methode verwendet ein Formular, das Daten ändert: eine Registrierung, eine Ergänzung oder eine Löschung.

Dieses erste Formular ist eine Buchsuche.

4.5.1. Das Modell: app/Models/Book.php und SearchModel.php

<?php
// app/Models/Book.php: ein Buch

namespace App\Models;

readonly class Book
{
    public function __construct(
        public string $title,
        public string $author,
        public string $genre,
    ) {
    }
}
<?php
// app/Models/SearchModel.php: das Modell der View: die Eingabe (um sie erneut anzuzeigen),
// die Genres, die Ergebnisse

namespace App\Models;

readonly class SearchModel
{
    /**
     * @param list<string> $genres
     * @param list<Book> $results
     */
    public function __construct(
        public string $keyword,
        public string $genre,
        public array $genres,
        public array $results,
    ) {
    }
}
  • Zeilen 14–17: Das View-Modell enthält die Eingabe des Benutzers – die das Formular anzeigen wird –, die Liste der vorgeschlagenen Genres und die Ergebnisse.

4.5.2. Der Controller: app/Http/Controllers/BooksController.php

<?php
// app/Http/Controllers/BooksController.php: ein per GET gesendetes Suchformular

namespace App\Http\Controllers;

use App\Models\Book;
use App\Models\SearchModel;
use Illuminate\Http\Request;
use Illuminate\View\View;

class BooksController
{
    // Klassen-KONSTANTEN: die Daten, für das Beispiel im Code festgeschrieben
    private const GENRES = ['novel', 'poetry', 'drama'];

    /** @return list<Book> */
    private static function books(): array
    {
        return [
            new Book('Le Rouge et le Noir', 'Stendhal', 'novel'),
            new Book('Les Fleurs du mal', 'Baudelaire', 'poetry'),
            new Book('Madame Bovary', 'Flaubert', 'novel'),
            new Book('Alcools', 'Apollinaire', 'poetry'),
            new Book('Le Cid', 'Corneille', 'drama'),
        ];
    }

    // GET / und GET /search?keyword=...&genre=...: das Formular UND seine Ergebnisse
    public function search(Request $request): View
    {
        // string: der Parameter als String ('' falls er fehlt)
        $keyword = $request->string('keyword')->value();
        $genre = $request->string('genre')->value();
        $word = mb_strtolower($keyword);
        $results = array_values(array_filter(self::books(), fn (Book $book) =>
            ($word === '' || str_contains(mb_strtolower($book->title), $word)
                || str_contains(mb_strtolower($book->author), $word))
            && ($genre === '' || $book->genre === $genre)));
        return view('books.search', [
            'model' => new SearchModel($keyword, $genre, self::GENRES, $results),
        ]);
    }
}
  • Zeile 14: eine private Klassenkonstante namens [self::GENRES] ([self] bezeichnet die aktuelle Klasse). Eine Konstante darf keine Objekte enthalten: Deshalb werden die Bücher von einer statischen Methode geliefert (Zeilen 17–25). In einer realen Anwendung kämen sie aus einer Datenbank;
  • Zeilen 32–33: Die Formularfelder werden als URL-Parameter gelesen (Beispiel 07). Die Methode [string] liefert den Parameter als Objekt vom Typ [Stringable] von [Laravel] (eine um Methoden angereicherte Zeichenkette), das leer ist, wenn der Parameter fehlt; [value()] extrahiert daraus die [PHP]-Zeichenkette;
  • Zeilen 35–38: das Filtern. Die Funktion [array_filter] behält die Elemente eines Arrays, für die die übergebene Funktion [true] zurückgibt: Ein Buch wird behalten, wenn das Schlüsselwort leer ist oder in seinem Titel oder Autor vorkommt (auf beiden Seiten in Kleinbuchstaben), und wenn das Genre leer ist oder mit seinem eigenen übereinstimmt. [array_filter] behält die Schlüssel der ausgewählten Elemente (0, 2 ...): [array_values] nummeriert sie ab 0 neu;
  • Zeilen 39–41: das View-Modell.

Die Routing-Tabelle ordnet zwei URL-Einträge derselben Aktion zu: Beim ersten Besuch ([/]) gibt es keine Parameter, und alle Bücher werden angezeigt.

1
2
3
4
5
6
7
8
9
<?php
// routes/web.php: die Routen von Beispiel 17

use App\Http\Controllers\BooksController;
use Illuminate\Support\Facades\Route;

// zwei Routen für dieselbe Action
Route::get('/', [BooksController::class, 'search']);
Route::get('search', [BooksController::class, 'search']);

4.5.3. Die View: resources/views/books/search.blade.php

@extends('layout')

@section('content')
  <h1 class="h3">Book search</h1>
  {{-- method="get": the fields are sent in the URL (?keyword=...&genre=...) --}}
  <form method="get" action="/search" class="row g-2 align-items-end mb-3">
    <div class="col-auto">
      <label class="form-label" for="keyword">Title or author</label>
      {{-- value: the field displays again what was typed (escaped by {{ }}) --}}
      <input class="form-control" id="keyword" name="keyword" value="{{ $model->keyword }}">
    </div>
    <div class="col-auto">
      <label class="form-label" for="genre">Genre</label>
      <select class="form-select" id="genre" name="genre">
        <option value="">(all)</option>
        @foreach ($model->genres as $genre)
          {{-- @selected: the boolean selected attribute, written if the condition is true, omitted otherwise --}}
          <option value="{{ $genre }}" @selected($genre === $model->genre)>{{ $genre }}</option>
        @endforeach
      </select>
    </div>
    <div class="col-auto">
      <button class="btn btn-primary" type="submit">Search</button>
    </div>
  </form>
  <p>{{ count($model->results) }} book(s) found.</p>
  <ul>
    @foreach ($model->results as $book)
      <li><i>{{ $book->title }}</i>, {{ $book->author }} ({{ $book->genre }})</li>
    @endforeach
  </ul>
@endsection
  • Zeile 6: das Tag [<form>]. Das Attribut [action] ist die URL, an die das Formular gesendet wird; [method="get"] legt die Felder in die URL. Die Klassen von [Bootstrap] ordnen die Felder in einer einzigen Zeile an;
  • Zeile 8: ein Label. Sein Attribut [for] gibt den Bezeichner ([id]) des Felds an, das es beschreibt: Ein Klick auf das Label setzt den Cursor in das Feld, und Screenreader lesen das Label zusammen mit dem Feld vor;
  • Zeile 10: ein Eingabefeld. Sein Attribut [name] ist der Name des Parameters, der an den Server gesendet wird: Das ist die Verbindung zwischen dem Formular und der Aktion ([$request->string('keyword')]). Das Attribut [value] ist der angezeigte Wert: die vorherige Eingabe, erneut angezeigt (und maskiert durch [{{ }}], was in einem Attribut unerlässlich ist: Eine Eingabe, die ein Anführungszeichen ["] enthält, würde andernfalls das Attribut schließen);
  • Zeilen 14–20: eine Dropdown-Liste. Jede [<option>] hat einen Wert ([value]), der an den Server gesendet wird, und einen angezeigten Text. Die erste Option mit leerem Wert bedeutet „alle Genres“;
  • Zeile 18: Der in der vorherigen Anfrage ausgewählten Option wird das Attribut [selected] zugewiesen. Es ist ein boolesches Attribut: Seine bloße Anwesenheit genügt; es hat keinen Wert. Die Direktive [@selected(condition)] setzt es, wenn die Bedingung wahr ist, andernfalls setzt sie nichts. Ebenso gibt es [@checked], [@disabled], [@readonly], und [@required];
  • Zeile 23: der Submit-Button;
  • Zeile 26: die Anzahl der Ergebnisse.

4.5.4. Ausführung

Image

Geben Sie [le] ein und wählen Sie den Typ [novel]:

Image

Die URL der Ergebnisseite enthält die Formularfelder: [/search?keyword=le&genre=novel]. Die Antwort auf das Formular:

curl "http://localhost:8000/search?keyword=le&genre=novel"
...
  <form method="get" action="/search" class="row g-2 align-items-end mb-3">
    <div class="col-auto">
      <label class="form-label" for="keyword">Title or author</label>
      <input class="form-control" id="keyword" name="keyword" value="le">
    </div>
    <div class="col-auto">
      <label class="form-label" for="genre">Genre</label>
      <select class="form-select" id="genre" name="genre">
        <option value="">(all)</option>
          <option value="novel" selected>novel</option>
          <option value="poetry" >poetry</option>
          <option value="drama" >drama</option>
              </select>
    </div>
...
  </form>
  <p>1 book(s) found.</p>
  <ul>
          <li><i>Le Rouge et le Noir</i>, Stendhal (novel)</li>
      </ul>
...

„Madame Bovary“ wird nicht ausgewählt: „le“ kommt weder im Titel noch im Namen des Autors vor.

4.6. Beispiel 18: Formularfelder

Dieses Beispiel stellt alle Feldtypen eines HTML-Formulars vor, das hier per POST gesendet wird. Es zeigt, wie sich jeder Feldtyp mit seinem aktuellen Wert erneut anzeigen lässt, wie der Browser die Werte jedes Felds sendet und wie der Server prüft, dass ein empfangener Wert tatsächlich eine der verfügbaren Optionen ist. [Laravel] hat keine Bibliothek, die Formulare mithilfe von Klassen definiert (wie [WTForms] in [Python]): Die Felder werden in der View in HTML geschrieben, und die Direktiven von [Blade] ([@checked], [@selected] ...) helfen bei ihrer Darstellung.

4.6.1. Der Listen-Service: app/Services/ListsService.php

<?php
// app/Services/ListsService.php: die vom Formular angebotenen Listen. In einer
// realen Anwendung kämen sie aus einer Datenbank.

namespace App\Services;

class ListsService
{
    // jede Liste: ein assoziatives Array, gesendeter Wert => angezeigter Text
    public function titles(): array
    {
        return ['Mr' => 'Mr', 'Mme' => 'Mme', 'Melle' => 'Melle'];
    }

    public function countries(): array
    {
        return ['fr' => 'France', 'be' => 'Belgium', 'ch' => 'Switzerland', 'ca' => 'Canada'];
    }

    public function hobbies(): array
    {
        return ['reading' => 'reading', 'music' => 'music', 'sport' => 'sport',
            'cinema' => 'cinema'];
    }

    public function languages(): array
    {
        return ['French' => 'French', 'English' => 'English', 'Spanish' => 'Spanish',
            'German' => 'German'];
    }
}

Die Dropdown-Listen des Formulars (Anreden, Länder, Hobbys, Sprachen) werden von einem Service bereitgestellt, nach dem Muster aus Beispiel 06: In einer realen Anwendung kämen sie aus einer Datenbank. Jede Liste ist ein assoziatives Array: Der Schlüssel ist der an den Server gesendete Wert, und der Wert ist der angezeigte Text. Der Service ist eine konkrete Klasse: Der Container von [Laravel] weiß, wie er sie ohne Deklaration erzeugt (Beispiel 06).

4.6.2. Der Controller: app/Http/Controllers/FormController.php

<?php
// app/Http/Controllers/FormController.php: ein Formular, das alle Feldtypen verwendet

namespace App\Http\Controllers;

use App\Services\ListsService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
use Illuminate\View\View;

class FormController
{
    // der Listen-Service wird vom Container injiziert (siehe Beispiel 06)
    public function __construct(private ListsService $lists)
    {
    }

    // GET: das Formular mit Anfangswerten (einer pro Feld)
    public function display(): View
    {
        $input = ['title' => 'Mme', 'country' => 'fr', 'languages' => ['French'], 'token' => 'A7X2'];
        return view('form.form', ['lists' => $this->lists, 'input' => $input]);
    }

    // POST: die gesendeten Felder werden validiert und dann vom Formular erneut angezeigt
    public function process(Request $request): View
    {
        $l = $this->lists;
        // array_keys: die erlaubten WERTE jeder Liste (die Schlüssel der Arrays)
        $validator = Validator::make($request->post(), [
            'title' => ['required', Rule::in(array_keys($l->titles()))],
            'birth_date' => 'nullable|date_format:Y-m-d',
            'hobbies' => 'array',
            'hobbies.*' => Rule::in(array_keys($l->hobbies())),
            'country' => ['required', Rule::in(array_keys($l->countries()))],
            'languages' => 'array',
            'languages.*' => Rule::in(array_keys($l->languages())),
        ]);
        // was der Browser tatsächlich gesendet hat, Parameter für Parameter
        $received = [];
        foreach ($request->post() as $name => $value) {
            $received[] = "$name = [".implode(', ', (array) $value).']';
        }
        return view('form.form', [
            'lists' => $l,
            'input' => $request->post(),
            'received' => implode("\n", $received),
            'valid' => $validator->passes(),
            'errors' => $validator->errors(),
        ]);
    }
}
  • Zeile 15: Der Service wird über den Konstruktor injiziert;
  • Zeilen 20–23: die anfänglichen Formularwerte, ein assoziatives Array: ein Wert pro Feld (ein Array bei einem Feld mit mehreren Werten). Die View erhält diese Werte in der Variablen [$input] zusammen mit dem Listen-Service;
  • Zeilen 31–39: Die empfangenen Felder werden validiert. Dropdown-Felder müssen einen der vorgeschlagenen Werte enthalten: Ein böswilliger Benutzer könnte beliebige Werte senden, nicht nur das, was die Seite vorgeschlagen hat. [Rule::in(...)] erzeugt die Regel [in] (Beispiel 08) aus einem Array von Werten – hier den Schlüsseln der Liste ([array_keys]). Felder mit mehreren Werten werden Element für Element geprüft ([hobbies.*], Beispiel 10). [date_format:Y-m-d]: Ein Feld [<input type="date">] tauscht seine Werte mit dem Server im Format [yyyy-mm-dd] aus, unabhängig vom Format, in dem der Browser es anzeigt;
  • Zeilen 41–44: für das Beispiel die Liste dessen, was der Browser tatsächlich gesendet hat. [(array) $value] wandelt einen einzelnen Wert in ein Array mit einem Element um (ein Array bleibt ein Array); [implode] verbindet die Elemente eines Arrays zu einer Zeichenkette, getrennt durch den ersten Parameter;
  • Zeilen 45–51: Das Formular wird mit den empfangenen Werten erneut angezeigt ([$input]), außerdem das, was der Server empfangen hat, das Validierungsergebnis ([passes()], das Gegenteil von [fails()]) und eventuelle Fehler.

Die Routing-Tabelle ordnet der URL [/form] für die Methode GET die Aktion [display] und für die Methode POST die Aktion [process] zu.

4.6.3. Die View: resources/views/form/form.blade.php

@extends('layout')

@section('content')
  <h1 class="h3">A complete form</h1>
  <form method="post" action="/form" style="max-width: 40rem">
    {{-- the hidden fields: Laravel's anti-CSRF token, and our [token] field --}}
    @csrf
    <input type="hidden" name="token" value="{{ $input['token'] ?? '' }}">

    <div class="mb-2">
      <span class="form-label me-3">Title</span>
      {{-- radio buttons: same [name], a single value sent --}}
      @foreach ($lists->titles() as $value => $text)
        <div class="form-check form-check-inline">
          <input class="form-check-input" type="radio" id="title-{{ $loop->index }}" name="title"
                 value="{{ $value }}" @checked(($input['title'] ?? '') === $value)>
          <label class="form-check-label" for="title-{{ $loop->index }}">{{ $text }}</label>
        </div>
      @endforeach
    </div>

    <div class="row g-2 mb-2">
      <div class="col">
        <label class="form-label" for="name">Name</label>
        <input class="form-control" type="text" id="name" name="name" value="{{ $input['name'] ?? '' }}">
      </div>
      <div class="col">
        {{-- a password is NEVER sent back in the page: no value attribute --}}
        <label class="form-label" for="password">Password</label>
        <input class="form-control" type="password" id="password" name="password">
      </div>
      <div class="col">
        <label class="form-label" for="birth_date">Date of birth</label>
        <input class="form-control" type="date" id="birth_date" name="birth_date" value="{{ $input['birth_date'] ?? '' }}">
      </div>
    </div>

    <div class="mb-2">
      <span class="form-label me-3">Hobbies</span>
      {{-- checkboxes: the hobbies[] name makes the received value an ARRAY (see example 10) --}}
      @foreach ($lists->hobbies() as $value => $text)
        <div class="form-check form-check-inline">
          <input class="form-check-input" type="checkbox" id="hobbies-{{ $loop->index }}" name="hobbies[]"
                 value="{{ $value }}" @checked(in_array($value, $input['hobbies'] ?? []))>
          <label class="form-check-label" for="hobbies-{{ $loop->index }}">{{ $text }}</label>
        </div>
      @endforeach
    </div>

    <div class="row g-2 mb-2">
      <div class="col">
        <label class="form-label" for="country">Country</label>
        <select class="form-select" id="country" name="country">
          @foreach ($lists->countries() as $value => $text)
            <option value="{{ $value }}" @selected(($input['country'] ?? '') === $value)>{{ $text }}</option>
          @endforeach
        </select>
      </div>
      <div class="col">
        <label class="form-label" for="languages">Spoken languages</label>
        {{-- multiple-selection list: several possible values, hence languages[] --}}
        <select class="form-select" id="languages" name="languages[]" multiple size="4">
          @foreach ($lists->languages() as $value => $text)
            <option value="{{ $value }}" @selected(in_array($value, $input['languages'] ?? []))>{{ $text }}</option>
          @endforeach
        </select>
      </div>
    </div>

    <div class="mb-2">
      <label class="form-label" for="comment">Comment</label>
      {{-- a text area: the value is BETWEEN the tags --}}
      <textarea class="form-control" id="comment" name="comment" rows="2">{{ $input['comment'] ?? '' }}</textarea>
    </div>

    <button class="btn btn-primary" type="submit">Send</button>
  </form>

  {{-- isset: true if the $received variable was passed to the view (by the POST action) --}}
  @isset($received)
    <h2 class="h5 mt-3">What the server received</h2>
    <pre class="bg-light p-2 border">{{ $received }}</pre>
    <p>Valid form: {{ $valid ? 'yes' : 'no' }}</p>
    {{-- $errors->messages(): field -> list of its error messages --}}
    <ul>
      @foreach ($errors->messages() as $field => $messages)
        <li>{{ $field }}: {{ implode(', ', $messages) }}</li>
      @endforeach
    </ul>
  @endisset
@endsection
  • Zeile 5: ein Formular mit der Methode POST;
  • Zeile 7: Die Direktive [@csrf] schreibt ein verstecktes Feld namens [_token], das das Anti-CSRF-Token enthält. Bei einem CSRF-Angriff (*Cross-Site Request Forgery*) bringt eine bösartige Website den Browser des Opfers dazu, ein Formular an unsere Anwendung zu senden. Der Browser fügt die Cookies unserer Anwendung in die Anfrage ein – und damit die Session des angemeldeten Benutzers –, wodurch die Anfrage legitim erscheint. Die Abwehr: Jedes Formular unserer Anwendung enthält ein zufälliges, an die Session des Benutzers gebundenes Token, das die bösartige Website nicht kennen kann. Die Middleware [PreventRequestForgery] in der Gruppe [web] (Beispiel 01) weist jede POST-Anfrage (ebenso PUT, PATCH und DELETE) zurück, deren Token fehlt oder ungültig ist, noch bevor die Aktion aufgerufen wird: Keine Aktion kann sie umgehen. Das ist die Middleware, die die Beispiele 02 und 11 für ihre [curl]-Anfragen ausgeschlossen haben;
  • Zeile 8: unser eigenes verstecktes Feld;
  • Zeilen 13–19: eine Gruppe von Optionsfeldern (Radiobuttons), eines pro Anrede. Alle haben dasselbe Attribut [name]: Es ist immer nur eines ausgewählt, und es wird nur ein Wert gesendet. Jeder Button hat seinen eigenen Bezeichner ([title-0], [title-1] ...), erzeugt mit [$loop->index], auf den sich sein Label bezieht. Die Direktive [@checked] aktiviert den Button, dessen Wert der aktuellen Anrede entspricht;
  • Zeile 25: das Eingabefeld für den Namen; [?? ''] behandelt den Fall, dass ein Name nicht im Array enthalten ist;
  • Zeile 30: Ein Passwort sollte niemals in einer HTML-Seite hin- und hergeschickt werden: Das Feld hat kein Attribut [value]; es ist bei der Anzeige immer leer;
  • Zeilen 41–47: Kontrollkästchen (Checkboxen), im Stil von Radiobuttons gestaltet. Auch sie haben denselben Namen; es können jedoch mehrere Kontrollkästchen ausgewählt werden, und der Browser sendet dann mehrere Werte: Der Name [hobbies[]] weist [PHP] an, sie in einem Array zu organisieren (Beispiel 10). Die Funktion [in_array] prüft, ob ein Wert in einem Array vorhanden ist;
  • Zeilen 53–57: eine Dropdown-Liste, deren aktuelle Option mit [@selected] markiert wird;
  • Zeile 62: eine Mehrfachauswahlliste (Attribut [multiple]), die über vier Zeilen angezeigt wird ([size]) und deren Name ebenfalls auf [[]] endet;
  • Zeile 73: ein Textfeld über zwei Zeilen. Sein Wert wird zwischen seinen Tags eingegeben, nicht in einem Attribut;
  • Zeilen 80–90: Die Direktive [@isset] prüft, ob eine Variable existiert: [$received] wurde der View nur von der POST-Aktion übergeben. [$errors->messages()] liefert für jedes ungültige Feld eine Liste seiner Fehlermeldungen (Beispiel 09).

4.6.4. Ausführung

Image

Die Standardwerte sind sichtbar: der Radiobutton „Mme“, das Land „France“ und die Sprache „French“. Das erzeugte HTML (Auszüge):

<input type="hidden" name="_token" value="mjFN6z3WBF79ZEA8EWgmoX3Hio8DjjmG7hGQlGax" autocomplete="off">
<input type="hidden" name="token" value="A7X2">
...
<input class="form-check-input" type="radio" id="title-1" name="title"
       value="Mme" checked>
<label class="form-check-label" for="title-1">Mme</label>
...
<input class="form-control" type="date" id="birth_date" name="birth_date" value="">
...
<input class="form-check-input" type="checkbox" id="hobbies-0" name="hobbies[]"
       value="reading" >
<label class="form-check-label" for="hobbies-0">reading</label>
...
<select class="form-select" id="country" name="country">
  <option value="fr" selected>France</option>
  <option value="be" >Belgium</option>
...
<select class="form-select" id="languages" name="languages[]" multiple size="4">
  <option value="French" selected>French</option>
...
<textarea class="form-control" id="comment" name="comment" rows="2"></textarea>

Das Anti-CSRF-Token ist eine zufällige Zeichenkette aus 40 Zeichen, die in der Session des Benutzers gespeichert wird (Beispiel 20). Füllen wir das Formular aus und senden es ab:

Image

Die Seite zeigt, was der Server empfangen hat: ein Parameter pro Feld, mit mehreren Werten bei den Kontrollkästchen und der Dropdown-Liste; das Passwort wurde gesendet, wird aber in seinem Feld nicht erneut angezeigt. Das versteckte Feld [token] wurde genau so zurückgegeben, wie es war: So lassen sich Informationen senden und empfangen, die der Benutzer nicht sieht (die Fallstudie verwendet dies für die Versionsnummer eines Datensatzes). Ein verstecktes Feld ist jedoch kein geschütztes Feld: Der Benutzer kann es mit den Entwicklerwerkzeugen seines Browsers ändern, und der Server muss es wie jedes andere Feld validieren. Außerdem fällt auf, dass sich das Anti-CSRF-Token ([_token]) unter den empfangenen Feldern befindet.

Senden wir nun mit [curl] ein Formular ohne Token ab:

curl -i -d "name=Martin&country=xx" http://localhost:8000/form
1
2
3
4
5
6
7
8
HTTP/1.1 419 unknown status
Content-Type: text/html; charset=utf-8

<!DOCTYPE html>
<html lang="en">
...
        <title>Page Expired</title>
...

Die Anfrage wird von der Middleware [PreventRequestForgery] mit dem Statuscode 419 zurückgewiesen, der für [Laravel] spezifisch ist (*Page Expired*: So lautet die Meldung, die ein Benutzer sieht, dessen Session zwischen der Anzeige und dem Absenden des Formulars abgelaufen ist). Um das zu beheben, [curl] muss sich wie ein Browser verhalten: zuerst das Formular anfordern und dabei das Session-Cookie behalten (Option [-c], die empfangene Cookies in einer Datei speichert), dann das Cookie (Option [-b]) und das aus der Seite gelesene Token erneut senden:

curl -c cookies.txt http://localhost:8000/form
curl -b cookies.txt -d "_token=WkdoQuahsZxMScUg5UJ5UOwWN4nDF8l3Niyce9WK&name=Martin&country=xx" http://localhost:8000/form
...
      <h2 class="h5 mt-3">What the server received</h2>
    <pre class="bg-light p-2 border">_token = [WkdoQuahsZxMScUg5UJ5UOwWN4nDF8l3Niyce9WK]
name = [Martin]
country = [xx]</pre>
    <p>Valid form: no</p>
    <ul>
              <li>title: The title field is required.</li>
              <li>country: The selected country is invalid.</li>
          </ul>
...

(Das Token stammt aus der Seite, die der erste Befehl empfangen hat.) Zwei Fehler: Das Land [xx] gehört nicht zu den Optionen; es wurde keine Anrede gesendet. Die Meldungen sind die Standardmeldungen von Laravel: Das folgende Beispiel passt sie an.

4.7. Beispiel 19: Formularvalidierung

Ein Registrierungsformular, bei dem jedes Feld eigene Validierungsregeln hat. Tritt ein Fehler auf, wird das Formular mit der Eingabe des Benutzers und einer Meldung unter jedem ungültigen Feld erneut angezeigt. Dieses Beispiel verwendet den Standardweg von [Laravel]: Ein Form Request (Beispiel 08) validiert die Felder vor der Aktion; tritt ein Fehler auf, leitet [Laravel] auf die Formularseite um und bewahrt die Eingabe des Benutzers und die Fehler für die nächste Anfrage auf.

4.7.1. Das Formular: app/Http/Requests/RegistrationRequest.php

<?php
// app/Http/Requests/RegistrationRequest.php: die Felder des Formulars und ihre Einschränkungen

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class RegistrationRequest extends FormRequest
{
    // die Regeln jedes Feldes. Die Leerzeichen um die Eingabe wurden bereits
    // von der Middleware TrimStrings entfernt, und eine leere Eingabe durch null ersetzt
    public function rules(): array
    {
        return [
            'name' => 'required|max:20',
            // email:filter: die Prüfung der PHP-Funktion filter_var, die
            // einen vollständigen Domainnamen verlangt (example.com und nicht example)
            'email' => 'required|email:filter',
            'age' => 'required|integer|between:18,120',
            'password' => 'required|min:6',
            // eine Regel über ZWEI Felder: same vergleicht dieses Feld mit einem anderen
            'confirmation' => 'required|same:password',
        ];
    }

    // die Fehlermeldungen, Feld.Regel => Meldung
    public function messages(): array
    {
        return [
            'name.required' => 'The name is required.',
            'name.max' => 'The name must not exceed 20 characters.',
            'email.required' => 'The email address is required.',
            'email.email' => 'Invalid email address.',
            'age.required' => 'The age is required.',
            'age.between' => 'The age must be between 18 and 120 years.',
            'password.required' => 'The password is required.',
            'password.min' => 'The password must have at least 6 characters.',
            'confirmation.required' => 'The confirmation is required.',
            'confirmation.same' => 'The confirmation does not match the password.',
        ];
    }
}
  • Zeilen 12–23: die Validierungsregeln für jedes Feld (Beispiel 08). Die die Eingabe umgebenden Leerzeichen wurden bereits von der Middleware [TrimStrings] entfernt (Beispiel 08): Ein Name, der aus Leerzeichen besteht, wird zu einer leeren Zeichenkette, dann zu [null] und von [required] abgelehnt;
  • Zeile 18: Die Regel [email] akzeptiert Varianten, die bestimmen, welche Validierung angewendet wird. Standardmäßig folgt sie dem Standard für E-Mail-Adressen, der [martin@example] (einen Hostnamen ohne Domain) akzeptiert. [email:filter] verwendet die Funktion [filter_var] von [PHP] (Beispiel 07), die einen vollständig qualifizierten Domainnamen verlangt ([example.com]);
  • Zeile 19: [integer] gefolgt von [between:18,120];
  • Zeile 22: eine Regel, die auf zwei Felder wirkt: [same:password] vergleicht den Wert eines Felds mit dem eines anderen Felds. [Laravel] bietet außerdem die Regel [confirmed], die, auf das Feld [password] angewendet, ein Feld namens [password_confirmation] verlangen würde;
  • Zeilen 27–40: Die Methode [messages] liefert Meldungen, die für dieses Formular spezifisch sind. Jeder Schlüssel bezeichnet ein Feld und eine Regel ([name.required]); ein einzelner Schlüssel wie [required] würde für alle Felder gelten. Diese Meldungen haben Vorrang vor denen in den Sprachdateien (Beispiel 09).

Meldungen, die die Klasse nicht liefert, stammen aus der Datei [lang/en/validation.php] (die Datei [.env] legt die Sprache auf [en] fest; siehe Beispiel 09):

1
2
3
4
5
6
<?php
// lang/en/validation.php: die Meldungen, die die Klasse RegistrationRequest nicht
// selbst liefert
return [
    'integer' => 'An integer is expected.',
];

Das ist der Fall bei der Meldung der Regel [integer], die nur angezeigt wird, wenn im Altersfeld etwas anderes als eine Zahl eingegeben wird – was ein Browser nicht tut (wir werden das mit [curl] sehen).

4.7.2. Der Controller: app/Http/Controllers/RegistrationController.php

<?php
// app/Http/Controllers/RegistrationController.php: ein vom Server validiertes Formular

namespace App\Http\Controllers;

use App\Http\Requests\RegistrationRequest;
use Illuminate\Http\Request;
use Illuminate\View\View;

class RegistrationController
{
    // GET /register: das Formular; ?html5=true: wir lassen den Browser es
    // vor dem Senden validieren
    public function display(Request $request): View
    {
        return view('registration.registration', ['html5' => $request->query('html5') === 'true']);
    }

    // POST /register: die Action wird nur aufgerufen, wenn das Formular GÜLTIG ist.
    // Andernfalls leitet Laravel auf die Seite des Formulars UM und behält die Eingabe und
    // die Fehler für die nächste Anfrage (siehe old und @error in den Views)
    public function register(RegistrationRequest $request): View
    {
        return view('registration.welcome', ['registration' => $request->validated()]);
    }
}
  • Zeilen 14–17: die Anzeige des Formulars. Der Parameter [?html5=true] aktiviert die Browser-Validierung (siehe unten);
  • Zeilen 22–25: Die Aktion akzeptiert nur gültige Formulare: Der Form Request [RegistrationRequest] wurde vor ihrem Aufruf validiert (Beispiel 08). Sie zeigt die Willkommensseite mit den validierten Daten an. (Das folgende Beispiel wird zeigen, dass es besser ist, nach einem erfolgreichen POST umzuleiten.)

Was ist mit einem ungültigen Formular? Es erreicht die Aktion nie. Der Form Request löst eine [ValidationException] aus (Beispiel 08), die [Laravel] bei einer Anfrage aus einem Browser wie folgt behandelt: Es speichert die Fehler und die eingegebenen Werte (außer Passwörtern) in der Session des Benutzers und antwortet dann mit einer Weiterleitung auf die vorherige Seite – die Formularseite. Der Browser fordert diese Seite sofort erneut an (per GET), und die Formular-View ruft die Fehler und die Benutzereingaben ab, die die Session nur einmal bereitstellt (diesen Mechanismus der „Flash“-Daten sehen wir im nächsten Beispiel). Das Formular wird also über seine GET-Aktion erneut angezeigt und nicht über die POST-Aktion: Das ist bereits das Post/Redirect/Get-Muster des folgenden Beispiels, angewendet auf Fehler.

4.7.3. Ein wiederverwendbares Feld: resources/views/components/field.blade.php

Jedes Feld wird auf dieselbe Weise angezeigt: ein Label, das Eingabefeld und, im Fehlerfall, der rot umrandete Bereich und die Meldung darunter. Eine Komponente erspart es, dies fünfmal zu schreiben:

{{-- an input field, with its label and its FIRST error message.
     old($name): the previous input, kept by Laravel after an invalid
     form; $attributes: the other attributes given to the component (required,
     min, max...), copied onto the input tag --}}
@props(['name', 'label', 'type' => 'text'])
<div class="mb-2">
  <label class="form-label" for="{{ $name }}">{{ $label }}</label>
  <input {{ $attributes->class(['form-control', 'is-invalid' => $errors->has($name)]) }}
         type="{{ $type }}" id="{{ $name }}" name="{{ $name }}"
         @if ($type !== 'password') value="{{ old($name) }}" @endif>
  {{-- @error: the block is displayed only if the field has an error, whose
       first message is in the $message variable --}}
  @error($name)
    <div class="invalid-feedback">{{ $message }}</div>
  @enderror
</div>
  • Zeile 5: die Parameter der Komponente: der Feldname, sein Label und sein Typ, standardmäßig [text] ;
  • Zeile 8: Die Variable [$attributes] enthält die der Komponente zugewiesenen Attribute, die keine von [@props] deklarierten Parameter sind (hier [required], [min], [max] ...): Im Tag geschrieben, kopiert sie diese. Ihre Methode [class] fügt ihr das Attribut [class] hinzu, ähnlich der Direktive [@class] (Beispiel 16): Die Klasse [is-invalid] von [Bootstrap] umrandet das Feld rot, wenn es einen Fehler enthält. Die Variable [$errors] steht in allen Views zur Verfügung: Sie ist ein „Behälter“ für Meldungen (Beispiel 09) – mit den in der Session gespeicherten Fehlern des vorherigen Formulars – oder ein leerer Behälter; [has] prüft, ob ein Feld Fehler hat;
  • Zeile 10: Die Funktion [old] liefert den im vorherigen Formular eingegebenen Wert, der in der Session gespeichert ist, oder [null]. Ein Feld vom Typ [password] hat nicht das Attribut [value] (Beispiel 18);
  • Zeilen 13–15: Der Block [@error] ... [@enderror] wird nur angezeigt, wenn das Feld einen Fehler enthält; in diesem Fall wird seine erste Meldung in der Variablen [$message] abgelegt. Das Element [invalid-feedback] wird von [Bootstrap] rot dargestellt, unterhalb eines mit [is-invalid] gekennzeichneten Bereichs.

4.7.4. Die Views

@extends('layout')

@section('content')
  <h1 class="h3">Registration</h1>
  @if ($html5)
    <p>Browser validation <b>enabled</b> - <a href="/register">disable it</a></p>
  @else
    <p>Browser validation <b>disabled</b> - <a href="/register?html5=true">enable it</a></p>
  @endif
  {{-- novalidate: the browser ignores the required, min... attributes and
       sends the form as is; only the server validates --}}
  <form method="post" action="/register" @if (! $html5) novalidate @endif>
    @csrf
    <x-field name="name" label="Name" required maxlength="20" />
    <x-field name="email" label="Email address" type="email" required />
    <x-field name="age" label="Age" type="number" required min="18" max="120" />
    <x-field name="password" label="Password" type="password" required minlength="6" />
    <x-field name="confirmation" label="Confirmation" type="password" required />
    <button class="btn btn-primary" type="submit">Register</button>
  </form>
@endsection
  • Zeile 12: Das Attribut [novalidate] deaktiviert die Browser-Validierung: Das Formular wird unverändert gesendet, und nur der Server validiert es. Genau das wollen wir zunächst beobachten;
  • Zeilen 14–18: eine Komponente pro Feld. Die HTML5-Attribute ([required], [maxlength], [min], [max], [minlength], [type="email"]) ermöglichen es dem Browser, die Eingabe schon vor dem Absenden zu prüfen (dazu später mehr). [Laravel] leitet diese nicht aus den Validierungsregeln ab: Sie werden in der View geschrieben und müssen mit den Regeln konsistent bleiben.
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Registration</title>
  <link rel="stylesheet" href="{{ route('bootstrap', 'css/bootstrap.min.css') }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">
    <main>
      @yield('content')
    </main>
    {{-- the global error, at the bottom of the page, on a light pink background. $errors: the errors
         of the previous form, available in all the views --}}
    @if ($errors->any())
      <div class="error-area" role="alert">The form contains errors.</div>
    @endif
  </div>
</body>
</html>
  • Zeilen 16–18: eine allgemeine Meldung am Seitenende, wenn das vorherige Formular Fehler enthielt ([any()] prüft, ob der Behälter mindestens eine Meldung enthält), in einem Bereich, dessen Stil in [public/css/styles.css] definiert ist (Beispiel 15). Das Attribut [role="alert"] kennzeichnet dies für Screenreader.
1
2
3
4
5
6
7
8
@extends('layout')

@section('content')
  {{-- $registration: the validated data --}}
  <h1 class="h3">Welcome {{ $registration['name'] }}</h1>
  <p>Your registration is saved: address <b>{{ $registration['email'] }}</b>,
    age <b>{{ $registration['age'] }}</b> years.</p>
@endsection

[$registration] enthält die validierten Daten: den Namen ohne Leerzeichen, das Alter (eine Zeichenkette; siehe Beispiel 08).

4.7.5. Ausführung

Senden wir ein Formular voller Fehler ab: ein Name aus Leerzeichen, eine E-Mail-Adresse ohne vollständige Domain, ein Alter von 12, ein zu kurzes Passwort und eine abweichende Bestätigung:

Image

Die Eingabe wurde bewahrt (außer den Passwörtern), und jeder Fehler wird unter dem zugehörigen Feld angezeigt. Die URL ist die des Formulars, und [/register] zeigt an, dass die Seite nach der Weiterleitung von der GET-Aktion angezeigt wurde. Mit [curl] sehen wir diese Weiterleitung, wenn wir wie in Beispiel 18 das Anti-CSRF-Token mitsenden:

curl -i -b cookies.txt -c cookies.txt -d "_token=...&name=Martin&email=martin@example.com&age=abc&password=abcdef&confirmation=abcdef" http://localhost:8000/register
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/register
Content-Type: text/html; charset=utf-8
...

Sie können auch etwas senden, was ein Browser nicht senden würde, etwa ein nicht numerisches Alter. Die folgende Seite ([curl -b cookies.txt http://localhost:8000/register]) zeigt das Altersfeld mit seiner Eingabe und der Meldung der Regel [integer], die der Sprachdatei entnommen ist:

1
2
3
4
  <input class="form-control is-invalid" required="required" min="18" max="120"
         type="number" id="age" name="age"
          value="abc" >
      <div class="invalid-feedback">An integer is expected.</div>

Wir sehen außerdem die von [$attributes] kopierten HTML5-Attribute: [required] (geschrieben als [required="required"], eine gleichwertige Form), [min], [max].

4.7.6. Browser-Validierung

Entfernen wir das Attribut [novalidate], indem wir dem Link „Enable“ folgen (Parameter [?html5=true]). Der Browser prüft dann die Attribute [required], [type="email"], [min], [maxlength] ... vor dem Absenden des Formulars und zeigt in einem Tooltip unter dem ersten ungültigen Feld seine eigenen Meldungen an („Bitte füllen Sie dieses Feld aus“, „Der Wert muss größer oder gleich 18 sein“ usw.): Das Formular wird nicht abgesendet, solange ein Fehler vorliegt.

Diese Validierung ist für den Benutzer bequem: Sie erfolgt sofort, ohne Hin und Her mit dem Server. Aber sie ersetzt nicht die serverseitige Validierung: Ein Benutzer kann sie deaktivieren, und ein Programm wie [curl] ignoriert sie vollständig. Die Regel gilt uneingeschränkt: Der Server validiert immer; die Validierung im Browser ist lediglich ein zusätzlicher Komfort.

Endlich eine korrekte Eingabe. Der Name, der mit Leerzeichen davor und danach eingegeben wurde, wurde von der Middleware [TrimStrings] bereinigt:

Image

4.8. Beispiel 20: Das Post/Redirect/Get-Muster

Wenn eine POST-Aktion eine Seite zurückgibt, ist diese Seite das Ergebnis eines POST. Aktualisiert der Benutzer die Seite (durch Drücken von [F5]), sendet der Browser die POST-Anfrage erneut, nach einer Warnung, die nur wenige lesen: Der Befehl wird zweimal gesendet, und die Nachricht wird zweimal gepostet. Das Post/Redirect/Get-Muster (PRG) vermeidet dieses Problem: Eine erfolgreiche POST-Aktion gibt keine Seite zurück, sondern antwortet mit einer Weiterleitung (Beispiel 04) auf eine GET-Seite, die der Browser sofort anfordert. Das Neuladen dieser Seite führt lediglich die GET-Aktion erneut aus.

Ein Problem bleibt: Die GET-Seite möchte eine Meldung anzeigen („Die Aufgabe wurde hinzugefügt“), aber diese Meldung kennt die POST-Aktion, und sie kann keine Variable an eine Anfrage übergeben, die noch nicht stattgefunden hat. Die Lösung: die Flash-Meldung, die von der POST-Aktion in der Session gespeichert, bis zur nächsten Anfrage aufbewahrt, angezeigt und dann verworfen wird. Das ist der Mechanismus, den [Laravel] in Beispiel 19 bereits für Formularfehler verwendet hat.

4.8.1. Der Service: app/Services/TasksService.php

<?php
// app/Services/TasksService.php: die Liste der Aufgaben, von allen
// Benutzern gemeinsam genutzt. In PHP überleben Objekte die Anfrage nicht: die Liste wird
// im CACHE von Laravel gespeichert (hier eine Datei im Ordner storage/framework/cache)

namespace App\Services;

use Illuminate\Support\Facades\Cache;

class TasksService
{
    private const KEY = 'tasks';

    /** @return list<string> */
    public function list(): array
    {
        // der unter dem Schlüssel [tasks] gespeicherte Wert oder die Anfangsliste
        return Cache::get(self::KEY, ['Read chapter 3']);
    }

    public function add(string $label): void
    {
        // mehrere Anfragen können GLEICHZEITIG laufen (der Server bearbeitet
        // sie in mehreren Prozessen): eine Sperre garantiert, dass immer nur eine
        // die Liste liest, ändert und zurückschreibt. block(5, ...) wartet höchstens 5
        // Sekunden auf die Sperre, führt die Funktion aus und gibt die Sperre dann frei
        Cache::lock('tasks-lock', 10)->block(5, function () use ($label) {
            $tasks = $this->list();
            $tasks[] = $label;
            // forever: der Wert wird ohne zeitliche Begrenzung aufbewahrt
            Cache::forever(self::KEY, $tasks);
        });
    }
}

Die Aufgabenliste wird von allen Benutzern gemeinsam genutzt und muss von einer Anfrage zur nächsten bestehen bleiben. In [Java], [C#] oder [Python] würde sie in einem einzigen Service im Speicher gehalten. In [PHP] ist das unmöglich: Wie wir in den Beispielen 01 und 06 gesehen haben, überlebt nichts die Anfrage. Die Liste muss daher außerhalb von [PHP] gespeichert werden: in einer Datenbank, einer Datei ... oder im Cache von [Laravel], den wir hier verwenden.

  • Zeile 18: Die Schnittstelle [Cache] bietet Zugriff auf den Cache der Anwendung: einen Speicher für Schlüssel→Wert-Paare. Die Datei [.env] der Beispiele speichert diese Daten in Dateien im Ordner [storage/framework/cache] ([CACHE_STORE=file], Beispiel 01); in der Produktion wird ein dedizierter Server wie [Redis] bevorzugt. [get] liefert den unter einem Schlüssel gespeicherten Wert oder den als zweiten Parameter angegebenen Standardwert. Es kann jeder Wert gespeichert werden (hier ein Array von Zeichenketten): [Laravel] serialisiert ihn – das heißt, es wandelt ihn in Text um – mit der Funktion [serialize] von [PHP];
  • Zeilen 27–32: Der Entwicklungsserver kann wie ein Produktionsserver mehrere Anfragen gleichzeitig in mehreren Prozessen verarbeiten (die Umgebungsvariable [PHP_CLI_SERVER_WORKERS] legt die Anzahl der Prozesse für [php artisan serve] fest). Zwei gleichzeitige Einfügungen könnten dieselbe Liste lesen, jeweils ihre eigene Aufgabe hinzufügen und sie dann zurückschreiben: Der zweite Schreibvorgang würde die erste Aufgabe überschreiben. Eine Sperre (Lock) stellt sicher, dass immer nur eine Anfrage den von ihr geschützten Code ausführt: [Cache::lock('tasks-lock', 10)] erzeugt eine benannte Sperre – die ebenfalls im Cache gespeichert wird –, die nach spätestens 10 Sekunden abläuft (falls die Anfrage, die sie hält, abrupt beendet würde); [block(5, function)] wartet bis zu 5 Sekunden darauf, dass die Sperre verfügbar wird, erwirbt sie, führt die Funktion aus und gibt sie dann frei. Das Schlüsselwort [use] in einer anonymen Funktion gibt ihr Zugriff auf eine Variable der umgebenden Funktion (hier [$label]); eine Pfeilfunktion sieht diese Variablen dagegen automatisch;
  • Zeile 31: [forever] speichert einen Wert unbegrenzt; [put(key, value, seconds)] würde ihn für eine bestimmte Dauer speichern.

4.8.2. Der Controller: app/Http/Controllers/TasksController.php

<?php
// app/Http/Controllers/TasksController.php: das Muster Post / Redirect / Get

namespace App\Http\Controllers;

use App\Services\TasksService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class TasksController
{
    public function __construct(private TasksService $tasks)
    {
    }

    // GET /tasks: die Liste und das Formular zum Hinzufügen
    public function display(): View
    {
        return view('tasks.tasks', ['tasks' => $this->tasks->list()]);
    }

    // POST /tasks: das Muster Post / Redirect / Get
    public function add(Request $request): View|RedirectResponse
    {
        $label = $request->string('label')->value();
        if ($label === '' || mb_strlen($label) > 40) {
            // ungültige Eingabe: wir zeigen die Seite ohne Weiterleitung erneut an
            return view('tasks.tasks', ['tasks' => $this->tasks->list(),
                'label' => $label,
                'error' => 'The label must have 1 to 40 characters.']);
        }
        $this->tasks->add($label);
        // keine Seite: eine Weiterleitung auf die GET-Seite; with legt eine "Flash"-Meldung
        // in der Session ab: sie überlebt die Weiterleitung für die NÄCHSTE Anfrage
        return redirect()->route('tasks')->with('message', "The task [$label] has been added.");
    }

    // POST /tasks/without-prg: das Gegenbeispiel (eine Seite als Antwort auf den POST)
    public function addWithoutPrg(Request $request): View
    {
        $this->tasks->add($request->string('label')->value() ?: '(untitled)');
        return view('tasks.tasks', ['tasks' => $this->tasks->list(), 'withoutPrg' => true]);
    }
}
  • Zeilen 26–31: Die Eingabe wird manuell validiert, um das Beispiel einfach zu halten. Eine ungültige Eingabe wird erneut angezeigt, ohne Weiterleitung: Es gibt nichts, wogegen man sich bei einem doppelten Absenden schützen müsste, da nichts geändert wurde. [mb_strlen] zählt die Zeichen einer UTF-8-Zeichenkette;
  • Zeile 36: die Weiterleitung auf die GET-Seite mit dem Namen [tasks]. Die Methode [with] einer Weiterleitung legt eine Flash-Meldung in der Session ab: Daten, die nur für die nächste Anfrage aufbewahrt werden;
  • Zeilen 40–43: das Gegenbeispiel: eine Seite als Antwort auf POST. Der Operator [?:] liefert seinen linken Operanden, wenn dieser „wahr“ ist (hier eine nicht leere Zeichenkette), andernfalls den rechten Operanden.

Die Routing-Tabelle:

<?php
// routes/web.php: die Routen von Beispiel 20

use App\Http\Controllers\TasksController;
use Illuminate\Support\Facades\Route;

Route::controller(TasksController::class)->group(function () {
    Route::get('tasks', 'display')->name('tasks');
    Route::post('tasks', 'add');
    Route::post('tasks/without-prg', 'addWithoutPrg');
});

4.8.3. Die Views

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Tasks</title>
  <link rel="stylesheet" href="{{ route('bootstrap', 'css/bootstrap.min.css') }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">
    {{-- the flash message, at the top of the page: left BEFORE the redirect; the session
         returns it during the next request, then forgets it --}}
    @session('message')
      <div class="alert alert-success" role="status">{{ $value }}</div>
    @endsession
    <main>
      @yield('content')
    </main>
    @isset($error)
      <div class="error-area" role="alert">{{ $error }}</div>
    @endisset
  </div>
</body>
</html>
  • Zeilen 13–15: Der Block [@session('message')] ... [@endsession] wird nur angezeigt, wenn die Session einen Eintrag [message] enthält; in diesem Fall wird sein Wert in der Variablen [$value] abgelegt. Die Klasse [alert alert-success] von [Bootstrap] zeigt die Meldung in einem grünen Rahmen an.
@extends('layout')

@section('content')
  <h1 class="h3">My tasks</h1>
  <ol>
    @foreach ($tasks as $task)
      <li>{{ $task }}</li>
    @endforeach
  </ol>
  <form method="post" action="/tasks" class="d-flex gap-2">
    @csrf
    <input class="form-control" name="label" value="{{ $label ?? '' }}" placeholder="New task">
    <button class="btn btn-primary text-nowrap" type="submit">Add</button>
    {{-- formaction: this button sends the SAME form to another address --}}
    <button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="/tasks/without-prg">Add without PRG</button>
  </form>
  @isset($withoutPrg)
    <p class="text-danger mt-2">Page displayed in response to a POST: press F5 and the task will be added a second time.</p>
  @endisset
@endsection
  • Zeile 15: Das Attribut [formaction] eines Buttons sendet das Formular an eine andere Adresse als die, die sein Attribut [action] angibt: Ein einziges Formular kann so zwei verschiedene Aktionen auslösen.

4.8.4. Wo werden Flash-Meldungen gespeichert?

Zwischen der POST-Anfrage und der darauffolgenden GET-Anfrage muss die Meldung irgendwo gespeichert werden: in der Session des Benutzers. Die [Laravel]-Session wird auf dem Server gespeichert: Die Datei [.env] der Beispiele legt sie in einer Datei im Ordner [storage/framework/sessions] ab ([SESSION_DRIVER=file]), mit einer Datei pro Benutzer. Der Browser erhält dagegen nur eine Session-ID im Cookie [example20_session] (der Name leitet sich von [APP_NAME] ab), das er mit jeder Anfrage zurücksendet. Untersuchen wir das mit [curl], wobei wir die Cookies in einer Datei speichern (Optionen [-c] und [-b], Beispiel 18) und das Anti-CSRF-Token mitsenden:

curl -i -b cookies.txt -c cookies.txt -d "_token=...&label=Do%20the%20exercises" http://localhost:8000/tasks
1
2
3
4
5
6
HTTP/1.1 302 Found
Location: http://localhost:8000/tasks
Content-Type: text/html; charset=utf-8
Set-Cookie: XSRF-TOKEN=eyJpdiI6IjFJLzhDVy9CWndjODZNb2s3N2VMUnc9PSIsInZhbHVlIjoiT3JXZy96MmJROHUrYmZaNUFNbUFoM3d4...; expires=...; Max-Age=7200; path=/; samesite=lax
Set-Cookie: example20_session=eyJpdiI6IlMwK3R3ZkQ2TEhKUVZ4SW9saDVMNUE9PSIsInZhbHVlIjoiMVVnUTNvTHFL...; expires=...; Max-Age=7200; path=/; httponly; samesite=lax
...

Die Antwort auf POST ist eine Weiterleitung (Statuscode 302, Header [Location]), begleitet vom Session-Cookie. Sein Wert ist verschlüsselt mit dem Schlüssel [APP_KEY] (das ist die Aufgabe der Middleware [EncryptCookies] in der Gruppe [web]): Der Benutzer kann ihn weder lesen noch ändern. Entschlüsselt enthält er nur die Session-ID – 40 zufällige Zeichen –, die auch der Name der Session-Datei auf dem Server ist: [storage/framework/sessions/HNuWctWJ0HcPvmsAhFN5v3iCiw1SFFDMXv46F6og]. Hier ist diese Datei nach der POST-Anfrage (über mehrere Zeilen dargestellt):

1
2
3
4
a:4:{s:6:"_token";s:40:"X0omnUmKl13zVLUrzTdZy5mWN7R6fBaiOmfEUPpr";
     s:9:"_previous";a:2:{s:3:"url";s:27:"http://localhost:8000/tasks";s:5:"route";s:5:"tasks";}
     s:6:"_flash";a:2:{s:3:"old";a:1:{i:0;s:7:"message";}s:3:"new";a:0:{}}
     s:7:"message";s:43:"The task [Do the exercises] has been added.";}

Das ist ein serialisiertes [PHP]-Array: [a:4] bezeichnet ein Array mit 4 Elementen, [s:6:"_token"] eine Zeichenkette von 6 Byte ... Es enthält das Anti-CSRF-Token der Session, die URL der vorherigen Seite ([_previous], die von der Weiterleitung auf die vorherige Seite in Beispiel 19 verwendet wird), unsere Meldung und die Liste [_flash] der Flash-Daten. Am Ende jeder Anfrage werden die während der Anfrage gesetzten Flash-Daten (Liste [new]) in die Liste [old] verschoben, und die Daten, die bereits in [old] standen, werden entfernt: So überlebt ein Flash-Datum genau eine Anfrage. Folgen wir der Weiterleitung, indem wir das Cookie zurücksenden:

curl -i -b cookies.txt -c cookies.txt http://localhost:8000/tasks
1
2
3
4
5
6
7
HTTP/1.1 200 OK
...
          <div class="alert alert-success" role="status">The task [Do the exercises] has been added.</div>
...
          <li>Read chapter 3</li>
          <li>Do the exercises</li>
...

Die Meldung wird angezeigt, und nach dieser Anfrage enthält die Session-Datei sie nicht mehr:

1
2
3
a:3:{s:6:"_token";s:40:"X0omnUmKl13zVLUrzTdZy5mWN7R6fBaiOmfEUPpr";
     s:9:"_previous";a:2:{s:3:"url";s:27:"http://localhost:8000/tasks";s:5:"route";s:5:"tasks";}
     s:6:"_flash";a:2:{s:3:"old";a:0:{}s:3:"new";a:0:{}}}

Eine neue GET-Anfrage würde die Meldung nicht mehr anzeigen. Die Aufgabenliste dagegen ist in einer Cache-Datei gespeichert, deren Name anhand des Schlüssels berechnet wird ([storage/framework/cache/data/55/d8/55d8727a05eb80b0788af57a5317f3e0a1f4aa55]):

9999999999a:2:{i:0;s:14:"Read chapter 3";i:1;s:16:"Do the exercises";}

Die ersten zehn Ziffern stellen das Ablaufdatum des Werts dar (hier: nie); der Rest ist die serialisierte Liste.

4.8.5. Ausführung

Hinzufügen einer Aufgabe: Der Browser ist der Weiterleitung gefolgt; die URL entspricht der GET-Seite, die gefahrlos neu geladen werden kann.

Image

Eine ungültige Eingabe, erneut angezeigt mit ihrer Fehlermeldung:

Image

Das Gegenbeispiel: Die Seite ist die Antwort auf POST, und ihre URL lautet [/tasks/without-prg]. Wenn Sie auf [F5] drücken, fragt der Browser, ob das Formular erneut gesendet werden soll; stimmen Sie zu, wird die Aufgabe ein zweites Mal hinzugefügt.

Image

Ein Grundsatz des HTTP-Protokolls: Eine GET-Anfrage ändert nichts. Browser, Suchmaschinen und Werkzeuge, die Seiten vorab laden, folgen Links nach Belieben, ohne den Benutzer um Erlaubnis zu fragen. Ein Link zum „Löschen“ ([<a href="/contacts/2/delete">]) wäre daher gefährlich: Ein Bot, der die Website durchsucht, würde alles löschen. In einer Webanwendung gilt:

  • Das Anzeigen erfolgt über einen Link ([<a href>]), der eine GET-Anfrage sendet;
  • das Ändern (Speichern, Duplizieren, Löschen) erfolgt über einen Button in einem Formular, das durch ein Anti-CSRF-Token geschützt ist.

Dieses Beispiel verwaltet eine Kontaktliste und zeigt vor jedem Löschen ein Bestätigungsfenster an.

4.9.1. Der Service: app/Services/ContactsService.php

<?php
// app/Services/ContactsService.php: die Kontakte, von allen gemeinsam genutzt, im
// Cache von Laravel gespeichert (siehe Beispiel 20)

namespace App\Services;

use App\Models\Contact;
use Illuminate\Support\Facades\Cache;

class ContactsService
{
    private const KEY = 'contacts';

    /** @return array{contacts: list<Contact>, lastId: int} */
    private function data(): array
    {
        return Cache::get(self::KEY, [
            'contacts' => [
                new Contact(1, 'Marie Durand', '01 23 45 67 89'),
                new Contact(2, 'Paul Martin', '06 12 34 56 78'),
                new Contact(3, 'Philippe Jandot', '02 98 76 54 32'),
            ],
            'lastId' => 3,
        ]);
    }

    // eine Änderung der Daten unter Sperre: die Funktion erhält die Daten,
    // ändert sie (&) und gibt das Ergebnis der Operation zurück
    private function editData(callable $operation): mixed
    {
        return Cache::lock('contacts-lock', 10)->block(5, function () use ($operation) {
            $data = $this->data();
            $result = $operation($data);
            Cache::forever(self::KEY, $data);
            return $result;
        });
    }

    /** @return list<Contact> */
    public function list(): array
    {
        return $this->data()['contacts'];
    }

    // der Kontakt oder null, falls er nicht existiert
    public function read(int $id): ?Contact
    {
        return array_find($this->list(), fn (Contact $c) => $c->id === $id);
    }

    public function edit(int $id, string $name, string $phone): ?Contact
    {
        return $this->editData(function (array &$data) use ($id, $name, $phone) {
            foreach ($data['contacts'] as $i => $contact) {
                if ($contact->id === $id) {
                    // ein Kontakt ist unveränderlich (readonly): wir bauen einen neuen,
                    // der den alten im Array ersetzt
                    return $data['contacts'][$i] = new Contact($id, $name, $phone);
                }
            }
            return null;
        });
    }

    public function add(string $name, string $phone): Contact
    {
        return $this->editData(function (array &$data) use ($name, $phone) {
            $contact = new Contact(++$data['lastId'], $name, $phone);
            $data['contacts'][] = $contact;
            return $contact;
        });
    }

    public function delete(int $id): ?Contact
    {
        return $this->editData(function (array &$data) use ($id) {
            foreach ($data['contacts'] as $i => $contact) {
                if ($contact->id === $id) {
                    // array_splice entfernt Element i aus dem Array und nummeriert die folgenden neu
                    array_splice($data['contacts'], $i, 1);
                    return $contact;
                }
            }
            return null;
        });
    }
}

Die Kontakte werden wie die Aufgaben in Beispiel 20 im Cache gespeichert. Jeder Kontakt ist ein unveränderliches [Contact]-Objekt (eine ID, ein Name, eine Telefonnummer), gespeichert in einem Array zusammen mit der zuletzt vergebenen ID. Einige Anmerkungen zu [PHP]:

  • Zeilen 29–37: Alle Änderungen folgen demselben Muster: die Sperre erwerben, die Daten lesen, sie ändern, sie zurückschreiben und die Sperre freigeben. Diese Methode schreibt das Array einmal; jede Änderung übergibt ihr eine Funktion (vom Typ [callable], „aufrufbar“), die die Daten erhält und ändert. Die Funktion muss das Array selbst ändern, nicht eine Kopie: Ihr Parameter ist als [array &$data] deklariert, wobei [&] eine Übergabe per Referenz angibt (ohne [&] wird ein Array kopiert; siehe Beispiel 06);
  • Zeilen 51–63: Ein Kontakt ist unveränderlich: Es wird ein neuer erzeugt, der den alten im Array ersetzt. Eine Zuweisung ist ein Ausdruck, dessen Wert der zugewiesene Wert ist: [return $data['contacts'][$i] = new Contact(...)] ersetzt den Kontakt und gibt ihn zurück;
  • Zeile 68: [++] vor einer Variablen erhöht sie um 1 und gibt den neuen Wert zurück;
  • Zeile 80: [array_splice] entfernt ein Element aus dem Array und nummeriert die folgenden Elemente neu;
  • Die Methoden geben für einen nicht existierenden Kontakt [null] zurück: Es ist Sache des Controllers, über die Antwort zu entscheiden.

4.9.2. Der Controller: app/Http/Controllers/ContactsController.php

<?php
// app/Http/Controllers/ContactsController.php: Links (GET) und Buttons (POST, DELETE)

namespace App\Http\Controllers;

use App\Models\Contact;
use App\Services\ContactsService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class ContactsController
{
    public function __construct(private ContactsService $contacts)
    {
    }

    // der Kontakt oder eine 404-Antwort, falls er nicht existiert
    private static function contactOr404(?Contact $contact): Contact
    {
        abort_if($contact === null, 404, 'unknown contact');
        return $contact;
    }

    // ein LINK (<a href>): eine GET-Anfrage, die nichts verändert
    public function list(): View
    {
        return view('contacts.list', ['contacts' => $this->contacts->list()]);
    }

    public function details(int $id): View
    {
        return view('contacts.details', ['contact' => self::contactOr404($this->contacts->read($id))]);
    }

    // ein BUTTON in einem POST-Formular: eine Anfrage, die Daten verändert
    public function save(Request $request, int $id): RedirectResponse
    {
        $contact = self::contactOr404($this->contacts->edit($id,
            $request->string('name')->value(), $request->string('phone')->value()));
        return redirect()->route('contacts')->with('message', "The contact [$contact->name] has been edited.");
    }

    // dasselbe Formular, ein anderer Button (Attribut formaction): eine andere Action
    public function duplicate(Request $request, int $id): RedirectResponse
    {
        $copy = $this->contacts->add($request->string('name')->value().' (copy)',
            $request->string('phone')->value());
        return redirect()->route('contacts')->with('message', "The contact [$copy->name] has been created.");
    }

    // eine DELETE-Anfrage, simuliert durch ein POST-Formular (siehe @method in der View)
    public function delete(int $id): RedirectResponse
    {
        $contact = self::contactOr404($this->contacts->delete($id));
        return redirect()->route('contacts')->with('message', "The contact [$contact->name] has been deleted.");
    }
}
  • Zeilen 19–23: eine Hilfsfunktion: Ein nicht existierender Kontakt beendet die Aktion mit einer 404-Antwort ([abort_if], siehe Beispiel 15);
  • Zeilen 26–34: die beiden GET-Aktionen, die nichts ändern: die Liste und der Datensatz eines Kontakts;
  • Zeilen 37–42: das Speichern des Datensatzes: eine POST-Aktion, die dem PRG-Schema folgt. Dieselbe URL [/contacts/2] wird je nach Methode von zwei verschiedenen Aktionen behandelt: GET zeigt an, POST speichert;
  • Zeilen 45–50: das Duplizieren – eine weitere POST-Aktion, ausgelöst durch einen zweiten Button im selben Formular;
  • Zeilen 53–57: das Löschen, behandelt durch eine DELETE-Anfrage.

Die Routing-Tabelle:

<?php
// routes/web.php: die Routen von Beispiel 21

use App\Http\Controllers\ContactsController;
use Illuminate\Support\Facades\Route;

Route::prefix('contacts')->controller(ContactsController::class)->group(function () {
    Route::get('/', 'list')->name('contacts');
    Route::get('{id}', 'details')->whereNumber('id')->name('contacts.details');
    Route::post('{id}', 'save')->whereNumber('id')->name('contacts.save');
    Route::post('{id}/duplicate', 'duplicate')->whereNumber('id')->name('contacts.duplicate');
    Route::delete('{id}', 'delete')->whereNumber('id')->name('contacts.delete');
});
  • Zeile 12: Das Löschen ist für die HTTP-Methode DELETE deklariert, die das HTTP-Protokoll für das Löschen einer Ressource vorsieht. Ein HTML-Formular kann jedoch nur GET- und POST-Anfragen senden. [Laravel] umgeht diese Einschränkung: Ein POST-Formular mit einem versteckten Feld [_method] mit dem Wert [DELETE] (oder [PUT], [PATCH]) wird als Anfrage mit dieser Methode behandelt. Das ist das Method Spoofing, das in Views von der Direktive [@method] umgesetzt wird.

4.9.3. Die Views

@extends('layout')

@section('content')
  <h1 class="h3">Contacts</h1>
  <table class="table align-middle">
    <tbody>
      @foreach ($contacts as $contact)
        <tr>
          <td>{{ $contact->name }}</td>
          <td>{{ $contact->phone }}</td>
          <td class="text-end">
            {{-- view: a simple link; route() places the id in the path: /contacts/2 --}}
            <a class="btn btn-sm btn-outline-primary" href="{{ route('contacts.details', $contact->id) }}">View</a>
            {{-- delete: a form, whose submission will be confirmed --}}
            <form method="post" class="d-inline" action="{{ route('contacts.delete', $contact->id) }}"
                  data-confirmation="Delete the contact {{ $contact->name }}?">
              {{-- the anti-CSRF token, required for any request that is not a GET --}}
              @csrf
              {{-- the DELETE method, which an HTML form cannot send --}}
              @method('DELETE')
              <button class="btn btn-sm btn-outline-danger" type="submit">Delete</button>
            </form>
          </td>
        </tr>
      @endforeach
    </tbody>
  </table>
@endsection
  • Zeile 13: ein Link, der durch die Klassen von [Bootstrap] ([btn] ...) als Button dargestellt wird: Das Erscheinungsbild hat nichts mit der HTTP-Methode zu tun. [route('contacts.details', $contact->id)] setzt die ID in den Pfad ein: [/contacts/2] (ein einzelner Parameter kann ohne Array übergeben werden);
  • Zeilen 15–22: ein Formular für jeden „Löschen“-Button, ohne weitere Felder als das Token und die Methode. Die Klasse [d-inline] zeigt es in derselben Zeile wie den Link an. Das Attribut [data-confirmation] enthält die Bestätigungsmeldung; die [data-...]-Attribute sind nicht festgelegt und für das [JavaScript] der Seite bestimmt;
  • Zeile 18: das Anti-CSRF-Token (Beispiel 18), erforderlich für jede Anfrage, die kein GET ist;
  • Zeile 20: Die Direktive [@method] schreibt das versteckte Feld [_method]: [<input type="hidden" name="_method" value="DELETE">].
@extends('layout')

@section('content')
  <h1 class="h3">Contact no. {{ $contact->id }}</h1>
  <form method="post" action="{{ route('contacts.save', $contact->id) }}">
    @csrf
    <div class="mb-2">
      <label class="form-label" for="name">Name</label>
      <input class="form-control" id="name" name="name" value="{{ $contact->name }}">
    </div>
    <div class="mb-3">
      <label class="form-label" for="phone">Phone</label>
      <input class="form-control" id="phone" name="phone" value="{{ $contact->phone }}">
    </div>
    {{-- two submit buttons for the same form --}}
    <button class="btn btn-primary" type="submit">Save</button>
    <button class="btn btn-outline-primary" type="submit"
            formaction="{{ route('contacts.duplicate', $contact->id) }}">Duplicate</button>
    <a class="btn btn-link" href="{{ route('contacts') }}">Back to the list</a>
  </form>
@endsection
  • Zeilen 16–18: zwei Submit-Buttons für dasselbe Formular: „Speichern“ sendet das Formular an die Adresse, die sein Attribut [action] angibt, und „Duplizieren“ sendet es an die Adresse, die sein Attribut [formaction] angibt (Beispiel 20). Dieses Formular verwendet [@method] nicht: Das Feld [_method] würde von beiden Buttons gesendet, und auch das Duplizieren würde zu einer PUT- oder DELETE-Anfrage;
  • Zeile 19: Rückkehr zur Liste: ein Link.

4.9.4. Das Bestätigungsfenster

Der Browser kann ein Bestätigungsfeld anzeigen (die [JavaScript]-Funktion [confirm]), aber es ist wenig ansprechend, und sein Aussehen hängt vom Browser ab. Hier verwenden wir ein modales Fenster von [Bootstrap], das von einigen Zeilen [JavaScript] angezeigt wird. Das Fenster ist ein Fragment, das in das Template eingebunden ist und daher – wenn auch verborgen – auf allen Seiten vorhanden ist:

{{-- a single window for the whole page, hidden (d-none) at first --}}
<div id="confirmation-modal" class="d-none">
  <div class="modal-backdrop fade show"></div>
  <div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true">
    <div class="modal-dialog modal-dialog-centered">
      <div class="modal-content">
        <div class="modal-header">
          <h5 class="modal-title">Confirmation</h5>
        </div>
        <div class="modal-body">
          <p class="mb-0" id="confirmation-modal-message"></p>
        </div>
        <div class="modal-footer">
          <button type="button" class="btn btn-secondary" data-action="no">No, go back</button>
          <button type="button" class="btn btn-danger" data-action="yes">Yes, confirm</button>
        </div>
      </div>
    </div>
  </div>
</div>
  • Zeile 2: Die Klasse [d-none] von [Bootstrap] blendet das Element aus;
  • Zeilen 3–4: der graue Hintergrund, gefolgt vom Fenster, werden durch die Klassen von [Bootstrap] dargestellt;
  • Zeile 11: die Position der Meldung;
  • Zeilen 14–15: die beiden Buttons vom Typ [button] (nicht [submit]: Sie senden kein Formular ab), unterschieden durch ihr Attribut [data-action].
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Contacts</title>
  <link rel="stylesheet" href="{{ route('bootstrap', 'css/bootstrap.min.css') }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3" style="max-width: 40rem">
    @session('message')
      <div class="alert alert-success" role="status">{{ $value }}</div>
    @endsession
    <main>
      @yield('content')
    </main>
  </div>
  {{-- the confirmation window, present in all the pages --}}
  @include('fragments.confirmation')
  {{-- the script, at the end of the page: the elements it looks for already exist --}}
  <script src="{{ asset('js/app.js') }}"></script>
</body>
</html>
  • Zeile 19: das Fenster, eingebunden auf allen Seiten;
  • Zeile 21: das Skript, am Ende der Seite platziert: Wenn es ausgeführt wird, existieren die Elemente, die es sucht, bereits. Es liegt im Ordner [public/js].

Das Skript [public/js/app.js]:

// Bestätigung der Formulare, die das Attribut data-confirmation="..." tragen.
// Ohne JavaScript werden diese Formulare einfach ohne Bestätigung gesendet.
(() => {
  const modal = document.getElementById('confirmation-modal');
  const message = document.getElementById('confirmation-modal-message');
  let pending = null; // das Formular, das gesendet wird, wenn der Benutzer bestätigt

  // 1. wir fangen das Absenden der zu bestätigenden Formulare ab
  document.querySelectorAll('form[data-confirmation]').forEach((form) => {
    form.addEventListener('submit', (event) => {
      event.preventDefault(); // das Absenden wird angehalten
      pending = form;
      message.textContent = form.dataset.confirmation;
      modal.classList.remove('d-none'); // das Fenster erscheint
    });
  });

  // 2. die beiden Buttons des Fensters
  modal.addEventListener('click', (event) => {
    const action = event.target.dataset.action;
    if (action === 'yes') {
      pending.submit(); // Absenden, OHNE das Ereignis 'submit' erneut auszulösen
    } else if (action === 'no') {
      modal.classList.add('d-none');
      pending = null;
    }
  });
})();
  • Zeile 3: Der Code ist in eine anonyme Funktion eingeschlossen, die sofort ausgeführt wird; ihre Variablen stören die der anderen Skripte der Seite nicht;
  • Zeilen 4–6: das Fenster, die Stelle der Meldung und das Formular, das auf Bestätigung wartet;
  • Zeilen 9–14: Für jedes Formular mit einem Attribut [data-confirmation] wird das Ereignis [submit] – ausgelöst beim Absenden des Formulars – abgefangen. [preventDefault()] setzt das Absenden aus; das Formular wird in die Warteposition gestellt, und seine Meldung ([dataset.confirmation], der Wert des Attributs [data-confirmation]) wird im Fenster angezeigt, das erscheint;
  • Zeilen 19–25: ein einziger Handler für Klicks im Fenster: [event.target] ist das angeklickte Element; sein Attribut [data-action] gibt an, um welchen Button es sich handelt. „Ja“ sendet das wartende Formular mit der Methode [submit()] ab, die – anders als ein Klick auf einen Button – das Ereignis [submit] nicht auslöst (sonst würde das Fenster erneut erscheinen); „Nein“ blendet das Fenster aus.

Ohne [JavaScript] wird das Formular einfach ohne Bestätigung abgesendet: Die Seite bleibt benutzbar. Das ist Progressive Enhancement: [JavaScript] bringt Komfort, aber die Anwendung hängt nicht davon ab.

4.9.5. Ausführung

Die Kontaktliste:

Image

Ein Klick auf „Delete“ zeigt das Bestätigungsfenster an:

Image

Nach der Bestätigung: die (simulierte) DELETE-Anfrage, die Weiterleitung und die Pop-up-Meldung:

Image

Das Profil eines Kontakts mit seinen beiden Sende-Buttons:

Image

Eine Anfrage ohne Anti-CSRF-Token wird abgewiesen, und ein nicht existierender Kontakt liefert einen 404-Fehler:

curl -i -X POST -d "_method=DELETE" http://localhost:8000/contacts/2
curl -i http://localhost:8000/contacts/9
HTTP/1.1 419 unknown status
Content-Type: text/html; charset=utf-8
...
        <title>Page Expired</title>
...
HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8
...
        <title>Not Found</title>
...

Die Fehlerseiten sind weiterhin die englischen von [Laravel]. Das Kapitel zum Lebenszyklus einer Anfrage zeigt, wie sie sich durch eigene Seiten ersetzen lassen.