# Single-Page-Anwendung

## Was es ist

Eine Single-Page-Anwendung, auch Single-Page-App und meist kurz SPA genannt, ist
eine Webanwendung, die ein HTML-Dokument lädt und es anschließend mit JavaScript
verändert, statt beim Server eine neue Seite anzufordern. Ein Klick auf einen
internen Link entlädt die Seite nicht. Ein Skript fängt den Klick ab, lädt die
für die nächste Ansicht benötigten Daten, schreibt einen Teil des DOM um und
aktualisiert die Adressleiste. Die URL zeigt dadurch weiterhin die aktuelle
Position in der Anwendung an.

Kein Standard definiert den Begriff verbindlich, und die Hersteller der
Werkzeuge räumen das ein. Next.js beginnt seinen Leitfaden dazu mit „Die
Definition einer SPA variiert“ und legt dann für sich selbst eine sogenannte
strikte SPA fest. Sie hat zwei Eigenschaften. Eine einzige HTML-Datei bedient
die ganze Anwendung, und JavaScript im Browser kümmert sich um jede Route,
jeden Seitenwechsel und jede Datenanfrage. Außerdem wird die Seite nie ganz neu
geladen: Bei einem Routenwechsel schreiben Skripte auf dem Client das DOM der
bereits geöffneten Seite um und laden Daten nach Bedarf, statt vom Server ein
neues Dokument anzufordern. Dieser Artikel verwendet diese Definition, weil sie
die direkteste verfügbare ist und die Eigenschaft benennt, von der alles andere
abhängt: ein Dokument, das nie ersetzt wird.

Die Browserbausteine sind standardisiert. Die History-Schnittstelle des
HTML-Standards stellt einer Seite `history.pushState()` bereit. Der Aufruf fügt
dem Sitzungsverlauf einen Eintrag hinzu und setzt die URL, ohne etwas zu laden.
`history.replaceState()` überschreibt stattdessen den aktuellen Eintrag.
Wechselt jemand mit Zurück oder Vorwärts zwischen diesen Einträgen, löst der
Browser am Fenster ein `popstate`-Ereignis aus und überlässt der Seite das
Neuzeichnen. Die neuere Navigation API, die der Standard als Nachfolgerin der
klassischen Location- und History-APIs vorstellt, setzt am anderen Ende an: Zu
Beginn einer Navigation wird ein `navigate`-Ereignis ausgelöst. Seine Methode
`intercept()` macht daraus eine Navigation innerhalb desselben Dokuments, die
die Seite selbst behandelt.

Das Gegenteil ist die gewöhnliche Website mit mehreren Seiten. Jeder Link
fordert dort ein neues Dokument vom Server an, und der Browser verwirft das
alte. Ob das HTML einer Seite einmal durch einen statischen Site-Generator oder
bei jeder Anfrage durch serverseitiges Rendering entsteht, ist eine andere
Frage. Sie betrifft die Erzeugung des HTML und nicht das, was nach seiner
Ankunft im Browser geschieht. Next.js verwischt die Grenze bewusst: Sein statischer Export schreibt
für jede Route eine HTML-Datei, und der Wechsel zwischen ihnen findet trotzdem
auf dem Client statt.

## Warum es wichtig ist

Weil das Dokument nie ersetzt wird, übersteht alles darin einen Klick: ein halb
ausgefülltes Formular, ein laufendes Video, die Scrollposition einer
Seitenleiste, bereits abgerufene Daten. Nur die für die nächste Ansicht benötigten Daten
müssen durchs Netz, keine ganz neue Seite samt Kopfbereich, Stilen und Skripten.
Ein Ansichtswechsel kann sich auf das Umschreiben eines einzigen Bereichs der
Seite beschränken.

Next.js nennt die Kosten im selben Atemzug wie die Definition. Eine strikte SPA
muss oft viel JavaScript laden, bevor die Seite interaktiv wird.
Datenanfragekaskaden auf dem Client, bei denen eine Anfrage erst nach der
Antwort auf eine andere beginnen kann, sind schwer zu steuern. Auch für Systeme, die die
Seite ohne Skriptausführung lesen, hat das Nachteile. Steht hinter jeder
Route eine einzige HTML-Datei, erhält ein Crawler ohne JavaScript stets dasselbe
fast leere Dokument, egal welche URL er anfragt. Next.js sagt dasselbe über
seine ausschließlich im Browser ausgeführten Komponenten: Wer die Seite ohne
Skriptausführung indexiert, erhält den Ersatzinhalt statt der Komponente.

Die Antwort von Next.js besteht darin, die clientseitige Navigation zu behalten
und den Rest zu verlagern. Next.js teilt JavaScript-Bundles automatisch auf und
erzeugt mehrere HTML-Einstiegspunkte für verschiedene Routen. Besucher laden so
keinen Code, den eine Route nicht braucht. Seine Komponente `next/link` lädt
Routen im Voraus. Routenwechsel wirken dadurch so unmittelbar wie in einer
vollständig auf dem Client gerenderten SPA. Zugleich bleibt der Routing-Zustand
der Anwendung in der URL und lässt sich verlinken und teilen. Ein statischer
Export geht weiter und schreibt für jede Route eine vollständig gerenderte
Seite. Besucher erhalten dadurch Inhalt, ohne auf das Client-Bundle zu warten,
während clientseitige Seitenwechsel so schnell wie in einer strikten SPA
bleiben.

Die Entscheidung fällt auch nicht ein für alle Mal. Next.js beschreibt ein
Projekt, das als statische Website oder sogar als vollständig clientseitig
gerenderte strikte SPA beginnt und beim Wachsen Serverfunktionen ergänzt. Eine
bestehende SPA könne umziehen, ohne von Grund auf neu geschrieben zu werden.

## Wie es in der Praxis aussieht

Der folgende, für diesen Artikel geschriebene Router ist die kleinste
funktionsfähige Fassung der Idee. Er setzt ein `<main>`-Element auf der Seite
voraus und einen Server, der jeden Anwendungspfad mit demselben HTML-Dokument
beantwortet. Die beiden Ansichten stehen für das, was die Anwendung tatsächlich
anzeigt.

```js
// router.js
const views = {
  "/": { title: "Orders", text: "Your recent orders." },
  "/settings": { title: "Settings", text: "Delivery preferences." },
};
const main = document.querySelector("main");

function show(path, moveFocus) {
  const view = views[path] ?? views["/"];
  const heading = document.createElement("h1");
  const body = document.createElement("p");
  heading.textContent = view.title;
  heading.tabIndex = -1;
  body.textContent = view.text;
  main.replaceChildren(heading, body);
  document.title = view.title;
  if (moveFocus) heading.focus();
}

document.addEventListener("click", (event) => {
  const link = event.target.closest("a[href]");
  const modified = event.metaKey || event.ctrlKey || event.shiftKey;
  if (!link || link.origin !== location.origin) return;
  if (modified || event.button !== 0) return;
  event.preventDefault();
  history.pushState(null, "", link.href);
  show(location.pathname, true);
});

window.addEventListener("popstate", () => show(location.pathname, true));
show(location.pathname, false);
```

Der Klick-Handler übernimmt einfache Linksklicks auf Links zum selben Origin
und lässt modifizierte Klicks durch. Ein Link lässt sich deshalb weiterhin in
einem neuen Tab öffnen. `preventDefault()` unterbindet die eigene Navigation
des Browsers, und `pushState()` trägt einen neuen Eintrag mit der Link-URL in
den Sitzungsverlauf ein. Sein mittleres Argument existiert nur aus historischen
Gründen und ist deshalb eine leere Zeichenfolge. `show()` ersetzt die Ansicht,
setzt den Dokumenttitel und verschiebt den Fokus auf die neue Überschrift. Ein
`tabIndex` von `-1` macht sie per Skript fokussierbar, hält sie aber aus der
Tab-Reihenfolge heraus. Der Listener für `popstate` zeichnet beim Zurück- oder
Vorwärtsgehen die passende Ansicht neu. Die letzte Zeile zeichnet die zur
anfänglichen URL gehörende Ansicht. Das funktioniert nur, wenn der Server für
`/settings` dasselbe Dokument wie für `/` sendet. Eine echte Anwendung würde
außerdem eine eigene Nicht-gefunden-Ansicht zeigen, statt still auf die
Startseite zurückzufallen, und Links zu Dateien und anderen Teilen der Website
unangetastet lassen.

In der aktuellen Arbeit der Gründerin bei NextMariner zeigt das Frontend mit
Next.js 16 diese Kosten an einem echten Produkt.
[Der zugehörige Portfolioeintrag](/de/portfolio/built-the-next-js-16-frontend-ssr-ssg-and-csr/)
beschreibt ein Dashboard mit Anmeldung, das sich schnell anfühlen und wirklich
interaktiv bleiben musste. Er benennt auch, was passiert, wenn alle Daten im
Client abgerufen werden: Der erste Ladevorgang zieht sich hin, und das
N+1-Muster tritt auf. Jede Komponente wird aktiv und sendet ihre eigene Anfrage,
bis eine einzelne Seite eine Kaskade von Hin- und Rückübertragungen auslöst.
Damit begegnet einem in der Praxis genau die Kaskade clientseitiger Datenabrufe,
vor der der Next.js-Leitfaden warnt. Die Lösung behielt clientseitige
Interaktivität dort bei, wo sie wichtig war, und verlagerte den ersten
Datenabruf auf den Server. Für das Dashboard und die großen Verzeichnislisten
übergibt eine Factory namens `createPrefetchedServerPage` jede Seite mit bereits
vorhandenen Daten an den Client. Der Eintrag benennt offen, was noch aussteht:
Die übrigen Seiten mit Anmeldung werden weiterhin im Client gerendert und
warten, bis sie an der Reihe sind. Er beschreibt also eine funktionierende
Migration, bei der die nächste umzustellende Seite klar ist, die aber noch nicht
abgeschlossen ist.

## Wo es schiefgeht

**Die Zurück-Schaltfläche verlässt die Anwendung.** Tauscht ein Skript Ansichten
ohne `pushState()` aus, gibt es dafür keinen Eintrag im Sitzungsverlauf. Zurück
überspringt jede gesehene Ansicht und verlässt die Anwendung ganz. Ein Neuladen
landet bei der URL, mit der die Anwendung zuerst geöffnet wurde. Legen Sie für
jede Ansicht, die ein Leser als Seite verstehen würde, einen Eintrag an.
Verwenden Sie `replaceState()` für Änderungen, die keine eigenen Schritte
werden sollen, etwa einen beim Tippen veränderten Filter, und behandeln Sie
`popstate`. Next.js empfiehlt aus demselben Grund, den Routing-Zustand in der
URL zu halten: So lässt sich eine Ansicht verlinken und teilen.

**Ein Link auf eine Unterseite trifft auf einen Server, der nur eine Datei kennt.** In einer
strikten SPA bedient eine HTML-Datei jede Route. Die Adressleiste zeigt aber
`/settings`, und genau das fordert der Browser beim Neuladen oder Öffnen eines
geteilten Links an. Ein Server mit nur einer `index.html` antwortet mit 404.
Konfigurieren Sie ihn so, dass er jeden Anwendungspfad mit dem Dokument
beantwortet, oder erzeugen Sie eine Datei pro Route. Der statische Export von
Next.js tut Letzteres: Sein Ordner `out` enthält Dateien wie `index.html`,
`404.html` und `blog/post-1.html`. Der Leitfaden zeigt eine nginx-Regel,
`try_files $uri $uri.html $uri/ =404;`, die eine saubere URL der passenden Datei
zuordnet.

**Der Fokus bleibt bei der alten Ansicht.** `pushState()` ändert den
Sitzungsverlauf und die URL, sonst nichts. Nach einem skriptgesteuerten
Ansichtswechsel bleibt der Tastaturfokus auf dem angeklickten Link oder geht
verloren, wenn sein Element entfernt wurde. Keine Meldung informiert assistive
Technik über die neue Ansicht, sofern die Seite das nicht selbst tut. Setzen Sie
den Titel und verschieben Sie den Fokus wie im Beispiel auf die Überschrift
der neuen Ansicht. Die Navigation API übernimmt davon mehr selbst. Eine mit
`intercept()` behandelte Navigation setzt den Fokus standardmäßig auf das erste
Element mit `autofocus`, andernfalls auf den Dokumentkörper. Nach Abschluss des
Handlers meldet der Browser dem Nutzer den Abschluss. Nach dem Standard schließt
das assistive Technik ein. Eine Anwendung, die den Fokus selbst setzt, schaltet
das automatische Zurücksetzen mit `focusReset: "manual"` ab.

**Alles wird im Voraus bezahlt.** Eine strikte SPA muss oft viel JavaScript
laden, bevor irgendetwas interaktiv ist. Ihre ersten Datenanfragen beginnen
erst, wenn dieser Code läuft. Teilen Sie das Bundle nach Routen auf, damit
Besucher nur den für die aktuelle Ansicht benötigten Code laden, und beginnen
Sie die ersten Anfragen auf dem Server. Das Next.js-Muster dafür beginnt den Datenabruf in
einer Server Component, ohne dessen Abschluss abzuwarten, und reicht das Promise an eine
Client Component weiter. Diese entpackt es mit `use()`. Weil die Anfrage schon
vor dem Rendern der restlichen Anwendung beginnt, kann laut Leitfaden sofort
die Übertragung der Antwort als Datenstrom beginnen. Dem Client bleibt eine Kaskade erspart, in der
jede Anfrage auf die vorherige wartet.

## Weiterführende Lektüre

- [Single-Page-Anwendungen mit Next.js bauen](https://nextjs.org/docs/app/guides/single-page-applications)
  — Die Definition einer strikten SPA, ihre Kosten und Next.js-Muster, die
  clientseitige Navigation beibehalten und Arbeit auf den Server verlagern.
- [HTML Standard: die History-Schnittstelle](https://html.spec.whatwg.org/multipage/nav-history-apis.html#the-history-interface)
  — `pushState()`, `replaceState()` und das Hinzufügen und Ersetzen von
  Einträgen im Sitzungsverlauf.
- [HTML Standard: Navigation API](https://html.spec.whatwg.org/multipage/nav-history-apis.html#navigation-api)
  — Das Ereignis `navigate`, `intercept()` und die damit verbundene Fokus- und
  Scrollsteuerung.
- [Einen statischen Export einer Next.js-Anwendung erzeugen](https://nextjs.org/docs/app/guides/static-exports)
  — Eine HTML-Datei pro Route, die Grenzen eines statischen Exports und das
  Ausliefern sauberer URLs mit nginx.

<https://engineer.company/de/glossary/single-page-application/>
