Svelte in der Praxis: Komponenten, State und Events mit Svelte 5

Eine kleine Aufgabenliste Schritt für Schritt: typisierte Props, Runes, Callback-Events, Snippets und gemeinsamer Zustand
Aktualisiert:
Abstract
- #Svelte
- #Svelte 5
- #Webentwicklung
- #JavaScript
- #TypeScript
- #Frontend
- #Komponenten
- #State Management
Vom Zähler zur echten Anwendung: Wie Svelte-Komponenten sauber zusammenarbeiten
Ein Zähler-Button ist in Svelte schnell geschrieben. Interessant wird es eine Stufe später: Wenn fünf Komponenten auf dieselben Daten zugreifen, eine Liste gefiltert wird, ein Formular validiert und der Zustand den Seitenwechsel überleben soll. Genau an dieser Stelle zeigt sich, ob man ein Framework nur ausprobiert oder wirklich damit arbeiten kann.
Dieser Praxisteil baut deshalb eine kleine Aufgabenliste für ein Team. Sie besteht aus einer Formular-Komponente, einer Zeile pro Aufgabe, einem Suchfeld, einer Layout-Karte und einem gemeinsamen Zustandsmodul. Alle Beispiele nutzen Svelte 5 mit TypeScript und sind mit svelte-check geprüft. Wer die Konzepte hinter den Runes zuerst in Ruhe verstehen möchte, beginnt besser mit unserer Einführung in Svelte 5 für JavaScript-Entwickler und kommt danach hierher zurück.
Projekt anlegen und von Anfang an prüfen
Neue Projekte legt man mit dem offiziellen Kommandozeilenwerkzeug sv an. Das früher verbreitete npm create svelte ist abgelöst.
npx sv create aufgaben --template minimal --types ts
cd aufgaben
npm install
npm run dev
Das Werkzeug erzeugt ein SvelteKit-Projekt mit Vite als Build-Werkzeug. Für die Beispiele hier genügt die Vorlage minimal. Die Komponenten landen in src/lib, die Seite in src/routes/+page.svelte.
Wichtiger als der Startbefehl ist ein zweiter: npm run check. Er ruft svelte-check auf, das Komponenten und TypeScript-Dateien gemeinsam prüft – Typfehler in Props, falsch geschriebene Ereignisse, ungenutzte CSS-Selektoren, Hinweise zur Barrierefreiheit. Unsere Empfehlung: Den Befehl von Beginn an in die CI-Pipeline aufnehmen, also in die automatischen Prüfungen bei jedem Commit. Gerade weil im Netz viel Code für Svelte 3 und 4 kursiert, fängt die Prüfung veraltete Syntax früh ab.
Der Zustand zuerst: eine Klasse mit Runes
Bevor es an die Oberfläche geht, braucht die Anwendung ein Datenmodell. In Svelte 5 lässt sich reaktiver Zustand außerhalb von Komponenten in Dateien mit der Endung .svelte.ts (oder .svelte.js) schreiben. Der Compiler wertet die Runes dort genauso aus wie in Komponenten.
// src/lib/aufgaben.svelte.ts
export type Aufgabe = {
id: number;
titel: string;
erledigt: boolean;
};
export class Aufgabenliste {
eintraege = $state<Aufgabe[]>([]);
offen = $derived(this.eintraege.filter((a) => !a.erledigt).length);
#naechsteId = 1;
hinzufuegen(titel: string) {
this.eintraege.push({ id: this.#naechsteId++, titel, erledigt: false });
}
umschalten(id: number) {
const aufgabe = this.eintraege.find((a) => a.id === id);
if (aufgabe) aufgabe.erledigt = !aufgabe.erledigt;
}
entfernen(id: number) {
this.eintraege = this.eintraege.filter((a) => a.id !== id);
}
}
Drei Dinge sind hier typisch für Svelte 5. $state macht das Feld eintraege reaktiv, und zwar tief: Ein push oder das Ändern von aufgabe.erledigt genügt, damit alle Stellen der Oberfläche aktualisiert werden, die diese Daten anzeigen. $derived berechnet die Zahl offener Aufgaben automatisch neu, sobald sich die Liste ändert – niemand muss daran denken, einen Zähler mitzuführen. Und die Logik steht in gewöhnlichen Methoden, die sich ohne Oberfläche testen lassen.
Warum eine Klasse und kein globales Objekt? Eine Klasse lässt sich mehrfach instanziieren, etwa für zwei Listen auf einer Seite oder für jeden Test einzeln. Ein Modul mit einem einzigen exportierten Objekt ist einfacher, teilt seinen Zustand aber mit allen, die es importieren. In einer serverseitig gerenderten SvelteKit-Anwendung gilt das sogar für alle Anfragen auf dem Server. Nutzerbezogene Daten gehören deshalb nicht in solche globalen Module.
Komponenten mit typisierten Props
Die Zeile für eine einzelne Aufgabe zeigt, wie Komponenten in Svelte 5 ihre Schnittstelle beschreiben. Eigenschaften, sogenannte Props, liest die Komponente mit der Rune $props(). Die frühere Schreibweise export let gehört zur alten Syntax.
<!-- src/lib/AufgabeZeile.svelte -->
<script lang="ts">
import type { Aufgabe } from './aufgaben.svelte.js';
interface Props {
aufgabe: Aufgabe;
ontoggle: (id: number) => void;
onremove?: (id: number) => void;
}
let { aufgabe, ontoggle, onremove }: Props = $props();
</script>
<li class={{ erledigt: aufgabe.erledigt }}>
<label>
<input
type="checkbox"
checked={aufgabe.erledigt}
onchange={() => ontoggle(aufgabe.id)}
/>
{aufgabe.titel}
</label>
{#if onremove}
<button type="button" onclick={() => onremove(aufgabe.id)}>Löschen</button>
{/if}
</li>
<style>
.erledigt {
text-decoration: line-through;
opacity: 0.6;
}
</style>
Das Interface Props ist die Dokumentation der Komponente. Wer sie verwendet, bekommt im Editor Autovervollständigung, und svelte-check meldet fehlende oder falsch typisierte Werte. Optionale Props wie onremove tragen ein Fragezeichen. Das Markup reagiert darauf: Ohne Lösch-Funktion erscheint kein Lösch-Button.
Das class-Attribut nimmt seit Svelte 5.16 auch Objekte und Arrays an. class={{ erledigt: aufgabe.erledigt }} setzt die Klasse nur, wenn der Wert wahr ist. Die ältere Direktive class:erledigt funktioniert weiterhin. Das CSS im Style-Block gilt nur für diese Komponente – der Compiler versieht die Selektoren mit einer eindeutigen Kennung, sodass .erledigt an anderer Stelle nichts durcheinanderbringt.
Events: Funktionen als Props statt createEventDispatcher
Die Zeile meldet Klicks nicht über eigene Ereignisse, sondern ruft Funktionen auf, die ihr die Elternkomponente übergibt. Das ist in Svelte 5 der empfohlene Weg. createEventDispatcher, mit dem Komponenten in Svelte 4 Ereignisse auslösten, gilt als veraltet. Die Direktive on:click ist durch das gewöhnliche Attribut onclick ersetzt.
Der Vorteil ist mehr als Geschmack. Callback-Props sind normale Funktionen mit normalen Typen. Ob eine Komponente ein Ereignis anbietet, steht im Interface, und ein Tippfehler wie ontogle fällt beim Prüfen auf. Wer aus React kommt, kennt das Muster als onChange-Prop.
Das Formular zum Anlegen neuer Aufgaben nutzt dasselbe Prinzip und zeigt zusätzlich Formularbindung und abgeleitete Validierung:
<!-- src/lib/AufgabeFormular.svelte -->
<script lang="ts">
let { onadd }: { onadd: (titel: string) => void } = $props();
let titel = $state('');
let zuKurz = $derived(titel.trim().length < 3);
function absenden(event: SubmitEvent) {
event.preventDefault();
if (zuKurz) return;
onadd(titel.trim());
titel = '';
}
</script>
<form onsubmit={absenden}>
<input bind:value={titel} placeholder="Neue Aufgabe" />
<button disabled={zuKurz}>Hinzufügen</button>
</form>
bind:value verbindet das Eingabefeld in beide Richtungen mit der Variablen titel: Tippen ändert die Variable, titel = '' leert das Feld. Die Prüfung zuKurz ist ein abgeleiteter Wert und kein Effekt. Sie wird nur neu berechnet, wenn sich titel ändert. Der frühere Modifikator on:submit|preventDefault existiert in Svelte 5 nicht mehr, deshalb steht event.preventDefault() direkt in der Funktion.
Zwei-Wege-Bindung gezielt erlauben mit $bindable
Normalerweise fließen Daten in Svelte 5 nur von oben nach unten. Eine Kindkomponente darf eine Prop zwar lokal überschreiben, die Elternkomponente bekommt davon aber nichts mit. Für Eingabekomponenten ist das unpraktisch. Wer ein eigenes Suchfeld baut, möchte es wie ein normales Eingabefeld mit bind: verwenden.
Dafür gibt es die Rune $bindable:
<!-- src/lib/Suchfeld.svelte -->
<script lang="ts">
let { wert = $bindable(''), label = 'Suche' } = $props();
</script>
<label>
{label}
<input type="search" bind:value={wert} />
</label>
Nur Props, die so gekennzeichnet sind, lassen sich von außen binden. Das ist eine bewusste Einschränkung: Wer eine Komponente liest, sieht sofort, welche Werte sie zurückschreiben kann. Für Formularbausteine ist das sinnvoll, für fast alles andere sind Callback-Props die klarere Wahl.
Snippets statt Slots: flexible Layout-Komponenten
Viele Oberflächen brauchen Rahmen-Komponenten – Karten, Dialoge, Tabellen –, in die andere Komponenten Inhalte einsetzen. In Svelte 4 übernahmen das Slots. Svelte 5 ersetzt sie durch Snippets: benannte Markup-Blöcke, die man wie Props übergibt und mit {@render} ausgibt.
<!-- src/lib/Karte.svelte -->
<script lang="ts">
import type { Snippet } from 'svelte';
interface Props {
kopf: Snippet;
children: Snippet;
fuss?: Snippet<[number]>;
anzahl?: number;
}
let { kopf, children, fuss, anzahl = 0 }: Props = $props();
</script>
<section class="karte">
<header>{@render kopf()}</header>
{@render children()}
{#if fuss}
<footer>{@render fuss(anzahl)}</footer>
{/if}
</section>
<style>
.karte {
border: 1px solid #d4d4d8;
border-radius: 0.5rem;
padding: 1rem;
}
</style>
children ist ein besonderer Name: Alles, was zwischen öffnendem und schließendem Tag der Komponente steht und kein eigenes Snippet ist, landet darin. Snippets können außerdem Parameter haben. Snippet<[number]> beschreibt einen Fußbereich, dem die Karte eine Zahl mitgibt. Slots funktionieren in Svelte 5 aus Kompatibilitätsgründen noch, neue Komponenten sollten aber Snippets verwenden.
Alles zusammensetzen: die Seite
Die Seite verbindet Zustand und Komponenten. Hier zeigt sich, wie wenig Verkabelung nötig ist:
<!-- src/routes/+page.svelte -->
<script lang="ts">
import { Aufgabenliste } from '#lib/aufgaben.svelte.js';
import AufgabeFormular from '#lib/AufgabeFormular.svelte';
import AufgabeZeile from '#lib/AufgabeZeile.svelte';
import Karte from '#lib/Karte.svelte';
import Suchfeld from '#lib/Suchfeld.svelte';
const liste = new Aufgabenliste();
let suche = $state('');
let sichtbar = $derived(
liste.eintraege.filter((a) =>
a.titel.toLowerCase().includes(suche.toLowerCase()),
),
);
$effect(() => {
localStorage.setItem('aufgaben', JSON.stringify(liste.eintraege));
});
</script>
<Karte anzahl={liste.offen}>
{#snippet kopf()}
<h2>Aufgaben im Team</h2>
{/snippet}
<AufgabeFormular onadd={(titel) => liste.hinzufuegen(titel)} />
<Suchfeld bind:wert={suche} label="Filtern" />
<ul>
{#each sichtbar as aufgabe (aufgabe.id)}
<AufgabeZeile
{aufgabe}
ontoggle={(id) => liste.umschalten(id)}
onremove={(id) => liste.entfernen(id)}
/>
{:else}
<li>Keine Aufgaben gefunden.</li>
{/each}
</ul>
{#snippet fuss(offen)}
<p>{offen} offen</p>
{/snippet}
</Karte>
Ein Hinweis zu den Importen: Ab SvelteKit 3 heißt der Import-Alias für src/lib #lib und nutzt die Subpath-Imports aus der package.json. In Projekten mit SvelteKit 2 steht an derselben Stelle $lib. Außerhalb von SvelteKit, etwa in einem reinen Vite-Projekt, funktionieren relative Pfade.
Der Ausdruck (aufgabe.id) hinter dem each-Block ist ein Schlüssel. Er sorgt dafür, dass Svelte beim Filtern und Löschen die richtigen Zeilen entfernt, statt Inhalte in vorhandene Zeilen umzukopieren. Der :else-Zweig erscheint, wenn die Liste leer ist.
Effekte sparsam einsetzen
In der Seite steht genau ein $effect: Er schreibt die Liste bei jeder Änderung in den localStorage des Browsers. Das ist der typische Einsatzzweck. Effekte synchronisieren Svelte-Zustand mit etwas außerhalb von Svelte – Browser-Speicher, Diagramm-Bibliotheken, Websockets, Analyse-Werkzeuge. Svelte führt sie nur im Browser aus, nie beim serverseitigen Rendern. Deshalb ist der Zugriff auf localStorage hier unproblematisch.
Der häufigste Fehler im Alltag ist der umgekehrte Fall: Ein Effekt berechnet einen Wert aus anderem Zustand und schreibt ihn in eine Variable. Das funktioniert, ist aber langsamer und fehleranfälliger als $derived, weil der Wert kurzzeitig veraltet ist und Effekte sich gegenseitig auslösen können. Eine einfache Faustregel für Code-Reviews: Steht in einem Effekt nur eine Zuweisung an eine $state-Variable, gehört der Code fast immer in ein $derived.
Für Code, der einmalig beim Einblenden der Komponente laufen soll, gibt es weiterhin onMount aus dem Paket svelte. Es ist nicht veraltet und liest sich für diesen Zweck oft klarer als ein Effekt ohne Abhängigkeiten. onDestroy lässt sich in der Regel durch die Aufräumfunktion ersetzen, die ein Effekt zurückgeben kann.
Context für Werte, die viele Ebenen brauchen
Die Aufgabenliste wird hier als Prop weitergereicht. Das ist bei zwei Ebenen in Ordnung. Braucht eine tief verschachtelte Komponente die Liste, wird das Durchreichen lästig. Dafür gibt es Context: Eine Komponente legt einen Wert ab, alle Komponenten darunter können ihn abholen.
// src/lib/kontext.ts
import { createContext } from 'svelte';
import type { Aufgabenliste } from './aufgaben.svelte.js';
export const [holeAufgaben, setzeAufgaben] = createContext<Aufgabenliste>();
Die Seite ruft im Script-Block setzeAufgaben(liste) auf, eine beliebig tief verschachtelte Kindkomponente erhält die Liste mit holeAufgaben(). createContext gibt es seit Svelte 5.40. Es kommt ohne selbst gewählte Schlüssel aus und ist durchgehend typisiert. In älteren Versionen erledigen setContext und getContext dieselbe Aufgabe. Anders als ein globales Modul ist Context an den Komponentenbaum gebunden. Beim serverseitigen Rendern bekommt also jede Anfrage ihre eigene Instanz.
Was sich im Team bewährt
Aus dem Beispiel lassen sich einige Regeln ableiten, die über Aufgabenlisten hinaus tragen:
- Logik in Klassen oder Funktionen in
.svelte.ts-Dateien, Komponenten für Darstellung und Interaktion. Das hält Komponenten kurz und macht die Logik mit Vitest testbar, ohne eine Oberfläche zu rendern. - Props mit Interface typisieren, auch in kleinen Projekten. Die Schnittstelle ist dann zugleich Dokumentation.
- Callback-Props für Ereignisse,
$bindablenur für Formularbausteine. Daten fließen nach unten, Ereignisse nach oben. $derivedvor$effect. Effekte nur für die Verbindung zur Außenwelt.- Context statt globaler Module, sobald SvelteKit serverseitig rendert und Daten nutzerbezogen sind.
npm run checkin der CI, damit veraltete Syntax gar nicht erst in die Codebasis kommt.
Für wen lohnt sich dieser Stil? Teams, die von React kommen, finden die meisten Muster wieder – Props, Callbacks, einseitigen Datenfluss –, schreiben aber spürbar weniger Code dafür. Teams mit Svelte-4-Erfahrung müssen umlernen, gewinnen dafür Typprüfung und Reaktivität außerhalb von Komponenten. Warum Svelte dabei ohne virtuelles DOM auskommt und was das für die Performance bedeutet, erklärt unser Beitrag über den Compiler-Ansatz von Svelte. Sobald Routing, Datenladen und serverseitiges Rendern dazukommen, führt der Weg zu SvelteKit, beschrieben in SvelteKit und serverseitiges Rendering.
Wenn Sie ein Team auf Svelte 5 umstellen, eine bestehende Svelte-4-Codebasis migrieren oder einen Einstieg mit Übungen planen, unterstützen wir Sie mit Beratung, Coaching und Seminaren zu Svelte und SvelteKit.
Häufige Fragen zur Svelte-Entwicklung
Braucht man für Svelte zwingend TypeScript?
Nein. Alle Beispiele funktionieren ohne lang="ts" und ohne Typangaben. Für Projekte, an denen mehrere Personen arbeiten, empfehlen wir TypeScript trotzdem, weil svelte-check dann Props und Callback-Signaturen prüft. Wer kein TypeScript möchte, kann mit JSDoc-Kommentaren einen Teil dieser Prüfung erhalten.
Sind Svelte-Stores in Svelte 5 noch sinnvoll?
Stores aus svelte/store sind nicht abgekündigt und funktionieren weiter. Für neuen Code reichen meist Klassen oder Funktionen mit Runes in .svelte.ts-Dateien. Stores bleiben praktisch, wenn bestehender Code sie nutzt oder wenn Sie mit Datenströmen arbeiten, etwa aus RxJS.
Wie lassen sich Svelte-Komponenten testen?
Für Logik in .svelte.ts-Dateien genügen Unit-Tests mit Vitest. Für Komponenten eignet sich die Testing Library für Svelte, für ganze Abläufe im Browser Playwright. sv create bietet beides als Erweiterung an, nachträglich lässt es sich mit npx sv add vitest oder npx sv add playwright ergänzen.
Lassen sich Svelte-4-Komponenten mit diesen Mustern mischen?
Ja, Svelte 5 führt Komponenten in alter Syntax weiter aus. Eine einzelne Komponente muss allerdings entweder ganz in der alten oder ganz in der neuen Syntax geschrieben sein. Das offizielle Migrationsskript npx sv migrate svelte-5 übernimmt einen großen Teil der Umstellung.