Skip to content

5. Kapitel 4 - Einführung in [Angular]

5.1. Quellen

Dieses Kapitel basiert auf der offiziellen Dokumentation von [Angular]: angular.dev.

5.2. Von AngularJS 1.x zu [Angular]

Das ursprüngliche Dokument (2014) verwendete AngularJS 1.x: ein Framework (JavaScript – 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) organisiert war.

Ab 2016 wurde dieses Framework unter dem Namen [Angular] (ohne „JS“) vollständig neu geschrieben, in TypeScript und mit einer komponentenbasierten Architektur. Es folgten weitere Versionen (2, 4 … bis 22, die in diesem Dokument verwendet wird), mit zwei wesentlichen Änderungen, die Sie kennen sollten, bevor Sie mit dem Code des [RdvMedecins]-Clients arbeiten:

  • die Ablösung der NgModules (@NgModule) zugunsten eigenständiger, in sich geschlossener Komponenten (Standalone);
  • die Einführung der Signals (signal()), eines neuen Reaktivitätsmodells, das $watch/$digest ersetzt.

Dieses Kapitel stellt diese Konzepte nacheinander vor, mit kurzen Beispielen, die von der Fallstudie unabhängig sind – das nächste Kapitel zeigt sie in Aktion im vollständigen [RdvMedecins]-Client.

5.3. Das Konzept einer [Angular]-Anwendung: die „Single-Page-Anwendung“

Eine [Angular]-Anwendung ist eine Single-Page-Anwendung (SPA): Der Server liefert dem Browser nur eine einzige Seite (HTML), 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 – daran hat sich nichts geändert.

5.4. Komponenten

Eine Komponente ist die Grundeinheit einer [Angular]-Anwendung: Sie verbindet eine Ansicht (ein HTML-Template) mit einer TypeScript-Klasse, die deren Zustand und Verhalten verwaltet – genau die Rolle, die im ursprünglichen Dokument das Paar „Ansicht + Controller C“ in AngularJS 1.x spielte, hier aber in einer einzigen Einheit vereint.

Hier eine sehr kleine, von der Fallstudie unabhängige Komponente, die mit ng generate component counter erstellt werden könnte:

// counter.component.ts
import { Component, signal } from '@angular/core';

@Component({
  selector: 'app-counter',
  templateUrl: './counter.component.html',
})
export class CounterComponent {
  readonly value = signal(0);

  increment(): void {
    this.value.update((v) => v + 1);
  }
}
<!-- counter.component.html -->
<p>Value: {{ value() }}</p>
<button (click)="increment()">+1</button>
  • Zeile 4: [@Component]({...}) ist ein Dekorator (derselbe Mechanismus wie in [NestJS]; siehe Kapitel 2), der die folgende Klasse als [Angular]-Komponente deklariert;
  • Zeile 5: selector: 'app-counter': der Name des benutzerdefinierten HTML-Tags (<app-counter>), das, wenn es im Template einer anderen Komponente verwendet wird, diese Komponente an dieser Stelle einfügt – der Mechanismus der Ansichtskomposition, der in AngularJS 1.x (in anderer Form, den Direktiven) bereits vorhanden war;
  • Zeile 6: templateUrl: die mit dieser Komponente verbundene HTML-Datei (Sie können HTML auch direkt im Dekorator schreiben, mit der Eigenschaft template);
  • Zeile 9: signal(0) erzeugt einen reaktiven Wert mit dem Anfangswert 0 (siehe den nächsten Abschnitt);
  • Zeile 16: {{ value() }} im Template: Die doppelten geschweiften Klammern zeigen einen von der Klasse berechneten Wert an – eine Syntax, die identisch mit der von AngularJS 1.x ist, aber beachten Sie die Klammern: `value` ist ein Signal und damit eine Funktion, die aufgerufen werden muss, um ihren aktuellen Wert zu lesen;
  • Zeile 17: (click)="increment()": Die Klammern um `click` bedeuten „auf das `DOM`-Ereignis click lauschen“ und die angegebene Methode aufrufen – das exakte Äquivalent der Direktive `ng-click` in `AngularJS` 1.x.

5.5. Signals: das neue Reaktivitätsmodell

In AngularJS 1.x erkannte [Angular] Datenänderungen über eine systematische Prüfschleife (den $digest), die bei jeder möglichen Interaktion alle überwachten Ausdrücke ($watch) durchlief. Dieser Mechanismus war zwar einfach zu benutzen, wurde aber mit wachsender Anwendung teuer.

Ein Signal ist ein Wertbehälter, der weiß, wann er sich ändert, und weiß, was von ihm abhängt (ein Template, eine andere Berechnung usw.) – so muss [Angular] nicht mehr alles erneut prüfen: Nur die Teile der Anwendung, die tatsächlich von einem geänderten Signal abhängen, werden neu berechnet. Drei Funktionen genügen, um die Grundlagen zu verstehen:

Funktion
Rolle
mySignal(initialValue)
erzeugt ein Signal; sein Wert wird gelesen, indem es als Funktion aufgerufen wird: mySignal()
mySignal.set(newValue)
ersetzt den Wert des Signals
mySignal.update(v => ...)
berechnet den neuen Wert auf Basis des alten (siehe increment() oben)
computed(() => ...)
erzeugt ein Signal, das automatisch aus anderen Signals berechnet und nur bei Bedarf neu berechnet wird

Zwei spezialisierte Varianten von signal() ermöglichen es einer Komponente, mit ihrer übergeordneten Komponente zu kommunizieren – sie kommen im [RdvMedecins]-Client häufig vor (siehe das nächste Kapitel):

  • input() (und seine Variante input.required()) deklariert einen Eingang: einen Wert, den die übergeordnete Komponente liefert. Dies ist die moderne Weiterentwicklung des klassischen Dekorators @Input() und konzeptionell das Äquivalent eines Direktivenattributs von AngularJS 1.x;
  • output() deklariert einen Ausgang: ein Ereignis, das die Komponente an ihre übergeordnete Komponente senden kann (mit der Methode .emit(value)). Dies ist die moderne Weiterentwicklung von @Output() / EventEmitter und das Äquivalent der benutzerdefinierten Ereignisse ($emit) von AngularJS 1.x.

5.6. Standalone-Komponenten

Eine AngularJS-1.x-Anwendung war in Module (angular.module(...)) gegliedert, die Controller, Direktiven und Services deklarierten. [Angular] übernahm diese Idee zunächst in einer starreren Form (dem NgModule, Dekorator @NgModule), bevor in neueren Versionen eigenständige Komponenten (Standalone) eingeführt wurden, die inzwischen zum Standardbetriebsmodus geworden sind.

Eine Standalone-Komponente deklariert alles, was sie benötigt – etwa die anderen Komponenten, die sie in ihrem Template verwendet –, im eigenen Dekorator [@Component], statt sich auf ein gemeinsames Modul zu stützen:

1
2
3
4
5
6
@Component({
  selector: 'app-parent',
  imports: [CounterComponent], // die im Template verwendeten Komponenten
  templateUrl: './parent.component.html',
})
export class ParentComponent {}

Dies ist der Stil, der im gesamten [RdvMedecins]-Client verwendet wird (siehe das nächste Kapitel): Dateien *.module.ts kommen dort nicht mehr vor, eine deutliche Vereinfachung sowohl gegenüber AngularJS 1.x als auch gegenüber früheren Versionen von Angular.

5.7. Services und Dependency Injection

Wie in [NestJS] (Kapitel 2) ist ein [Angular]-Service eine gewöhnliche Klasse, dekoriert mit [@Injectable], die [Angular] automatisch erzeugen und jeder Komponente bereitstellen kann, die sie benötigt – dasselbe Konzept der Dependency Injection, deren Prinzip AngularJS 1.x tatsächlich als eines der allerersten JavaScript-Frameworks populär machte (es ist kein Zufall, dass sich [NestJS] direkt davon inspirieren ließ, wie in Kapitel 2 erwähnt).

1
2
3
4
5
6
7
8
import { Injectable } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class MyService {
  greet(): string {
    return 'Hello';
  }
}
  • Zeile 3: providedIn: 'root' gibt an, dass für die gesamte Anwendung eine einzige Instanz dieses Services erzeugt wird (ein Singleton) – das Äquivalent dessen, was in AngularJS 1.x ein .service() oder ein .factory() war.

Um diesen Service in einer Komponente zu erhalten, stellt das moderne [Angular] die Funktion inject() bereit, die die klassische Konstruktorinjektion ersetzt (beide funktionieren weiterhin, aber inject() ist zur Standardpraxis geworden und wird vom [RdvMedecins]-Client verwendet):

1
2
3
4
5
6
7
import { Component, inject } from '@angular/core';
import { MyService } from './my.service';

@Component({ ... })
export class MyComponent {
  private readonly myService = inject(MyService);
}

5.8. Kommunikation mit dem Server: [HttpClient]

Das Modul [HttpClient] ([@angular/common/http]) ermöglicht es, HTTP-Anfragen – GET, POST … – an einen Server zu senden und dessen Antwort zu verarbeiten. Es ist eine direkte Weiterentwicklung des Services $http von AngularJS 1.x, der im ursprünglichen Dokument verwendet wurde.

1
2
3
4
5
6
7
8
import { inject } from '@angular/core';
import { HttpClient } from '@angular/common/http';

const http = inject(HttpClient);
http.get<{ message: string }>('http://localhost:8080/hello').subscribe({
  next: (response) => console.log(response.message),
  error: (error) => console.error(error),
});

Ein wichtiger Unterschied zu $http: Die Methoden von [HttpClient] (get, post …) geben weder direkt die Antwort noch, wie man erwarten könnte, ein Promise zurück, sondern ein Observable (RxJS-Bibliothek) – einen Strom von Werten über die Zeit, den Sie mit .subscribe({ next, error }) abonnieren, um benachrichtigt zu werden, wenn die Antwort eintrifft (oder ein Fehler auftritt). Sie können ein Observable auch vor dem Abonnieren transformieren, mit Operatoren wie map:

1
2
3
http.get<{ message: string }>('...').pipe(
  map((response) => response.message), // we only keep the "message" field
);

Der Service [AppointmentService] des [RdvMedecins]-Clients (nächstes Kapitel) verwendet durchgängig diese Kombination .pipe(map(...)), und zwar aus einem bestimmten Grund, der dort erläutert wird.

5.9. Die neue Syntax zur Ablaufsteuerung: [@if] und [@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. [Angular] nutzte lange ein sehr ähnliches Äquivalent (*ngIf, *ngFor), bevor es in seinen neueren Versionen eine in die Template-Sprache selbst integrierte Syntax einführte – diejenige, die im gesamten [RdvMedecins]-Client verwendet wird:

@if (loggedInUser()) {
  <p>Welcome!</p>
} @else {
  <p>Please log in.</p>
}

<ul>
  @for (item of itemList(); track item.id) {
    <li>{{ item.name }}</li>
  }
</ul>
  • Zeile 8: track item.[id] (bei [@for] erforderlich) teilt [Angular] mit, wie es ein bereits angezeigtes Element wiedererkennt, wenn es die Liste neu zeichnet – ähnlich wie „track by“ bei ng-repeat bereits optional möglich war.

5.10. Zusammenfassung: Entsprechungen AngularJS 1.x -> [Angular]

AngularJS 1.x (2014)
[Angular] (2026)
Controller + $scope
Komponente (Klasse + Template)
$watch / $digest loop
Signals (signal(), computed())
angular.module(...), @NgModule
Standalone-Komponenten
@Input() / @Output() (legacy)
input() / output() (Signals)
.service() / .factory()
[@Injectable]({ providedIn: 'root' })
Constructor injection
inject() (oder weiterhin über den Konstruktor)
$http
[HttpClient] (Observables von RxJS)
ng-if / ng-repeat
[@if] / [@for]
JavaScript
TypeScript

Dieser Hintergrund genügt, um im nächsten Kapitel den [RdvMedecins]-Client anzugehen: Jede neue Funktion wird dort dennoch noch einmal erklärt, im Verlauf des Codes, genau an der Stelle, an der sie auftritt.