Skip to content

5. Kapitel 4 - Einführung in [Vue.js]

5.1. Quellen

Dieses Kapitel basiert auf der offiziellen Dokumentation von [Vue.js]: vuejs.org, und insbesondere auf deren Guide (vuejs.org/guide/introduction.html).

5.2. Von AngularJS 1.x zu [Vue.js]

Das ursprüngliche Dokument (2014) verwendete AngularJS 1.x: ein Framework (noch ohne TypeScript), das um $scope, Controller, Direktiven (ng-repeat, ng-if …) und einen Mechanismus zur Änderungserkennung auf Basis der „Digest-Schleife“ ($digest) und der Variablenüberwachung ($watch) organisiert war.

[Vue.js] (2014 von Evan You geschaffen, nach einer Erfahrung bei Google mit AngularJS) ist wie [Angular] ein vollwertiges Framework: Anders als [React] (eine einfache Bibliothek für Oberflächen) bringt es ein eigenes Komponentensystem und eine eigene reaktive Zustandsverwaltung mit und bietet – über separate offizielle Pakete, die in diesem Dokument nicht verwendet werden – einen Router ([vue-router]) und einen globalen Zustandsverwalter ([Pinia]). [Vue.js] bezeichnet sich selbst als „progressiv“: ein auf die View-Schicht konzentrierter Kern (vom Konzept her vergleichbar mit $scope/Template von AngularJS 1.x), ergänzt durch ein eigenes Komponentenformat – die [.vue]-Dateien (siehe unten). Dieses Kapitel stellt diese Konzepte einzeln vor, mit kurzen, von der Fallstudie unabhängigen Beispielen – das folgende Kapitel zeigt ihre Anwendung im vollständigen [RdvMedecins]-Client, in [Vue.js] 3.

5.3. Das Konzept hinter einer [Vue.js]-Anwendung: die „Single-Page-Anwendung“

Eine [Vue.js]-Anwendung ist, wie eine [Angular]- oder [React]-Anwendung, eine Single-Page-Anwendung (SPA): Der Server liefert nur eine einzige HTML-Seite an den Browser, die eine einzige JavaScript-Datei enthält, in der die gesamte Logik der Anwendung steckt. Sobald diese Seite geladen ist, gibt es nie wieder ein vollständiges Neuladen der Seite: Jede Benutzerinteraktion (Wechsel der Ansicht, Absenden eines Formulars usw.) wird vom bereits im Browser vorhandenen JavaScript-Code verarbeitet, der die Anzeige aktualisiert und im Hintergrund über asynchrone HTTP-Anfragen (meist mit JSON) mit dem Server kommuniziert. Das war bereits das Prinzip des ursprünglichen Dokuments mit AngularJS 1.x sowie der Varianten [Angular] und [React] in diesem Kurs – es hat sich nicht geändert: Nur das Framework, das die Anzeige übernimmt, unterscheidet sich von Variante zu Variante.

5.4. Die Komponenten: [.vue]-Dateien und [Composition API]

Wie in [Angular] und [React] ist eine Komponente die Grundeinheit einer [Vue.js]-Anwendung: Sie erzeugt anhand ihres aktuellen Zustands und der Eigenschaften, die sie erhält, das, was auf dem Bildschirm angezeigt werden soll. Der Unterschied liegt in der Form: Eine [Angular]-Komponente ist eine dekorierte Klasse, die mit einem separaten (oder Inline-)HTML-Template verbunden ist; eine [React]-Komponente ist eine Funktion, die [JSX] zurückgibt; eine [Vue.js]-Komponente ist eine „Single-File“-Datei [.vue], die drei verschiedene Blöcke in einer einzigen Datei vereint: ein [<template>] (das HTML, ähnlich dem von [Angular]), ein [<script setup>] (die Logik, wie in TypeScript) und optional ein [<style>] (die für diese Komponente spezifischen Stile).

Hier ist eine sehr kleine, von der Fallstudie unabhängige Komponente, die [CounterComponent] ([Angular]) und [Counter.tsx] ([React]) entspricht, die in diesem Kurs bereits vorgestellt wurden:

<!-- Counter.vue -->
<script setup lang="ts">
import { ref } from 'vue';

const value = ref(0);

function increment(): void {
  value.value++;
}
</script>

<template>
  <p>Value: {{ value }}</p>
  <button @click="increment">+1</button>
</template>

Zerlegen wir diesen Code:

  • Zeile 3: [import { ref } from 'vue';] — [ref] ist die Funktion von [Vue.js], die einen reaktiven Wert erzeugt: eine Rolle, die mit der eines Signals auf der [Angular]-Seite oder von [useState] auf der [React]-Seite vergleichbar ist;
  • Zeile 5: [const value = ref(0);] — [ref(0)] erzeugt eine reaktive „Box“, die mit 0 initialisiert wird. Anders als [useState]() ([React]), das ein PAAR zurückgibt (den Wert und einen Setter), [ref()] gibt ein EINZIGES Objekt zurück, dessen Wert über seine Eigenschaft [.value] gelesen und geschrieben wird – ein Mechanismus, der konzeptionell eher einem [signal()] [Angular] ähnelt (das mit [mySignal()] gelesen und mit [mySignal.set(...)] geschrieben wird) als einem [value, setValue]-Paar;
  • Zeile 8: [value.value++;] — die Änderung von [.value] aktualisiert den Wert UND zeichnet automatisch alles neu, was in [<template>] davon abhängt – genau wie bei [mySignal.update(v => v + 1)] in [Angular]; anders als in [React] (wo Zustandswerte unveränderlich sind) hindert hier nichts daran, [.value] direkt zu inkrementieren (++), ohne eine separate Update-Funktion zu durchlaufen;
  • Zeilen 12–13: [Value: {{ value }}] — [<template>] IST das Template, so wie das HTML bei [Angular] getrennt ist – anders als bei [JSX] und [React], die von JavaScript abgeleitet sind und mit dem Code der Komponentenfunktion vermischt werden. Die doppelten geschweiften Klammern [{{ }}] fügen dort einen Ausdruck ein – dieselbe Rolle wie [{{ value() }}] in [Angular] ([Vue.js] erfordert KEINE Aufrufklammern ([value], nicht [value()]): In einem [<template>] wird ein [ref] automatisch „ausgepackt“; es ist nie nötig, [.value] zu schreiben).

5.5. Der lokale Zustand: [ref]/[reactive] und die Props

In AngularJS 1.x erkannte [Angular] die Änderung eines Datums mit einer systematischen Prüfschleife ($digest), die in der Variante [Angular] dieses Kurses durch Signals (signal(), computed()) ersetzt wurde. [React] verfolgt einen anderen Ansatz: Eine Komponente führt bei jeder Zustandsänderung ihre Funktion vollständig neu aus. [Vue.js] verfolgt einen dritten, hybriden Ansatz: Wie [Angular] verfolgt es genau, welche reaktiven Werte eine Komponente verwendet (dank des kompilierten [<template>] und des „Proxy“-Systems von [ref]/[reactive]) und aktualisiert nur die Teile des DOM, die tatsächlich von ihnen abhängen – ohne je das gesamte [<script setup>] neu auszuführen und ohne den Aufwand des virtuellen DOM, den [React] für ein vergleichbares Ergebnis verwendet.

Funktion
Rolle
ref(initialValue)
erzeugt einen lokalen Zustand mit einem EINZIGEN Wert; wird über [.value] in [<script>] gelesen/geschrieben (nie in [<template>])
reactive(initialObject)
erzeugt einen lokalen Zustand mit MEHREREN Eigenschaften (ein Objekt); wird direkt gelesen/geschrieben, OHNE [.value], Eigenschaft für Eigenschaft
computed(() => ...)
leitet einen Wert aus anderen [ref]/[reactive] ab, der automatisch nur dann neu berechnet wird, wenn sich seine Abhängigkeiten ändern – das direkte Äquivalent zu [computed()] auf der [Angular]-Seite und zu [useMemo]() auf der [React]-Seite
watch(source, callback)
führt [callback] erneut aus, sobald sich [source] ändert – das Äquivalent zu [useEffect](..., [dep]) auf der [React]-Seite oder zu [effect()] auf der [Angular]-Seite

Zwei Mechanismen ergänzen [ref]/[reactive] und ermöglichen es einer Komponente, mit ihrer Elternkomponente zu kommunizieren – sie finden sich durchgängig im [RdvMedecins]-Client (nächstes Kapitel), genau dort, wo [input()]/[output()] auf der [Angular]-Seite standen und auf der [React]-Seite die Props/Callback-Props:

  • die Props ([defineProps<...>()]): Eine [Vue.js]-Komponente deklariert das Format ihrer Eingaben mit [defineProps], einer speziellen Funktion, die der Compiler erkennt (sie erfordert keinerlei [import]) – das direkte Äquivalent zu [input.required<Doctor[]>()] auf der [Angular]-Seite und zu einem destrukturierten Props-Objekt auf der [React]-Seite;
  • die Ereignisse ([defineEmits<...>()]): Statt einer einfachen, als Prop übergebenen Funktion (der Wahl von [React]) unterscheidet [Vue.js] ausdrücklich die Ereignisse, die eine Komponente auslöst – die Funktion [emit(‘eventName’, value)] , die es zurückgibt, ist das direkte Äquivalent zu [search.emit(value)] auf der [Angular]-Seite ([output<...>()]).

5.6. Keine Module: Jede Datei ist bereits eigenständig

Eine AngularJS-1.x-Anwendung war in Module gegliedert (angular.module(...)). [Angular] übernahm diese Idee zunächst in einer starreren Form (die NgModule-Dateien), bevor es Standalone-Komponenten als Standardmodus einführte. Wie [React] hat [Vue.js] dieses Konzept nie benötigt: Eine [.vue]-Datei exportiert ihre Komponente implizit (das [<script setup>] IST der Default-Export der Datei, ohne dass man auch nur das Schlüsselwort [export] angeben müsste), und eine andere Datei verwendet sie mit einem einfachen [import] – die standardmäßigen ECMAScript-Module, ohne zusätzliche frameworkspezifische Schichten:

<!-- Parent.vue -->
<script setup lang="ts">
import Counter from './Counter.vue';
</script>

<template>
  <div>
    <Counter />
  </div>
</template>

Dieser Stil wird im gesamten [RdvMedecins]-Client (nächstes Kapitel) verwendet: keine *.module.ts-Dateien, keine zu pflegenden [imports: [...]]-Dekoratoren – eine Vereinfachung, die der bereits bei [React] gesehenen entspricht, im Vergleich zu AngularJS 1.x und [Angular] mit NgModule.

5.7. Geteilte Logik: Composables und [provide]/[inject]

Wie in [NestJS] (Kapitel 2) benötigt der [RdvMedecins]-Client Logik, die von mehreren Komponenten gemeinsam genutzt wird: die Kommunikation mit dem Server, die Identifizierung des angemeldeten Benutzers und den Wechsel der Sprache. [Angular] begegnet diesem Bedarf mit injizierbaren Services ([@Injectable]({ providedIn: ‘root’ }) + inject(...)); [React] kombiniert eigene Hooks mit [Context]. [Vue.js] verwendet eine kombinierte Lösung ähnlich der von [React], aber mit eigenem Vokabular und eigenem Mechanismus:

  • ein Composable – eine Funktion, deren Name per Konvention mit [use] beginnt (wie ein [React]-Hook) und die selbst andere [Vue.js]-Funktionen aufrufen kann ([ref], [inject] …) – kapselt wiederverwendbare Logik, genau wie eine serverseitige Service-Methode in [Angular];
  • das Paar [provide]/[inject] teilt einen Wert (Zustand + Funktionen) mit dem GESAMTEN Komponentenunterbaum, ohne ihn Eigenschaft für Eigenschaft manuell durch jede Zwischenebene reichen zu müssen – die Rolle, die auf der [providedIn: ‘root’] -Seite von [Angular] und auf der [Context] -Seite von [React] gespielt wird. Anders als [React], das verlangt, dass eine [Provider]-Komponente im Baum sichtbar um die Wurzelkomponente herum VERSCHACHTELT wird, [Vue.js] liefert einen Wert mit einem einzigen Funktionsaufruf, [app.provide(key, value)], auf der Anwendungsinstanz (siehe main.ts, nächstes Kapitel) – ganz ohne Komponentenverschachtelung.

Hier ist ein kurzes, von der Fallstudie unabhängiges Beispiel, das konzeptionell [MyService] ([Angular]) und [my-context.tsx] ([React]) entspricht, die in diesem Kurs bereits vorgestellt wurden:

// my-composable.ts
import { inject, reactive, type InjectionKey } from 'vue';

interface MyStore {
  greet: () => string;
}

const MyStoreKey: InjectionKey<MyStore> = Symbol('MyStore');

export function createMyStore(): MyStore {
  return reactive<MyStore>({
    greet: () => 'Hello',
  });
}

export function useMyStore(): MyStore {
  const store = inject(MyStoreKey);
  if (!store) {
    throw new Error('useMyStore() must be called after app.provide(MyStoreKey, ...)');
  }
  return store;
}

Zerlegen wir diesen Code:

  • Zeile 8: [const MyStoreKey: InjectionKey<MyStore> = Symbol('MyStore');] — der Injektionsschlüssel: ein [Symbol] statt eines einfachen Strings, um jede versehentliche Kollision mit einem anderen Schlüssel desselben Namens zu vermeiden – [InjectionKey<T>] ist auf der Typseite einfach ein Alias für [Symbol] , wodurch [inject()] den Typ des zurückgegebenen Werts automatisch bestimmen kann;
  • Zeile 10: [export function createMyStore(): MyStore {] — die Factory, die NUR EINMAL aufgerufen wird (in [main.ts]; siehe nächstes Kapitel), BEVOR irgendeine Komponente existiert – weshalb sie etwaige Abhängigkeiten als gewöhnliche Funktionsparameter erhält und nicht über [inject()];
  • Zeile 11: [return reactive<MyStore>({] — [reactive(...)] hüllt das Objekt in einen JavaScript-Proxy: Jedes Lesen einer seiner Eigenschaften in einem [<template>] registriert automatisch eine Abhängigkeit; jeder Schreibvorgang zeichnet alles neu, was davon abhängt – anders als bei [ref()] wird die Eigenschaft ([store.greet]) direkt gelesen und geschrieben, ohne [.value];
  • Zeilen 16–22: [export function useMyStore(): MyStore { …] — das Composable, das die Komponenten aufrufen ([const my = useMyStore();]), so wie sie [inject(MyService)] von [Angular] oder [useMyContext()] von [React] aufgerufen hätten; der Fehler, der ausgelöst wird, wenn [inject(MyStoreKey)] den Wert [undefined] zurückgibt, weist auf eine vergessene Verdrahtung hin (der entsprechende [app.provide(...)] wurde nicht aufgerufen) – genau dasselbe Sicherheitsnetz wie auf der [React]-Seite (Context ist standardmäßig null).

5.8. Kommunikation mit dem Server: [fetch]

[HttpClient] ([Angular]) war der direkte Nachfolger des Services $http von AngularJS 1.x, der im ursprünglichen Dokument verwendet wurde. Wie [React] ist [Vue.js] lediglich ein Framework für Oberflächen und stellt im Kern keinen HTTP-Client bereit: Der [RdvMedecins]-Client verwendet direkt [fetch], die Standard-API des Browsers (ohne zusätzliche Abhängigkeiten verfügbar):

1
2
3
const httpResponse = await fetch('http://localhost:8080/hello');
const response = (await httpResponse.json()) as { message: string };
console.log(response.message);

Ein wichtiger Unterschied zu $http und [HttpClient]: [fetch] gibt direkt ein Promise zurück (den asynchronen Standardmechanismus von JavaScript), kein Observable – keine RxJS-Bibliothek, kein [.subscribe]({ next, error }), kein [.pipe(map(...))]. Es kann mit [.then(...)] oder, für bessere Lesbarkeit, mit async/await verwendet werden (wie oben gezeigt). Ein Netzwerkfehler oder eine Fehlerantwort wird dann mit einem einfachen try/catch-Block behandelt und nicht mit dem Fehlerzweig eines RxJS-Abonnements – genau wie auf der [React]-Seite.

Das Composable [useAppointmentService()] des [RdvMedecins]-Clients (nächstes Kapitel) kapselt systematisch diesen Aufruf von [fetch] gefolgt von [.json()], und zwar aus einem bestimmten Grund, der an der entsprechenden Stelle erklärt wird (der [ServerResponse]<T>-Umschlag, der allen Serverantworten gemeinsam ist).

5.9. Bedingtes Rendern und Listen: [v-if]/[v-else] und [v-for]

AngularJS 1.x verwendete strukturelle Direktiven (ng-if, ng-repeat), um ein Element bedingt anzuzeigen oder einen Template-Block für jedes Element einer Liste zu wiederholen. Die Variante [Angular] dieses Kurses verwendet die integrierte Syntax [@if]/[@for]; der [React]-Client drückt dasselbe mit dem ternären Operator und [.map(...)] in reinem JavaScript aus. [Vue.js] steht in diesem speziellen Punkt [Angular] näher: Sein [<template>] hat eine eigene „Sprache“ von Direktiven, die dem Geist von AngularJS 1.x sehr ähnelt (ng-if wird zu [v-if], ng-repeat wird zu [v-for]):

1
2
3
4
5
6
<p v-if="loggedInUser">Welcome!</p>
<p v-else>Please log in.</p>

<ul>
  <li v-for="item in itemList" :key="item.id">{{ item.name }}</li>
</ul>

Zerlegen wir diesen Code:

  • Zeilen 1–2: [v-if="loggedInUser" … v-else …] — [v-if]/[v-else] ersetzen [@if]/[@else] ([Angular]) und ng-if (AngularJS 1.x): Nur der Zweig, dessen Bedingung wahr ist, wird im DOM EINGEHÄNGT – genau dasselbe Verhalten wie beim ternären Operator von [React] ({ condition ? ... : ... }), jedoch als HTML-Attribut ausgedrückt und nicht als in [JSX] eingebetteter JavaScript-Ausdruck;
  • Zeile 5: [v-for="item in itemList" :key="item.id"] — [v-for] ersetzt [@for] ([Angular]) und ng-repeat (AngularJS 1.x) und dient genau demselben Zweck wie [.map(...)] auf der [React]-Seite: Es wiederholt das Element für jeden Eintrag des Arrays. [:key] (erforderlich, genau wie [key={item.id}] in [React] und track in [Angular]) teilt [Vue.js] mit, wie es ein bereits angezeigtes Element wiedererkennt, wenn es die Liste neu zeichnet.

5.10. Zusammenfassung: Zuordnungen [Angular] -> [React] -> [Vue.js]

[Angular]/[React] (frühere Versionen dieses Kurses)
[Vue.js] (2026)
Standalone components ([@Component]) / functional components ([React])
Single-File-Komponenten ([.vue])
Signals (signal(), input(), output(), computed()) / [useState](), props, [useMemo]() ([React])
[ref]()/[reactive](), [defineProps]/[defineEmits], [computed]()
effect() / [useEffect]() ([React])
[watch]()
Separate template (.html) + decorator (.ts) / embedded [JSX] (.tsx) ([React])
[<template>] + [<script setup>] in derselben Datei vereint [.vue]
[@if], [@for] / ternary operator, .map() ([React])
[v-if]/[v-else], [v-for]
Injectable services ([@Injectable]) + inject() / custom hooks + [Context] ([React])
Composables + [provide]/[inject]
[HttpClient] (RxJS Observables) / [fetch] (Promises) ([React])
[fetch] (native Promises, wie bei [React])
[@angular/router] (empty routing table) / No router ([React])
Kein Router (gleiche Schlussfolgerung, einen Schritt weitergedacht)
Angular CLI / [@angular/build] / [Vite] ([React])
[Vite] (mit [@vitejs/plugin-vue] statt [@vitejs/plugin-react])

Diese Konzepte genügen, um den [RdvMedecins]-Client im nächsten Kapitel in Angriff zu nehmen: Jede neue Verwendung wird dort dennoch im Verlauf des Codes noch einmal an genau der Stelle erklärt, an der sie auftritt.