5. Kapitel 4 - Einführung in [React]
5.1. Quellen
Dieses Kapitel basiert auf der offiziellen Dokumentation von [React]: react.dev.
5.2. Von AngularJS 1.x zu [React]
Das ursprüngliche Dokument (2014) verwendete AngularJS 1.x: ein JavaScript-Framework (noch nicht 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) herum organisiert ist.
[React] (von Meta entwickelt, 2013) ist kein vollständiges Framework wie AngularJS 1.x oder [Angular]: Es ist eine Bibliothek , die einer einzigen Aufgabe gewidmet ist: dem Aufbau von Oberflächen aus Komponenten. Für sich genommen bietet sie weder einen HTTP-Client noch einen Router noch einen Dependency-Injection-Mechanismus – weshalb sich der [RdvMedecins]-Client in diesem Kapitel hierfür auf die native API des Browsers (fetch(), siehe unten) und auf einen für [React] spezifischen Mechanismus, den Context, stützt statt auf dedizierte Module wie [HttpClient] oder den [Angular]-Router. Dieses Kapitel stellt diese Konzepte einzeln vor, mit kurzen Beispielen unabhängig von der Fallstudie – das nächste Kapitel zeigt sie in Aktion im vollständigen [RdvMedecins]-Client, in [React] 19.
5.3. Das Konzept einer [React]-Anwendung: die „Single-Page-Anwendung“
Eine [React]-Anwendung ist, wie eine [Angular]-Anwendung, eine Single-Page-Anwendung (SPA): Der Server liefert dem Browser nur eine einzige Seite (HTML) mit einer einzigen Datei (JavaScript), die die gesamte Logik der Anwendung enthält. Ist diese Seite geladen, 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 behandelt, der die Anzeige aktualisiert und im Hintergrund über asynchrone HTTP-Anfragen (meist mit JSON) mit dem Server kommuniziert. Dies war bereits das Prinzip des ursprünglichen Dokuments mit AngularJS 1.x sowie der [Angular]-Variante dieses Kurses – es hat sich nicht geändert: Nur die Bibliothek, die die Anzeige verwaltet, unterscheidet sich von Variante zu Variante.
5.4. Komponenten: Funktionen und [JSX]
Wie in [Angular] ist eine Komponente die Grundeinheit einer [React]-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 verknüpft ist; eine [React]-Komponente ist einfach eine JavaScript-(oder TypeScript-)Funktion, die [JSX] zurückgibt – eine Syntax, die HTML ähnelt, vom Compiler aber tatsächlich in gewöhnliche JavaScript-Funktionsaufrufe umgewandelt wird.
Hier ist eine sehr kleine Komponente, unabhängig von der Fallstudie, die [CounterComponent] entspricht, die in der [Angular]-Variante dieses Kurses vorgestellt wurde:
Kommentieren wir diesen Code:
- Zeile 3: import { useState } from 'react'; — [useState] ist ein Hook von [React]: eine spezielle Funktion (erkennbar am Präfix „use“), die es einer Komponentenfunktion erlaubt, einen Zustand zu halten, der von einem Rendering zum nächsten erhalten bleibt – eine Rolle, die mit der eines Signals auf der [Angular]-Seite oder des $scope/AngularJS-Controllers vergleichbar ist;
- Zeile 5: export function Counter() { — eine [React]-Komponente ist eine gewöhnliche, exportierte Funktion: Es gibt weder einen Dekorator noch einen eigenen (HTML-)Selektor zu deklarieren (anders als [@Component]({ selector: … }) auf der [Angular]-Seite) – sie wird direkt als Tag mit ihrem eigenen Namen verwendet, <Counter />, im [JSX] einer übergeordneten Komponente;
- Zeile 6: const [value, setValue] = useState(0); — [useState](0) erzeugt einen mit 0 initialisierten Zustandswert und gibt ein Paar zurück: den aktuellen Wert (value) und eine Funktion zu seiner Ersetzung (setValue). Die Array-Destrukturierung ([value, setValue]) ist lediglich eine Namenskonvention – nichts hindert Sie daran, diese beiden Elemente anders zu benennen;
- Zeilen 8–10: setValue((v) => v + 1); — der Aufruf von setValue ändert `value` nicht an Ort und Stelle (die Zustandswerte von [React] sind unveränderlich): Er weist [React] an, die Komponente mit dem neuen, aus dem alten berechneten Wert neu zu zeichnen, genau wie mySignal.update(v => …) auf der [Angular]-Seite;
- Zeilen 13–16: <p>Value: {value}</p> — das von der Funktion zurückgegebene [JSX] IST das Template: Die geschweiften Klammern { } fügen einen JavaScript-Ausdruck ein (hier den aktuellen Wert) – sie spielen dieselbe Rolle wie die doppelten geschweiften Klammern {{ value() }} im [Angular]-Template, aber ohne die Aufrufklammern: `value` ist der Wert selbst, kein Signal, das beim Aufruf ausgewertet werden muss.
Das Tag <> … </> (ein „Fragment“) fasst mehrere Elemente zusammen, ohne einen überflüssigen HTML-Knoten um sie herum hinzuzufügen – ein technisches Detail von [JSX], das verlangt, dass eine Komponentenfunktion nur ein einziges Wurzelelement zurückgibt.
5.5. Der lokale Zustand: [useState] und Props
In AngularJS 1.x erkannte [Angular] die Änderung eines Datenwerts über eine systematische Prüfschleife ($digest), die in der [Angular]-Variante dieses Kurses durch Signale (signal(), computed()) ersetzt wurde. [React] verfolgt einen dritten Ansatz, der einfacher erscheint: Eine Komponente führt ihre Funktion vollständig erneut aus (und berechnet damit ihr gesamtes [JSX] neu), sobald sich einer ihrer [useState]-Werte ändert – [React] vergleicht dann das Ergebnis mit dem vorherigen Rendering und ändert im tatsächlichen DOM des Browsers nur das, was sich wirklich geändert hat (eine Technik namens Reconciliation oder „Virtual DOM“). Anders als Signale „weiß“ ein [useState]-Zustand nicht von selbst, was von ihm abhängt: Der Mechanismus des erneuten Renderns der gesamten Komponente übernimmt das, was einfacher nachzuvollziehen, in sehr großen Anwendungen aber – theoretisch – etwas teurer ist, ein bewusster Kompromiss in [React].
Funktion | Rolle |
erzeugt einen lokalen Zustand und gibt das Paar [value, setValue] zurück; setValue zeichnet die Komponente mit dem neuen Wert neu | |
ersetzt den Zustandswert durch einen zuvor berechneten Wert | |
berechnet den neuen Wert auf Basis des alten (siehe increment() weiter oben) | |
berechnet einen abgeleiteten Wert nur neu, wenn sich eines der Elemente von [deps] ändert – das konzeptionelle Äquivalent zu computed() auf der [Angular]-Seite |
Zwei Mechanismen ergänzen [useState] , damit eine Komponente mit ihrer übergeordneten Komponente kommunizieren kann – wir begegnen ihnen im [RdvMedecins]-Client (nächstes Kapitel) ständig, genau dort, wo auf der [Angular]-Seite input()/output() standen:
- Props: Eine [React]-Komponente erhält ihre Eingaben als einfache Funktionsparameter (ein destrukturiertes Objekt, { doctors, onSearch }) – das direkte Äquivalent zu input.required<Doctor[]>() auf der [Angular]-Seite und, konzeptionell, zu einem Attribut einer AngularJS-1.x-Direktive;
- Callback-Props: eine vom Elternteil bereitgestellte Funktion (onSearch: (criteria) => void), die als Prop übergeben und vom Kind im richtigen Moment aufgerufen wird – das direkte Äquivalent zu output<...>() (und seiner Methode .emit(value)) auf der [Angular]-Seite und zu den benutzerdefinierten Ereignissen ($emit) von AngularJS 1.x.
5.6. Keine Module: Jede Datei ist bereits in sich geschlossen
Eine AngularJS-1.x-Anwendung war in Modulen organisiert (angular.module(...)). [Angular] übernahm diese Idee zunächst in einer starreren Form (dem NgModule), bevor es Standalone-Komponenten als Standardmodus vorschlug – eine Vereinfachung, die die [Angular]-Variante dieses Kurses bereits übernommen hat. [React] brauchte dieses Konzept nie: Eine .tsx-Datei exportiert eine Komponente mit dem Schlüsselwort export der Sprache JavaScript selbst, und eine andere Datei verwendet sie mit einem einfachen import – die standardmäßigen ECMAScript-Module, ohne zusätzliche, für die Oberflächenbibliothek spezifische Schicht:
Dies ist der Stil, der im gesamten [RdvMedecins]-Client (nächstes Kapitel) verwendet wird: keine *.module.ts-Dateien, keine zu pflegenden imports:-Dekoratoren [...] – eine weitere Vereinfachung gegenüber AngularJS 1.x, gegenüber [Angular] mit NgModule, und sogar gegenüber den Standalone-Komponenten von [Angular] (die jedoch ihre Abhängigkeiten weiterhin in imports auflisten: [...] des Dekorators [@Component]).
5.7. Logik gemeinsam nutzen: Custom Hooks und [Context]
Wie in [NestJS] (Kapitel 2) benötigt der Client [RdvMedecins] 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(...)) – dem direkten Nachfolger von .service()/.factory() aus AngularJS 1.x. [React] hat keinen eingebauten Dependency-Injection-Mechanismus; die moderne Praxis kombiniert zwei bereits weiter oben besprochene Werkzeuge:
- Ein Custom Hook – eine Funktion, deren Name mit `use` beginnt und die ihrerseits andere Hooks aufrufen kann ([useState], [useContext] …) – kapselt wiederverwendbare Logik, genau wie eine Service-Methode auf der [Angular]-Seite;
- Der Context ([React.createContext]) teilt einen Wert (Zustand + Funktionen) mit einem ganzen Teilbaum von Komponenten, ohne ihn Prop für Prop manuell durch jede Zwischenebene reichen zu müssen – die Rolle, die zuvor providedIn: 'root' auf der [Angular]-Seite spielte: eine einzige Instanz, verfügbar überall, wo sie gebraucht wird.
Ein kurzes Beispiel, unabhängig von der Fallstudie, konzeptionell äquivalent zu [MyService] , das in der [Angular]-Variante dieses Kurses vorgestellt wurde:
Kommentieren wir diesen Code:
- Zeile 8: const MyContext = createContext<MyContextValue | null>(null); — erzeugt den Context selbst; `null` ist der Standardwert, der nur verwendet wird, wenn darüber im Baum kein `<MyProvider>` vorhanden ist – ein Programmierfehler, der in Zeile 17 erkannt wird;
- Zeilen 10–13: <MyContext.Provider value={value}>{children}</MyContext.Provider> — die Provider-Komponente stellt den Wert allen ihren Nachkommen zur Verfügung ({children}); sie wird nur ein einziges Mal nahe der Wurzel der Anwendung platziert (siehe main.tsx des Clients [RdvMedecins], nächstes Kapitel) – das Äquivalent der impliziten „Registrierung“ durch providedIn: 'root' auf der [Angular]-Seite;
- Zeilen 15–21: export function useMyContext(): MyContextValue { — der Custom Hook, der den Zugriff auf den Wert des Contexts bietet; ihn rufen die Komponenten auf (const my = useMyContext();), genau wie sie inject(MyService) auf der [Angular]-Seite aufgerufen hätten.
5.8. Kommunikation mit dem Server: [fetch]
[HttpClient] ([Angular]) war der direkte Nachfolger des Services $http aus AngularJS 1.x, der im ursprünglichen Dokument verwendet wurde. Da [React] lediglich eine Oberflächenbibliothek ist, bietet es keinen HTTP-Client: Der Client [RdvMedecins] verwendet direkt [fetch], die Standard-API des Browsers (ohne zusätzliche Abhängigkeiten verfügbar):
Ein wichtiger Unterschied zu $http und [HttpClient]: [fetch] gibt direkt ein Promise zurück (den standardmäßigen asynchronen Mechanismus von JavaScript), kein Observable – keine RxJS-Bibliothek, kein .subscribe({ next, error }), kein .pipe(map(...)). Es lässt sich mit .then(...) oder, für bessere Lesbarkeit, mit async/await verwenden (wie oben gezeigt; dies hält die Ausführung der Funktion an, bis das Promise aufgelöst ist, ohne den Rest der Anwendung zu blockieren). Ein Netzwerkfehler oder eine Fehlerantwort wird dann mit einem einfachen try/catch-Block behandelt, statt mit dem Fehlerzweig eines RxJS-Subscriptions.
Der Hook useAppointmentService() des [RdvMedecins]-Clients (nächstes Kapitel) kapselt systematisch diesen [fetch]-Aufruf samt anschließendem .json(), aus einem bestimmten Grund, der an der entsprechenden Stelle erklärt wird (der [ServerResponse]<T>-Umschlag, der allen Serverantworten gemeinsam ist).
5.9. Bedingtes Rendering und Listen: reines [JSX]
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 [Angular]-Variante dieses Kurses verwendet die eingebaute Syntax [@if]/[@for]. [React] hat keine separate Template-Syntax, die man lernen müsste: Das von einer Komponente zurückgegebene [JSX] IST JavaScript, und der Kontrollfluss wird mit gewöhnlichen JavaScript-Operatoren ausgedrückt:
Kommentieren wir diesen Code:
- Zeilen 1–5: loggedInUser ? (...) : (...) — der ternäre Operator von JavaScript ersetzt [@if]/[@else] ([Angular]) und ng-if (AngularJS 1.x): Die Bedingung bestimmt, welcher der beiden [JSX] -Ausdrücke zurückgegeben wird. Für eine Bedingung ohne Alternative genügt der Operator &&: {condition && <p>...</p>} zeigt überhaupt nichts an, wenn die Bedingung falsch ist (dies ist der Stil, der zum Beispiel für das ADMIN/USER-Banner in der Komponente App des [RdvMedecins]-Clients verwendet wird, die im nächsten Kapitel besprochen wird);
- Zeile 8: itemList.map((item) => (...)) — .map() (eine Standard-Array-Methode von JavaScript) ersetzt [@for] ([Angular]) und ng-repeat (AngularJS 1.x): Sie wandelt jedes Element des Arrays in ein [JSX]-Element um;
- Zeile 9: key={item.id} (in einer [JSX]-Liste erforderlich) — teilt [React] mit, wie es ein bereits angezeigtes Element beim erneuten Zeichnen der Liste wiedererkennt; dies spielt genau dieselbe Rolle wie track item.id nach [@for] auf der [Angular]-Seite.
5.10. Zusammenfassung: Zuordnungen [Angular] -> [React]
[Angular] (vorherige Version dieses Kurses) | [React] (2026) |
Funktionale Komponenten | |
[useState](), Props, Callback-Props, [useMemo]() | |
[useEffect]() | |
[JSX] in die Komponente eingebettet (.tsx) | |
Ternärer Operator / &&, .map() | |
Custom Hooks + [Context] | |
[fetch] (native Promises) | |
Kein Router (gleiche Schlussfolgerung, einen Schritt weitergedacht) | |
[Vite] |
Diese Konzepte genügen, um den [RdvMedecins]-Client im nächsten Kapitel anzugehen: Jede neue Verwendung wird dort dennoch im Verlauf des Codes an genau der Stelle, an der sie auftritt, erneut erklärt.