Skip to content

4. Die View und ihr Modell

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

[Symfony] verwendet die View-Engine [Twig], die vom selben Team entwickelt wurde. Eine [Twig]-View ist eine Datei, deren Name auf [.html.twig] endet (das Ausgabeformat, gefolgt von der Engine) und die im Ordner [templates] der Anwendung gespeichert ist. Es ist eine Textdatei – in diesem Fall HTML –, in der drei Arten von Tags auf dem Server interpretiert werden:

  • [{{ expression }}]: der Wert eines Ausdrucks, der in die Seite eingefügt wird;
  • [{% instruction %}]: eine Anweisung (Tag); eine Bedingung ([{% if %}]); eine Schleife ([{% for %}]), Template-Vererbung ([{% extends %}], [{% block %}]), Einbindung ([{% include %}]) ...;
  • [{# comment #}]: ein Kommentar, der auf der erzeugten Seite nicht erscheint.

Alles andere wird unverändert übernommen. Die Ausdrücke sind nicht in [PHP] geschrieben, sondern in der Sprache von [Twig], die einfacher und sicherer ist: [model.title] bezeichnet die Eigenschaft [title] des Objekts [model] (oder seine Methode [getTitle()] oder den Schlüssel [title] eines Arrays: [Twig] sucht es selbst heraus); Filter transformieren einen Wert ([name|upper] wandelt einen Namen in Großbuchstaben um); Funktionen führen Berechnungen durch ([path('home')] erzeugt eine URL). [Twig] ähnelt damit [Jinja2] ([Flask]), von dem es sich inspirieren ließ, oder der Engine von [Django]; es unterscheidet sich von [Blade] ([Laravel]) und [Razor] ([ASP.NET Core]), die HTML mit Code der Host-Sprache mischen. Eine [Twig]-View kann nicht beliebigen [PHP]-Code ausführen: Sie kann nur die ihr übergebenen Daten anzeigen. Das ist beabsichtigt: Die Anwendungslogik bleibt in den Klassen. Eine View wird nicht bei jeder Anfrage interpretiert: Bei der ersten Verwendung kompiliert [Twig] sie in eine [PHP]-Klasse, die im Ordner [var/cache/dev/twig] abgelegt 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/
├── config/
│   ├── packages/
│   │   ├── framework.yaml
│   │   └── twig.yaml
│   └── bundles.php
├── src/
│   ├── Controller/
│   │   └── ViewsController.php
│   ├── Model/
│   │   └── PageModel.php
│   └── Kernel.php
├── templates/
│   └── views/
│       ├── unknown.html.twig
│       └── index.html.twig
└── ...

4.1.1. Die Konfiguration: config/bundles.php und config/packages/twig.yaml

[Twig] wird über ein Bundle in [Symfony] integriert, TwigBundle, das der Bundle-Liste der Anwendung hinzugefügt werden muss (Beispiel 01):

1
2
3
4
5
6
7
<?php
// config/bundles.php: die Bundles der Anwendung; das TwigBundle integriert die
// View-Engine Twig
return [
    Symfony\Bundle\FrameworkBundle\FrameworkBundle::class => ['all' => true],
    Symfony\Bundle\TwigBundle\TwigBundle::class => ['all' => true],
];

und konfiguriert:

1
2
3
4
# config/packages/twig.yaml: die Konfiguration des TwigBundle
twig:
    # der Ordner der Views
    default_path: '%kernel.project_dir%/templates'

Der einzige Schlüssel gibt den Ordner der Views an: [templates], im Projektordner gelegen. Das ist auch der Standardwert. In einem Standardprojekt werden diese beiden Dateien von [Symfony Flex] angelegt, wenn Sie [Twig] installieren ([composer require twig], siehe Einleitung).

4.1.2. Das Modell der View: src/Model/PageModel.php

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

namespace App\Model;

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 anzeigen wird. Es besteht keine Pflicht, 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 wichtige View ihre eigene Modellklasse hat.

4.1.3. Der Controller: src/Controller/ViewsController.php

<?php
// src/Controller/ViewsController.php: Actions, die eine VIEW zurückgeben

namespace App\Controller;

use App\Model\PageModel;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

#[Route(methods: ['GET'])]
class ViewsController extends AbstractController
{
    // render: Die Twig-Engine baut die Seite aus dem View-Template
    // templates/views/index.html.twig und aus den im Array übergebenen Variablen (hier
    // nur eine, [model]); die erzeugte Seite ist der Body der Antwort
    #[Route('/', name: 'index')]
    public function index(): Response
    {
        $model = new PageModel(
            'My first view',
            'This page was built by Twig, on the server.',
            date('H:i:s'));
        return $this->render('views/index.html.twig', ['model' => $model]);
    }

    // dieselbe View mit einem anderen Modell; oder eine andere View, mit dem Code 404
    #[Route('/hello/{name}', name: 'hello')]
    public function hello(string $name): Response
    {
        if ($name === 'unknown') {
            // der dritte Parameter von render: die zu vervollständigende Antwort, hier mit dem Code 404
            return $this->render('views/unknown.html.twig', ['name' => $name],
                new Response(status: Response::HTTP_NOT_FOUND));
        }
        $model = new PageModel(
            "Hello $name",
            'This time, the title of the page comes from the URL.',
            date('H:i:s'));
        return $this->render('views/index.html.twig', ['model' => $model]);
    }
}
  • Zeilen 20–23: Die Action erstellt das Modell der View. Die Funktion [date], aus [PHP] übernommen, formatiert die aktuelle Uhrzeit: [H] formatiert die Stunden, [i] formatiert die Minuten und [s] formatiert die Sekunden;
  • Zeile 24: Die Methode [render] von [AbstractController] weist [Twig] an, die Seite zu erzeugen. Der erste Parameter ist der Name der View: der Dateipfad, relativ zum Ordner [templates]. Der zweite Parameter ist ein assoziatives Array, dessen Schlüssel jeweils zu einer Variablen in der View wird – hier nur eine: [model]. [render] liefert ein Objekt [Response] zurück, dessen Body die erzeugte Seite ist (vom Typ [text/html]);
  • Zeilen 31–35: eine weitere View mit einer weiteren Variablen ([name]). Der dritte Parameter von [render] ist eine zu befüllende Antwort: hier eine 404-Antwort für eine benutzerdefinierte Fehlerseite. [new Response(status: ...)] übergibt den Code über einen benannten Parameter, während die übrigen Parameter ihre Standardwerte behalten;
  • Zeilen 36–40: 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.4. Die View: templates/views/index.html.twig

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  {# {{ ... }}: der Wert eines Ausdrucks, in die Seite eingefügt #}
  <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 [Twig]-Kommentar;
  • Zeile 6: [{{ model.title }}] fügt den Wert der Eigenschaft [title] der Variablen [model] ein. Der Punkt ist der Zugriffsoperator von [Twig], wo [PHP] [$model->title] schreibt.

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

4.1.5. Die View: templates/views/unknown.html.twig

<!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.6. Ausführung

Image

Image

Die angezeigte Uhrzeit entspricht der in [PHP] konfigurierten Zeitzone (der Direktive [date.timezone] in der Datei [php.ini]), hier die koordinierte Weltzeit (UTC); die Fallstudie wird zeigen, wie man sie für die Anwendung festlegt. Die Rohantwort zeigt die Arbeit von [Twig]: Die Tags [{{ }}] wurden durch ihre Werte ersetzt, und der Kommentar wurde entfernt.

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 Twig, on the server.</p>
  <p>Page built at 09:31:47.</p>
</body>
</html>

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

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>
  <p>This time, the title of the page comes from the URL.</p>
...

Das Tag [<b>] wurde maskiert, obwohl weder die Action noch die View sich darum kümmern mussten (auch das Apostroph wurde maskiert: [&#039;]). Hier schließlich die von [Twig] kompilierte View, wie sie sich im Ordner [var/cache/dev/twig] findet (unter einem generierten Namen wie [f1/f1e0ff0a8a0dc68657a0b1aa94f3ef4b.php]), auf das Wesentliche reduziert:

/* views/index.html.twig */
class __TwigTemplate_9c9473b678a753b61e2666e1a8e3a2a4 extends Template
{
    ...
    protected function doDisplay(array $context, array $blocks = []): iterable
    {
        // line 1
        yield "<!doctype html>
<html lang=\"en\">
<head>
  <meta charset=\"utf-8\">
  ";
        // line 6
        yield "  <title>";
        yield (string) $this->escaper->escape(CoreExtension::getAttribute($this->env, $this->source,
            ... $context["model"] ..., "title", ...), "html", null, true);
        yield "</title>
...

Die View ist zu einer Klasse mit dem Namen [PHP] geworden, deren Methode [doDisplay] die Seite Stück für Stück erzeugt ([yield]). Jedes [{{ model.title }}] ist zu einem Aufruf von [CoreExtension::getAttribute] geworden (der die Eigenschaft, Methode oder den Schlüssel [title] sucht), der an die Methode [escape] (Maskierung) übergeben wird. Eine [Twig]-View ist also schlicht eine sicherere und besser lesbare Art, eine [PHP]-Datei zu schreiben, die HTML erzeugt.

4.2. Beispiel 14: Die Sprache Twig

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

4.2.1. Das Modell und die Action

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

<?php
// src/Model/Product.php: ein Produkt

namespace App\Model;

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

namespace App\Model;

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

namespace App\Model;

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 wir ganze Cent-Beträge bevorzugen).

<?php
// src/Controller/BasicsController.php: eine View, die die wichtigsten Konstrukte von Twig verwendet

namespace App\Controller;

use App\Model\Address;
use App\Model\BasicsModel;
use App\Model\Product;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class BasicsController extends AbstractController
{
    #[Route('/', name: 'index', methods: ['GET'])]
    public function index(): Response
    {
        $model = new BasicsModel(
            title: 'Twig 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 $this->render('basics/index.html.twig', ['model' => $model]);
    }
}

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

4.2.2. Die View: templates/basics/index.html.twig

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>{{ model.title }}</title>
</head>
<body>
  {# set: eine Variable der View; der Filter reduce summiert die Preise, der Filter length zählt die Produkte #}
  {% set total = model.products|reduce((sum, p) => sum + p.price, 0) %}
  {% set count = model.products|length %}
  <h1>{{ model.title }}</h1>
  {# 1. einen Wert des Modells anzeigen; null wird als leerer String angezeigt;
     der Filter default ersetzt einen leeren Wert. Dieser Twig-Kommentar erscheint nicht
     in der erzeugten Seite #}
  <p>1. Name: {{ model.name }} - nickname: [{{ model.nickname }}] [{{ model.nickname|default('none') }}]</p>
  {# 2. {{ }} maskiert HTML; der Filter raw fügt es unverändert ein #}
  <p>2a. {{ model.html }}</p>
  <p>2b. {{ model.html|raw }}</p>
  {# 3. eine Bedingung #}
  {% if model.loggedIn %}
    <p>3. You are logged in.</p>
  {% else %}
    <p>3. You are not logged in.</p>
  {% endif %}
  {# 4. eine Schleife: die Variable loop beschreibt den Zustand der Schleife #}
  <p>4. Our products:</p>
  <ul>
    {% for product in model.products %}
      <li>no. {{ loop.index0 }}: {{ 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>
    {% endfor %}
  </ul>
  {# 5. die leere Liste: der else-Block einer for-Schleife #}
  <p>5. Your cart:
    {% for p in model.cart %}<span>{{ p.name }}</span>{% else %} it is empty.{% endfor %}
  </p>
  {# 6. berechnete Ausdrücke, die set-Variablen und der Filter number_format #}
  <p>6. {{ count }} products, for a total of {{ total }} {{ model.currency }};
    average price: {{ (total / count)|number_format(2, '.', ',') }} {{ model.currency }}</p>
  {# 7. ein Objekt in einem Objekt und ein Filter, der in Großbuchstaben umwandelt #}
  <p>7. Address: {{ model.address.street }}, {{ model.address.city|upper }}</p>
  {# 8. verbatim: ein Text, den Twig ohne Interpretation kopiert #}
  <p>8. Braces displayed as is: {% verbatim %}{{ model.name }}{% endverbatim %}</p>
</body>
</html>
  • Zeilen 9–10: Die Anweisung [{% set %}] erzeugt eine Variable in der View. Der Gesamtpreis wird vom Filter [reduce] berechnet, der ein Array auf einen einzigen Wert reduziert (wie [array_reduce], Beispiel 06): Seine Funktion erhält den akkumulierten Wert und das aktuelle Element; [(sum, p) => sum + p.price] ist eine Pfeilfunktion von [Twig]. Der Filter [length] liefert die Anzahl der Elemente eines Arrays (oder der Zeichen einer Zeichenkette). Solche Berechnungen sollten der Darstellung vorbehalten bleiben: Die Berechnung gehört normalerweise in die Action;
  • Zeile 15: Ein Wert [null] wird als leere Zeichenkette angezeigt. Der Filter [default] ersetzt einen leeren (oder fehlenden) Wert durch einen Standardwert;
  • Zeilen 17–18: [{{ }}] maskiert HTML (2a); der Filter [raw], fügt den Wert dagegen unverändert ein, ohne ihn zu maskieren (2b). [raw] ist dem von der Anwendung selbst erzeugten HTML vorbehalten, niemals für Benutzereingaben;
  • Zeilen 20–24: eine Bedingung: [{% if %}], [{% elseif %}], [{% else %}], [{% endif %}]. Jeder Block wird durch eine Anweisung [{% end... %}] geschlossen;
  • Zeilen 28–34: eine Schleife [{% for ... in ... %}] ... [{% endfor %}]. Innerhalb der Schleife beschreibt die spezielle Variable [loop] den Zustand der Schleife: [loop.index0] (die Nummer des Durchlaufs, bei 0 beginnend), [loop.index] (bei 1 beginnend), [loop.first], [loop.last] (true beim ersten bzw. letzten Durchlauf), [loop.length] (die Anzahl der Elemente). Variablen außerhalb der Schleife ([model.name]) bleiben zugänglich;
  • Zeile 30: der ternäre Operator [condition ? a : b] ([Twig] akzeptiert auch [condition ? a], was eine leere Zeichenkette liefert, wenn die Bedingung falsch ist);
  • Zeile 38: Eine Schleife [for] kann einen Block [{% else %}]haben, der 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 41–42: berechnete Ausdrücke ([total / count]) und die Variablen aus [set]. Der Filter [number_format] formatiert eine Zahl: zwei Nachkommastellen, einen Punkt als Dezimaltrennzeichen und ein Komma als Tausendertrennzeichen. In Beispiel 16 werden wir eine viel bessere Möglichkeit sehen, Zahlen und Beträge zu formatieren;
  • Zeile 44: Der Punkt durchläuft Objekte ([model.address.city]), und der Filter [upper] wandelt eine Zeichenkette in Großbuchstaben um (wobei Zeichen mit Akzenten korrekt behandelt werden);
  • Zeile 46: Die Anweisung [{% verbatim %}] kopiert ihren Inhalt, ohne ihn zu interpretieren: Das ist nützlich, wenn eine Seite geschweifte Klammern enthält, die für ein [JavaScript]-Framework bestimmt sind.

[Twig] hat etwa fünfzig Filter ([lower], [capitalize], [trim], [join], [split], [slice], [sort], [date], [json_encode], [escape]...), etwa fünfzehn Funktionen ([range], [min], [max], [random]...) und Tests ([is defined], [is empty], [is null], [is iterable], [is even]...); die Bundles von [Symfony] ergänzen einige ([path], [asset], [form_row], [is_granted]...), und die Anwendung kann eigene schreiben (Beispiel 16).

4.2.3. Ausführung

Image

Die erzeugte Seite:

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Twig basics</title>
</head>
<body>
        <h1>Twig 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. Braces displayed as is: {{ model.name }}</p>
</body>
</html>

Die Kommentare und Anweisungen sind verschwunden, hinterlassen aber ihre Leerzeichen: [Twig] entfernt den Zeilenumbruch, der auf ein Tag folgt, nicht aber die Einrückung, die ihm vorausgeht. Das hat keine Auswirkung: Der Browser ignoriert diese Leerzeichen. (Ein Bindestrich innerhalb eines Tags – wie [{%- ... -%}] oder [{{- ... -}}] – würde die umgebenden Leerzeichen entfernen.) Eine in die Seite eingefügte Zahl vom Typ [float] wird 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/
├── config/
│   ├── packages/
│   │   └── twig.yaml
│   └── services.yaml
├── public/
│   └── css/
│       └── styles.css
├── src/
│   ├── Controller/
│   │   └── PagesController.php
│   ├── Model/
│   │   └── Member.php
│   └── Kernel.php
├── templates/
│   ├── fragments/
│   │   └── navbar.html.twig
│   ├── layout.html.twig
│   ├── macros.html.twig
│   └── pages/
│       ├── home.html.twig
│       ├── raw.html.twig
│       └── team.html.twig
└── ...

4.3.1. Statische Dateien

Eine HTML-Seite verweist auf weitere Dateien: Stylesheets, [JavaScript]-Skripte und Bilder. Diese Dateien, die der Server unverändert sendet, heißen statische Dateien. Bei [Symfony] 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 [Symfony] beteiligt ist.

/* einige 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 zusätzlich zu [Bootstrap]: ein hellgrauer Hintergrund, der Stil der Fußzeile und der Stil für einen Fehlerbereich, der in den folgenden Beispielen verwendet wird.

[Bootstrap] wird in den Beispielen 15 bis 28 verwendet. Statt in den Ordner [public] jedes Benutzers eine Kopie zu legen, teilen sich die Beispiele es: Es befindet sich im Ordner [examples/common/bootstrap]. Dieser Ordner wird nicht vom Webserver ausgeliefert: Ein Controller, den alle diese Beispiele gemeinsam nutzen, liefert seine Dateien aus. Das ist die Datei [examples/common/BootstrapController.php]:

<?php
// common/BootstrapController.php: ein Controller, der die Bootstrap-Dateien ausliefert,
// die von den Beispielen 15 bis 28 gemeinsam genutzt werden (Ordner examples/common/bootstrap), unter
// der URL /bootstrap/... Jedes dieser Beispiele deklariert ihn in seiner
// Datei config/services.yaml

namespace Common;

use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Routing\Requirement\Requirement;

class BootstrapController
{
    #[Route('/bootstrap/{file}', name: 'bootstrap', requirements: ['file' => Requirement::CATCH_ALL],
        methods: ['GET'])]
    public function serve(string $file): BinaryFileResponse
    {
        $folder = realpath(__DIR__.'/bootstrap');
        // realpath: der absolute Pfad der angeforderten Datei, ohne . und ..;
        // false, wenn die Datei nicht existiert
        $path = realpath($folder.'/'.$file);
        // eine Datei, die existiert und tatsächlich IM Ordner liegt (kein ../, um aus ihm auszubrechen)
        if ($path === false || ! str_starts_with($path, $folder.DIRECTORY_SEPARATOR) || ! is_file($path)) {
            throw new NotFoundHttpException("unknown file: $file");
        }
        // eine Antwort, die den Inhalt einer Datei sendet; ihr Typ richtet sich nach der Dateiendung
        $response = new BinaryFileResponse($path);
        $types = ['css' => 'text/css', 'js' => 'text/javascript', 'map' => 'application/json'];
        $response->headers->set('Content-Type', $types[pathinfo($path, PATHINFO_EXTENSION)] ?? 'application/octet-stream');
        return $response;
    }
}
  • Zeile 7: Die Klasse liegt im Namespace [Common], den die Datei [examples/composer.json] dem Ordner [examples/common] zuordnet (siehe Einleitung): Der Class Loader von [Composer] findet sie daher unabhängig vom jeweiligen Beispiel;
  • Zeilen 16–17: eine Route, deren Parameter [{file}] jedes Pfadende akzeptiert, einschließlich Schrägstrichen (Beispiel 02): Die URL [/bootstrap/css/bootstrap.min.css] verweist auf die Datei [css/bootstrap.min.css] im Ordner. Die Route heißt [bootstrap];
  • Zeilen 20–27: Das Ausliefern von Dateien, die über eine URL bezeichnet werden, erfordert Vorsicht: Eine URL wie [/bootstrap/..%2F..%2F15-layout%2F.env] (in der [/] als [%2F] kodiert ist) darf keinen Zugriff auf eine Datei außerhalb des Ordners gewähren. Die Funktion [realpath] von [PHP] berechnet den absoluten Pfad einer Datei, wobei sie deren Bestandteile [.] und [..] entfernt, oder liefert [false] zurück, wenn die Datei nicht existiert. Wir prüfen, ob der resultierende Pfad mit dem Pfad des Ordners beginnt ([str_starts_with]) und ob er auf eine Datei verweist ([is_file]); andernfalls wird ein 404-Fehler zurückgegeben. [DIRECTORY_SEPARATOR] ist das Pfadtrennzeichen des Systems: [\] unter [Windows], [/] anderswo;
  • Zeilen 29–32: Ein Objekt [BinaryFileResponse] ist eine Antwort, die den Inhalt einer Datei sendet. Der Inhaltstyp wird anhand der Dateierweiterung bestimmt (geliefert von [pathinfo]), sodass ein Stylesheet korrekt als [text/css] deklariert wird: Ein Browser lehnt ein Stylesheet ab, das als etwas anderes deklariert ist.

Jedes Beispiel, das [Bootstrap] verwendet, deklariert diesen Controller als Service in seiner Datei [config/services.yaml]:

# config/services.yaml: die Services der Anwendung (siehe Beispiel 06)
services:
    _defaults:
        autowire: true
        autoconfigure: true

    App\:
        resource: '../src/'

    # der Controller, der Bootstrap ausliefert, gemeinsam genutzt von den Beispielen 15 bis 28 (siehe Beispiel 15)
    Common\BootstrapController: ~
  • Zeile 11: der Service [Common\BootstrapController] ohne spezielle Konfiguration ([~] ist der Wert von [null] in [YAML]): Er erhält die Einstellungen aus [_defaults], und [autoconfigure] macht ihn zu einem Controller, dessen Route sich zu denen der Anwendung gesellt (Beispiel 02).

4.3.2. Das Template: templates/layout.html.twig

<!doctype html>
{# das Layout der Seiten: die Seiten ERWEITERN es und füllen seine Blöcke #}
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  {# block: ein Platzhalter, den die Seite füllen kann; hier mit einem Standardinhalt #}
  <title>{% block title %}Home{% endblock %} - {{ site_name }}</title>
  {# path(): die URL der Route namens [bootstrap]; asset(): die URL einer Datei aus public/ #}
  <link rel="stylesheet" href="{{ path('bootstrap', {file: 'css/bootstrap.min.css'}) }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3">
    {# Einfügen der Datei fragments/navbar.html.twig #}
    {% include 'fragments/navbar.html.twig' %}
    <main>
      {# der Inhalt der von der Action angeforderten Seite wird hier eingefügt #}
      {% block content %}{% endblock %}
    </main>
    {# app: die Variable, die Symfony allen Views bereitstellt (die aktuelle Anfrage ...);
       site_name: eine globale Variable (siehe config/packages/twig.yaml) #}
    <footer class="footer">Page [{{ app.request.pathInfo }}] - © {{ 'now'|date('Y') }} {{ site_name }}</footer>
  </div>
</body>
</html>
  • Zeile 6: Das Tag [viewport] weist mobile Browser an, die Seite in der Breite des Bildschirms darzustellen, was [Bootstrap] erwartet;
  • Zeile 8: Die Direktive [{% block %}] markiert einen benannten Slot, den Seiten, die das Template erweitern, durch die Definition eines Blocks mit demselben Namen füllen können. Der zwischen [{% block title %}] und [{% endblock %}] geschriebene Inhalt ist der Standard-Inhalt des Platzhalters, den eine Seite verwendet, die diesen Block nicht definiert. [site_name] ist eine globale Variable, die in allen Views vorhanden ist (siehe [config/packages/twig.yaml], unten);
  • Zeilen 10–11: Die Funktion [path] erzeugt die URL einer benannten Route (Beispiel 04) anhand der Werte ihrer Parameter, die in einem assoziativen Array von [Twig] übergeben werden ([{file: '...'}], das Äquivalent zu [['file' => '...']] in [PHP]). Die Funktion [asset] erzeugt die URL zu einer Datei im Ordner [public]. Die URLs von Hand zu schreiben ([/css/styles.css]) würde ebenfalls funktionieren, aber [path] und [asset] funktionieren 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 23: Die Variable [app] ist in allen Views vorhanden: [Symfony] legt dort die aktuelle Anfrage ([app.request]), die Session ([app.session]), den angemeldeten Benutzer ([app.user], siehe den Abschnitt zur Sicherheit) und den Namen der Route ([app.current_route]) ab ... [app.request.pathInfo] ist der Pfad der angeforderten URL. Der Filter [date] formatiert ein Datum; die Zeichenkette ['now'] steht für die aktuelle Zeit.

Die Klasse [container] von [Bootstrap] zentriert den Inhalt und begrenzt seine Breite; [py-3] fügt einen vertikalen Innenabstand hinzu (padding): [Bootstrap] stellt Hunderte Klassen dieser Art bereit, die im Attribut [class] kombiniert werden. Die globale Variable [site_name] wird in der Konfiguration von [Twig] deklariert:

1
2
3
4
5
6
# config/packages/twig.yaml: die Konfiguration des TwigBundle
twig:
    default_path: '%kernel.project_dir%/templates'
    # GLOBALE Variablen, in allen Views vorhanden
    globals:
        site_name: 'My site'

Variablen unter dem Schlüssel [globals] werden allen Views hinzugefügt, ohne dass die Actions sie bereitstellen müssen. Eine globale Variable kann auch ein Service sein (['@App\Service\...']), dessen Methoden von den Views aufgerufen werden.

4.3.3. Die Navigationsleiste: templates/fragments/navbar.html.twig

{# ein Fragment: ein Seitenstück, per include eingefügt #}
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">{{ site_name }}</span>
  <div class="navbar-nav">
    {# path(): die URL einer Route, anhand ihres Namens bestimmt #}
    <a class="nav-link" href="{{ path('home') }}">Home</a>
    <a class="nav-link" href="{{ path('team') }}">Team</a>
    <a class="nav-link" href="{{ path('raw') }}">Page without layout</a>
  </div>
</nav>

Ein Fragment: ein Teil einer Seite, der für sich genommen keine Bedeutung hat. Die Klassen [navbar], [navbar-brand] und [nav-link] sind die der Navigationsleiste von [Bootstrap]. Die Links werden von [path] anhand der Routennamen erzeugt.

4.3.4. Ein Makro: templates/macros.html.twig

{# MAKROS: Seitenstücke mit Parametern, wie Funktionen #}

{# eine Bootstrap-Karte mit Name und Rolle #}
{% macro card(name, role = '') %}
  <div class="card">
    <div class="card-body">
      <h5 class="card-title">{{ name }}</h5>
      <p class="card-text">{{ role }}</p>
    </div>
  </div>
{% endmacro %}
  • Zeile 4: Ein Makro ist ein Abschnitt einer Seite, der Parameter hat; das ist die Funktion von [Twig]. Es wird deklariert durch [{% macro name(parameters) %}] ... [{% endmacro %}]; ein Parameter kann einen Standardwert haben ([role = '']). Eine Datei kann mehrere Makros enthalten. Die Karte ([card]) ist eine Komponente von [Bootstrap].

Ein Makro kann nur auf seine eigenen Parameter (und auf globale Variablen) zugreifen; auf die Variablen der aufrufenden View hat es keinen Zugriff. Gerade das macht es wiederverwendbar. (Die Bibliothek [Symfony UX Twig Component] bietet funktionsreichere Komponenten – [PHP]-Klassen, die einer View zugeordnet sind –, die wie HTML-Tags verwendet werden: [<twig:Card name="..." />]; wir werden sie nicht benötigen.)

4.3.5. Die Seiten

{# diese Seite ERWEITERT das Layout: sie liefert nur den Inhalt seiner Blöcke #}
{% extends 'layout.html.twig' %}
{# die Makros der Datei macros.html.twig unter dem Namen m #}
{% import 'macros.html.twig' as m %}

{% block 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.html.twig</code> layout.</p>
  {# das Makro [card], aufgerufen mit zwei direkt angegebenen Parametern #}
  {{ m.card('A macro', 'called with parameters written on the spot') }}
{% endblock %}
  • Zeile 2: Die Seite erweitert das Template: [Twig] erzeugt die Seite des Templates und ersetzt dessen Blöcke durch die von der Seite definierten. In einer View, die ein Template erweitert, muss sich der gesamte Inhalt innerhalb von Blöcken befinden: Außerhalb davon geschriebener Text erscheint nicht in der erzeugten Seite;
  • Zeile 4: [{% import %}] importiert Makros aus einer Datei unter einem frei wählbaren Namen ([m]);
  • Zeilen 6–12: der Block [content], der den gleichnamigen Slot füllt. Die Seite definiert den Block [title] nicht: Der Slot behält seinen Standardinhalt, „Home“;
  • Zeile 11: der Aufruf des Makros [card] als Funktion: [m.card(...)], innerhalb von [{{ }}], da es einzufügenden Text erzeugt. Seine Ausgabe wird nicht ein zweites Mal maskiert: [Twig] weiß, dass sie bereits HTML-sicher ist (ihre Parameter wurden hingegen innerhalb des Makros maskiert).
{% extends 'layout.html.twig' %}
{% import 'macros.html.twig' as m %}

{% block title %}Our team{% endblock %}

{% block content %}
  <h1>Our team</h1>
  <div class="row g-3">
    {% for member in members %}
      <div class="col-md-4">
        {# die Parameter des Makros sind beliebige Ausdrücke #}
        {{ m.card(member.name, member.role) }}
      </div>
    {% endfor %}
  </div>
{% endblock %}
  • Zeile 4: der Block [title] in einer einzigen Zeile;
  • Zeilen 8–15: eine Karte pro Teammitglied, in einem Raster von [Bootstrap] ([row], [col-md-4]: drei Spalten auf einem mittelgroßen oder großen Bildschirm, eine Spalte auf einem schmalen Bildschirm);
  • Zeile 12: Die Parameter des Makros sind beliebige Ausdrücke.

Der Controller enthält nichts Neues:

<?php
// src/Controller/PagesController.php: drei Seiten

namespace App\Controller;

use App\Model\Member;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

#[Route(methods: ['GET'])]
class PagesController extends AbstractController
{
    #[Route('/', name: 'home')]
    public function home(): Response
    {
        return $this->render('pages/home.html.twig');
    }

    #[Route('/team', name: 'team')]
    public function team(): Response
    {
        $members = [
            new Member('Marie Pélissier', 'Director'),
            new Member('Jacques Bromard', 'Developer'),
            new Member('Philippe Jandot', 'Graphic designer'),
        ];
        return $this->render('pages/team.html.twig', ['members' => $members]);
    }

    #[Route('/raw', name: 'raw')]
    public function raw(): Response
    {
        return $this->render('pages/raw.html.twig');
    }
}

Die dritte Seite schließlich verwendet das Template nicht:

<!doctype html>
{# diese View verwendet das Layout nicht: sie ist eine vollständige Seite #}
<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="{{ path('home') }}">Back to home</a></p>
</body>
</html>

4.3.6. Ausführung

Image

Image

Image

Die Teamseite, wie sie der Browser empfängt:

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="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/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 My site</footer>
  </div>
</body>
</html>

Der Browser hat eine vollständige Seite erhalten: Template, Fragment, Seite und Makros wurden auf dem Server zusammengesetzt. Die URLs der Stylesheets wurden von [path] und [asset] erzeugt: Es sind auf die Website bezogene URLs. Sie können überprüfen, ob die Stylesheets korrekt ausgeliefert 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
HTTP/1.1 200 OK
Cache-Control: public
Last-Modified: Sun, 27 Sep 2026 09:32:39 GMT
Content-Type: text/css; charset=UTF-8
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 von unserem Controller gesendet ([BinaryFileResponse] fügt das Änderungsdatum der Datei hinzu und erlaubt das Caching: [Cache-Control: public]); die zweite wurde direkt vom Entwicklungsserver gesendet, ohne [Symfony] zu durchlaufen. Zum Schluss ein Versuch, den Ordner zu verlassen:

curl -s -o /dev/null -w "%{http_code}\n" "http://localhost:8000/bootstrap/..%2F..%2F15-layout%2F.env"
404

(Die Optionen [-s -o /dev/null -w "%{http_code}\n"] zeigen nur den Antwortcode an; geben Sie unter [Windows] [-o NUL] ein).

4.4. Beispiel 16: Twig-Erweiterungen

Eine View muss oft Werte formatieren: einen Betrag mit seiner Währung, ein ausgeschriebenes Datum oder Text in Großbuchstaben. Dieser Code gehört nicht in die Action (die sich nicht um die Darstellung kümmert), und [Twig] erlaubt es nicht, ihn in der View zu schreiben (die kein [PHP] ausführen kann; siehe die Einleitung dieses Kapitels). Er wird als [PHP] geschrieben, in einer Erweiterung von [Twig]: einer Klasse, die der Sprache der Views eigene Filter, Funktionen oder Tests hinzufügt. Bibliotheken stellen fertige bereit, etwa [twig/intl-extra], das mit den Beispielen installiert wird und Datumsangaben und Beträge sprachabhängig formatiert. Makros schließlich erzeugen HTML-Fragmente (Beispiel 15).

16-extensions/
├── config/
│   └── services.yaml
├── src/
│   ├── Controller/
│   │   └── PagesController.php
│   ├── EventListener/
│   │   └── SetLanguage.php
│   ├── Model/
│   │   └── Product.php
│   ├── Twig/
│   │   └── FormatsExtension.php
│   └── Kernel.php
├── templates/
│   ├── fragments/
│   │   └── navbar.html.twig
│   ├── layout.html.twig
│   ├── macros.html.twig
│   └── pages/
│       ├── home.html.twig
│       └── products.html.twig
└── ...

4.4.1. Die Erweiterung: src/Twig/FormatsExtension.php

<?php
// src/Twig/FormatsExtension.php: eine Twig-EXTENSION, die der Sprache der Views
// zwei Filter hinzufügt: money und long_date

namespace App\Twig;

use DateTimeInterface;
use IntlDateFormatter;
use NumberFormatter;
use Symfony\Component\HttpFoundation\RequestStack;
use Twig\Extension\AbstractExtension;
use Twig\TwigFilter;

class FormatsExtension extends AbstractExtension
{
    // der Request-Stack, um die Sprache der aktuellen Anfrage zu kennen
    public function __construct(private RequestStack $requests)
    {
    }

    // die Filter der Extension: ihr Name in den Views und die Methode, die sie implementiert
    public function getFilters(): array
    {
        return [
            new TwigFilter('money', $this->money(...)),
            new TwigFilter('long_date', $this->longDate(...)),
        ];
    }

    // ein Betrag in Cent in einer Währung, im Format der Sprache der
    // Anfrage: 114990 -> "€1,149.90" auf Englisch, "1 149,90 €" auf Französisch.
    // Die PHP-Erweiterung intl kennt die Konventionen jedes Landes
    public function money(int $cents, string $currency = 'EUR'): string
    {
        $formatter = new NumberFormatter($this->language(), NumberFormatter::CURRENCY);
        return $formatter->formatCurrency($cents / 100, $currency);
    }

    // ein Datum in ausgeschriebenen Wörtern, in der Sprache der Anfrage: "Sunday, September 27, 2026"
    public function longDate(DateTimeInterface $day): string
    {
        $formatter = new IntlDateFormatter($this->language(), IntlDateFormatter::FULL, IntlDateFormatter::NONE);
        return $formatter->format($day);
    }

    private function language(): string
    {
        return $this->requests->getCurrentRequest()?->getLocale() ?? 'en';
    }
}
  • Zeile 14: Eine Erweiterung von [Twig] erbt von der Klasse [AbstractExtension]. Sie ist ein Service, wie jede Klasse im Ordner [src]; [Symfony] erkennt sie als Erweiterung ([autoconfigure]) und übergibt sie an [Twig];
  • Zeilen 17–19: Die Erweiterung benötigt die Sprache der aktuellen Anfrage. Sie erhält den Request-Stack ([RequestStack]), einen Service von [Symfony] , der die aktuelle Anfrage kennt (es gibt einen Stack, weil eine Anfrage intern eine weitere auslösen kann);
  • Zeilen 22–28: Die Methode [getFilters] liefert die Filter der Erweiterung: für jeden seinen Namen in den Views und die Funktion, die ihn implementiert. [$this->money(...)] (mit den drei Punkten) ruft die Methode nicht auf: Es macht daraus einen Wert – eine Funktion, die später aufgerufen werden kann (ein First-Class Callable). Eine Erweiterung kann auch Funktionen ([getFunctions]) und Tests ([getTests]) bereitstellen;
  • Zeilen 33–37: Formatierung eines in Cent empfangenen Betrags (siehe Beispiel 06). Das 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 [NumberFormatter], Teil der Erweiterung [intl] von [PHP], unterstützt die Konventionen aller Länder (sie verwendet Daten des Unicode-Projekts CLDR): Sie wird für eine Sprache und einen Stil erzeugt (hier [CURRENCY] für Beträge), und [formatCurrency] formatiert einen Betrag, wobei die Währung durch ihren internationalen Code bezeichnet wird ([EUR], [USD]). Der erste Parameter des Filters ist der gefilterte Wert; die folgenden Parameter sind seine Eigenschaften in der View ([priceCents|money('USD')]);
  • Zeilen 40–44: Formatierung eines Datums mit der Klasse [IntlDateFormatter] aus der Erweiterung [intl]: Der Stil [FULL] schreibt das Datum vollständig aus, einschließlich des Wochentags ([Sunday, September 27, 2026]); der Stil [NONE] für die Uhrzeit enthält sie nicht. Der Typ [DateTimeInterface] akzeptiert alle Datumsangaben von [PHP];
  • Zeilen 46–49: die Sprache ([fr], [en]) der aktuellen Anfrage oder Englisch, wenn es keine Anfrage gibt (zum Beispiel in einem Konsolenbefehl). Wir werden sehen, wer sie festlegt.

4.4.2. Die Sprache jeder Anfrage: src/EventListener/SetLanguage.php

<?php
// src/EventListener/SetLanguage.php: die Sprache jeder Anfrage

namespace App\EventListener;

use Symfony\Component\EventDispatcher\Attribute\AsEventListener;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\KernelEvents;

// priority: die Reihenfolge der Listener desselben Ereignisses (der höchste zuerst);
// 20: nach dem Routing (32), vor den Listenern von Symfony, die die Sprache verwenden (16, 15)
#[AsEventListener(event: KernelEvents::REQUEST, priority: 20)]
class SetLanguage
{
    // der URL-Parameter ?lang=fr, sonst Englisch
    public function __invoke(RequestEvent $event): void
    {
        $request = $event->getRequest();
        $request->setLocale($request->query->get('lang') === 'fr' ? 'fr' : 'en');
    }
}

Jede Anfrage hat eine Sprache (Locale), die standardmäßig der in der Konfiguration angegebenen Sprache [default_locale] entspricht ([en] , wenn nichts konfiguriert ist). Hier wählt der URL-Parameter [?lang=fr] Französisch; Englisch ist die Standardsprache. Ein Listener für das Ereignis [kernel.request] (Beispiel 12) legt sie vor jeder Action mit der Methode [setLocale] der Anfrage fest. Der Parameter [priority] des Attributs legt die Reihenfolge der Listener desselben Ereignisses fest: Die mit der höchsten Priorität werden zuerst ausgeführt (Standard ist 0). [Symfony] selbst hat mehrere Listener für [kernel.request]: das Routing (Priorität 32), gefolgt von denen, die sprachabhängige Services vorbereiten (16 und 15). Unserer muss zwischen beiden laufen: 20. Der Befehl [php bin/console debug:event-dispatcher kernel.request] zeigt alle Listener des Ereignisses in der richtigen Reihenfolge an. Die so festgelegte Sprache gilt nur für die aktuelle Anfrage: Bei der nächsten gilt wieder die Standardsprache. Das Kapitel über die Internationalisierung wird dieselbe Sprache verwenden, um die Texte zu übersetzen.

4.4.3. Die Konfiguration: config/services.yaml

# config/services.yaml: die Services der Anwendung (siehe Beispiel 06)
services:
    _defaults:
        autowire: true
        autoconfigure: true

    App\:
        resource: '../src/'

    # der Controller, der Bootstrap ausliefert, gemeinsam genutzt von den Beispielen 15 bis 28 (siehe Beispiel 15)
    Common\BootstrapController: ~

    # Intl-Extension von Twig (Bibliothek twig/intl-extra): die Filter
    # format_currency, format_date, format_number...
    Twig\Extra\Intl\IntlExtension: ~
  • Zeile 15: Die Filter der Bibliothek [twig/intl-extra] werden von der Erweiterung [IntlExtension] bereitgestellt. Ihre Klasse liegt nicht im Ordner [src]: Sie wird als Service deklariert, und [Symfony] erkennt sie als Erweiterung von [Twig] ([autoconfigure]). (In einem Standardprojekt erledigt das Paket [twig/extra-bundle], das von [Symfony Flex] installiert wird, dies selbst.)

4.4.4. Der Controller: src/Controller/PagesController.php

<?php
// src/Controller/PagesController.php: zwei Seiten

namespace App\Controller;

use App\Model\Product;
use DateTimeImmutable;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

#[Route(methods: ['GET'])]
class PagesController extends AbstractController
{
    #[Route('/', name: 'home')]
    public function home(): Response
    {
        return $this->render('pages/home.html.twig', ['today' => new DateTimeImmutable('today')]);
    }

    #[Route('/products', name: 'products')]
    public function products(): Response
    {
        return $this->render('pages/products.html.twig', ['products' => [
            new Product('keyboard', 2500, 12),
            new Product('mouse', 1250, 0),
            new Product('screen', 114990, 3),
        ]]);
    }
}

Die Actions übergeben den Views Rohwerte: ein Datum ([new DateTimeImmutable('today')], das heutige Datum um Mitternacht) und Beträge in Cent. Die Formatierung übernehmen die Views. Die Klasse [Product] vereint einen Namen, einen Preis (in Cent; siehe Beispiel 06) und einen Lagerbestand.

4.4.5. Die Views

{# ein Link der Navigationsleiste, der die Klasse [active] erhält, wenn die
   aktuelle Seite unter dem Pfad [path] liegt. app.request.pathInfo: der Pfad der
   aktuellen Anfrage; starts with: ein Twig-Test #}
{% macro link(href, path, text) %}
  <a class="nav-link{{ app.request.pathInfo starts with path ? ' active' }}" href="{{ href }}">{{ text }}</a>
{% endmacro %}

{# ein Bootstrap-Badge: grün, wenn das Produkt auf Lager ist, sonst rot #}
{% macro badge(stock) %}
  <span class="badge {{ stock > 0 ? 'text-bg-success' : 'text-bg-danger' }}">{{ stock > 0 ? stock ~ ' in stock' : 'sold out' }}</span>
{% endmacro %}
  • Zeilen 4–6: ein Makro, das einen Link für die Navigationsleiste erzeugt. Dem Link der aktuellen Seite wird die Klasse [active] von [Bootstrap] zugewiesen, die ihn hervorhebt. Ein Makro greift auf die globale Variable [app] zu (Beispiel 15): [app.request.pathInfo] ist der Pfad der aktuellen Anfrage; [starts with] ist ein Operator von [Twig], der den Anfang einer Zeichenkette prüft. Der ternäre Operator ohne „else“-Zweig ([condition ? ' active']) liefert eine leere Zeichenkette, wenn die Bedingung falsch ist (Beispiel 14);
  • Zeilen 9–11: ein Badge von [Bootstrap], grün ([text-bg-success]) oder rot ([text-bg-danger]) je nach Lagerbestand. Der Operator [~] von [Twig] verkettet zwei Zeichenketten (der [.] von [PHP]).
{% import 'macros.html.twig' as m %}
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">Extensions</span>
  <div class="navbar-nav">
    {# 1. eine in der View geschriebene Bedingung; app.current_route: der Name der aktuellen Route #}
    <a class="nav-link{{ app.current_route == 'home' ? ' active' }}" href="{{ path('home') }}">Home</a>
    {# 2. das Makro [link] #}
    {{ m.link(path('products'), '/products', 'Products') }}
    {# 3. path() erstellt die URL einer benannten Route; ein Parameter, der kein
         Parameter der Route ist, wird am Ende der URL angehängt: /products?lang=fr #}
    <a class="nav-link" href="{{ path('products', {lang: 'fr'}) }}">Produits (fr)</a>
  </div>
</nav>
  • Zeile 1: Ein eingebundenes Fragment (Beispiel 15) erbt die Importe der View, die es einbindet, nicht: Es importiert die Makros, die es benötigt, selbst;
  • Zeile 6: dasselbe wie beim Makro, direkt in der View geschrieben, mit dem ternären Operator. [app.current_route] ist der Name der Route der aktuellen Anfrage. Das Makro erspart es, die Bedingung für jeden Link zu wiederholen;
  • Zeile 8: der Aufruf des Makros;
  • Zeile 11: Ein Parameter von [path] , der kein Routenparameter ist, wird der URL als Parameter angehängt: [/products?lang=fr].
{% extends 'layout.html.twig' %}
{% block title %}Home{% endblock %}

{% block content %}
  <h1>Home</h1>
  {# unser Filter long_date #}
  <p>Today is {{ today|long_date }}.</p>
  {# app.request.locale: die Sprache der Anfrage, vom Listener SetLanguage festgelegt #}
  <p>Formatting language: {{ app.request.locale }}
    (<a href="{{ path('home', {lang: 'fr'}) }}">in French</a>, <a href="{{ path('home') }}">in English</a>)</p>
{% endblock %}
  • Zeile 7: unser Filter [long_date];
  • Zeile 9: [app.request.locale], die Sprache der Anfrage, festgelegt vom Listener [SetLanguage].
{% extends 'layout.html.twig' %}
{% import 'macros.html.twig' as m %}
{% block title %}Products{% endblock %}

{% block 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>
      {% for product in products %}
        <tr>
          {# ein Twig-Filter (upper), dann unser Filter money, ohne und dann mit einem Parameter #}
          <td>{{ product.name|upper }}</td>
          <td>{{ product.priceCents|money }}</td>
          <td>{{ product.priceCents|money('USD') }}</td>
          {# das Makro [badge] erstellt das HTML des Badges #}
          <td>{{ m.badge(product.stock) }}</td>
        </tr>
      {% endfor %}
    </tbody>
  </table>
  {# der Filter format_currency der Intl-Erweiterung: ein Betrag (hier in Einheiten), eine
     Währung und die Sprache der Anfrage #}
  <p>Total stock value: {{ (products|reduce((s, p) => s + p.priceCents * p.stock, 0) / 100)|format_currency('EUR', locale: app.request.locale) }}</p>
{% endblock %}
  • Zeile 13: ein Filter von [Twig];
  • Zeilen 14–15: unser Filter [money], zuerst mit seiner Standardwährung, dann mit einem Parameter;
  • Zeile 17: der Aufruf des Makros [badge];
  • Zeile 24: der Filter [format_currency] der Intl-Erweiterung: ein Betrag (hier in Euro: der Gesamtlagerbestand, berechnet durch [reduce], geteilt durch 100), eine Währung und die Sprache der Anfrage, übergeben über einen benannten Parameter von [Twig] ([locale: ...]). Diese Erweiterung stellt außerdem [format_date], [format_datetime], [format_number], [country_name], [language_name] ... bereit. Unser Filter [money] ist also doppelt vorhanden: Wir haben ihn geschrieben, um zu zeigen, wie man eine Erweiterung schreibt.

Das Template [layout.html.twig] ist eine vereinfachte Version des Templates aus Beispiel 15; sein Attribut [lang] erhält die Sprache der Anfrage ([<html lang="{{ app.request.locale }}">]).

4.4.6. Ausführung

Image

Image

Dieselbe Seite mit dem Parameter [?lang=fr]. Es ändert sich nur die Formatierung der Zahlen: Der Text selbst ist in den Views fest codiert. Das Kapitel über die Internationalisierung wird auch den Text übersetzen.

Image

Ein Auszug aus dem erzeugten HTML:

curl "http://localhost:8000/products?lang=en"
...
              <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>
...
    <p>Total stock value: €3,749.70</p>
...

4.5. Beispiel 17: Ein GET-Formular

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

  • [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, weitergegeben oder gefahrlos neu geladen werden;
  • [method="post"]: Die Felder werden in den Body der Anfrage aufgenommen (siehe Beispiel 11). Diese Methode verwendet ein Formular, das Daten ändert: eine Registrierung, ein Hinzufügen oder ein Löschen.

Dieses erste Formular ist eine Buchsuche. Es ist in der View von Hand in HTML geschrieben; die folgenden Beispiele verwenden für die Formulare die Form-Komponente von [Symfony].

4.5.1. Das Modell: src/Model/Book.php und SearchModel.php

<?php
// src/Model/Book.php: ein Buch

namespace App\Model;

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

namespace App\Model;

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–19: Das Modell der View enthält die Eingaben des Benutzers, die das Formular anzeigt, die Liste der vorgeschlagenen Genres und die Ergebnisse.

4.5.2. Der Controller: src/Controller/BooksController.php

<?php
// src/Controller/BooksController.php: ein per GET gesendetes Suchformular

namespace App\Controller;

use App\Model\Book;
use App\Model\SearchModel;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class BooksController extends AbstractController
{
    // 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;
    // zwei Routen für dieselbe Action: Das Attribut #[Route] kann wiederholt werden
    #[Route('/', name: 'books_home', methods: ['GET'])]
    #[Route('/search', name: 'books_search', methods: ['GET'])]
    public function search(Request $request): Response
    {
        // getString: der Parameter als String ('', falls er fehlt)
        $keyword = $request->query->getString('keyword');
        $genre = $request->query->getString('genre');
        $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 $this->render('books/search.html.twig', [
            'model' => new SearchModel($keyword, $genre, self::GENRES, $results),
        ]);
    }
}
  • Zeile 16: Eine private Klassenkonstante namens [self::GENRES] ([self] bezeichnet die aktuelle Klasse). Eine Konstante kann keine Objekte enthalten: Die Bücher werden daher von einer statischen Methode bereitgestellt (Zeilen 19–28). In einer realen Anwendung kämen sie aus einer Datenbank;
  • Zeilen 32–33: zwei Routen für dieselbe Action: Das Attribut [#[Route]] kann wiederholt werden. Beim ersten Aufruf ([/]) gibt es keine Parameter, und alle Bücher werden angezeigt;
  • Zeilen 37–38: Die Formularfelder werden als URL-Parameter gelesen (Beispiel 07). Die Methode [getString] liefert den Parameter als Zeichenkette zurück, leer, wenn er fehlt;
  • Zeilen 40–43: Filterung. Die Funktion [array_filter] behält die Elemente eines Arrays, für die die angegebene Funktion [true] zurückliefert: Ein Buch wird ausgewählt, wenn das Schlüsselwort leer ist oder in seinem Titel oder Autor vorkommt (auf beiden Seiten in Kleinbuchstaben; [mb_strtolower] behandelt Zeichen mit Akzenten korrekt), und wenn das Genre leer ist oder dem Genre des Buchs entspricht. [array_filter] behält die Schlüssel der ausgewählten Elemente (0, 2 ...): [array_values] nummeriert sie ab 0 neu;
  • Zeilen 44–46: das Modell der View.

4.5.3. Die View: templates/books/search.html.twig

{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">Book search</h1>
  {# method="get": die Felder werden in der URL gesendet (?keyword=...&genre=...) #}
  <form method="get" action="{{ path('books_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: das Feld zeigt erneut an, was eingegeben wurde (durch {{ }} maskiert) #}
      <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>
        {% for genre in model.genres %}
          {# das boolesche Attribut selected, geschrieben, wenn die Bedingung wahr ist, sonst weggelassen #}
          <option value="{{ genre }}"{{ genre == model.genre ? ' selected' }}>{{ genre }}</option>
        {% endfor %}
      </select>
    </div>
    <div class="col-auto">
      <button class="btn btn-primary" type="submit">Search</button>
    </div>
  </form>
  <p>{{ model.results|length }} book(s) found.</p>
  <ul>
    {% for book in model.results %}
      <li><i>{{ book.title }}</i>, {{ book.author }} ({{ book.genre }})</li>
    {% endfor %}
  </ul>
{% endblock %}
  • 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 Action ([$request->query->getString('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 mit einem Anführungszeichen ["] würde sonst das Attribut schließen);
  • Zeilen 14–20: eine Dropdown-Liste. Jede [<option>] hat einen Wert ([value]), der an den Server gesendet wird, und einen Text, der angezeigt wird. Die erste Option mit einem leeren 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. Der ternäre Operator ohne „else“-Teil schreibt es, wenn die Bedingung wahr ist, und schreibt andernfalls nichts. [==] ist die Gleichheit in [Twig];
  • Zeile 23: der Submit-Button;
  • Zeile 26: die Anzahl der Ergebnisse.

4.5.4. Ausführung

Image

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

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, diesmal per POST gesendet. Es zeigt, wie jeder Feldtyp mit seinem aktuellen Wert erneut angezeigt wird, wie der Browser die Werte der einzelnen Felder sendet und wie der Server prüft, ob ein empfangener Wert tatsächlich eine der verfügbaren Optionen ist. All das wie in Beispiel 17 von Hand zu schreiben, wäre aufwendig und repetitiv. [Symfony] delegiert diese Aufgabe an seine Form-Komponente: Ein Formular wird durch eine Klasse beschrieben, seinen Typ; [Symfony] erzeugt das HTML, liest die gesendeten Felder, konvertiert und validiert sie und zeigt das Formular mit den Eingaben des Benutzers und etwaigen Fehlern erneut an. Das ist das Gegenstück zu [WTForms] in [Python].

18-fields/
├── config/
│   └── packages/
│       ├── framework.yaml
│       └── twig.yaml
├── src/
│   ├── Controller/
│   │   └── FormController.php
│   ├── Form/
│   │   └── FieldsType.php
│   ├── Service/
│   │   └── ListsService.php
│   └── Kernel.php
├── templates/
│   ├── form/
│   │   └── form.html.twig
│   └── layout.html.twig
└── ...

4.6.1. Der Listen-Service: src/Service/ListsService.php

<?php
// src/Service/ListsService.php: die vom Formular angebotenen Listen. In einer
// echten Anwendung kämen sie aus einer Datenbank.

namespace App\Service;

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

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

    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 Vorbild von Beispiel 06: In einer realen Anwendung kämen sie aus einer Datenbank. Jede Liste ist ein assoziatives Array: Der Schlüssel ist der angezeigte Text und der Wert das, was an den Server gesendet wird (das ist die Reihenfolge, die die Form-Komponente erwartet).

4.6.2. Die Konfiguration

# config/packages/framework.yaml: die Konfiguration des FrameworkBundle
framework:
    secret: '%env(APP_SECRET)%'
    # die Meldungen (Fehler der Formulare) auf Englisch (siehe Beispiel 09)
    default_locale: en
    translator:
        default_path: '%kernel.project_dir%/translations'
    # die SESSION: Dort wird das Anti-CSRF-Token der Formulare aufbewahrt (siehe Beispiel 20)
    session: true
    # der Anti-CSRF-Schutz der Formulare (siehe weiter unten)
    csrf_protection: true
  • Zeilen 5–7: die Sprache und der Translator (Beispiel 09): Die Fehlermeldungen der Form-Komponente werden wie die des Validators auf Englisch sein;
  • Zeile 9: die Session des Benutzers, auf die wir in Beispiel 20 noch näher eingehen werden: Die Form-Komponente legt dort das Anti-CSRF-Token ab (siehe unten);
  • Zeile 11: der Anti-CSRF-Schutz für Formulare.
1
2
3
4
5
# config/packages/twig.yaml: die Konfiguration des TwigBundle
twig:
    default_path: '%kernel.project_dir%/templates'
    # das THEMA der Formulare: Die Felder werden mit den Bootstrap-5-Klassen gezeichnet
    form_themes: ['bootstrap_5_layout.html.twig']
  • Zeile 5: das Theme der Formulare. [Symfony] rendert jedes Feld mithilfe von [Twig]-Blöcken; ein Theme liefert die für ein CSS-Framework passende Version. Das Theme [bootstrap_5_layout.html.twig], das in [Symfony] enthalten ist, verwendet die Klassen von [Bootstrap] 5 ([form-control], [form-label], [is-invalid] ...). Die Anwendung kann eigene Themes schreiben oder einzelne Blöcke eines bestehenden Themes überschreiben.

4.6.3. Formulartyp: src/Form/FieldsType.php

<?php
// src/Form/FieldsType.php: die BESCHREIBUNG des Formulars: seine Felder, ihr Typ, ihre Optionen

namespace App\Form;

use App\Service\ListsService;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\ChoiceType;
use Symfony\Component\Form\Extension\Core\Type\DateType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\TextareaType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Validator\Constraints\NotBlank;

class FieldsType extends AbstractType
{
    // Ein Formulartyp ist ein Service: Er erhält den Listen-Service
    public function __construct(private ListsService $lists)
    {
    }

    // die Felder des Formulars in der Reihenfolge, in der sie angezeigt werden
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            // Radiobuttons: eine Liste von Auswahlmöglichkeiten (ChoiceType), „expanded“;
            // constraints: die Validierungs-Constraints des Feldes (siehe Beispiel 08)
            ->add('title', ChoiceType::class, [
                'choices' => $this->lists->titles(),
                'expanded' => true,
                'label_attr' => ['class' => 'radio-inline'],
                'constraints' => [new NotBlank(message: 'The title is required.')],
            ])
            // ein Eingabefeld; required => false: Das Feld ist nicht erforderlich
            ->add('name', TextType::class, ['required' => false])
            // ein Passwort: wird in der Seite nie wieder angezeigt
            ->add('password', PasswordType::class, ['label' => 'Password', 'required' => false])
            // ein Datum: ein Feld <input type="date">; der Wert ist ein String im Format yyyy-mm-dd
            ->add('birth_date', DateType::class, [
                'label' => 'Date of birth',
                'widget' => 'single_text',
                'input' => 'string',
                'required' => false,
            ])
            // Checkboxen: eine expandierte Liste von Auswahlmöglichkeiten mit MEHRFACHAUSWAHL
            ->add('hobbies', ChoiceType::class, [
                'choices' => $this->lists->hobbies(),
                'expanded' => true,
                'multiple' => true,
                'label_attr' => ['class' => 'checkbox-inline'],
                'required' => false,
            ])
            // Dropdown-Liste: eine Liste von Auswahlmöglichkeiten, die nicht expandiert ist
            ->add('country', ChoiceType::class, ['choices' => $this->lists->countries()])
            // Mehrfachauswahlliste, auf vier Zeilen angezeigt
            ->add('languages', ChoiceType::class, [
                'label' => 'Spoken languages',
                'choices' => $this->lists->languages(),
                'multiple' => true,
                'attr' => ['size' => 4],
                'required' => false,
            ])
            ->add('comment', TextareaType::class, ['required' => false, 'attr' => ['rows' => 2]])
            // ein verstecktes Feld
            ->add('token', HiddenType::class);
    }
}
  • Zeile 17: Ein Formulartyp erbt von der Klasse [AbstractType]. Er ist ein Service (im Ordner [src] gelegen): Er kann andere Services entgegennehmen, hier den Listen-Service (Zeile 20);
  • Zeile 25: Die Methode [buildForm] beschreibt die Felder, indem sie sie ([add]) einem Form-Builder hinzufügt: für jedes Feld seinen Namen, seinen Typ und seine Optionen. Der Feldname ist auch der Name der Daten, die es anzeigt; sein Label ist standardmäßig sein als Text formatierter Name ([name] wird zu „Name“);
  • Zeilen 30–35: Ein Feld [ChoiceType] ist eine Dropdown-Liste, die durch die Option [choices] definiert wird. Mit der Option [expanded] wird es zu einer Gruppe von Radiobuttons (einem Feld mit Einfachauswahl). Die Option [label_attr] weist dem Label der Gruppe eine Klasse zu: [radio-inline] legt im Theme nebeneinander angeordnete Buttons fest. Die Option [constraints] legt die Validierungs-Constraints des Felds fest (Beispiel 08): Eine Anrede ist erforderlich;
  • Zeile 37: Ein Feld [TextType] ist ein Eingabefeld. Die Option [required] hat standardmäßig den Wert [true]: [Symfony] setzt dann das HTML-Attribut [required], das der Browser prüft (Beispiel 19). Es sendet keinerlei Information an den Server: Es ist eine Constraint ([NotBlank]), die ein Feld für den Server verpflichtend macht;
  • Zeile 39: ein Passwort ([PasswordType]), das niemals an die Seite zurückgegeben wird: Sein Feld ist bei der Anzeige immer leer;
  • Zeilen 41–46: ein Datum ([DateType]), angezeigt durch ein einziges Feld [<input type="date">] (Option [widget]). Ein solches Feld tauscht seinen Wert mit dem Server im Format [yyyy-mm-dd] aus, unabhängig vom Format, in dem der Browser es anzeigt; die Option [input] legt fest, dass die Daten eine Zeichenkette sind (und kein Objekt [DateTime], was der Standard ist);
  • Zeilen 48–54: eine Dropdown-Liste mit Mehrfachauswahl ([multiple]): Kontrollkästchen;
  • Zeile 56: eine nicht erweiterte Liste mit Einfachauswahl: eine Dropdown-Liste;
  • Zeilen 58–64: eine nicht erweiterte Liste mit Mehrfachauswahl: eine Mehrfachauswahlliste, die über vier Zeilen angezeigt wird (das HTML-Attribut [size], festgelegt durch die Option [attr]);
  • Zeile 65: ein Textfeld ([TextareaType]) über zwei Zeilen;
  • Zeile 67: ein verstecktes Feld ([HiddenType]).

[Symfony] stellt etwa dreißig Feldtypen bereit: [EmailType], [IntegerType], [MoneyType], [UrlType], [CheckboxType], [FileType], [CountryType], [RepeatedType] (Beispiel 19), [CollectionType] (eine Liste von Unterformularen) ...

4.6.4. Der Controller: src/Controller/FormController.php

<?php
// src/Controller/FormController.php: ein Formular, das alle Feldtypen verwendet

namespace App\Controller;

use App\Form\FieldsType;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class FormController extends AbstractController
{
    // GET: das Formular mit Anfangswerten; POST: Die gesendeten Felder
    // werden gelesen, validiert und dann vom selben Formular erneut angezeigt
    #[Route('/form', name: 'form', methods: ['GET', 'POST'])]
    public function form(Request $request): Response
    {
        // die Anfangswerte (einer pro Feld, ein Array für ein Mehrfachfeld)
        $initial = ['title' => 'Mme', 'country' => 'fr', 'languages' => ['French'], 'token' => 'A7X2'];
        // createForm: das Formular, aus seiner Beschreibung gebaut
        $form = $this->createForm(FieldsType::class, $initial);
        // handleRequest: Ist die Anfrage ein POST, werden die empfangenen Felder
        // in das Formular kopiert und dann validiert
        $form->handleRequest($request);
        $model = ['form' => $form];
        if ($form->isSubmitted()) {
            // was der Browser tatsächlich gesendet hat, Feld für Feld
            $received = [];
            foreach ($request->request->all() as $name => $value) {
                foreach ((array) $value as $key => $v) {
                    $received[] = "{$name}[$key] = [".implode(', ', (array) $v).']';
                }
            }
            $model += [
                'received' => implode("\n", $received),
                'valid' => $form->isValid(),
                // getErrors(true): die Fehler aller Felder
                'errors' => $form->getErrors(true),
                // getData(): die Werte des Formulars, von jedem Feld umgewandelt
                'data' => $form->getData(),
            ];
        }
        return $this->render('form/form.html.twig', $model);
    }
}
  • Zeile 16: eine einzige Action für beide Methoden: GET zeigt das Formular an, POST verarbeitet es. Das ist die übliche Art, eine Formular-Action mit [Symfony] zu schreiben;
  • Zeile 20: die Anfangswerte des Formulars: ein assoziatives Array mit einem Wert pro Feld (einem Array für ein Feld mit mehreren Werten);
  • Zeile 22: [createForm] erzeugt das Formular – ein Objekt [Form] – anhand seines Typs und der Anfangsdaten;
  • Zeile 25: [handleRequest] untersucht die Anfrage. Bei einem GET tut es nichts. Bei einem POST, der die Formularfelder enthält, kopiert es sie in das Formular: Jedes Feld konvertiert seinen Wert (das Datum, die Listen usw.) und prüft, ob eine Auswahl zu den angebotenen gehört; danach validiert das Formular die Constraints und das Anti-CSRF-Token;
  • Zeile 27: [isSubmitted]: Wurde das Formular gesendet?;
  • Zeilen 29–34: für dieses Beispiel die Liste dessen, was der Browser tatsächlich gesendet hat. Die Felder eines [Symfony]-Formulars sind nach dem Formular benannt: [fields[name]], [fields[hobbies][]]. [PHP] organisiert sie daher in einem Array namens [fields] (Beispiel 10), das anschließend durchlaufen wird. [(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 35–42: Das Modell der View erhält, was der Server empfangen hat: das Validierungsergebnis ([isValid]), die Fehler ([getErrors(true)]: die aller Felder) und die Daten ([getData]) des Formulars, von jedem Feld konvertiert. Der Operator [+=] fügt diese Schlüssel dem Array [$model] hinzu;
  • Zeile 44: Das Formular wird an die View übergeben, die es zusammen mit den Eingaben des Benutzers und etwaigen Fehlern anzeigt.

4.6.5. Die View: templates/form/form.html.twig

{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">A complete form</h1>
  {# form_start: das Tag <form>, hier mit der Methode POST und der URL der Seite #}
  {{ form_start(form, {attr: {style: 'max-width: 40rem'}}) }}
    {# form_row: ein vollständiges Feld (Label, Eingabefeld, Fehler) #}
    {{ form_row(form.title) }}
    <div class="row g-2">
      <div class="col">{{ form_row(form.name) }}</div>
      <div class="col">{{ form_row(form.password) }}</div>
      <div class="col">{{ form_row(form.birth_date) }}</div>
    </div>
    {{ form_row(form.hobbies) }}
    <div class="row g-2">
      <div class="col">{{ form_row(form.country) }}</div>
      <div class="col">{{ form_row(form.languages) }}</div>
    </div>
    {{ form_row(form.comment) }}
    <button class="btn btn-primary" type="submit">Send</button>
  {# form_end: die restlichen Felder (das versteckte Feld, das Anti-CSRF-Token), dann </form> #}
  {{ form_end(form) }}

  {# is defined: true, wenn die empfangene Variable an die View übergeben wurde (Formular gesendet) #}
  {% if received is defined %}
    <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>
    <ul>
      {% for error in errors %}
        {# error.origin: das fehlerhafte Feld; error.message: die Meldung #}
        <li>{{ error.origin.getName() }}: {{ error.message }}</li>
      {% endfor %}
    </ul>
    {% if valid %}
      <p>The data of the form:</p>
      <ul>
        {# eine Schleife über ein assoziatives Array: der Schlüssel und der Wert #}
        {% for key, value in data %}
          <li>{{ key }}: {{ value is iterable ? value|join(', ') : value }}</li>
        {% endfor %}
      </ul>
    {% endif %}
  {% endif %}
{% endblock %}
  • Zeile 6: Die Funktion [form_start] schreibt das Tag [<form>]: standardmäßig die Methode POST und die URL der aktuellen Seite; der zweite Parameter fügt HTML-Attribute hinzu;
  • Zeile 8: Die Funktion [form_row] schreibt ein vollständiges Feld: sein Label, sein Eingabefeld (mit seinem aktuellen Wert) und seine Fehler, unter Verwendung der Klassen des Themes. [form.title] bezeichnet das Feld [title] im Formular. Sie können die Teile auch getrennt schreiben: [form_label], [form_widget], [form_errors];
  • Zeilen 9–19: die übrigen Felder, angeordnet durch die Raster-Klassen von [Bootstrap];
  • Zeile 22: [form_end] schreibt die noch nicht geschriebenen Felder (hier das versteckte Feld [token] und das versteckte Feld [_token], das Anti-CSRF-Token) und schließt dann das Tag [</form>];
  • Zeile 25: die Prüfung [is defined]: Die Variable [received] existiert erst nach einem Absenden;
  • Zeilen 30–33: die Fehler. Jeder ist ein Objekt [FormError], bei dem [origin] das Feld ist, das den Fehler enthält;
  • Zeilen 39–41: Eine Schleife [for] über ein assoziatives Array, die sowohl die Schlüssel als auch die Werte durchläuft. Der Test [is iterable] unterscheidet zwischen Arrays (zusammengefasst durch den Filter [join]) und einzelnen Werten.

Das gesamte Formular hätte in einer einzigen Zeile geschrieben werden können: [{{ form(form) }}]. Die Funktionen [form_start], [form_row], und [form_end] erlauben es, die Felder nach Belieben anzuordnen.

4.6.6. Ausführung

Image

Die Standardwerte sind sichtbar: der Radiobutton „Mme“, das Land „France“ und die Sprache „French“. Das erzeugte HTML lautet wie folgt (Auszüge, über mehrere Zeilen dargestellt):

<form name="fields" method="post" style="max-width: 40rem">
  <fieldset class="mb-3"><legend class="col-form-label required">Title</legend>
    <div id="fields_title">
      <div class="form-check form-check-inline">
        <input type="radio" id="fields_title_0" name="fields[title]" required="required" class="form-check-input" value="Mr" />
        <label class="form-check-label required" for="fields_title_0">Mr</label></div>
      <div class="form-check form-check-inline">
        <input type="radio" id="fields_title_1" name="fields[title]" required="required" class="form-check-input" value="Mme" checked="checked" />
...
  <div class="mb-3"><label for="fields_name" class="form-label">Name</label>
    <input type="text" id="fields_name" name="fields[name]" class="form-control" /></div>
...
    <input type="checkbox" id="fields_hobbies_0" name="fields[hobbies][]" class="form-check-input" value="reading" />
...
  <select id="fields_country" name="fields[country]" class="form-select">
    <option value="fr" selected="selected">France</option><option value="be">Belgium</option>...
  <select id="fields_languages" name="fields[languages][]" size="4" class="form-select" multiple="multiple">
    <option value="French" selected="selected">French</option>...
...
  <input type="hidden" id="fields_token" name="fields[token]" value="A7X2" />
  <input type="hidden" id="fields__token" name="fields[_token]" data-controller="csrf-protection" value="9863be7bac.KU7NzSfFyCspR2sfBG_fTqNV6UuMueZ2pOsuPACnvFo.X32P9UOQm1FPIxhHUVqHGvcBmWbl36Il8KJsCVnS8A1ZJYGudJSrRmwoWw" />
</form>

[Symfony] hat alles geschrieben: die Bezeichner ([fields_title_1]), die mit ihren Feldern verknüpften Labels, die auf [[]] endenden Namen bei Feldern mit mehreren Werten (Beispiel 10), die Attribute [checked] und [selected] der gemeinsamen Werte und die Klassen von [Bootstrap]. Das letzte versteckte Feld, [fields[_token]], enthält das Anti-CSRF-Token. Ein CSRF-Angriff (Cross-Site Request Forgery) besteht darin, dass eine bösartige Website den Browser ihres Opfers dazu bringt, 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 –, sodass die Anfrage legitim erscheint. Die Gegenmaßnahme: 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 Form-Komponente fügt jedem Formular dieses Token hinzu, und [handleRequest] lehnt jedes Formular ab, dessen Token fehlt oder falsch ist: Kein Formular kann es weglassen. (Das Attribut [data-controller] wird von einem optionalen Skript für [Symfony] verwendet, das den Schutz verstärkt; hier hat es keine Wirkung.) 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 für die Kontrollkästchen und die Dropdown-Liste; das Passwort wurde gesendet, wird aber in seinem Feld nicht erneut angezeigt. Das versteckte Feld [token] wurde unverändert zurückgesendet: So lassen sich Informationen hin und her senden, die der Benutzer nicht sieht (die Fallstudie nutzt 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. Das Anti-CSRF-Token ist ebenfalls unter den empfangenen Feldern enthalten; es gehört nicht zu den Formulardaten.

Senden wir nun mit [curl] ein Formular ohne Token und mit einem Land, das nicht als Option aufgeführt war:

curl -g -d "fields[name]=Martin&fields[country]=xx" http://localhost:8000/form
...
        <h2 class="h5 mt-3">What the server received</h2>
    <pre class="bg-light p-2 border">fields[name] = [Martin]
fields[country] = [xx]</pre>
    <p>Valid form: no</p>
    <ul>
                      <li>fields: The CSRF token is invalid. Please try to resubmit the form.</li>
                      <li>title: The title is required.</li>
                      <li>country: The selected choice is invalid.</li>
          </ul>
...

Das Formular ist aus drei Gründen ungültig : Das Anti-CSRF-Token fehlt (der Fehler ist dem Formular selbst zugeordnet), es wurde keine Anrede gesendet, und das Land [xx] gehört nicht zu den verfügbaren Optionen. Diese letzte Prüfung führt das Feld [ChoiceType] selbst durch, ohne dass wir sie verlangt hätten: Ein böswilliger Benutzer könnte alles Beliebige senden, nicht nur das, was die Seite angeboten hat. Die Meldungen sind auf Englisch: Die der Form-Komponente werden von [Symfony] übersetzt, ebenso wie die des Validators (Beispiel 09). Die Antwort hat den Statuscode 422 (Unprocessable Content): [render] wählt ihn automatisch, wenn ihm ein gesendetes, ungültiges Formular übergeben wird. Beachten Sie den Unterschied zu anderen Frameworks: [Symfony] lehnt die Anfrage nicht vor der Action ab; das Formular erklärt sich für ungültig, und die Action entscheidet, wie es weitergeht.

Damit das Token akzeptiert wird, muss sich [curl] 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. Die Option [--data-urlencode] kodiert den Wert des Tokens selbst:

curl -c cookies.txt http://localhost:8000/form
curl -b cookies.txt -g --data-urlencode "fields[_token]=9863be7bac.KU7N..." -d "fields[name]=Martin&fields[country]=xx" http://localhost:8000/form
1
2
3
4
5
6
...
    <ul>
                      <li>title: The title is required.</li>
                      <li>country: The selected choice is invalid.</li>
          </ul>
...

(Das Token ist das der Seite, die vom ersten Befehl empfangen wurde.) Es bleiben nur die beiden Eingabefehler.

4.7. Beispiel 19: Formularvalidierung

Ein Registrierungsformular, in dem jedes Feld eigene Validierungsregeln hat. Tritt ein Fehler auf, wird das Formular mit den Eingaben des Benutzers und einer Meldung unter jedem fehlerhaften Feld erneut angezeigt. Dieses Beispiel verwendet den Standardansatz von [Symfony]: Die Formulardaten sind ein Objekt, dessen Klasse die Constraints enthält (Beispiel 08); das Formular befüllt das Objekt und validiert es anschließend.

19-form-validation/
├── src/
│   ├── Controller/
│   │   └── RegistrationController.php
│   ├── Form/
│   │   └── RegistrationType.php
│   ├── Model/
│   │   └── Registration.php
│   └── Kernel.php
├── templates/
│   ├── registration/
│   │   ├── welcome.html.twig
│   │   └── registration.html.twig
│   └── layout.html.twig
└── ...

Die Dateien [config/packages/framework.yaml] und [config/packages/twig.yaml] sind die aus Beispiel 18.

4.7.1. Die Daten und ihre Constraints: src/Model/Registration.php

<?php
// src/Model/Registration.php: die Daten des Registrierungsformulars und ihre Constraints

namespace App\Model;

use Symfony\Component\Validator\Constraints as Assert;

class Registration
{
    #[Assert\NotBlank(message: 'The name is required.')]
    #[Assert\Length(max: 20, maxMessage: 'The name must not exceed 20 characters.')]
    public ?string $name = null;

    // Email: eine gültige Adresse mit vollständigem Domainnamen (example.com und nicht example)
    #[Assert\NotBlank(message: 'The email address is required.')]
    #[Assert\Email(message: 'Invalid email address.')]
    public ?string $email = null;

    #[Assert\NotBlank(message: 'The age is required.')]
    #[Assert\Range(notInRangeMessage: 'The age must be between 18 and 120 years.', min: 18, max: 120)]
    public ?int $age = null;

    #[Assert\NotBlank(message: 'The password is required.')]
    #[Assert\Length(min: 6, minMessage: 'The password must have at least 6 characters.')]
    public ?string $password = null;
}
  • Zeile 8: eine gewöhnliche Klasse, deren Eigenschaften öffentlich und veränderbar sind; das Formular befüllt sie nacheinander. Alle sind mit [null] initialisiert; das Objekt ist bei der ersten Anzeige leer;
  • Zeilen 10–12: Der Name ist erforderlich und darf 20 Zeichen nicht überschreiten. Jeder Constraint wird hier eine eigene Meldung auf Englisch zugewiesen (Beispiel 09): [message] für [NotBlank], [maxMessage] für die Überschreitung von [Length];
  • Zeilen 15–17: Die Constraint [Email] prüft, ob eine Adresse gültig ist, und verlangt einen vollqualifizierten Domainnamen ([example.com], nicht [example]);
  • Zeilen 19–21: Das Alter ist eine ganze Zahl zwischen 18 und 120 ([notInRangeMessage]: die Meldung für [Range] bei Vorgabe eines Minimums und eines Maximums). Das Formular hat die Eingabe in eine ganze Zahl konvertiert;
  • Zeilen 23–25: Das Passwort muss mindestens 6 Zeichen lang sein.

4.7.2. Das Formular: src/Form/RegistrationType.php

<?php
// src/Form/RegistrationType.php: die Felder des Registrierungsformulars

namespace App\Form;

use App\Model\Registration;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\EmailType;
use Symfony\Component\Form\Extension\Core\Type\IntegerType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\Form\Extension\Core\Type\RepeatedType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;

class RegistrationType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            // attr: zusätzliche HTML-Attribute auf dem Eingabefeld (für die
            // Validierung durch den Browser, siehe weiter unten)
            ->add('name', TextType::class, ['attr' => ['maxlength' => 20]])
            ->add('email', EmailType::class, ['label' => 'Email address'])
            // IntegerType: eine Ganzzahl; eine Eingabe, die keine ist, erzeugt
            // den Fehler invalid_message
            ->add('age', IntegerType::class, [
                'label' => 'Age',
                'attr' => ['min' => 18, 'max' => 120],
                'invalid_message' => 'An integer is expected.',
            ])
            // RepeatedType: ZWEI Felder, die denselben Wert erhalten müssen (das
            // Passwort und seine Bestätigung); ein einziger Wert in den Daten
            ->add('password', RepeatedType::class, [
                'type' => PasswordType::class,
                'first_options' => ['label' => 'Password', 'attr' => ['minlength' => 6]],
                'second_options' => ['label' => 'Confirmation'],
                'invalid_message' => 'The confirmation does not match the password.',
            ]);
    }

    // die Optionen des Formulars: Seine Daten sind ein Registration-Objekt
    public function configureOptions(OptionsResolver $options): void
    {
        $options->setDefaults(['data_class' => Registration::class]);
    }
}
  • Zeile 23: Die Option [attr] fügt dem Eingabefeld HTML-Attribute hinzu: [maxlength] begrenzt die Eingabe im Browser;
  • Zeile 24: Ein Feld [EmailType] erzeugt ein [<input type="email">], das der Browser validieren kann;
  • Zeilen 27–31: Ein Feld [IntegerType] erzeugt ein [<input type="number">] und konvertiert die Eingabe in eine ganze Zahl. Eine Eingabe, die keine ganze Zahl ist, kann nicht konvertiert werden: Das ist ein Konvertierungsfehler (kein Validierungsfehler; siehe Beispiel 08), dessen Fehlermeldung von der Option [invalid_message] geliefert wird;
  • Zeilen 34–39: Ein Feld [RepeatedType] besteht aus zwei Feldern (hier zwei [PasswordType]-Feldern), die denselben Wert enthalten müssen: das Passwort und seine Bestätigung. Jedes hat seine eigenen Optionen ([first_options], [second_options]); unterscheiden sich die beiden Eingaben, lautet der Fehler [invalid_message]. Die Daten haben nur einen Wert: das Passwort;
  • Zeilen 43–46: Die Methode [configureOptions] legt die Optionen des Formulars selbst fest: [data_class] gibt an, dass seine Daten ein Objekt [Registration] sind. Jedes Feld liest und schreibt die gleichnamige Eigenschaft.

[Symfony] kann den Typ eines Felds auch anhand der Constraints und des Typs der Eigenschaft ableiten: [->add('age')], das keinen Typ hat, würde einen [IntegerType] erzeugen, mit den aus [Range] abgeleiteten Attributen [min] und [max]. Wir haben dies der Klarheit halber ausdrücklich ausgeschrieben.

4.7.3. Der Controller: src/Controller/RegistrationController.php

<?php
// src/Controller/RegistrationController.php: ein vom Server validiertes Formular

namespace App\Controller;

use App\Form\RegistrationType;
use App\Model\Registration;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Attribute\MapQueryParameter;
use Symfony\Component\Routing\Attribute\Route;

class RegistrationController extends AbstractController
{
    // GET /register: das Formular; ?html5=true: Wir lassen den Browser es
    // vor dem Senden validieren. POST /register: das gesendete Formular
    #[Route('/register', name: 'register', methods: ['GET', 'POST'])]
    public function register(Request $request, #[MapQueryParameter] bool $html5 = false): Response
    {
        $registration = new Registration();
        $form = $this->createForm(RegistrationType::class, $registration);
        $form->handleRequest($request);
        // isValid: Die Felder konnten umgewandelt werden, und das Registration-Objekt
        // erfüllt seine Constraints
        if ($form->isSubmitted() && $form->isValid()) {
            return $this->render('registration/welcome.html.twig', ['registration' => $registration]);
        }
        // die erste Anzeige oder ein ungültiges Formular, erneut angezeigt mit der Eingabe
        // und den Fehlern (render sendet es dann mit dem Code 422 zurück)
        return $this->render('registration/registration.html.twig',
            ['form' => $form, 'html5' => $html5]);
    }
}
  • Zeile 19: Der Parameter [?html5=true] aktiviert die Validierung durch den Browser (siehe unten). [#[MapQueryParameter]] konvertiert ihn in einen booleschen Wert (Beispiel 07);
  • Zeilen 21–23: Das leere Objekt [Registration] wird an das Formular übergeben; [handleRequest] befüllt es mit den gesendeten Feldern;
  • Zeilen 26–28: [isValid] ist wahr, wenn jedes Feld konvertiert werden konnte und wenn das Objekt [Registration] seine Constraints erfüllt. Die Willkommensseite erhält dann das ausgefüllte Objekt (das folgende Beispiel wird zeigen, dass es besser ist, nach einem erfolgreichen POST weiterzuleiten);
  • Zeilen 31–32: Andernfalls wird das Formular angezeigt: leer bei der ersten Anzeige; nach einem ungültigen Absenden zeigt es die Eingaben und Fehler zusammen mit dem Code 422 (Beispiel 18).

Das ungültige Formular wird also von der POST-Action selbst erneut angezeigt, die Eingaben und Fehler behält: So geht [Symfony] vor. Andere Frameworks wie [Laravel] antworten stattdessen mit einer Weiterleitung auf die Formularseite und behalten Eingaben und Fehler für die nächste Anfrage in der Session.

4.7.4. Die Views

{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">Registration</h1>
  {% if html5 %}
    <p>Browser validation <b>enabled</b> - <a href="{{ path('register') }}">disable it</a></p>
  {% else %}
    <p>Browser validation <b>disabled</b> - <a href="{{ path('register', {html5: 'true'}) }}">enable it</a></p>
  {% endif %}
  {# novalidate: der Browser ignoriert die Attribute required, min ... und sendet
     das Formular unverändert; nur der Server validiert #}
  {{ form_start(form, {attr: html5 ? {} : {novalidate: 'novalidate'}}) }}
    {# form_widget: alle Felder des Formulars, jedes mit seinem Label und seinen Fehlern #}
    {{ form_widget(form) }}
    <button class="btn btn-primary" type="submit">Register</button>
  {{ form_end(form) }}
{% endblock %}

{% block page_bottom %}
  {# der globale Fehler am Seitenende auf hellrosa Hintergrund. vars: die
     Informationen des Formulars (gesendet? gültig?) #}
  {% if form.vars.submitted and not form.vars.valid %}
    <div class="error-area" role="alert">The form contains errors.</div>
  {% endif %}
{% endblock %}
  • Zeile 12: Das Attribut [novalidate] deaktiviert die Validierung durch den Browser: Das Formular wird unverändert gesendet, und nur der Server validiert es. Genau das wollen wir zuerst beobachten. Der ternäre Operator wählt zwischen zwei Arrays von Attributen;
  • Zeile 14: [form_widget(form)], auf das gesamte Formular angewendet, schreibt alle seine Felder, jeweils mit Label, Eingabefeld und Fehlermeldungen: Das Theme [Bootstrap] hebt ein ungültiges Feld rot hervor (Klasse [is-invalid]) und zeigt seine Meldung darunter an (Klasse [invalid-feedback]). Dafür mussten wir keine Komponenten schreiben;
  • Zeilen 19–25: der Block [page_bottom], definiert durch das Template (siehe unten). [form.vars] enthält die für die View berechneten Formulardaten: [submitted] (gesendet?), [valid] (gültig?), [value], [errors] ... Wurde das Formular gesendet und ist ungültig, erscheint eine allgemeine Meldung in einem Bereich, dessen Stil durch [public/css/styles.css] definiert ist (Beispiel 15). Das Attribut [role="alert"] kennzeichnet dies für Screenreader.
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Registration</title>
  <link rel="stylesheet" href="{{ path('bootstrap', {file: 'css/bootstrap.min.css'}) }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">
    <main>
      {% block content %}{% endblock %}
    </main>
    {# ein Block, den die Seiten füllen können, am Seitenende #}
    {% block page_bottom %}{% endblock %}
  </div>
</body>
</html>
  • Zeile 15: ein zweiter Block, [page_bottom], der standardmäßig leer ist: Ein Template kann beliebig viele Blöcke haben.
1
2
3
4
5
6
7
8
{% extends 'layout.html.twig' %}

{% block content %}
  {# registration: das Objekt Registration, vom Formular gefüllt #}
  <h1 class="h3">Welcome {{ registration.name }}</h1>
  <p>Your registration is saved: address <b>{{ registration.email }}</b>,
    age <b>{{ registration.age }}</b> years.</p>
{% endblock %}

[registration] ist das Objekt [Registration], befüllt und validiert: Beim Namen wurden die Leerzeichen entfernt (siehe unten), und das Alter ist eine ganze Zahl.

4.7.5. Ausführung

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

Image

Die Eingaben wurden beibehalten (außer den Passwörtern), und jeder Fehler wird unter dem zugehörigen Feld angezeigt. Der nur aus Leerzeichen bestehende Name wird als fehlend gemeldet: Die Form-Komponente entfernt die Leerzeichen um jede Eingabe (Feldoption [trim], standardmäßig auf true gesetzt). Beim Passwort gibt es hingegen nur einen Fehler, und zwar bei der Bestätigung: Wenn die beiden Eingaben voneinander abweichen, liefert das Feld [RepeatedType] keinen Wert, und die Länge wird nicht geprüft. Die URL ist die des Formulars, und [/register] zeigt an, dass die Seite von der Action als Antwort auf POST angezeigt wurde. Mit [curl] können Sie, indem Sie wie in Beispiel 18 das Anti-CSRF-Token mitsenden, auch etwas senden, was ein Browser nicht senden würde – ein nicht numerisches Alter:

curl -i -b cookies.txt -g --data-urlencode "registration[_token]=..." -d "registration[name]=Martin&registration[email]=martin@example.com&registration[age]=abc&registration[password][first]=abcdef&registration[password][second]=abcdef" http://localhost:8000/register
1
2
3
4
5
HTTP/1.1 422 Unprocessable Content
...
<input type="number" id="registration_age" name="registration[age]" required="required" min="18" max="120" aria-describedby="registration_age_error1" aria-invalid="true" class="form-control is-invalid" value="abc" />
<div class="invalid-feedback d-block" id="registration_age_error1">An integer is expected.</div>
...

Wir sehen die erneut angezeigten Eingaben, zusammen mit den HTML5-Attributen ([required], [min], [max]), der Klasse [is-invalid], der Konvertierungsmeldung und den Attributen [aria-...], die das Feld für Screenreader mit seiner Meldung verknüpfen.

4.7.6. Validierung durch den Browser

Entfernen wir das Attribut [novalidate], indem wir dem Link „aktivieren“ folgen (Parameter [?html5=true]). Der Browser prüft dann die Attribute [required], [type="email"], [min], [maxlength] ... vor dem Absenden des Formulars und zeigt eigene Meldungen in einem Tooltip unter dem ersten fehlerhaften Feld an („Bitte füllen Sie dieses Feld aus“, „Der Wert muss größer oder gleich 18 sein“ usw.): Das Formular wird nicht gesendet, solange ein Fehler vorliegt. [Symfony] erzeugt diese Attribute automatisch: [required] für jedes Feld (Option [required], z. B. 18), [type="email"] und [type="number"] je nach Feldtyp; [maxlength], [min], [max] und [minlength] stammen aus unseren Optionen [attr]. Sie müssen mit den Constraints konsistent bleiben.

Diese Validierung ist für den Benutzer bequem: Sie erfolgt sofort, ohne Hin und Her mit dem Server. Sie ersetzt jedoch 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 auf beiden Seiten eingegeben wurde, wurde vom Formular bereinigt:

Image

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

Wenn eine POST-Aktion mit einer Seite antwortet, ist diese Seite das Ergebnis eines POST. Lädt der Benutzer die Seite neu (drückt [F5]), sendet der Browser die POST-Anfrage erneut, nachdem er eine Warnung angezeigt hat, die kaum jemand liest: Der Befehl wird zweimal gesendet, und die Nachricht wird zweimal veröffentlicht. Das Post/Redirect/Get-Muster (PRG) vermeidet dieses Problem: Eine erfolgreiche POST-Aktion liefert keine Seite zurück, sondern antwortet mit einer Weiterleitung (Beispiel 04) auf eine GET-Seite, die der Browser sofort abruft. Das Neuladen dieser Seite führt lediglich die GET-Aktion erneut aus.

Ein Problem bleibt: Die GET-Seite möchte eine Nachricht anzeigen („Die Aufgabe wurde hinzugefügt“), aber diese Nachricht kennt die POST-Aktion, und sie kann keine Variable an eine Anfrage übergeben, die noch nicht stattgefunden hat. Die Lösung: Die Flash-Nachricht, die von der POST-Aktion in der Session abgelegt wird, bleibt erhalten, bis sie gelesen und angezeigt wurde, und wird dann verworfen.

4.8.1. Konfiguration: config/packages/framework.yaml

# config/packages/framework.yaml: die Konfiguration des FrameworkBundle
framework:
    secret: '%env(APP_SECRET)%'
    # die SESSION: Ihre Daten werden auf dem Server gespeichert, eine Datei pro Session,
    # im Ordner var/sessions/dev (handler_id: null: die eigenen Dateien von PHP)
    session:
        handler_id: null
        save_path: '%kernel.project_dir%/var/sessions/%kernel.environment%'
    # die LOCKS (Komponente Lock): gesperrte Dateien (flock) im Ordner var/lock
    lock: 'flock://%kernel.project_dir%/var/lock'
  • Zeilen 6–8: die Session des Benutzers (Kapitel über Gültigkeitsbereiche): browserspezifische Daten, die von einer Anfrage zur nächsten erhalten bleiben. Sie wird auf dem Server gespeichert; der Browser hält nur einen Bezeichner dafür in einem Cookie. [handler_id: null] überlässt das Speichern dieser Daten [PHP] selbst, das jede Session in einer Datei ablegt; [save_path] wählt den Ordner – [var/sessions/dev] –, damit wir sie untersuchen können. [%kernel.environment%] ist die Umgebung ([dev]);
  • Zeile 10: die Sperren (die Lock-Komponente, weiter unten beschrieben), gespeichert im Ordner [var/lock].

4.8.2. Der Service: src/Service/TasksService.php

<?php
// src/Service/TasksService.php: die Liste der Aufgaben, die von allen
// Benutzern gemeinsam genutzt wird. In PHP überleben Objekte die Anfrage nicht: Die Liste wird
// im CACHE der Anwendung gespeichert (hier eine Datei im Ordner var/cache/dev/pools)

namespace App\Service;

use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\Lock\LockFactory;

class TasksService
{
    private const KEY = 'tasks';

    // der Cache der Anwendung (der Service cache.app) und die Lock-Factory
    public function __construct(
        private CacheItemPoolInterface $cache,
        private LockFactory $locks,
    ) {
    }

    /** @return list<string> */
    public function list(): array
    {
        // das unter dem Schlüssel [tasks] gespeicherte Cache-Element; isHit: Es existiert
        $item = $this->cache->getItem(self::KEY);
        return $item->isHit() ? $item->get() : ['Read chapter 3'];
    }

    public function add(string $label): void
    {
        // Mehrere Anfragen können GLEICHZEITIG laufen (der Server verarbeitet
        // sie in mehreren Prozessen): Ein Lock garantiert, dass immer nur eine
        // die Liste liest, ändert und zurückschreibt
        $lock = $this->locks->createLock('tasks');
        // acquire(true): warten, bis der Lock frei ist, und ihn dann nehmen
        $lock->acquire(true);
        try {
            $tasks = $this->list();
            $tasks[] = $label;
            // das Cache-Element erhält seinen neuen Wert, ohne Zeitbegrenzung
            $item = $this->cache->getItem(self::KEY);
            $this->cache->save($item->set($tasks));
        } finally {
            // finally: Der Lock wird in jedem Fall freigegeben, auch nach einer Exception
            $lock->release();
        }
    }
}

Die Aufgabenliste wird von allen Benutzern gemeinsam genutzt und muss von einer Anfrage zur nächsten erhalten 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 Anwendungs-Cache, den wir hier verwenden.

  • Zeilen 16–20: Der Service erhält zwei Services von [Symfony]. Der erste ist der Anwendungs-Cache (der Service [cache.app] aus der Cache-Komponente), ein Speicher für Schlüssel-Wert-Paare, repräsentiert durch das standardisierte Interface [CacheItemPoolInterface] (der PSR-6-Standard). Standardmäßig speichert er seine Werte in Dateien im Ordner [var/cache/dev/pools]; in der Produktion wird ein dedizierter Server bevorzugt, etwa [Redis] (eine Konfigurationszeile). Der zweite ist die Lock-Factory der Lock-Komponente;
  • Zeilen 23–28: [getItem] ruft das Cache-Element ab, das unter einem Schlüssel gespeichert ist; [isHit] prüft, ob es existiert, und [get] liefert seinen Wert. Es kann jeder beliebige Wert gespeichert werden (hier ein Array von Zeichenketten): [Symfony] serialisiert ihn – das heißt, es wandelt ihn in Text um – mit der Funktion [serialize] von [PHP];
  • Zeilen 35–47: Der Entwicklungsserver kann wie ein Produktionsserver mehrere Anfragen gleichzeitig in mehreren Prozessen verarbeiten (die Umgebungsvariable [PHP_CLI_SERVER_WORKERS] legt die Anzahl der Prozesse von [php -S] fest). Zwei gleichzeitige Hinzufügungen könnten dieselbe Liste lesen, jeweils ihre eigene Aufgabe hinzufügen und die Liste zurückschreiben: Der zweite Schreibvorgang würde die erste Aufgabe überschreiben. Eine Sperre stellt sicher, dass immer nur eine Anfrage den Code ausführt, den sie schützt: [createLock('tasks')] erstellt eine benannte Sperre; [acquire(true)] wartet, bis sie verfügbar ist, und erwirbt sie dann; [release()] gibt sie frei. Hier ist die Sperre eine Datei im Ordner [var/lock], die vom Betriebssystem gesperrt wird (die Funktion [flock]); alternativ würden sich mehrere Server eine Sperre teilen, die in [Redis] oder in einer Datenbank gespeichert ist;
  • Zeilen 38–47: Der Block [try] … [finally] stellt sicher, dass die Sperre in jedem Fall freigegeben wird, selbst wenn eine Exception den Code unterbricht, den sie schützt;
  • Zeilen 42–43: Das Cache-Element erhält seinen neuen Wert ([set]), danach wird es gespeichert ([save]). Ohne angegebene Lebensdauer bleibt es unbegrenzt erhalten ([expiresAfter(3600)] würde es eine Stunde lang aufbewahren).

4.8.3. Der Controller: src/Controller/TasksController.php

<?php
// src/Controller/TasksController.php: das Muster Post / Redirect / Get

namespace App\Controller;

use App\Service\TasksService;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

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

    // GET /tasks: die Liste und das Formular zum Hinzufügen
    #[Route('/tasks', name: 'tasks', methods: ['GET'])]
    public function display(): Response
    {
        return $this->render('tasks/tasks.html.twig', ['tasks' => $this->tasks->list()]);
    }

    // POST /tasks: das Muster Post / Redirect / Get
    #[Route('/tasks', name: 'tasks_add', methods: ['POST'])]
    public function add(Request $request): Response
    {
        $label = trim($request->request->getString('label'));
        if ($label === '' || mb_strlen($label) > 40) {
            // ungültige Eingabe: Wir zeigen die Seite ohne Weiterleitung erneut an
            return $this->render('tasks/tasks.html.twig', ['tasks' => $this->tasks->list(),
                'label' => $label,
                'error' => 'The label must have 1 to 40 characters.']);
        }
        $this->tasks->add($label);
        // addFlash legt eine „Flash“-Meldung in der Session ab: Sie überlebt die
        // Weiterleitung, für die NÄCHSTE Anfrage
        $this->addFlash('success', "The task [$label] has been added.");
        // keine Seite: eine Weiterleitung auf die GET-Seite
        return $this->redirectToRoute('tasks');
    }

    // POST /tasks/without-prg: das Gegenbeispiel (eine Seite als Antwort auf den POST)
    #[Route('/tasks/without-prg', name: 'tasks_without_prg', methods: ['POST'])]
    public function addWithoutPrg(Request $request): Response
    {
        $this->tasks->add(trim($request->request->getString('label')) ?: '(untitled)');
        return $this->render('tasks/tasks.html.twig', ['tasks' => $this->tasks->list(), 'withoutPrg' => true]);
    }
}
  • Zeilen 29–35: Die Eingabe wird manuell validiert, um das Beispiel knapp zu halten ([trim] entfernt die umgebenden Leerzeichen). Eine ungültige Eingabe wird erneut angezeigt (ohne Weiterleitung): Es gibt nichts, wovor man sich bei einer doppelten Übermittlung schützen müsste, da nichts verändert wurde;
  • Zeile 39: Die Methode [addFlash] von [AbstractController] legt eine Flash-Nachricht vom Typ [success] in der Session ab (der Typ ist beliebig: Er erlaubt es, zwischen Erfolgs- und Fehlermeldungen usw. zu unterscheiden);
  • Zeile 41: die Weiterleitung auf die GET-Seite mit dem Namen [tasks] (Beispiel 04);
  • Zeilen 45–50: das Gegenbeispiel: eine Seite als Antwort auf POST. Der Operator [?:] liefert seinen linken Operanden, wenn dieser „wahr“ ist (hier ein nicht leerer String), andernfalls den rechten Operanden.

4.8.4. Die Views

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Tasks</title>
  <link rel="stylesheet" href="{{ path('bootstrap', {file: 'css/bootstrap.min.css'}) }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">
    {# die Flash-Nachrichten [success] am Seitenanfang: VOR der Weiterleitung hinterlegt;
       app.flashes ENTFERNT sie beim Lesen aus der Sitzung #}
    {% for message in app.flashes('success') %}
      <div class="alert alert-success" role="status">{{ message }}</div>
    {% endfor %}
    <main>
      {% block content %}{% endblock %}
    </main>
    {% if error is defined %}
      <div class="error-area" role="alert">{{ error }}</div>
    {% endif %}
  </div>
</body>
</html>
  • Zeilen 13–15: [app.flashes('success')] liefert die Liste der Flash-Nachrichten vom Typ [success] und entfernt sie aus der Session: Eine Flash-Nachricht wird nur einmal angezeigt. Die Klasse [alert alert-success] von [Bootstrap] zeigt die Nachricht in einem grünen Rahmen an;
  • Zeilen 19–21: die Fehlermeldung am Ende der Seite, wenn die Aktion eine erzeugt hat.
{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">My tasks</h1>
  <ol>
    {% for task in tasks %}
      <li>{{ task }}</li>
    {% endfor %}
  </ol>
  <form method="post" action="{{ path('tasks_add') }}" class="d-flex gap-2">
    <input class="form-control" name="label" value="{{ label ?? '' }}" placeholder="New task">
    <button class="btn btn-primary text-nowrap" type="submit">Add</button>
    {# formaction: dieser Button sendet dasselbe Formular an eine andere Adresse #}
    <button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="{{ path('tasks_without_prg') }}">Add without PRG</button>
  </form>
  {% if withoutPrg is defined %}
    <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>
  {% endif %}
{% endblock %}
  • Zeile 11: der Operator [??] von [Twig] liefert seinen rechten Operanden, wenn der linke nicht existiert (oder gleich [null] ist): Die Variable [label] existiert nur nach einer ungültigen Eingabe;
  • Zeile 14: Das [formaction]-Attribut eines Buttons sendet das Formular an eine andere Adresse als die in seinem [action]-Attribut angegebene: So kann ein einzelnes Formular zwei verschiedene Aktionen auslösen.

Diesem handcodierten Formular fehlt ein Anti-CSRF-Token: Um das Beispiel einfach zu halten, ergänzen wir es im nächsten Beispiel.

4.8.5. Wo werden Flash-Nachrichten gespeichert?

Zwischen der POST-Anfrage und der darauffolgenden GET-Anfrage muss die Nachricht irgendwo gespeichert werden: in der Session des Benutzers oder auf dem Server. Untersuchen wir das mit [curl] und speichern dabei die Cookies in einer Datei (Optionen [-c] und [-b], Beispiel 18):

curl -i -b cookies.txt -c cookies.txt -d "label=Do%20the%20exercises" http://localhost:8000/tasks
1
2
3
4
5
6
7
HTTP/1.1 302 Found
Cache-Control: max-age=0, must-revalidate, private
Location: /tasks
Content-Type: text/html; charset=utf-8
Expires: Sun, 27 Sep 2026 09:36:41 GMT
Set-Cookie: PHPSESSID=1e1f574eccd93268b1eb829dd714a029; path=/; httponly; samesite=lax
...

Die Antwort auf POST ist eine Weiterleitung (Statuscode 302, Header [Location]) in Begleitung des Session-Cookies [PHPSESSID] (der Name, den [PHP] diesem Cookie gibt), das die Session-ID enthält: 32 zufällige Zeichen, die sich unmöglich erraten lassen. Dieses Cookie ist [httponly] (das [JavaScript] auf der Seite kann es nicht lesen) und [samesite=lax] (der Browser sendet es nicht mit einer POST-Anfrage, die von einer anderen Website stammt). Die Header [Cache-Control] und [Expires] verhindern das Caching einer Antwort, die von einer Session abhängt. Der Bezeichner ist zugleich der Name der Session-Datei auf dem Server: [var/sessions/dev/sess_1e1f574eccd93268b1eb829dd714a029]. Hier ist diese Datei nach der POST-Anfrage:

_symfony_flashes|a:1:{s:7:"success";a:1:{i:0;s:43:"The task [Do the exercises] has been added.";}}_sf2_meta|a:3:{s:1:"u";i:1790501801;s:1:"c";i:1790501801;s:1:"l";i:0;}

Das ist das Serialisierungsformat für Sessions in [PHP]: Jedes Stück Session-Daten wird in der Form [name|serialized value] geschrieben. [a:1:{...}] deklariert ein Array mit einem Element, [s:7:"success"] ein 7-Byte-String ... Sie enthält Flash-Nachrichten ([_symfony_flashes]), nach Typ sortiert, und Metadaten von [Symfony] ([_sf2_meta]: Erstellungsdatum der Session und Datum ihrer letzten Verwendung). Folgen wir der Weiterleitung und senden das Cookie zurück:

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 Nachricht wird von [app.flashes] angezeigt und aus der Session entfernt. Die nun leere Session ist sogar verschwunden: [Symfony] speichert keine leere Session, und die Datei wurde gelöscht. Eine neue GET-Anfrage würde die Nachricht nicht mehr anzeigen. Die Aufgabenliste hingegen wird in einer Cache-Datei gespeichert, deren Name aus dem Schlüssel berechnet wird ([var/cache/dev/pools/app/VT2eLxVxyZ/P/W/CElt3eODhIKkushDZW1A]):

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

Die erste Zeile ist das Ablaufdatum des Werts (0: nie), die zweite der Schlüssel und die dritte die serialisierte Liste. Die Sperre ist eine leere Datei, [var/lock/sf.tasks.CFFUCEx.lock], die das System für die Dauer einer Änderung sperrt.

4.8.6. Ausführung

Hinzufügen einer Aufgabe: Der Browser ist der Weiterleitung gefolgt; die URL ist die 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] klicken, fragt der Browser, ob Sie das Formular erneut senden möchten; wenn Sie zustimmen, wird die Aufgabe ein zweites Mal hinzugefügt.

Image

Ein Prinzip des HTTP-Protokolls: Eine GET-Anfrage ändert nichts. Browser, Suchmaschinen und Tools, die Seiten vorab laden, folgen Links ohne Weiteres, ohne den Benutzer um Erlaubnis zu fragen. Ein „Löschen“-Link ([<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:

  • Ansehen erfolgt über einen Link ([<a href>]), der eine GET-Anfrage sendet;
  • Ä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. Konfiguration: config/packages/framework.yaml

# config/packages/framework.yaml: die Konfiguration des FrameworkBundle
framework:
    secret: '%env(APP_SECRET)%'
    # Ein POST-Formular, das ein Feld _method enthält (DELETE, PUT...), wird
    # als Anfrage dieser Methode behandelt
    http_method_override: true
    # die Session (Flash-Meldungen, Anti-CSRF-Tokens), gespeichert in var/sessions (siehe Beispiel 20)
    session:
        handler_id: null
        save_path: '%kernel.project_dir%/var/sessions/%kernel.environment%'
    csrf_protection: true
    lock: 'flock://%kernel.project_dir%/var/lock'
  • Zeile 6: Ein HTML-Formular kann nur GET- und POST-Anfragen senden. Das HTTP-Protokoll sieht jedoch weitere Methoden vor: DELETE zum Löschen sowie PUT und PATCH zum Ändern. [Symfony] umgeht diese Einschränkung: Mit der Option [http_method_override] wird ein POST-Formular mit einem versteckten Feld [_method] mit dem Wert [DELETE] (oder [PUT], [PATCH]) als Anfrage mit dieser Methode behandelt. Das ist Method Spoofing;
  • die übrigen Zeilen stammen aus den Beispielen 18 und 20: die Session, der CSRF-Schutz und die Sperren.

4.9.2. Der Service: src/Service/ContactsService.php

<?php
// src/Service/ContactsService.php: die Kontakte, von allen gemeinsam genutzt, gespeichert im
// Cache der Anwendung (siehe Beispiel 20)

namespace App\Service;

use App\Model\Contact;
use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\Lock\LockFactory;

class ContactsService
{
    private const KEY = 'contacts';

    public function __construct(
        private CacheItemPoolInterface $cache,
        private LockFactory $locks,
    ) {
    }

    /** @return array{contacts: list<Contact>, lastId: int} */
    private function data(): array
    {
        $item = $this->cache->getItem(self::KEY);
        return $item->isHit() ? $item->get() : [
            '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 Lock: Die Funktion erhält die Daten,
    // ändert sie (&) und gibt das Ergebnis der Operation zurück
    private function editData(callable $operation): mixed
    {
        $lock = $this->locks->createLock('contacts');
        $lock->acquire(true);
        try {
            $data = $this->data();
            $result = $operation($data);
            $this->cache->save($this->cache->getItem(self::KEY)->set($data));
            return $result;
        } finally {
            $lock->release();
        }
    }

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

    // der Kontakt oder null, wenn 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 das Element i aus dem Array und nummeriert die folgenden neu
                    array_splice($data['contacts'], $i, 1);
                    return $contact;
                }
            }
            return null;
        });
    }
}

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

  • Zeilen 37–49: Alle Änderungen folgen demselben Muster: Sperre erwerben, Daten lesen, ändern, zurückschreiben und die Sperre freigeben. Diese Methode schreibt einmal in das Array; jeder Änderung wird eine Funktion übergeben (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). Das Schlüsselwort [use] in einer anonymen Funktion gibt ihr Zugriff auf Variablen der umgebenden Funktion (Zeile 65: [$id], [$name], [$phone]);
  • Zeile 44: Die Aufrufe folgen aufeinander: [getItem] liefert das Element, [set] weist ihm einen Wert zu und gibt das Element selbst zurück, [save] speichert es;
  • Zeilen 63–75: Ein Kontakt ist unveränderlich: Es wird ein neuer erstellt, 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 80: [++] vor einer Variablen erhöht diese um 1 und gibt den neuen Wert zurück;
  • Zeile 92: [array_splice] entfernt ein Element aus dem Array und nummeriert die nachfolgenden Elemente neu;
  • Die Methoden geben [null] für einen nicht existierenden Kontakt zurück: Der Controller entscheidet über die Antwort.

4.9.3. Das Formular für den Datensatz: src/Form/ContactType.php

<?php
// src/Form/ContactType.php: das Formular mit den Details eines Kontakts, mit ZWEI Submit-Buttons

namespace App\Form;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\Validator\Constraints\NotBlank;

class ContactType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('name', TextType::class, ['constraints' => [new NotBlank()]])
            ->add('phone', TextType::class, ['label' => 'Phone', 'constraints' => [new NotBlank()]])
            // zwei Submit-Buttons: Das Formular weiß, auf welchen geklickt wurde
            ->add('save', SubmitType::class, ['attr' => ['class' => 'btn-primary']])
            ->add('duplicate', SubmitType::class, ['attr' => ['class' => 'btn-outline-primary']]);
    }
}
  • Zeilen 17–18: Die beiden Felder sind Pflichtfelder;
  • Zeilen 20–21: zwei Submit-Buttons ([SubmitType]) sind Teil des Formulars. Beim Absenden des Formulars sendet der Browser den Namen des angeklickten Buttons, und das Formular weiß, welcher es ist. Die Option [attr] weist ihnen ihre Klassen aus [Bootstrap] zu.

4.9.4. Der Controller: src/Controller/ContactsController.php

<?php
// src/Controller/ContactsController.php: Links (GET) und Buttons (POST, DELETE)

namespace App\Controller;

use App\Form\ContactType;
use App\Model\Contact;
use App\Service\ContactsService;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Form\SubmitButton;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\Routing\Attribute\Route;

#[Route('/contacts', name: 'contacts')]
class ContactsController extends AbstractController
{
    public function __construct(private ContactsService $contacts)
    {
    }

    // der Kontakt oder eine 404-Antwort, wenn er nicht existiert
    private function contactOr404(?Contact $contact): Contact
    {
        return $contact ?? throw $this->createNotFoundException('unknown contact');
    }

    // ein LINK (<a href>): eine GET-Anfrage, die nichts ändert
    #[Route('', name: '', methods: ['GET'])]
    public function list(): Response
    {
        return $this->render('contacts/list.html.twig', ['contacts' => $this->contacts->list()]);
    }

    // GET /contacts/2: die Details; POST /contacts/2: einer seiner beiden Buttons
    #[Route('/{id<\d+>}', name: '_details', methods: ['GET', 'POST'])]
    public function details(Request $request, int $id): Response
    {
        $contact = $this->contactOr404($this->contacts->read($id));
        $form = $this->createForm(ContactType::class,
            ['name' => $contact->name, 'phone' => $contact->phone]);
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            ['name' => $name, 'phone' => $phone] = $form->getData();
            $duplicate = $form->get('duplicate');
            // isClicked: der Button, der das Formular gesendet hat
            if ($duplicate instanceof SubmitButton && $duplicate->isClicked()) {
                $copy = $this->contacts->add("$name (copy)", $phone);
                $this->addFlash('success', "The contact [$copy->name] has been created.");
            } else {
                $this->contacts->edit($id, $name, $phone);
                $this->addFlash('success', "The contact [$name] has been edited.");
            }
            return $this->redirectToRoute('contacts');
        }
        return $this->render('contacts/details.html.twig', ['contact' => $contact, 'form' => $form]);
    }

    // eine DELETE-Anfrage, simuliert durch ein POST-Formular (verstecktes Feld _method)
    #[Route('/{id<\d+>}', name: '_delete', methods: ['DELETE'])]
    public function delete(Request $request, int $id): Response
    {
        // das Anti-CSRF-Token des Formulars, spezifisch für diesen Kontakt
        if (! $this->isCsrfTokenValid("delete-contact-$id", $request->request->getString('_token'))) {
            throw new AccessDeniedHttpException('invalid anti-CSRF token');
        }
        $contact = $this->contactOr404($this->contacts->delete($id));
        $this->addFlash('success', "The contact [$contact->name] has been deleted.");
        return $this->redirectToRoute('contacts');
    }
}
  • Zeile 16: das Namenspräfix [contacts]: Die Route für die Liste, deren Name leer ist (Zeile 30), heißt daher [contacts], und die für den Datensatz heißt [contacts_details] ...;
  • Zeilen 24–27: eine Hilfsfunktion: Ein nicht existierender Kontakt beendet die Aktion mit einer 404-Antwort;
  • Zeilen 30–34: die GET-Aktion für die Liste, die nichts verändert;
  • Zeilen 37–58: der Datensatz eines Kontakts. Bei GET zeigt sie das Formular an, gefüllt mit den Informationen des Kontakts; bei POST verarbeitet sie es. Dieselbe URL, nämlich [/contacts/2], dient somit sowohl zum Ansehen als auch zum Speichern;
  • Zeile 45: die Formulardaten, ein unstrukturiertes assoziatives Array: [['name' => $name, 'phone' => $phone] = ...] speichert jedes Element in einer Variablen;
  • Zeilen 46–54: [get('duplicate')] liefert den Button [duplicate] des Formulars; [isClicked()] stellt fest, ob er derjenige war, der das Formular abgesendet hat (der Test [instanceof SubmitButton] bestätigt dem Editor den Objekttyp). Je nach Button dupliziert die Aktion den Kontakt oder speichert ihn;
  • Zeile 55: in beiden Fällen das PRG-Schema (Beispiel 20) mit einer Flash-Nachricht;
  • Zeilen 61–71: das Löschen, verarbeitet durch eine DELETE-Anfrage (dieselbe URL, aber mit einer anderen Methode). Das Löschformular ist fest in der View codiert: Die Aktion prüft ihr eigenes Anti-CSRF-Token mit der Methode [isCsrfTokenValid] von [AbstractController]. Ein Token ist an einen Bezeichner (hier [delete-contact-2]) gebunden: Das Token eines Formulars ist nur für dieses Formular gültig. Ein fehlendes oder ungültiges Token beendet die Aktion mit einem 403-Fehler (Forbidden). (Das Attribut [#[IsCsrfTokenValid('...')]], an der Aktion angebracht, würde dieselbe Prüfung durchführen.)

4.9.5. Die Views

{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">Contacts</h1>
  <table class="table align-middle">
    <tbody>
      {% for contact in contacts %}
        <tr>
          <td>{{ contact.name }}</td>
          <td>{{ contact.phone }}</td>
          <td class="text-end">
            {# view: ein einfacher Link; path() setzt die id in den Pfad: /contacts/2 #}
            <a class="btn btn-sm btn-outline-primary" href="{{ path('contacts_details', {id: contact.id}) }}">View</a>
            {# delete: ein Formular, dessen Absenden bestätigt werden muss #}
            <form method="post" class="d-inline" action="{{ path('contacts_delete', {id: contact.id}) }}"
                  data-confirmation="Delete the contact {{ contact.name }}?">
              {# die Methode DELETE, die ein HTML-Formular nicht senden kann #}
              <input type="hidden" name="_method" value="DELETE">
              {# das Anti-CSRF-Token, spezifisch für diesen Kontakt #}
              <input type="hidden" name="_token" value="{{ csrf_token('delete-contact-' ~ contact.id) }}">
              <button class="btn btn-sm btn-outline-danger" type="submit">Delete</button>
            </form>
          </td>
        </tr>
      {% endfor %}
    </tbody>
  </table>
{% endblock %}
  • 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. [path('contacts_details', {id: contact.id})] setzt die ID in den Pfad: [/contacts/2];
  • Zeilen 15–22: ein Formular für jeden „Löschen“-Button, ohne andere Felder als die Methode und das Token. Die Klasse [d-inline] zeigt es in derselben Zeile wie den Link an. Das Attribut [data-confirmation] enthält die Bestätigungsnachricht: Die Attribute [data-...] sind nicht belegt und für das [JavaScript] auf der Seite gedacht;
  • Zeile 18: das versteckte Feld [_method], das aus diesem POST eine DELETE-Anfrage macht;
  • Zeile 20: das Anti-CSRF-Token, erzeugt von der Funktion [csrf_token] von [Twig] für den Bezeichner [delete-contact-2] (der Operator [~] verkettet, Beispiel 16).
{% extends 'layout.html.twig' %}

{% block content %}
  <h1 class="h3">Contact no. {{ contact.id }}</h1>
  {{ form_start(form) }}
    {{ form_row(form.name) }}
    {{ form_row(form.phone) }}
    {# zwei Submit-Buttons für dasselbe Formular, nebeneinander #}
    <div class="d-flex gap-2">
      {{ form_widget(form.save) }}
      {{ form_widget(form.duplicate) }}
      <a class="btn btn-link" href="{{ path('contacts') }}">Back to the list</a>
    </div>
  {{ form_end(form) }}
{% endblock %}
  • Zeilen 10–11: die beiden Formular-Buttons, dargestellt von [form_widget], nebeneinander;
  • Zeile 12: der Link zurück zur Liste. [form_end] erzeugt das Anti-CSRF-Token, das die Form-Komponente selbst validiert (Beispiel 18).

4.9.6. Das Bestätigungsfenster

Der Browser kann einen Bestätigungsdialog anzeigen (Funktionen [JavaScript] und [confirm]), er ist jedoch wenig ansprechend, und sein Aussehen hängt vom Browser ab. Hier verwenden wir ein modales Fenster von [Bootstrap], das mit ein paar 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:

{# ein einziges Fenster für die ganze Seite, zunächst versteckt (d-none) #}
<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 und danach das Fenster werden von den Klassen von [Bootstrap] dargestellt;
  • Zeile 11: die Position der Nachricht;
  • 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="{{ path('bootstrap', {file: 'css/bootstrap.min.css'}) }}">
  <link rel="stylesheet" href="{{ asset('css/styles.css') }}">
</head>
<body>
  <div class="container py-3" style="max-width: 40rem">
    {% for message in app.flashes('success') %}
      <div class="alert alert-success" role="status">{{ message }}</div>
    {% endfor %}
    <main>
      {% block content %}{% endblock %}
    </main>
  </div>
  {# das Bestätigungsfenster, in allen Seiten vorhanden #}
  {% include 'fragments/confirmation.html.twig' %}
  {# das Skript am Seitenende: die Elemente, die es sucht, existieren bereits #}
  <script src="{{ asset('js/app.js') }}"></script>
</body>
</html>
  • Zeile 19: das Fenster, auf allen Seiten eingebunden;
  • Zeile 21: das Skript, am Ende der Seite platziert: Wenn es ausgeführt wird, existieren die gesuchten Elemente 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 ausgesetzt
      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 auf der Seite nicht;
  • Zeilen 4–6: das Fenster, die Stelle der Nachricht und das Formular, das auf Bestätigung wartet;
  • Zeilen 9–17: Für jedes Formular mit einem [data-confirmation]-Attribut wird das Ereignis [submit] – ausgelöst beim Absenden des Formulars – abgefangen. [preventDefault()] unterbricht das Absenden; das Formular wird in die Warteschleife gestellt, und seine Nachricht ([dataset.confirmation], der Wert des Attributs [data-confirmation]) wird im Fenster angezeigt, das erscheint;
  • Zeilen 20–28: 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 wieder erscheinen); „Nein“ blendet das Fenster aus.

Ohne [JavaScript] wird das Formular einfach ohne Bestätigung abgesendet: Die Seite bleibt benutzbar. Das ist inkrementelle Verbesserung: [JavaScript] fügt Komfort hinzu, aber die Anwendung hängt nicht davon ab.

4.9.7. Ausführung

Die Kontaktliste:

Image

Ein Klick auf „Löschen“ zeigt das Bestätigungsfenster an:

Image

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

Image

Das Profil eines Kontakts mit seinen beiden Sende-Buttons:

Image

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

curl -i -X POST -d "_method=DELETE" http://localhost:8000/contacts/3
curl -i http://localhost:8000/contacts/9
1
2
3
4
5
6
HTTP/1.1 403 Forbidden
X-Debug-Exception: invalid%20anti-CSRF%20token
...
HTTP/1.1 404 Not Found
X-Debug-Exception: unknown%20contact
...

Die Fehlerseiten sind weiterhin die detaillierten aus dem Debug-Modus von [Symfony]. Das Kapitel über den Lebenszyklus einer Anfrage zeigt, wie man sie durch eigene Seiten ersetzt.