3. Die Komponenten
Bisher passte jedes Beispiel in eine einzige Komponente, [App.vue]. Eine echte Anwendung enthält Dutzende davon: eine Navigationsleiste, Formulare, Fenster... Jede Komponente ist ein eigenständiger Teil der Oberfläche (ihr HTML, ihr Code, ihr Stil) und wiederverwendbar. Dieses Kapitel zeigt, wie Komponenten ineinandergreifen und miteinander kommunizieren.
3.1. Beispiel 07: Komponenten und ihre Props
Das Beispiel zeigt pro Arzt eine Karte an. Die Karte ist eine Komponente, [DoctorCard.vue], die von ihrer Elternkomponente [App.vue] dreimal verwendet wird.
Der Arzttyp, der von beiden Komponenten gemeinsam genutzt wird, steht in einer gewöhnlichen [TypeScript]-Datei:
| // der Datentyp, den das Elternelement (App.vue) und das Kindelement (DoctorCard.vue) gemeinsam nutzen
export interface Doctor {
id: number;
title: string;
firstName: string;
lastName: string;
specialty: string;
available: boolean;
}
|
Die Kindkomponente:
| <!--
=========================================================================
07-components/src/components/DoctorCard.vue - a CHILD component
-------------------------------------------------------------------------
It receives its data from its parent through PROPS (properties), declared
with defineProps. The TypeScript type of the props is checked at
compile time: <DoctorCard :doctor="42"> would be rejected.
Golden rule: a component NEVER MODIFIES its props. The data
flows down from the parent to the child ("one-way data flow"); to
request a change, the child emits an event (see example 08).
=========================================================================
-->
<script setup lang="ts">
import { computed } from 'vue';
import type { Doctor } from '../doctor';
// withDefaults: ein Standardwert für die optionalen Props (?)
const props = withDefaults(
defineProps<{
doctor: Doctor;
rank: number;
compact?: boolean;
}>(),
{ compact: false },
);
// ein Computed auf Basis einer Prop: wird neu berechnet, wenn das Elternelement die Prop ändert
const initials = computed(() => `${props.doctor.firstName[0]}${props.doctor.lastName[0]}`);
</script>
<template>
<div class="card h-100" :class="{ 'border-success': doctor.available }">
<div class="card-body d-flex gap-3 align-items-center">
<div class="initials">{{ initials }}</div>
<div>
<!-- im Template werden die Props direkt über ihren Namen verwendet -->
<h2 class="h6 mb-1">{{ rank }}. {{ doctor.title }} {{ doctor.firstName }} {{ doctor.lastName }}</h2>
<p v-if="!compact" class="mb-0 text-muted small">{{ doctor.specialty }}</p>
</div>
</div>
</div>
</template>
<style scoped>
.initials {
width: 2.5rem;
height: 2.5rem;
border-radius: 50%;
display: flex;
align-items: center;
justify-content: center;
background: #0d6efd;
color: white;
font-weight: bold;
}
</style>
|
- Zeile 16: [import type] importiert nur einen Typ: Von diesem Import bleibt nichts im resultierenden [JavaScript] übrig;
- Zeilen 19–26: [defineProps<{...}>()] deklariert die Props der Komponente – also die Daten, die sie von ihrer Elternkomponente erhält – samt ihren Typen. Eine Prop, auf die [?] folgt, ist optional; [withDefaults] gibt ihr einen Standardwert. [defineProps] muss nicht importiert werden: Es ist ein „Makro“, das der Compiler der [.vue]-Dateien erkennt;
- Zeile 29: Im Skript werden die Props über das Objekt [props] gelesen. [computed] verfolgt die Props: Wenn die Elternkomponente den zugewiesenen Arzt ändert, werden die Initialen neu berechnet;
- Zeile 38: Im Template werden die Props direkt über ihren Namen verwendet;
- Zeile 39: Eine Prop kann die Anzeige verändern.
Die Elternkomponente:
| <!--
=========================================================================
07-components/src/App.vue - the PARENT component
-------------------------------------------------------------------------
It imports the DoctorCard component and uses it as a new
HTML tag, <DoctorCard>, as many times as needed: a component
is a REUSABLE piece of interface, with its own data, its
template and its style.
=========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
// in <script setup> ist eine importierte Komponente im Template sofort verwendbar
import DoctorCard from './components/DoctorCard.vue';
import type { Doctor } from './doctor';
const doctors = ref<Doctor[]>([
{ id: 1, title: 'Mme', firstName: 'Marie', lastName: 'PELISSIER', specialty: 'general practitioner', available: true },
{ id: 2, title: 'Mr', firstName: 'Paul', lastName: 'TATOU', specialty: 'pediatrician', available: false },
{ id: 3, title: 'Melle', firstName: 'Sophie', lastName: 'DUPONT', specialty: 'general practitioner', available: true },
]);
const compact = ref(false);
// das Elternelement ändert SEINE Daten: Die betroffenen Kinder aktualisieren sich selbst
function toggleAvailability(): void {
for (const m of doctors.value) {
m.available = !m.available;
}
}
</script>
<template>
<div class="container py-4">
<h1 class="h3 mb-3">Example 07 - components and their props</h1>
<div class="d-flex gap-3 mb-3">
<label class="form-check-label"><input v-model="compact" type="checkbox" class="form-check-input"> compact display</label>
<button class="btn btn-sm btn-outline-primary" @click="toggleAvailability">Toggle availabilities</button>
</div>
<div class="row g-3">
<div v-for="(m, i) in doctors" :key="m.id" class="col-md-4">
<!-- :doctor="m" passes the OBJECT m (an expression);
compact, without a colon, would pass the STRING "compact" -->
<DoctorCard :doctor="m" :rank="i + 1" :compact="compact" />
</div>
</div>
</div>
</template>
|
- Zeile 14: In [<script setup>] ist eine importierte Komponente sofort im Template verwendbar, wie ein neues Tag;
- Zeile 43: Jede Karte erhält IHREN Arzt. [:doctor="m"] (mit Doppelpunkt) übergibt den Wert des Ausdrucks [m]; ohne Doppelpunkt würde die Zeichenkette ["m"] übergeben, was [TypeScript] hier ablehnen würde. Die Tag-Namen von Komponenten werden in [PascalCase] geschrieben, um sie von HTML-Tags zu unterscheiden;
- Zeilen 25–29: Die Elternkomponente ändert IHRE Daten; die betroffenen Karten aktualisieren sich.
Die goldene Regel: Eine Komponente ändert niemals ihre eigenen Props. Die Daten fließen von der Elternkomponente zur Kindkomponente ([one-way data flow]): Die Elternkomponente besitzt sie. Um eine Änderung anzufordern, löst die Kindkomponente ein Ereignis aus, das die Elternkomponente verarbeitet: Das ist das Thema des folgenden Beispiels.

3.2. Beispiel 08: Komponentenereignisse und v-model
3.2.1. Ein Ereignis auslösen
Die Komponente [Counter] benachrichtigt ihre Elternkomponente bei jedem Klick auf ihre Schaltfläche:
| <!--
=========================================================================
08-component-events/src/components/Counter.vue
-------------------------------------------------------------------------
A child that NOTIFIES its parent: defineEmits declares the events
it can emit, with the type of their data. The parent listens to them
like HTML events: <Counter @change="..." @limit="...">.
=========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
const props = defineProps<{ label: string; max: number }>();
// zwei Ereignisse: 'change' (mit dem neuen Wert) und 'limit' (ohne Daten)
const emit = defineEmits<{
change: [value: number];
limit: [];
}>();
const value = ref(0);
function plus(): void {
if (value.value >= props.max) {
emit('limit');
return;
}
value.value++;
emit('change', value.value);
}
</script>
<template>
<div class="d-flex align-items-center gap-2 mb-2">
<span class="w-25">{{ label }}</span>
<button class="btn btn-sm btn-outline-primary" @click="plus">+1</button>
<span class="badge text-bg-secondary">{{ value }} / {{ max }}</span>
</div>
</template>
|
- Zeilen 16–19: [defineEmits] deklariert die Ereignisse, die die Komponente auslösen kann, samt den Datentypen: [change] trägt eine Zahl, [limit] trägt nichts;
- Zeilen 25 und 29: Ein Ereignis auslösen. [TypeScript] prüft den Ereignisnamen und den Datentyp;
- Zeile 21: Die Kindkomponente darf einen eigenen Zustand haben: [value] gehört ihr, nicht der Elternkomponente.
3.2.2. v-model auf einer Komponente
Die Komponente [TextField] ist ein „benutzerdefiniertes“ Formularfeld: eine Beschriftung, das Feld selbst, ein Tooltip und ein Zeichenzähler. Wir möchten sie mit [v-model] verwenden, genau wie ein gewöhnliches [<input>]:
| <!--
=========================================================================
08-component-events/src/components/TextField.vue
-------------------------------------------------------------------------
A "home-made" form field (label + field + help + character
counter) that accepts v-model, like an ordinary <input>:
<TextField v-model="lastName" label="Last name" :max="20" />
defineModel() creates a ref linked to the parent's v-model: READING it gives the
parent's value, WRITING it emits the 'update:modelValue' event, which the
parent handles by updating its data. The data thus remains
the property of the parent.
=========================================================================
-->
<script setup lang="ts">
import { useId } from 'vue';
const model = defineModel<string>({ required: true });
defineProps<{ label: string; max: number; help?: string }>();
// ein eindeutiger Bezeichner pro Instanz, um <label for> und <input id> zu verknüpfen
const id = useId();
</script>
<template>
<div class="mb-3">
<label class="form-label" :for="id">{{ label }}</label>
<!-- v-model="model": Das native Feld ist mit dem Ref von defineModel verknüpft -->
<input :id="id" v-model="model" class="form-control" :maxlength="max" :class="{ 'is-invalid': model.length === max }">
<div class="form-text">{{ help }} ({{ model.length }} / {{ max }})</div>
</div>
</template>
|
- Zeile 18: [defineModel] erzeugt ein [ref] , das mit dem [v-model] der Elternkomponente verbunden ist. Beim Lesen erhält man den Wert der Elternkomponente; beim Schreiben wird das Ereignis [update:modelValue] ausgelöst, das die Elternkomponente verarbeitet, indem sie IHRE Daten ändert. [v-model="lastName"] auf einer Komponente ist lediglich eine Kurzform für die Eigenschaft [modelValue] und dieses Ereignis: Das Datum bleibt Eigentum der Elternkomponente;
- Zeile 22: [useId()] liefert pro Komponenteninstanz einen eindeutigen Bezeichner: Die beiden [TextField]-Instanzen auf der Seite haben nicht dieselbe [id], und jedes [<label for>] verweist korrekt auf SEIN Feld;
- Zeile 29: Das native Feld ist mit dem [ref] aus [defineModel] verbunden.
3.2.3. Die Elternkomponente
| <!--
=========================================================================
08-component-events/src/App.vue - the parent listens to its children
-------------------------------------------------------------------------
Two ways for a child to pass information up:
1. emitting an event, which the parent listens to with @ (Counter);
2. v-model on a component (TextField): a shortcut for the prop
modelValue + the event update:modelValue.
=========================================================================
-->
<script setup lang="ts">
import { computed, ref } from 'vue';
import Counter from './components/Counter.vue';
import TextField from './components/TextField.vue';
const total = ref(0);
const message = ref('');
const firstName = ref('Marie');
const lastName = ref('PELISSIER');
const fullName = computed(() => `${firstName.value} ${lastName.value.toUpperCase()}`);
// der Handler des Ereignisses 'change': Er erhält die ausgegebenen Daten
function onChange(label: string, value: number): void {
total.value++;
message.value = `${label} is now ${value}`;
}
</script>
<template>
<div class="container py-4" style="max-width: 640px">
<h1 class="h3 mb-3">Example 08 - events and v-model on a component</h1>
<div class="card p-3 mb-4">
<h2 class="h6">1. Events emitted by the children</h2>
<Counter label="Coffees" :max="3" @change="(v) => onChange('Coffees', v)" @limit="message = 'No more than 3 coffees!'" />
<Counter label="Glasses of water" :max="8" @change="(v) => onChange(`Glasses of water`, v)" @limit="message = 'Enough drinking.'" />
<p class="mb-0">Total clicks: {{ total }} - <em>{{ message }}</em></p>
</div>
<div class="card p-3">
<h2 class="h6">2. v-model on a component</h2>
<TextField v-model="firstName" label="First name" :max="20" help="Required" />
<TextField v-model="lastName" label="Last name" :max="20" help="Displayed in upper case" />
<p class="mb-0">Data of the parent: <strong>{{ fullName }}</strong></p>
<button class="btn btn-sm btn-outline-secondary mt-2 align-self-start" @click="firstName = ''; lastName = ''">Clear (from the parent)</button>
</div>
</div>
</template>
|
- Zeile 35: Die Elternkomponente lauscht mit [@] auf die Ereignisse ihrer Kindkomponenten, genau wie bei HTML-Ereignissen. Die Pfeilfunktion [(v) => onChange('Coffees', v)] erhält die Ereignisdaten; [@limit] führt eine einzelne Anweisung aus;
- Zeile 42: [v-model] auf einer Komponente;
- Zeile 45: Wenn die ELTERNKOMPONENTE ihre Daten leert, folgen die Felder: Die Verbindung funktioniert in beide Richtungen.

3.3. Beispiel 09: Templates und Slots
Props übergeben Daten; Slots übergeben Inhalt: aus HTML, aus anderen Komponenten. Die Komponente [Card] legt den Rahmen fest (Umrandung, Kopfzeile, Fußzeile), und ihre Elternkomponente bestimmt, was hineinkommt:
| <!--
=========================================================================
09-slots/src/components/Card.vue - a reusable TEMPLATE
-------------------------------------------------------------------------
Props pass DATA; slots pass CONTENT
(HTML, other components). Card sets the frame (border, header,
footer), the parent provides what goes inside:
- <slot /> the default slot: the "main" content;
- <slot name="header"> a named slot, filled by <template #header>;
- the text placed BETWEEN <slot> and </slot> is displayed if the parent
provides nothing (default content).
It is the client-side equivalent of the layout.hbs template and its {{{body}}}
in the NestJS course.
=========================================================================
-->
<script setup lang="ts">
defineProps<{ color?: 'primary' | 'success' | 'danger' }>();
</script>
<template>
<div class="card mb-3" :class="color ? `border-${color}` : ''">
<div class="card-header" :class="color ? `text-bg-${color}` : ''">
<slot name="header">Untitled</slot>
</div>
<div class="card-body">
<slot />
</div>
<!-- $slots.footer: Hat das Elternelement einen Footer bereitgestellt? Wenn nicht, kein leeres <div> -->
<div v-if="$slots.footer" class="card-footer text-muted small">
<slot name="footer" />
</div>
</div>
</template>
|
- Zeile 23: ein benannter Slot; der Text zwischen [<slot>] und [</slot>] wird angezeigt, wenn die Elternkomponente nichts liefert;
- Zeile 26: der Standard-Slot: der „Hauptinhalt“;
- Zeile 29: [$slots] gibt an, welche Slots die Elternkomponente befüllt hat: Ohne Fußzeile gibt es kein leeres [<div>].
Dies ist das clientseitige Gegenstück zum Template [layout.hbs] und seinem [{{{body}}}] im Kurs [NestJS].
Eine zweite Komponente, [DataTable], zeigt Zeilen beliebigen Typs an:
| <!--
=========================================================================
09-slots/src/components/DataTable.vue - a GENERIC table, with a "scoped" slot
-------------------------------------------------------------------------
generic="T": a generic component, like a generic TypeScript
class - it displays rows of any type T.
The table knows how to iterate over the rows, but not how to display a
row: it PASSES each row to its slot (<slot name="row" :row="l">),
and it is the parent that says what to do with it (<template #row="{ row }">).
This is called a "scoped" slot: the content provided by the parent uses
data that belongs to the child.
=========================================================================
-->
<script setup lang="ts" generic="T extends { id: number }">
defineProps<{ rows: T[]; columns: string[] }>();
</script>
<template>
<table class="table table-sm align-middle mb-0">
<thead>
<tr><th v-for="c in columns" :key="c">{{ c }}</th></tr>
</thead>
<tbody>
<tr v-for="(l, i) in rows" :key="l.id">
<slot name="row" :row="l" :index="i" />
</tr>
<tr v-if="rows.length === 0">
<td :colspan="columns.length" class="text-muted"><slot name="empty">No data.</slot></td>
</tr>
</tbody>
</table>
</template>
|
- Zeile 15: eine generische Komponente, wie eine generische [TypeScript]-Klasse: [T] ist der Typ der Zeilen, für den nur eine Eigenschaft verlangt wird: [id] (für den Schlüssel von [v-for]);
- Zeile 26: Das Array weiß, wie es die Zeilen durchläuft, aber nicht, wie eine Zeile anzuzeigen ist. Es übergibt jede Zeile an seinen Slot, und die Elternkomponente zeigt sie an. Man spricht von einem „Scoped“ Slot: Der von der Elternkomponente gelieferte Inhalt verwendet Daten, die der Kindkomponente gehören.
Die Elternkomponente:
| <!--
=========================================================================
09-slots/src/App.vue - using the Card and DataTable templates
=========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
import Card from './components/Card.vue';
import DataTable from './components/DataTable.vue';
interface Slot {
id: number;
time: string;
patient: string | null;
}
const slots = ref<Slot[]>([
{ id: 1, time: '8:00 - 8:20', patient: null },
{ id: 2, time: '8:20 - 8:40', patient: 'Mme Alice DURAND' },
{ id: 3, time: '8:40 - 9:00', patient: null },
]);
</script>
<template>
<div class="container py-4" style="max-width: 720px">
<h1 class="h3 mb-3">Example 09 - templates and slots</h1>
<!-- #header ist die Kurzform von v-slot:header -->
<Card color="primary">
<template #header>Schedule of Mme PELISSIER</template>
<!-- der Default-Slot: alles, was nicht in einem <template #...> steht -->
<DataTable :rows="slots" :columns="['#', 'Slot', 'Status']">
<!-- wir erhalten die von der DataTable übergebenen Daten: { row, index } -->
<template #row="{ row, index }">
<td>{{ index + 1 }}</td>
<td>{{ row.time }}</td>
<td>
<span v-if="row.patient" class="badge text-bg-secondary">{{ row.patient }}</span>
<span v-else class="badge text-bg-success">Free</span>
</td>
</template>
</DataTable>
<template #footer>{{ slots.filter((c) => c.patient === null).length }} free slot(s)</template>
</Card>
<Card color="success">
<template #header>A card without a footer</template>
<p class="mb-0">The footer is not provided: the card does not display it.</p>
</Card>
<Card>
<!-- kein Header angegeben: der Standardinhalt des Slots, "Untitled" -->
<DataTable :rows="[]" :columns="['Name']">
<template #empty>Nobody for now.</template>
</DataTable>
</Card>
</div>
</template>
|
- Zeile 30: [<template #header>] (Kurzform von [v-slot:header]) befüllt den Slot mit dem Namen [header];
- Zeile 32: Alles, was nicht in einem [<template #...>] steht, kommt in den Standard-Slot;
- Zeile 34: Die über das Array übergebenen Daten werden abgerufen. Dank der generischen Komponente [TypeScript] weiß, dass [row] ein [Slot] ist;
- Zeile 51: eine Karte ohne Kopfzeile: Der Standardinhalt „Untitled“ wird angezeigt.

3.4. Beispiel 10: Der Lebenszyklus einer Komponente
Eine Komponente wird erstellt, angezeigt, aktualisiert und dann entfernt. [Vue.js] ermöglicht es, in jeder dieser Phasen Code auszuführen. Die Komponente [Clock]:
| <!--
=========================================================================
10-lifecycle/src/components/Clock.vue
-------------------------------------------------------------------------
The lifecycle of a component:
1. setup : the code of <script setup> runs (creation);
2. onMounted : the component is DISPLAYED, its HTML elements exist;
3. onUpdated : its display has just been updated;
4. onUnmounted: the component has been REMOVED from the page.
A clock starts a timer (setInterval) when displayed... and must
absolutely stop it when it disappears: otherwise the timer
would keep running for nothing (memory leak).
=========================================================================
-->
<script setup lang="ts">
import { onMounted, onUnmounted, ref } from 'vue';
const emit = defineEmits<{ log: [message: string] }>();
const time = ref(new Date().toLocaleTimeString());
let timer: number | undefined;
emit('log', 'Clock: setup (creation)');
onMounted(() => {
emit('log', 'Clock: onMounted - starting the timer');
timer = window.setInterval(() => {
time.value = new Date().toLocaleTimeString();
}, 1000);
});
onUnmounted(() => {
window.clearInterval(timer);
emit('log', 'Clock: onUnmounted - timer stopped');
});
</script>
<template>
<div class="display-6 font-monospace">{{ time }}</div>
</template>
|
- Zeile 23: Der Code von [<script setup>] wird einmal ausgeführt, wenn die Komponente erstellt wird;
- Zeilen 25–30: [onMounted]: Die Komponente ist angezeigt, und ihre HTML-Elemente existieren. Der Timer wird gestartet;
- Zeilen 32–35: [onUnmounted]: Die Komponente wurde von der Seite entfernt . Der Timer muss angehalten werden; andernfalls würde er für eine nicht mehr existierende Komponente weiterlaufen (ein „Speicherleck“).
Die Elternkomponente:
| <!--
=========================================================================
10-lifecycle/src/App.vue
-------------------------------------------------------------------------
- v-if on <Clock>: checking / unchecking the box creates / destroys the
component (onMounted / onUnmounted, see Clock.vue);
- a "template ref": ref="field" gives access to the HTML <input> element
itself, once the component is displayed (to give it the focus);
- watch with { immediate: true }: executed right away, then on each
change;
- nextTick: waiting for Vue to have updated the page.
=========================================================================
-->
<script setup lang="ts">
import { nextTick, onMounted, ref, useTemplateRef, watch } from 'vue';
import Clock from './components/Clock.vue';
const withClock = ref(true);
const log = ref<string[]>([]);
const search = ref('');
const showSearch = ref(false);
// das Element <input ref="field"> des Templates (null, solange es nicht angezeigt wird)
const field = useTemplateRef<HTMLInputElement>('field');
function trace(message: string): void {
log.value.push(`${new Date().toLocaleTimeString()} ${message}`);
}
onMounted(() => trace('App: onMounted'));
watch(
search,
(value) => {
document.title = value ? `Search: ${value}` : 'Example 10';
},
{ immediate: true },
);
async function openSearch(): Promise<void> {
showSearch.value = true;
// in diesem Moment existiert das <input> noch nicht: Vue aktualisiert die Seite
// etwas später. nextTick() wartet auf diese Aktualisierung.
await nextTick();
field.value?.focus();
}
</script>
<template>
<div class="container py-4" style="max-width: 720px">
<h1 class="h3 mb-3">Example 10 - the lifecycle of a component</h1>
<div class="card p-3 mb-3">
<label class="form-check-label mb-2">
<input v-model="withClock" type="checkbox" class="form-check-input"> show the clock
</label>
<Clock v-if="withClock" @log="trace" />
</div>
<div class="card p-3 mb-3">
<button v-if="!showSearch" class="btn btn-outline-primary align-self-start" @click="openSearch">
Search...
</button>
<input v-else ref="field" v-model="search" class="form-control" placeholder="the tab title follows what you type">
</div>
<h2 class="h6">Log</h2>
<ol class="small">
<li v-for="(line, i) in log" :key="i">{{ line }}</li>
</ol>
</div>
</template>
|
- Zeile 57: Das Setzen und Entfernen des Häkchens erzeugt und zerstört die Uhr: Das Protokoll zeigt [setup], [onMounted], [onUnmounted];
- Zeile 24: Eine Template-Referenz: Das Attribut [ref="field"] des Elements [<input>] gewährt Zugriff auf das HTML-Element selbst. Sie ist gleich [null] , solange das Element nicht angezeigt wird;
- Zeilen 32–37: [watch] mit [{ immediate: true }] wird sofort und danach bei jeder Änderung ausgeführt: Der Titel des Tabs aktualisiert sich während der Texteingabe;
- Zeilen 40–45: Nach [showSearch.value = true] existiert das Feld noch nicht: [Vue.js] bündelt die Aktualisierungen der Seite und führt sie etwas später aus. [await nextTick()] wartet auf diese Aktualisierung; erst danach kann dem Feld der Fokus gegeben werden.

3.5. Beispiel 11: Composables, provide und inject
Wie lässt sich Logik zwischen Komponenten teilen? Auf der Serverseite ließ [NestJS] seine Services in die Controller injizieren. [Vue.js] hat seine Composables: einfache Funktionen, deren Namen mit [use] beginnen und die reaktiven Zustand und den dazugehörigen Code vereinen.
| // =========================================================================
// 11-composables/src/composables/useClock.ts - ein COMPOSABLE
// -------------------------------------------------------------------------
// Ein Composable ist eine einfache Funktion, deren Name per Konvention
// mit "use" beginnt und die einen reaktiven Zustand UND die dazugehörige Logik
// bündelt (hier: den Timer, sein Starten und sein Stoppen). Jede Komponente, die
// es aufruft, erhält IHRE eigene Uhr, ohne den Code zu kopieren.
//
// Es ist die Vue.js-Art, Logik zwischen Komponenten zu teilen - die
// Rolle, die auf der Serverseite die NestJS-Services übernehmen.
// =========================================================================
import { onMounted, onUnmounted, ref, type Ref } from 'vue';
export function useClock(periodMs = 1000): { now: Ref<Date> } {
const now = ref(new Date());
let timer: number | undefined;
// die Lifecycle-Hooks hängen sich an die Komponente, die das Composable AUFRUFT
onMounted(() => {
timer = window.setInterval(() => (now.value = new Date()), periodMs);
});
onUnmounted(() => window.clearInterval(timer));
return { now };
}
|
- Zeile 15: Die Funktion gibt ein Objekt zurück, das [ref] [now] enthält;
- Zeilen 20–22: Die Lebenszyklusfunktionen, die innerhalb eines Composables aufgerufen werden, sind an die Komponente gebunden, die das Composable aufruft : Jede Komponente hat ihren eigenen Timer, der angehalten wird, wenn die Komponente zerstört wird.
Ein zweites Composable, ohne Lebenszyklus:
| // =========================================================================
// 11-composables/src/composables/useCart.ts
// -------------------------------------------------------------------------
// Ein zweites Composable, OHNE Lifecycle: ein Warenkorb (Liste der Artikel,
// Summe, Hinzufügen, Entfernen). Jeder Aufruf von useCart() erzeugt einen NEUEN
// Warenkorb: Zwei Komponenten, die es aufrufen, haben jeweils ihren eigenen.
// (Für einen von der gesamten Anwendung GEMEINSAM genutzten Warenkorb siehe provide / inject
// weiter unten und Pinia in Beispiel 15.)
// =========================================================================
import { computed, ref } from 'vue';
export interface Item {
label: string;
price: number;
}
export function useCart() {
const items = ref<Item[]>([]);
const total = computed(() => items.value.reduce((sum, a) => sum + a.price, 0));
function add(item: Item): void {
items.value.push(item);
}
function remove(index: number): void {
items.value.splice(index, 1);
}
return { items, total, add, remove };
}
// der Typ dessen, was useCart zurückgibt: nützlich für provide / inject
export type Cart = ReturnType<typeof useCart>;
|
- Zeile 19: Jeder Aufruf von [useCart()] erzeugt einen NEUEN Warenkorb;
- Zeile 33: der Typ dessen, was [useCart] zurückgibt, von [TypeScript] abgeleitet.
Damit mehrere Komponenten sich DENSELBEN Warenkorb teilen können, verwenden wir [provide] und [inject], eine Form der Dependency Injection:
| // =========================================================================
// 11-composables/src/keys.ts - die Schlüssel für provide / inject
// -------------------------------------------------------------------------
// provide(key, value): Eine Komponente STELLT einen Wert für
// alle ihre Nachfahren bereit, unabhängig von der Tiefe;
// inject(key): Ein Nachfahre ruft ihn ab - ohne dass die dazwischenliegenden
// Komponenten ihn von Props zu Props weiterreichen müssen.
// Es ist eine Form der Dependency Injection, wie in NestJS.
//
// Ein InjectionKey<T> (ein typisiertes Symbol) garantiert, dass inject() einen
// Wert des richtigen Typs zurückgibt.
// =========================================================================
import type { InjectionKey } from 'vue';
import type { Cart } from './composables/useCart';
export const CART_KEY: InjectionKey<Cart> = Symbol('cart');
|
- Zeile 17: der Schlüssel, unter dem der Warenkorb bereitgestellt wird: ein [Symbol] (eindeutiger Wert), typisiert durch [InjectionKey<Cart>], damit [inject] ein Objekt des richtigen Typs zurückgibt.
Die Wurzelkomponente erstellt den Warenkorb und stellt ihn bereit:
| <!--
=========================================================================
11-composables/src/App.vue
-------------------------------------------------------------------------
- useClock(): App has its clock (1 s), CartSummary its own (5 s);
- useCart() + provide: App creates ONE cart and provides it to all its
descendants; Catalog and CartSummary inject it and therefore
share the same one.
=========================================================================
-->
<script setup lang="ts">
import { provide } from 'vue';
import { useClock } from './composables/useClock';
import { useCart } from './composables/useCart';
import { CART_KEY } from './keys';
import Catalog from './components/Catalog.vue';
import CartSummary from './components/CartSummary.vue';
const { now } = useClock();
provide(CART_KEY, useCart());
</script>
<template>
<div class="container py-4" style="max-width: 720px">
<h1 class="h3 mb-3">Example 11 - composables and provide / inject</h1>
<p class="text-muted">Clock of App: {{ now.toLocaleTimeString() }}</p>
<div class="row g-3">
<div class="col-md-6"><Catalog /></div>
<div class="col-md-6"><CartSummary /></div>
</div>
</div>
</template>
|
- Zeile 19: App hat ihre eigene Uhr, die jede Sekunde aktualisiert wird;
- Zeile 20: Die App stellt ALLEN ihren Nachkommen einen Warenkorb zur Verfügung, unabhängig von ihrer Tiefe, ohne ihn von Prop zu Prop weiterreichen zu müssen.
Zwei Nachkommen injizieren ihn:
| <!--
11-composables/src/components/Catalog.vue - a descendant that INJECTS the cart
-->
<script setup lang="ts">
import { inject } from 'vue';
import { CART_KEY } from '../keys';
import type { Item } from '../composables/useCart';
// der von App.vue bereitgestellte Warenkorb (provide); expliziter Fehler, falls er fehlt
const cart = inject(CART_KEY);
if (!cart) {
throw new Error('Catalog must be placed under a component that provides the cart');
}
const catalog: Item[] = [
{ label: 'Consultation', price: 30 },
{ label: 'Vaccine', price: 12.5 },
{ label: 'Certificate', price: 5 },
];
</script>
<template>
<ul class="list-group">
<li v-for="a in catalog" :key="a.label" class="list-group-item d-flex justify-content-between align-items-center">
{{ a.label }} (€{{ a.price }})
<button class="btn btn-sm btn-outline-primary" @click="cart.add(a)">Add</button>
</li>
</ul>
</template>
|
- Zeile 10: Der von einem Vorfahren bereitgestellte Warenkorb wird abgerufen; [inject] gibt [undefined] zurück, wenn kein Vorfahre ihn bereitgestellt hat: Dies wird durch einen expliziten Fehler angezeigt.
| <!--
11-composables/src/components/CartSummary.vue - another descendant, the SAME cart
-->
<script setup lang="ts">
import { inject } from 'vue';
import { CART_KEY } from '../keys';
import { useClock } from '../composables/useClock';
const cart = inject(CART_KEY)!;
// diese Komponente hat IHRE eigene Uhr, die alle 5 Sekunden aktualisiert wird
const { now } = useClock(5000);
</script>
<!-- cart.items.value: in a template, Vue only "unwraps" (implicit
.value) the TOP-LEVEL refs of the script, like now.
The refs stored INSIDE an object (cart.items) are written with .value -->
<template>
<div class="card p-3">
<h2 class="h6">Cart ({{ cart.items.value.length }} item(s)) - {{ now.toLocaleTimeString() }}</h2>
<ul class="mb-2">
<li v-for="(a, i) in cart.items.value" :key="i">
{{ a.label }} <a href="#" @click.prevent="cart.remove(i)">remove</a>
</li>
</ul>
<strong>Total: €{{ cart.total.value }}</strong>
</div>
</template>
|
- Zeile 9: dieselbe Injektion; [!] bestätigt gegenüber [TypeScript] , dass der Wert existiert;
- Zeile 11: Diese Komponente hat ihre EIGENE Uhr, die alle 5 Sekunden aktualisiert wird;
- Zeile 19: In einem Template „entpackt“ [Vue.js] automatisch nur die [ref]-Elemente der obersten Ebene des Skripts. Ein [ref] , das INNERHALB eines Objekts gespeichert ist ([cart.items]), wird mit [.value] geschrieben.
Beide Komponenten zeigen denselben Warenkorb an; die beiden Uhren laufen in ihrem eigenen Takt:

3.6. Beispiel 12: Ein wiederverwendbares Bestätigungsfenster
Bevor ein Element gelöscht wird, fragt das System: „Sind Sie sicher?“ Die Browserfunktion [window.confirm()] existiert zwar, aber ihr Dialogfeld lässt sich nicht formatieren, und ihre Schaltflächen lassen sich nicht übersetzen. Wir ersetzen sie durch ein [Bootstrap]-Fenster, das von einem Composable gesteuert wird. Dies ist die [Vue.js]-Version von Beispiel 21 aus dem Kurs [NestJS].
| // =========================================================================
// 12-confirmation/src/composables/useConfirmation.ts
// -------------------------------------------------------------------------
// "Sind Sie sicher?": window.confirm() existiert, lässt sich aber weder
// gestalten, noch können seine Buttons übersetzt werden. Wir ersetzen es durch einen Bootstrap-Dialog
// (ConfirmDialog.vue), gesteuert von diesem Composable.
//
// Der Trick: confirm(message) gibt ein PROMISE zurück, das mit true (Ja)
// oder false (Nein) aufgelöst wird, sobald der Benutzer antwortet. Der aufrufende Code wird dann
// so einfach geschrieben wie mit window.confirm:
//
// if (await confirm('Delete this doctor?')) { ... }
//
// Der Zustand (angezeigte Meldung, bei der Antwort aufzurufende Funktion) wird
// AUSSERHALB der Funktion deklariert: Er ist daher für die gesamte Anwendung EINMALIG. Ein
// einziger Dialog, einmal in App.vue platziert, bedient alle Komponenten.
// =========================================================================
import { readonly, ref } from 'vue';
const message = ref<string | null>(null); // null: Dialog geschlossen
let answer: ((yes: boolean) => void) | null = null;
export function useConfirmation() {
function confirm(text: string): Promise<boolean> {
message.value = text;
return new Promise<boolean>((resolve) => {
answer = resolve;
});
}
function respond(yes: boolean): void {
message.value = null;
answer?.(yes);
answer = null;
}
// readonly: Die Komponenten lesen die Meldung, nur das Composable ändert sie
return { message: readonly(message), confirm, respond };
}
|
- Zeilen 21 und 22: Der Zustand wird AUSSERHALB der Funktion [useConfirmation] auf Modulebene deklariert. Er ist daher in der gesamten Anwendung einzigartig : Ein einziges Fenster bedient alle Komponenten;
- Zeilen 25–30: [confirm] öffnet das Fenster (indem der Nachricht ein Wert zugewiesen wird) und gibt ein Promise zurück. Es speichert die Funktion [resolve] dieses Promise in [answer]: Das Promise wird erst aufgelöst, wenn der Benutzer geantwortet hat;
- Zeilen 32–35: Die Antwort des Benutzers schließt das Fenster und löst das Promise mit [true] oder [false] auf;
- Zeile 39: Komponenten können die Nachricht lesen, aber nicht ändern.
Das Fenster:
| <!--
=========================================================================
12-confirmation/src/components/ConfirmDialog.vue
-------------------------------------------------------------------------
The modal dialog, placed ONCE in App.vue.
- <Teleport to="body">: its HTML is inserted at the end of <body>, outside
the component tree - a modal dialog must go
above everything, wherever it is declared;
- same Bootstrap classes as a real modal (.modal, .modal-backdrop),
displayed "hard-coded" (show d-block): no need for Bootstrap's JavaScript;
- keyboard: Escape = No; the focus is placed on the "No" button (the
least dangerous choice) on opening.
=========================================================================
-->
<script setup lang="ts">
import { nextTick, onUnmounted, useTemplateRef, watch } from 'vue';
import { useConfirmation } from '../composables/useConfirmation';
const { message, respond } = useConfirmation();
const noButton = useTemplateRef<HTMLButtonElement>('noButton');
function onKeydown(e: KeyboardEvent): void {
if (e.key === 'Escape') {
respond(false);
}
}
// beim Öffnen: Fokus auf "No", Lauschen auf die Escape-Taste; beim Schließen: Das Lauschen wird beendet
watch(message, async (value) => {
if (value !== null) {
document.addEventListener('keydown', onKeydown);
await nextTick();
noButton.value?.focus();
} else {
document.removeEventListener('keydown', onKeydown);
}
});
onUnmounted(() => document.removeEventListener('keydown', onKeydown));
</script>
<template>
<Teleport to="body">
<template v-if="message !== null">
<div class="modal-backdrop fade show"></div>
<div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true" @click.self="respond(false)">
<div class="modal-dialog modal-dialog-centered">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title">Confirmation</h5>
<button type="button" class="btn-close" aria-label="Close" @click="respond(false)"></button>
</div>
<div class="modal-body">
<p class="mb-0">{{ message }}</p>
</div>
<div class="modal-footer">
<button ref="noButton" type="button" class="btn btn-secondary" @click="respond(false)">No, go back</button>
<button type="button" class="btn btn-danger" @click="respond(true)">Yes, confirm</button>
</div>
</div>
</div>
</div>
</template>
</Teleport>
</template>
|
- Zeile 42: Das HTML des Fensters wird am Ende von [<body>] eingefügt, außerhalb des Komponentenbaums: Ein modales Fenster muss Vorrang vor allem anderen haben, unabhängig davon, wo es deklariert ist;
- Zeile 45: die [Bootstrap]-Klassen eines modalen Fensters, „fest codiert“ angezeigt ([show d-block]): Das [JavaScript] von [Bootstrap] wird dafür nicht benötigt;
- Zeile 45: der Modifikator [.self]: Nur ein Klick auf das Element selbst (den schattierten Bereich) und nicht auf das darin enthaltene Fenster löst die Antwort „Nein“ aus;
- Zeilen 29–37: Beim Öffnen lauscht das Programm auf die Esc-Taste und setzt den Fokus auf die Schaltfläche „Nein“ (die sicherste Option: Ein versehentliches Drücken der Eingabetaste löscht nichts); beim Schließen hört das Programm auf, die Tastatur abzuhören.
Die Komponente, die es verwendet:
| <!--
=========================================================================
12-confirmation/src/App.vue - using the confirmation dialog
-------------------------------------------------------------------------
Same page as example 21 of the NestJS course (links, buttons, confirmation),
but without any round trip to a server.
=========================================================================
-->
<script setup lang="ts">
import { ref } from 'vue';
import ConfirmDialog from './components/ConfirmDialog.vue';
import { useConfirmation } from './composables/useConfirmation';
interface Contact {
id: number;
name: string;
}
const contacts = ref<Contact[]>([
{ id: 1, name: 'Jean MARTIN' },
{ id: 2, name: 'Alice DURAND' },
{ id: 3, name: 'Luc GERMAN' },
]);
const message = ref('');
const { confirm } = useConfirmation();
// eine async-Funktion: Sie "wartet" auf die Antwort des Benutzers
async function remove(c: Contact): Promise<void> {
if (!(await confirm(`Delete the contact ${c.name}?`))) {
message.value = 'Deletion cancelled.';
return;
}
contacts.value = contacts.value.filter((x) => x.id !== c.id);
message.value = `${c.name} has been deleted.`;
}
async function removeAll(): Promise<void> {
if (await confirm(`Delete the ${contacts.value.length} contacts?`)) {
contacts.value = [];
message.value = 'All the contacts have been deleted.';
}
}
</script>
<template>
<div class="container py-4" style="max-width: 640px">
<h1 class="h3 mb-3">Example 12 - a confirmation dialog</h1>
<ul class="list-group mb-3">
<li v-for="c in contacts" :key="c.id" class="list-group-item d-flex justify-content-between align-items-center">
{{ c.name }}
<button class="btn btn-sm btn-outline-danger" @click="remove(c)">Delete</button>
</li>
<li v-if="contacts.length === 0" class="list-group-item text-muted">No contacts.</li>
</ul>
<button class="btn btn-danger" :disabled="contacts.length === 0" @click="removeAll">Delete all</button>
<p v-if="message" class="alert alert-info mt-3">{{ message }}</p>
</div>
<!-- der Dialog, EINMAL für die gesamte Anwendung -->
<ConfirmDialog />
</template>
|
- Zeile 29: Dank des Promise ist der Code ebenso einfach zu schreiben wie mit [window.confirm]: Die [async]-Funktion „wartet“ auf die Antwort des Benutzers;
- Zeile 59: das Fenster, EINMAL für die gesamte Anwendung erstellt.

Nach „Ja, bestätigen“:
