Skip to content

3. Die Komponenten

3.1. Beispiel 10: Komponenten und ihre Inputs

Eine Komponente ist ein wiederverwendbarer Baustein der Oberfläche. Dieses Beispiel zeigt Profile von Ärzten an: eine Komponente namens [DoctorCard] (das Kind), die von der Komponente [App] (dem Elternteil) mehrfach verwendet wird.

Die Dateien einer Komponente liegen üblicherweise in einem Ordner, der nach der Komponente benannt ist:

1
2
3
4
5
6
7
8
10-components/src/app/
├── doctor-card/
│   ├── doctor-card.ts     the class of the component
│   ├── doctor-card.html   its template
│   └── doctor-card.css    its style
├── doctor.ts             the Doctor type
├── app.ts
└── app.html

Der Datentyp, den Eltern- und Kindkomponente gemeinsam nutzen:

1
2
3
4
5
6
7
8
9
// der Datentyp, den das Elternelement (App) und das Kindelement (DoctorCard) gemeinsam verwenden
export interface Doctor {
  id: number;
  title: string;
  firstName: string;
  lastName: string;
  specialty: string;
  available: boolean;
}

3.1.1. Das Kind

// =========================================================================
// 10-components/src/app/doctor-card/doctor-card.ts - eine KIND-Komponente
// -------------------------------------------------------------------------
// Sie erhält ihre Daten von ihrem Elternelement über INPUTS, deklariert
// mit input(): Jeder Input ist ein schreibgeschütztes SIGNAL, das dem
// vom Elternelement übergebenen Wert folgt. Ihr Typ wird zur Kompilierzeit geprüft:
// <app-doctor-card [doctor]="42"> würde abgelehnt.
//
// Goldene Regel: Eine Komponente ändert ihre Inputs NIEMALS. Die Daten
// fließen vom Elternelement zum Kind; um eine Änderung anzufordern,
// löst das Kind ein Ereignis aus (siehe Beispiel 11).
// =========================================================================

import { booleanAttribute, Component, computed, input } from '@angular/core';
import { Doctor } from '../doctor';

@Component({
  // der Selektor: das Tag, das diese Komponente in ihrem Elternelement repräsentiert
  selector: 'app-doctor-card',
  templateUrl: './doctor-card.html',
  styleUrl: './doctor-card.css',
})
export class DoctorCard {
  // input.required: das Elternelement MUSS diesen Input angeben
  readonly doctor = input.required<Doctor>();
  readonly rank = input.required<number>();
  // input(Standardwert): ein optionaler Input. booleanAttribute
  // erlaubt es, einfach <app-doctor-card compact> für true zu schreiben
  readonly compact = input(false, { transform: booleanAttribute });

  // ein computed auf Basis eines Inputs: wird neu berechnet, wenn das Elternelement ihn ändert
  protected readonly initials = computed(() => `${this.doctor().firstName[0]}${this.doctor().lastName[0]}`);
}
  • Zeile 19: der Selektor: Die Elternkomponente schreibt [<app-doctor-card>];
  • Zeilen 25–29: die Inputs der Komponente ([inputs]) – die Daten, die ihr von ihrer Elternkomponente übergeben werden. [input()] erzeugt ein schreibgeschütztes Signal, das den von der Elternkomponente übergebenen Wert verfolgt:
    • Zeilen 25–26: [input.required<T>()]: ein erforderlicher Input. Fehlt [[doctor]] im Template der Elternkomponente, führt das zu einem Kompilierungsfehler;
    • Zeile 29: [input(default value)]: ein optionaler Input. Die Option [transform] wandelt den empfangenen Wert um: [booleanAttribute] wandelt das Vorhandensein des Attributs ([<app-doctor-card compact>], ohne Wert) in ein [true] um, wie beim HTML-Attribut [disabled];
  • Zeile 32: ein [computed], das auf einem Input beruht: wird neu berechnet, wenn die Elternkomponente den Input ändert.

Die Inputs sind nicht [protected]: Sie gehören zur öffentlichen Schnittstelle der Komponente, die ihre Elternkomponente verwendet.

Goldene Regel: Eine Komponente ändert ihre Inputs nie (sie sind ohnehin schreibgeschützt). Die Daten fließen von der Eltern- zur Kindkomponente; um eine Änderung anzufordern, sendet die Kindkomponente ein Ereignis (Beispiel 11).

<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>
      <!-- die Inputs sind Signale: sie werden durch Aufruf gelesen -->
      <h2 class="h6 mb-1">{{ rank() }}. {{ doctor().title }} {{ doctor().firstName }} {{ doctor().lastName }}</h2>
      @if (!compact()) {
        <p class="mb-0 text-muted small">{{ doctor().specialty }}</p>
      }
    </div>
  </div>
</div>
  • Zeilen 1, 6, 8: Die Inputs sind Signals: Sie werden durch Aufruf gelesen;
  • Zeilen 7–9: Die Fachrichtung wird nur in der normalen Version der Karte angezeigt.
/* der Stil der Komponente: er gilt nur für IHRE Elemente */
.initials {
  width: 2.5rem;
  height: 2.5rem;
  border-radius: 50%;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #dd0031;
  color: white;
  font-weight: bold;
}

Die Klasse [initials] gilt nur für diese Komponente: Eine andere Komponente könnte ihre eigene Klasse [initials] haben, ohne jeden Konflikt.

3.1.2. Die Elternkomponente

// =========================================================================
// 10-components/src/app/app.ts - die ELTERN-Komponente
// -------------------------------------------------------------------------
// Sie importiert die Komponente DoctorCard (Array imports) und verwendet sie als
// neues HTML-Tag, <app-doctor-card>, so oft wie
// nötig: Eine Komponente ist ein WIEDERVERWENDBARER Teil der Oberfläche mit
// eigenen Daten, eigenem Template und eigenem Stil.
// =========================================================================

import { Component, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { DoctorCard } from './doctor-card/doctor-card';
import { Doctor } from './doctor';

@Component({
  selector: 'app-root',
  imports: [FormsModule, DoctorCard],
  templateUrl: './app.html',
})
export class App {
  protected readonly doctors = signal<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 },
  ]);
  protected readonly compact = signal(false);

  // das Elternelement ändert SEINE Daten: die betroffenen Kinder werden aktualisiert
  protected toggleAvailability(): void {
    this.doctors.update((list) => list.map((m) => ({ ...m, available: !m.available })));
  }
}
  • Zeile 17: Die Elternkomponente importiert die Kindkomponente; ohne dies wäre [<app-doctor-card>] ein unbekanntes Tag, und die Kompilierung würde fehlschlagen;
  • Zeilen 29–31: Die Elternkomponente ändert IHRE Daten. Sie ersetzt jeden Arzt durch eine geänderte Kopie: Das an jede Karte übergebene Objekt [m] ändert sich, und die Karten aktualisieren sich.
<div class="container py-4">
  <h1 class="h3 mb-3">Example 10 - components and their inputs</h1>
  <div class="d-flex gap-3 mb-3">
    <label class="form-check-label">
      <input type="checkbox" class="form-check-input" [(ngModel)]="compact"> compact display
    </label>
    <button class="btn btn-sm btn-outline-primary" (click)="toggleAvailability()">Toggle availability</button>
  </div>
  <div class="row g-3">
    @for (m of doctors(); track m.id; let i = $index) {
      <div class="col-md-4">
        <!-- [doctor]="m" übergibt das OBJEKT m (einen Ausdruck);
             doctor="m" ohne Klammern würde den STRING "m" übergeben -->
        <app-doctor-card [doctor]="m" [rank]="i + 1" [compact]="compact()" />
      </div>
    }
  </div>
  <p class="mt-3 mb-1 small text-muted">The same card, in compact version, through an attribute without a value:</p>
  <div class="w-50">
    <app-doctor-card [doctor]="doctors()[0]" [rank]="1" compact />
  </div>
</div>
  • Zeile 14: Die Kindkomponente wird als HTML-Tag verwendet. [[doctor]="m"] ist ein Property Binding an den Input [doctor]: Es übergibt das OBJEKT [m]. Ohne eckige Klammern würde [doctor="m"] den STRING ["m"] übergeben, was der Compiler ablehnen würde. Eine Komponente ohne Inhalt kann mit einem selbstschließenden Tag geschrieben werden ([/>]);
  • Zeile 20: [compact] ohne Wert: Dank [booleanAttribute] erhält der Input [true].

[npm start 10-components]; klicken Sie auf „Verfügbarkeit umschalten“:

Image

3.2. Beispiel 11: Outputs einer Komponente und model()

Ein Kind hat zwei Möglichkeiten, Informationen an seine Elternkomponente zurückzusenden:

  1. ein Ereignis (einen Output, [output]) senden, auf das die Elternkomponente wie auf ein HTML-Ereignis lauscht; 2. eine bidirektionale Verbindung, [[( )]], an einem [model()].

3.2.1. Ein Ereignis senden

Ein Zähler, der seine Elternkomponente bei jedem Klick und bei Erreichen seiner Grenze benachrichtigt:

// =========================================================================
// 11-outputs-model/src/app/counter/counter.ts
// -------------------------------------------------------------------------
// Ein Kind, das sein Elternelement BENACHRICHTIGT: output() deklariert ein Ereignis, das die
// Komponente auslösen kann, mit dem Typ seiner Daten. Das Elternelement hört darauf
// wie auf ein HTML-Ereignis: <app-counter (incremented)="..." (limit)="...">.
// =========================================================================

import { Component, input, output, signal } from '@angular/core';

@Component({
  selector: 'app-counter',
  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>
  `,
})
export class Counter {
  readonly label = input.required<string>();
  readonly max = input.required<number>();

  // zwei Ereignisse: incremented (mit dem neuen Wert) und limit (ohne Daten)
  readonly incremented = output<number>();
  readonly limit = output<void>();

  protected readonly value = signal(0);

  protected plus(): void {
    if (this.value() >= this.max()) {
      this.limit.emit();
      return;
    }
    this.value.update((v) => v + 1);
    this.incremented.emit(this.value());
  }
}
  • Zeilen 13–19: das Template der Komponente, im Dekorator geschrieben (Eigenschaft [template], in Backticks eingeschlossen);
  • Zeilen 26–27: [output<T>()] deklariert einen Output: ein Ereignis, das die Komponente senden kann, samt dem Typ seiner Daten. [limit] hat keine Daten ([void]);
  • Zeilen 33 und 37: [emit(data)] sendet das Ereignis; die Elternkomponente erhält die Daten.

Vermeiden Sie es, einen Output nach einem Browser-Ereignis zu benennen ([change], [click] ...): Browser-Ereignisse, die von den Elementen der Komponente ausgelöst werden, propagieren bis zu ihrem Host-Element, und die Elternkomponente würde sie ebenfalls empfangen.

3.2.2. Ein Two-Way-Binding

Ein „benutzerdefiniertes“ Formularfeld (Beschriftung, Feld, Tooltip, Zeichenzähler), das wie [ngModel] mit Daten der Elternkomponente verbunden ist:

// =========================================================================
// 11-outputs-model/src/app/text-field/text-field.ts
// -------------------------------------------------------------------------
// Ein "selbstgeschriebenes" Formularfeld (Label + Feld + Hilfe + Zeichenzähler),
// das wie ngModel ein ZWEI-Wege-Binding akzeptiert:
//     <app-text-field [(value)]="lastName" label="Last name" [max]="20" />
//
// model() erstellt ein BESCHREIBBARES Signal, das mit dem Elternelement verknüpft ist: LESEN liefert den
// Wert des Elternelements, SCHREIBEN (set) löst das Ereignis valueChange aus, das die
// Syntax [( )] in eine Aktualisierung des Signals des Elternelements umsetzt. Die Daten
// bleiben so tatsächlich Eigentum des Elternelements.
// =========================================================================

import { Component, input, model } from '@angular/core';

// ein von allen Instanzen geteilter Zähler: eine eindeutige Kennung pro
// Feld, um <label for> und <input id> zu verknüpfen
let nextNumber = 0;

@Component({
  selector: 'app-text-field',
  template: `
    <div class="mb-3">
      <label class="form-label" [for]="id">{{ label() }}</label>
      <!-- [value]: der Wert des Elternelements; (input): jeder Tastendruck ersetzt ihn -->
      <input class="form-control" [id]="id" [value]="value()" [attr.maxlength]="max()"
             [class.is-invalid]="value().length === max()" (input)="onInput($event)">
      <div class="form-text">{{ help() }} ({{ value().length }} / {{ max() }})</div>
    </div>
  `,
})
export class TextField {
  readonly value = model.required<string>();
  readonly label = input.required<string>();
  readonly max = input.required<number>();
  readonly help = input('');

  protected readonly id = `text-field-${++nextNumber}`;

  protected onInput(event: Event): void {
    this.value.set((event.target as HTMLInputElement).value);
  }
}
  • Zeile 33: [model()] erzeugt ein beschreibbares Signal, das mit der Elternkomponente verknüpft ist. Beim LESEN liefert es den Wert der Elternkomponente; beim SCHREIBEN ([set], Zeile 41) ändert es den Wert UND sendet das Ereignis [valueChange] (der Modellname gefolgt von [Change]). Bei der Elternkomponente, die [[(value)]="signal"] schreibt, wird somit ihr Signal aktualisiert;
  • Zeile 18: eine Modulvariable (außerhalb der Klasse) wird von allen Instanzen der Komponente gemeinsam genutzt: ein Zähler, der jedem Feld einen eindeutigen Bezeichner zuweist (Zeile 38), um [<label for>] und [<input id>] zu verknüpfen;
  • Zeilen 26–27: [[value]] zeigt den Wert der Elternkomponente an; [(input)] ersetzt ihn bei jedem Tastendruck (Zeile 41). [[attr.maxlength]] ist ein Attribut-Binding an HTML (das Attribut [maxlength]), kein Property Binding.

3.2.3. Die Elternkomponente

// =========================================================================
// 11-outputs-model/src/app/app.ts - das Elternelement hört auf seine Kinder
// -------------------------------------------------------------------------
// Zwei Wege, wie ein Kind Informationen nach oben gibt:
//   1. ein Ereignis auslösen (output), auf das das Elternelement mit ( ) hört;
//   2. ein Zwei-Wege-Binding [( )] auf einem model(): eine Kurzform
//      für den Input [value] + das Ereignis (valueChange).
// =========================================================================

import { Component, computed, signal } from '@angular/core';
import { Counter } from './counter/counter';
import { TextField } from './text-field/text-field';

@Component({
  selector: 'app-root',
  imports: [Counter, TextField],
  templateUrl: './app.html',
})
export class App {
  protected readonly total = signal(0);
  protected readonly message = signal('');
  protected readonly firstName = signal('Marie');
  protected readonly lastName = signal('PELISSIER');
  protected readonly fullName = computed(() => `${this.firstName()} ${this.lastName().toUpperCase()}`);

  // der Handler des Ereignisses incremented: er erhält die ausgelösten Daten ($event)
  protected onChange(label: string, value: number): void {
    this.total.update((t) => t + 1);
    this.message.set(`${label} is now ${value}`);
  }

  protected clear(): void {
    this.firstName.set('');
    this.lastName.set('');
  }
}
<div class="container py-4" style="max-width: 640px">
  <h1 class="h3 mb-3">Example 11 - the outputs of a component and model()</h1>

  <div class="card p-3 mb-4">
    <h2 class="h6">1. Events emitted by the children</h2>
    <!-- $event: die vom Kind ausgelösten Daten (hier der neue Wert) -->
    <app-counter label="Coffees" [max]="3" (incremented)="onChange('Coffees', $event)"
                  (limit)="message.set('No more than 3 coffees!')" />
    <app-counter label="Glasses of water" [max]="8" (incremented)="onChange('Glasses of water', $event)"
                  (limit)="message.set('Enough drinking.')" />
    <p class="mb-0">Total clicks: {{ total() }} - <em>{{ message() }}</em></p>
  </div>

  <div class="card p-3">
    <h2 class="h6">2. A two-way binding with model()</h2>
    <!-- [(value)]="firstName": das Signal firstName des Elternelements, vom Kind gelesen UND geändert -->
    <app-text-field [(value)]="firstName" label="First name" [max]="20" help="Required" />
    <app-text-field [(value)]="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)="clear()">Clear (from the parent)</button>
  </div>
</div>
  • Zeile 7: [(incremented)="..."] lauscht auf den Output [incremented] des Zählers; [$event] sind die Daten des Outputs (der neue Wert). [label="Coffees"] ohne eckige Klammern: Ein Input vom Typ String kann einen konstanten Wert erhalten;
  • Zeile 8: [(limit)]: Eine Methode eines Signals ([set]) kann direkt im Template aufgerufen werden;
  • Zeile 9: ein zweiter Zähler mit eigener Beschriftung, Grenze und eigenen Meldungen;
  • Zeile 17: [[(value)]="firstName"]: das Signal [firstName] der Elternkomponente (ohne Klammern: Es wird das Signal selbst angegeben), von der Kindkomponente gelesen UND geändert. Das ist die Kurzform für [[value]="firstName()" (valueChange)="firstName.set($event)"];
  • Zeile 20: Die Elternkomponente ändert ihre Daten: Die beiden Felder folgen.

[npm start 11-outputs-model]; viermal auf die Kaffees klicken, einmal auf das Wasser, dann einen Namen eingeben:

Image

3.3. Beispiel 12: Content Projection

Inputs übermitteln Daten; Content Projection übermittelt Inhalt (aus HTML und anderen Komponenten), den die Elternkomponente ZWISCHEN den Tags der Komponente schreibt. Das ist das clientseitige Gegenstück zum Template [layout.hbs] des Kurses [NestJS] und seinem [{{{body}}}].

3.3.1. Eine Karte

Ein wiederverwendbarer Rahmen (Rand, Kopfzeile, Fußzeile), dessen Inhalt die Elternkomponente liefert:

// =========================================================================
// 12-projection/src/app/card/card.ts - ein wiederverwendbares TEMPLATE
// -------------------------------------------------------------------------
// Inputs übergeben DATEN; die Inhalts-PROJEKTION übergibt
// INHALT (HTML, andere Komponenten), den das Elternelement ZWISCHEN den Tags
// <app-card> und </app-card> schreibt. Die Card legt den Rahmen fest (Rand,
// Kopf- und Fußbereich), das Elternelement liefert, was hineinkommt:
//   - <ng-content />                   : der "Haupt"-Inhalt;
//   - <ng-content select="[header]" /> : nur die Elemente, die das
//                                        Attribut header haben;
//   - der Inhalt zwischen <ng-content> und </ng-content> wird angezeigt, wenn
//     das Elternelement nichts liefert (Standardinhalt).
// Es ist das clientseitige Äquivalent des Templates layout.hbs und seines {{{body}}}
// im NestJS-Kurs.
// =========================================================================

import { Component, input } from '@angular/core';

@Component({
  selector: 'app-card',
  template: `
    <div class="card mb-3" [class]="color() ? 'border-' + color() : ''">
      <div class="card-header" [class]="color() ? 'text-bg-' + color() : ''">
        <ng-content select="[header]">Untitled</ng-content>
      </div>
      <div class="card-body">
        <ng-content />
      </div>
      <!-- ein leerer Footer (das Elternelement hat nichts geliefert) wird durch das CSS :empty ausgeblendet -->
      <div class="card-footer text-muted small"><ng-content select="[footer]" /></div>
    </div>
  `,
  styles: `
    .card-footer:empty {
      display: none;
    }
  `,
})
export class Card {
  readonly color = input<'primary' | 'success' | 'danger'>();
}
  • Zeile 27: [<ng-content />]: die Stelle, an der [Angular] den Inhalt platziert, den die Elternkomponente zwischen [<app-card>] und [</app-card>] schreibt;
  • Zeile 24: [<ng-content select="[header]">]: nur die Inhaltselemente, die das Attribut [header] haben. [select] akzeptiert einen CSS-Selektor (ein Tag, eine Klasse oder ein Attribut). Der Text zwischen [<ng-content>] und [</ng-content>] wird angezeigt, wenn das übergeordnete Element keinen Inhalt liefert: Das ist der Standardinhalt;
  • Zeile 30: die Fußzeile: Elemente, die das Attribut [footer] haben;
  • Zeilen 33–37: Eine leere Fußzeile (das übergeordnete Element hat nichts geliefert) wird ausgeblendet: Die CSS-Pseudoklasse [:empty] bezeichnet ein Element ohne Inhalt;
  • Zeile 40: ein optionaler Input, der nur drei Werte annehmen kann; wenn kein Standardwert angegeben ist, ist er standardmäßig [undefined].

3.3.2. Eine generische Tabelle

Eine Tabelle, die weiß, wie man Zeilen durchläuft, aber nicht, wie man EINE Zeile anzeigt: Ihre Elternkomponente teilt es ihr mit, indem sie ihr ein Zeilen-Template übergibt.

// =========================================================================
// 12-projection/src/app/data-table/data-table.ts - eine GENERISCHE Tabelle
// -------------------------------------------------------------------------
// DataTable<T> ist eine generische Klasse: Sie zeigt Zeilen beliebigen
// Typs T an. Sie weiß, wie man über die Zeilen iteriert, aber nicht, wie man EINE
// Zeile darstellt: Das sagt ihr das Elternelement, indem es ihr ein Zeilen-TEMPLATE übergibt
// (ein <ng-template #row>, ein HTML-Stück, das nicht direkt
// angezeigt wird, aber bei Bedarf angezeigt werden kann, beliebig oft).
//
// contentChild('row'): das <ng-template #row>, das das Elternelement zwischen
// <app-data-table> und </app-data-table> platziert. Die Tabelle zeigt es für jede Zeile
// mit ngTemplateOutlet an und übergibt ihm einen KONTEXT: die Zeile ($implicit)
// und ihren Rang (index). Der vom Elternelement gelieferte Inhalt nutzt so
// Daten, die dem Kind gehören.
// =========================================================================

import { Component, contentChild, input, TemplateRef } from '@angular/core';
import { NgTemplateOutlet } from '@angular/common';

// was die Tabelle an das Template jeder Zeile übergibt
export interface RowContext<T> {
  $implicit: T; // der von let-row abgerufene Wert
  index: number; // abgerufen mit let-i="index"
}

@Component({
  selector: 'app-data-table',
  imports: [NgTemplateOutlet],
  template: `
    <table class="table table-sm align-middle mb-0">
      <thead>
        <tr>
          @for (c of columns(); track c) {
            <th>{{ c }}</th>
          }
        </tr>
      </thead>
      <tbody>
        @for (l of rows(); track l.id; let i = $index) {
          <tr>
            <ng-container [ngTemplateOutlet]="rowTemplate() ?? null" [ngTemplateOutletContext]="{ $implicit: l, index: i }" />
          </tr>
        } @empty {
          <tr>
            <td class="text-muted" [attr.colspan]="columns().length">
              <ng-content select="[empty]">No data.</ng-content>
            </td>
          </tr>
        }
      </tbody>
    </table>
  `,
})
export class DataTable<T extends { id: number }> {
  readonly rows = input.required<T[]>();
  readonly columns = input.required<string[]>();
  protected readonly rowTemplate = contentChild<TemplateRef<RowContext<T>>>('row');
}
  • Zeile 54: [DataTable<T>] ist eine generische Klasse: Sie zeigt Zeilen beliebigen Typs [T] an, sofern sie eine [id] haben (für [track], Zeile 39);
  • Zeile 57: [contentChild('row')]: ein Signal, das auf das Element des projizierten Inhalts verweist, das mit [#row] markiert ist. Das wird ein [<ng-template>] sein: ein HTML-Abschnitt, der nicht unverändert angezeigt wird, sondern bei Bedarf beliebig oft angezeigt werden kann (ein [TemplateRef]);
  • Zeile 41: Die Direktive [ngTemplateOutlet] zeigt ein Template an, indem sie ihm einen Kontext übergibt – ein Objekt, dessen Eigenschaften im Template zu Variablen werden. [$implicit] ist der Standardwert (Zeilen 21–24);
  • Zeilen 43–49: Wenn die Liste leer ist, der Block [@empty] mit projiziertem Inhalt ([[empty]]) und Standardinhalt;
  • Zeile 45: [[attr.colspan]]: ein Attribut-Binding, da [colspan] keine Eigenschaft des Elements [<td>] ist.

3.3.3. Die Elternkomponente

// =========================================================================
// 12-projection/src/app/app.ts - die Templates Card und DataTable verwenden
// =========================================================================

import { Component, computed, signal } from '@angular/core';
import { Card } from './card/card';
import { DataTable } from './data-table/data-table';

interface Slot {
  id: number;
  time: string;
  patient: string | null;
}

@Component({
  selector: 'app-root',
  imports: [Card, DataTable],
  templateUrl: './app.html',
})
export class App {
  protected readonly slots = signal<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 },
  ]);
  protected readonly free = computed(() => this.slots().filter((c) => c.patient === null).length);
  protected readonly nobody: { id: number; name: string }[] = [];
}
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 12 - content projection</h1>

  <app-card color="primary">
    <!-- das Attribut header: dieses <span> landet im <ng-content select="[header]"> -->
    <span header>Schedule of Mme PELISSIER</span>
    <!-- alles, was weder header noch footer hat, landet im Haupt-<ng-content /> -->
    <app-data-table [rows]="slots()" [columns]="['#', 'Slot', 'Status']">
      <!-- das Template einer Zeile: let-c erhält die Zeile, let-i ihren Rang -->
      <ng-template #row let-c let-i="index">
        <td>{{ i + 1 }}</td>
        <td>{{ c.time }}</td>
        <td>
          @if (c.patient) {
            <span class="badge text-bg-secondary">{{ c.patient }}</span>
          } @else {
            <span class="badge text-bg-success">Free</span>
          }
        </td>
      </ng-template>
    </app-data-table>
    <span footer>{{ free() }} free slot(s)</span>
  </app-card>

  <app-card color="success">
    <span header>A card without a footer</span>
    <p class="mb-0">The footer is not provided: the card does not display it.</p>
  </app-card>

  <app-card>
    <!-- kein Header angegeben: der Standardinhalt, "Untitled" -->
    <app-data-table [rows]="nobody" [columns]="['Name']">
      <span empty>Nobody for now.</span>
    </app-data-table>
  </app-card>
</div>
  • Zeilen 4–23: eine blaue Karte. Ihr Inhalt wird von der Karte verteilt: [<span header>] (Zeile 6) kommt in die Kopfzeile, [<span footer>] (Zeile 22) in die Fußzeile und der Rest (die Tabelle) in den Hauptteil;
  • Zeilen 10–20: das Template für eine Zeile. [let-c] ruft den Wert [$implicit] aus dem Kontext (der Zeile) ab, und [let-i="index"] ruft dessen Eigenschaft [index] ab. Der vom Elternelement bereitgestellte Inhalt verwendet somit Daten, die zum Kindelement gehören;
  • Zeilen 25–28: eine Karte ohne Fußbereich;
  • Zeilen 30–35: eine Karte ohne Kopfbereich (mit dem Standardinhalt „Untitled“) und eine leere Tabelle.

[npm start 12-projection]:

Image

Der Compiler erkennt den Typ von [c] im Template (Zeilen 10–20) nicht: Er behandelt ihn als [any]. Dies lässt sich beheben (mit einer Direktive, die den Kontexttyp deklariert), allerdings um den Preis von etwas mehr Code; darin besteht die Einschränkung dieser Technik.

3.4. Beispiel 13: Der Lebenszyklus einer Komponente

Eine Komponente wird erzeugt, angezeigt, existiert und verschwindet schließlich wieder. [Angular] ermöglicht es, in jeder Phase einzugreifen: Das ist der Lebenszyklus der Komponente.

3.4.1. Eine Uhr

Eine Uhr startet einen Timer, wenn sie erzeugt wird ... und muss ihn beenden, wenn sie verschwindet: Andernfalls würde der Timer grundlos weiterlaufen (Speicherleck).

// =========================================================================
// 13-lifecycle/src/app/clock/clock.ts
// -------------------------------------------------------------------------
// Der Lebenszyklus einer Komponente:
//   1. constructor      : die Klasse wird erzeugt; die Inputs sind noch
//                         nicht verfügbar;
//   2. ngOnInit         : die Inputs haben ihren ersten Wert erhalten;
//   3. afterNextRender  : die Komponente wird ANGEZEIGT, ihre HTML-Elemente
//                         existieren in der Seite;
//   4. ngOnDestroy      : die Komponente wird gleich aus der Seite ENTFERNT.
// Eine Uhr startet beim Start einen Timer (setInterval) ... und muss ihn
// unbedingt stoppen, wenn sie verschwindet: Andernfalls würde der Timer
// sinnlos weiterlaufen (Speicherleck).
// =========================================================================

import { afterNextRender, Component, OnDestroy, OnInit, output, signal } from '@angular/core';

@Component({
  selector: 'app-clock',
  template: `<div class="display-6 font-monospace">{{ time() }}</div>`,
})
// implements OnInit, OnDestroy: TypeScript prüft, dass die Methoden existieren
export class Clock implements OnInit, OnDestroy {
  readonly log = output<string>();
  protected readonly time = signal(new Date().toLocaleTimeString());
  private timer: number | undefined;

  constructor() {
    console.log('Clock: constructor'); // das Elternelement hört noch nicht auf log
    // afterNextRender wird im Konstruktor registriert; die Funktion wird
    // einmal aufgerufen, direkt nach der ersten Anzeige der Komponente
    afterNextRender(() => this.log.emit('Clock: afterNextRender - displayed'));
  }

  ngOnInit(): void {
    this.log.emit('Clock: ngOnInit - starting the timer');
    this.timer = window.setInterval(() => this.time.set(new Date().toLocaleTimeString()), 1000);
  }

  ngOnDestroy(): void {
    window.clearInterval(this.timer);
    this.log.emit('Clock: ngOnDestroy - timer stopped');
  }
}

Die Phasen:

  • Zeilen 28–33: der Konstruktor: Die Klasse wird erzeugt. Den Eingaben wurden noch keine Werte zugewiesen, und das Elternelement hört die Ausgaben noch nicht ab (daher das [console.log] in Zeile 29 anstelle eines [emit]);
  • Zeilen 35–38: [ngOnInit()]: Die Eingaben haben ihre ersten Werte erhalten. Dies ist der übliche Ort, um Aktionen auszulösen, die von ihnen abhängen: ein Ladevorgang, ein Timer;
  • Zeile 32: [afterNextRender(function)], im Konstruktor aufgerufen, registriert eine Funktion, die einmal ausgeführt wird, unmittelbar nachdem die Komponente zum ersten Mal angezeigt wurde: Ihre HTML-Elemente existieren dann auf der Seite;
  • Zeilen 40–43: [ngOnDestroy()]: Die Komponente wird gleich von der Seite entfernt. Der Timer wird gestoppt.

[implements OnInit, OnDestroy] (Zeile 23) ist nicht erforderlich: [Angular] ruft [ngOnInit] auf, falls die Methode existiert. [TypeScript] prüft dann jedoch, ob die Methoden korrekt geschrieben sind.

[Angular] bietet weitere Phasen an, die seit der Einführung der Signale weniger nützlich sind: [ngOnChanges] (eine Eingabe hat sich geändert; hierfür bevorzugen wir ein [computed] oder ein [effect] auf dieser Eingabe), [ngAfterViewInit] ... Und eine Alternative zu [ngOnDestroy]: [inject(DestroyRef).onDestroy(function)], die Beispiel 14 verwenden wird.

3.4.2. Das Elternelement

// =========================================================================
// 13-lifecycle/src/app/app.ts
// -------------------------------------------------------------------------
//   - @if um <app-clock>: Das Anhaken / Abwählen des Kästchens erstellt / zerstört
//     die Komponente (ngOnInit / ngOnDestroy, siehe clock.ts);
//   - viewChild('field'): ein Signal, das das mit #field markierte HTML-Element
//     im Template liefert (undefined, solange es nicht angezeigt wird);
//   - effect: wird zuerst einmal ausgeführt, dann bei jeder Änderung der
//     Signale, die er liest. Hier, um dem Feld den Fokus zu geben, sobald es
//     erscheint, und damit der Titel des Tabs der Eingabe folgt.
// =========================================================================

import { Component, effect, ElementRef, OnInit, signal, viewChild } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { Clock } from './clock/clock';

@Component({
  selector: 'app-root',
  imports: [FormsModule, Clock],
  templateUrl: './app.html',
})
export class App implements OnInit {
  protected readonly withClock = signal(true);
  protected readonly log = signal<string[]>([]);
  protected readonly search = signal('');
  protected readonly showSearch = signal(false);

  // das Element <input #field> des Templates; ElementRef.nativeElement: das HTML-Element
  private readonly field = viewChild<ElementRef<HTMLInputElement>>('field');

  constructor() {
    // das Feld erscheint (viewChild ändert sich): wir geben ihm den Fokus
    effect(() => this.field()?.nativeElement.focus());
    // der Titel des Tabs folgt von Anfang an der Eingabe
    effect(() => {
      const text = this.search();
      document.title = text ? `Search: ${text}` : 'Example 13';
    });
  }

  ngOnInit(): void {
    this.trace('App: ngOnInit');
  }

  protected trace(message: string): void {
    this.log.update((j) => [...j, `${new Date().toLocaleTimeString()} ${message}`]);
  }
}
  • Zeile 29: [viewChild('field')]: ein Signal, das auf das Template-Element verweist, das mit [#field] markiert ist. Es steht auf [undefined] , solange das Element nicht existiert (das Feld erscheint erst nach einem Klick). [ElementRef] kapselt das HTML-Element, auf das über seine Eigenschaft [nativeElement] zugegriffen werden kann;
  • Zeile 33: ein [effect] , der dieses Signal liest: Wenn das Feld erscheint, wird der Effect erneut ausgelöst und setzt den Fokus darauf. Es ist nicht nötig, auf die Aktualisierung der Seite zu „warten“: Das Signal ändert sich erst, wenn das Element erzeugt wurde;
  • Zeilen 35–38: ein zweiter Effect: Der Titel des Tabs wird während der Texteingabe aktualisiert, und zwar gleich von Anfang an (ein Effect läuft immer einmal beim Start);
  • Zeilen 41–43: Das Elternelement hat ebenfalls sein eigenes [ngOnInit].
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 13 - the lifecycle of a component</h1>

  <div class="card p-3 mb-3">
    <label class="form-check-label mb-2">
      <input type="checkbox" class="form-check-input" [(ngModel)]="withClock"> show the clock
    </label>
    @if (withClock()) {
      <app-clock (log)="trace($event)" />
    }
  </div>

  <div class="card p-3 mb-3">
    @if (!showSearch()) {
      <button class="btn btn-outline-primary align-self-start" (click)="showSearch.set(true)">Search...</button>
    } @else {
      <!-- #field: das Element, das von viewChild('field') bezeichnet wird -->
      <input #field class="form-control" placeholder="the tab title follows what you type" [(ngModel)]="search">
    }
  </div>

  <h2 class="h6">Log</h2>
  <ol class="small">
    @for (line of log(); track $index) {
      <li>{{ line }}</li>
    }
  </ol>
</div>
  • Zeilen 8–10: Das Aktivieren oder Deaktivieren des Kontrollkästchens erzeugt oder zerstört die Uhr: [@if] fügt die Komponente tatsächlich zur Seite hinzu oder entfernt sie von dort;
  • Zeile 18: [#field], das Element, auf das [viewChild('field')] verweist.

[npm start 13-lifecycle]; deaktivieren und aktivieren Sie das Kontrollkästchen erneut und klicken Sie auf „Search...“:

Image

Das Protokoll zeigt die Reihenfolge der Phasen: zuerst das Elternelement ([App: ngOnInit]), dann die Uhr ([ngOnInit], [afterNextRender]), ihre Zerstörung ([ngOnDestroy]) und eine neue Uhr. Das Suchfeld hat den Fokus.

3.5. Beispiel 14: Services und Dependency Injection

Ein Service ist eine Klasse, die Daten und Code bündelt, die von mehreren Komponenten gemeinsam genutzt werden: Serverzugriff, der angemeldete Benutzer, ein Warenkorb usw. Komponenten erzeugen keine Services (niemals [new CartService()]): Sie fordern sie von [Angular] mit der Funktion [inject()] an. Das ist Dependency Injection, der Mechanismus, den der [NestJS]-Kurs auf der Serverseite vorgestellt hat.

Wenn eine Komponente einen Service anfordert, sucht [Angular] danach, wer ihn bereitstellt: die Komponente selbst, dann ihr Elternelement, dessen Elternelement ... bis hinauf zur Anwendung. Je nachdem, wo er bereitgestellt wird, wird ein Service daher mehr oder weniger weit geteilt. Dieses Beispiel zeigt drei Ebenen.

3.5.1. Ein Root-Service

import { Injectable, signal } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class LogService {
  private readonly _lines = signal<string[]>([]);
  // asReadonly(): die Komponenten LESEN die Zeilen; nur der Service ändert sie
  readonly lines = this._lines.asReadonly();

  trace(message: string): void {
    this._lines.update((l) => [`${new Date().toLocaleTimeString()} ${message}`, ...l].slice(0, 6));
  }
}
  • Zeile 14: [@Injectable({ providedIn: 'root' })]: Der Service wird auf der Root-Ebene der Anwendung bereitgestellt. [Angular] erzeugt bei der ersten Anforderung eine einzige Instanz, und jeder, der ihn anfordert, erhält diese Instanz;
  • Zeilen 16–18: Die Daten der Zeilen sind privat; [asReadonly()] stellt eine öffentliche, schreibgeschützte Version davon bereit. Die Komponenten lesen die Zeilen; nur der Service ändert sie (Zeile 21). Dies ist die übliche Organisation für einen Service, der einen Zustand verwaltet.

3.5.2. Ein von einer Komponente bereitgestellter Service

import { computed, inject, Injectable, signal } from '@angular/core';
import { LogService } from './log.service';

export interface Item {
  label: string;
  price: number;
}

@Injectable()
export class CartService {
  // ein Service kann selbst andere Services anfordern
  private readonly log = inject(LogService);

  private readonly _items = signal<Item[]>([]);
  readonly items = this._items.asReadonly();
  readonly total = computed(() => this._items().reduce((sum, a) => sum + a.price, 0));

  add(item: Item): void {
    this._items.update((a) => [...a, item]);
    this.log.trace(`cart: + ${item.label}`);
  }

  remove(index: number): void {
    this.log.trace(`cart: - ${this._items()[index].label}`);
    this._items.update((a) => a.filter((_, i) => i !== index));
  }
}
  • Zeile 19: [@Injectable()] OHNE [providedIn]: Der Service wird standardmäßig nirgendwo bereitgestellt. Eine Komponente stellt ihn in ihrem Array [providers] bereit;
  • Zeile 22: Ein Service kann selbst andere Services anfordern: Der Warenkorb wird protokolliert;
  • Zeilen 24–26: der Zustand des Warenkorbs (privat), seine schreibgeschützte Version und seine Summe;
  • Zeilen 28–36: die beiden Aktionen, die den Zustand ändern.

3.5.3. Ein konfigurierter Service

import { DestroyRef, inject, Injectable, InjectionToken, signal } from '@angular/core';

// factory: der Wert, der verwendet wird, wenn niemand dieses Token bereitstellt
export const CLOCK_PERIOD = new InjectionToken<number>('period of the clock', { factory: () => 1000 });

@Injectable()
export class ClockService {
  private readonly period = inject(CLOCK_PERIOD);
  readonly now = signal(new Date());

  constructor() {
    const timer = window.setInterval(() => this.now.set(new Date()), this.period);
    inject(DestroyRef).onDestroy(() => window.clearInterval(timer));
  }
}
  • Zeile 15: Ein Injection-Token ([InjectionToken]) verweist auf einen Wert, der keine Klasse ist: in diesem Fall eine Zahl, die Periode der Uhr. [factory] liefert den Wert, der verwendet wird, wenn niemand dieses Token bereitstellt;
  • Zeile 19: Der Wert des Tokens wird auf dieselbe Weise angefordert wie ein Service;
  • Zeile 24: [DestroyRef] repräsentiert die „Lebensdauer“ der Komponente, die den Service bereitgestellt hat; [onDestroy] registriert eine Funktion, die bei ihrer Zerstörung ausgeführt wird: Der Timer stoppt zusammen mit der Komponente, die die Uhr bereitgestellt hat.

[inject()] wird nur in einem Injektionskontext aufgerufen: bei der Initialisierung der Eigenschaften einer von [Angular] erzeugten Klasse (Komponente, Service, Direktive, Pipe) oder in ihrem Konstruktor. Später, innerhalb einer gewöhnlichen Methode, kann es nicht aufgerufen werden.

3.5.4. Komponenten

Ein Katalog, der Artikel zum Warenkorb hinzufügt:

// 14-services/src/app/catalog/catalog.ts - ein Nachfahre, der den Warenkorb INJIZIERT
import { Component, inject } from '@angular/core';
import { Item, CartService } from '../services/cart.service';

@Component({
  selector: 'app-catalog',
  template: `
    <ul class="list-group">
      @for (a of catalog; track a.label) {
        <li 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>
  `,
})
export class Catalog {
  // der von App bereitgestellte Warenkorb (Fehler zur Laufzeit, wenn ihn niemand bereitstellt)
  protected readonly cart = inject(CartService);

  protected readonly catalog: Item[] = [
    { label: 'Consultation', price: 30 },
    { label: 'Vaccine', price: 12.5 },
    { label: 'Certificate', price: 5 },
  ];
}
  • Zeile 20: [inject(CartService)]: der Warenkorb, der von einem Elternelement ([App]) bereitgestellt wird. Hätte ihn niemand bereitgestellt, würde [Angular] einen Laufzeitfehler melden;
  • Zeile 12: Das Template ruft direkt eine Methode des Services auf.

Eine Zusammenfassung des Warenkorbs:

import { Component, inject } from '@angular/core';
import { DatePipe } from '@angular/common';
import { CartService } from '../services/cart.service';
import { ClockService, CLOCK_PERIOD } from '../services/clock.service';

@Component({
  selector: 'app-cart-summary',
  imports: [DatePipe],
  // eine neue Instanz von ClockService für DIESE Komponente, mit einem anderen
  // Intervall: { provide: token, useValue: value }
  providers: [ClockService, { provide: CLOCK_PERIOD, useValue: 5000 }],
  template: `
    <div class="card p-3">
      <h2 class="h6">Cart ({{ cart.items().length }} item(s)) - {{ clock.now() | date: 'HH:mm:ss' }}</h2>
      <ul class="mb-2">
        @for (a of cart.items(); track $index) {
          <li>{{ a.label }} <a href="#" (click)="$event.preventDefault(); cart.remove($index)">remove</a></li>
        }
      </ul>
      <strong>Total: €{{ cart.total() }}</strong>
    </div>
  `,
})
export class CartSummary {
  protected readonly cart = inject(CartService);
  protected readonly clock = inject(ClockService);
}
  • Zeile 18: Die Komponente stellt ihre eigene Uhr bereit (eine neue Instanz von [ClockService]) und eine andere Zeitspanne: [{ provide: token, useValue: value }];
  • Zeilen 32–33: Der Warenkorb ist derjenige von [App] (derselbe wie im Katalog); die Uhr ist ihre eigene.

Und die Root-Komponente:

import { Component, inject } from '@angular/core';
import { DatePipe } from '@angular/common';
import { Catalog } from './catalog/catalog';
import { CartSummary } from './cart-summary/cart-summary';
import { ClockService } from './services/clock.service';
import { LogService } from './services/log.service';
import { CartService } from './services/cart.service';

@Component({
  selector: 'app-root',
  imports: [DatePipe, Catalog, CartSummary],
  providers: [CartService, ClockService],
  templateUrl: './app.html',
})
export class App {
  protected readonly clock = inject(ClockService);
  protected readonly log = inject(LogService);
}
  • Zeile 23: [App] stellt einen Warenkorb bereit (geteilt von ihr und allen ihren Nachfahren) sowie eine Uhr (Standardperiode: eine Sekunde);
  • Zeile 28: das Protokoll, ein Root-Service.
<div class="container py-4" style="max-width: 720px">
  <h1 class="h3 mb-3">Example 14 - services and dependency injection</h1>
  <p class="text-muted">Clock of App: {{ clock.now() | date: 'HH:mm:ss' }}</p>
  <div class="row g-3">
    <div class="col-md-6"><app-catalog /></div>
    <div class="col-md-6"><app-cart-summary /></div>
  </div>
  <h2 class="h6 mt-3">Log (LogService)</h2>
  <ul class="small">
    @for (line of log.lines(); track $index) {
      <li>{{ line }}</li>
    }
  </ul>
</div>

[npm start 14-services]; drei Artikel werden hinzugefügt, einer wird entfernt:

Image

Die beiden Timer laufen nicht gleich schnell: Jede Komponente hat die Instanz erhalten, die ihr am nächsten liegt. Der Warenkorb hingegen wird sowohl vom Katalog als auch von der Zusammenfassung geteilt.

Services sind in [Angular] das Mittel, Logik und Daten zwischen Komponenten zu teilen (die Rolle, die „Composables“ und [provide] / [inject] in [Vue.js] spielen). Beispiel 20 wird daraus einen Zustand machen, der von der gesamten Anwendung geteilt wird.

3.6. Beispiel 15: Eigene Direktiven schreiben

Eine Komponente ist eine Direktive , die ein Template besitzt. Eine Direktive „für sich allein“ hat keines: Sie wird an ein vorhandenes Element (ihren Host) angehängt, um dessen Aussehen oder Verhalten zu ändern. [Angular] stellt einige bereit ([ngModel], [routerLink], [ngTemplateOutlet] ...); Sie können eigene schreiben. Hier sind drei Beispiele.

3.6.1. Ein Element beim Überfahren hervorheben

// =========================================================================
// 15-directives/src/app/directives/highlight.directive.ts
// -------------------------------------------------------------------------
// Eine ATTRIBUT-DIREKTIVE fügt einem bestehenden Element ein Verhalten hinzu,
// ohne eigenes Template: <li appHighlight="gold">. Ihr Selektor ist ein
// CSS-Attributselektor ([appHighlight]).
// host: die Bindings, die die Direktive auf dem Element setzt, das sie trägt
// (ihrem "Host"):
//   - '[style.background-color]' : eine Eigenschaft des Elements;
//   - '(mouseenter)'             : ein Ereignis des Elements.
// =========================================================================

import { Directive, input, signal } from '@angular/core';

@Directive({
  selector: '[appHighlight]',
  host: {
    '[style.background-color]': 'hovered() ? color() : null',
    '[style.transition]': '"background-color 0.2s"',
    '(mouseenter)': 'hovered.set(true)',
    '(mouseleave)': 'hovered.set(false)',
  },
})
export class HighlightDirective {
  // der Input hat den Namen des Selektors: <li appHighlight="gold"> setzt ihn
  readonly color = input('#fff3cd', { alias: 'appHighlight', transform: (c: string) => c || '#fff3cd' });
  protected readonly hovered = signal(false);
}
  • Zeile 15: [@Directive] statt [@Component]: kein Template;
  • Zeile 16: Der Selektor ist ein CSS-Attributselektor: Die Direktive wird auf jedes Element angewendet, das das Attribut [appHighlight] besitzt;
  • Zeilen 17–22: [host]: die Bindings, die die Direktive auf ihren Host anwendet, geschrieben wie in einem Template:
    • Zeile 18: ein Property-Binding: die Hintergrundfarbe des Hosts, wenn die Maus darüber fährt ([null]: keine Farbe);
    • Zeilen 20–21: Ereignis-Bindings: Eintritt und Verlassen der Maus;
  • Zeile 26: Eine Eingabe, die nach dem Selektor benannt ist (Option [alias]): [<li appHighlight="gold">] befüllt sowohl den Selektor als auch die Eingabe. Die Funktion [transform] ersetzt eine leere Zeichenkette durch die Standardfarbe.

3.6.2. Fokus setzen

// =========================================================================
// 15-directives/src/app/directives/autofocus.directive.ts
// -------------------------------------------------------------------------
// <input appAutofocus>: das Feld erhält den Fokus, sobald es angezeigt wird.
// inject(ElementRef) liefert das HTML-Host-Element (nativeElement).
// (Das HTML-Attribut autofocus funktioniert nur beim Laden der Seite;
// in einer Single-Page-Anwendung erscheinen die Felder später.)
// =========================================================================

import { afterNextRender, Directive, ElementRef, inject } from '@angular/core';

@Directive({ selector: '[appAutofocus]' })
export class AutofocusDirective {
  constructor() {
    const element = inject<ElementRef<HTMLElement>>(ElementRef).nativeElement;
    afterNextRender(() => element.focus());
  }
}
  • Zeile 15: [inject(ElementRef)] liefert das Host-Element;
  • Zeile 16: Es erhält den Fokus, sobald es angezeigt wird. Das HTML-Attribut [autofocus] funktioniert nur beim Laden der Seite; in einer Single-Page-Anwendung erscheinen die Felder erst später.

3.6.3. Ein langer Klick

Eine Direktive kann auch Ereignisse auslösen. Diese hier löst ihr Ereignis nur aus, wenn der Host eine Sekunde lang gedrückt gehalten wird: eine Sicherung gegen versehentliche Klicks.

// =========================================================================
// 15-directives/src/app/directives/long-press.directive.ts
// -------------------------------------------------------------------------
// Eine Direktive kann auch Ereignisse AUSLÖSEN (output):
//     <button (appLongPress)="remove()">
// Das Ereignis wird nur ausgelöst, wenn der Button eine Sekunde lang gedrückt gehalten wird:
// ein Schutz vor versehentlichen Klicks. Während des Drückens wird die CSS-Klasse
// "pressed" auf den Button gesetzt.
// =========================================================================

import { DestroyRef, Directive, inject, input, output, signal } from '@angular/core';

@Directive({
  selector: '[appLongPress]',
  host: {
    '[class.pressed]': 'pressing()',
    '(pointerdown)': 'start()',
    '(pointerup)': 'stop()',
    '(pointerleave)': 'stop()',
  },
})
export class LongPressDirective {
  readonly duration = input(1000); // in Millisekunden
  readonly appLongPress = output<void>();
  protected readonly pressing = signal(false);
  private timer: number | undefined;

  constructor() {
    inject(DestroyRef).onDestroy(() => window.clearTimeout(this.timer));
  }

  protected start(): void {
    this.pressing.set(true);
    this.timer = window.setTimeout(() => {
      this.pressing.set(false);
      this.appLongPress.emit();
    }, this.duration());
  }

  protected stop(): void {
    window.clearTimeout(this.timer);
    this.pressing.set(false);
  }
}
  • Zeile 16: Solange der Host gedrückt wird, wird die Klasse [pressed] auf den Host angewendet;
  • Zeilen 17–19: Pointer-Ereignisse (Maus, Finger, Stift): drücken, loslassen, das Element verlassen;
  • Zeile 24: eine Ausgabe, die den Namen des Selektors trägt: Wir schreiben [(appLongPress)="..."] und wenden die Direktive an, während wir gleichzeitig ihr Ereignis abhören;
  • Zeile 29: Der Timer wird gestoppt, wenn der Host verschwindet.

3.6.4. Verwendung

// =========================================================================
// 15-directives/src/app/app.ts - eigene Direktiven schreiben
// -------------------------------------------------------------------------
// Eine Komponente ist eine Direktive MIT Template. Eine "einfache" Direktive
// hat kein Template: Sie hängt sich an ein bestehendes Element, um
// dessen Aussehen oder Verhalten zu ändern. Wie eine Komponente muss sie
// von der Komponente importiert werden, die sie verwendet.
// =========================================================================

import { Component, signal } from '@angular/core';
import { AutofocusDirective } from './directives/autofocus.directive';
import { LongPressDirective } from './directives/long-press.directive';
import { HighlightDirective } from './directives/highlight.directive';

@Component({
  selector: 'app-root',
  imports: [AutofocusDirective, LongPressDirective, HighlightDirective],
  templateUrl: './app.html',
  styles: `
    .pressed {
      outline: 4px solid #dc3545;
    }
  `,
})
export class App {
  protected readonly doctors = signal(['Mme Marie PELISSIER', 'Mr Paul TATOU', 'Melle Sophie DUPONT']);
  protected readonly message = signal('');

  protected remove(name: string): void {
    this.doctors.update((m) => m.filter((x) => x !== name));
    this.message.set(`${name} has been deleted.`);
  }
}
  • Zeile 17: Wie eine Komponente muss eine Direktive von der Komponente importiert werden, die sie verwendet;
  • Zeilen 19–23: der Stil der Klasse [pressed], die von der Direktive für den langen Klick gesetzt wird.
<div class="container py-4" style="max-width: 640px">
  <h1 class="h3 mb-3">Example 15 - writing your own directives</h1>
  <!-- appAutofocus: das Feld hat den Fokus, sobald die Seite angezeigt wird -->
  <input appAutofocus class="form-control mb-3" placeholder="this field received the focus by itself">

  <p class="small text-muted">Hover over the rows; hold a button down for one second to delete.</p>
  <ul class="list-group mb-3">
    @for (m of doctors(); track m; let even = $even) {
      <!-- appHighlight: ohne Wert die Standardfarbe, mit Wert die angegebene Farbe -->
      <li class="list-group-item d-flex justify-content-between align-items-center"
          [appHighlight]="even ? '' : '#d1e7dd'">
        {{ m }}
        <button class="btn btn-sm btn-outline-danger" (appLongPress)="remove(m)">Delete (long press)</button>
      </li>
    }
  </ul>
  @if (message()) {
    <p class="alert alert-info">{{ message() }}</p>
  }
</div>
  • Zeile 4: Das Feld erhält den Fokus, sobald es angezeigt wird;
  • Zeile 8: [let even = $even]: Ist die Zeilennummer gerade?
  • Zeile 11: Jede zweite Zeile wird in der Standardfarbe hervorgehoben, die andere in Grün;
  • Zeile 13: Ein langer Druck entfernt den Arzt.

[npm start 15-directives]; halten Sie die zweite Schaltfläche gedrückt und fahren Sie dann mit der Maus über die erste Zeile:

Image

3.7. Beispiel 16: Ein wiederverwendbares Bestätigungsfenster

Bevor ein Element gelöscht wird, wird der Benutzer um eine Bestätigung gebeten. Der Browser stellt [window.confirm()] bereit, aber sein Fenster lässt sich weder formatieren noch übersetzen. Dieses Beispiel ersetzt es durch ein [Bootstrap]-Fenster und kombiniert dabei, was die vorherigen Beispiele gezeigt haben: einen Service (Beispiel 14), der den Zustand des Fensters in einem Signal trägt, und eine Komponente, die es anzeigt. Die Fallstudie wird genau diesen Mechanismus verwenden.

1
2
3
4
5
6
16-confirmation/src/app/
├── confirmation/
│   ├── confirmation.service.ts   the service: the question asked, the answer
│   └── confirm-dialog.ts         the modal dialog
├── app.ts
└── app.html

3.7.1. Der Service

// =========================================================================
// 16-confirmation/src/app/confirmation/confirmation.service.ts
// -------------------------------------------------------------------------
// "Are you sure?": window.confirm() gibt es zwar, aber es lässt sich weder
// gestalten, noch lassen sich seine Buttons übersetzen. Wir ersetzen es durch einen Bootstrap-Dialog
// (confirm-dialog.ts), der von diesem Service gesteuert wird.
//
// Der Trick: confirm(message) liefert ein PROMISE, das mit true (Ja)
// oder false (Nein) aufgelöst wird, wenn der Benutzer antwortet. Der aufrufende Code
// ist dann so einfach geschrieben wie mit window.confirm:
//
//     if (await this.confirmation.confirm('Delete this doctor?')) { ... }
//
// providedIn: 'root': nur ein Service für die ganze Anwendung, also nur ein
// Dialog, einmal in der Wurzelkomponente platziert.
// =========================================================================

import { Injectable, signal } from '@angular/core';

@Injectable({ providedIn: 'root' })
export class ConfirmationService {
  private readonly _message = signal<string | null>(null); // null: Dialog geschlossen
  readonly message = this._message.asReadonly();
  private answer: ((yes: boolean) => void) | null = null;

  confirm(text: string): Promise<boolean> {
    this.answer?.(false); // eine noch offene Frage? Sie zählt als "Nein"
    this._message.set(text);
    return new Promise<boolean>((resolve) => {
      this.answer = resolve;
    });
  }

  respond(yes: boolean): void {
    this._message.set(null);
    const r = this.answer;
    this.answer = null;
    r?.(yes);
  }
}
  • Zeile 20: ein einziger Service für die gesamte Anwendung; es gibt daher nur ein Fenster, das ein für alle Mal in der Root-Komponente platziert wird;
  • Zeile 22: die angezeigte Nachricht; [null] bedeutet, dass das Fenster geschlossen ist;
  • Zeile 23: [asReadonly()]: Komponenten können die Nachricht lesen, aber nur der Service kann sie ändern;
  • Zeile 24: die Funktion, die das aktuelle Promise auflöst, das auf eine Antwort wartet;
  • Zeilen 26–32: [confirm] öffnet das Fenster (Zeile 28) und gibt ein Promise zurück. Seine Funktion [resolve] wird beiseitegelegt (Zeile 30): Das Promise wird erst später aufgelöst, wenn der Benutzer auf eine Schaltfläche klickt;
  • Zeile 27: Wäre noch eine Frage offen, würde sie mit „Nein“ beantwortet: Ihr Promise bleibt nicht für immer unaufgelöst;
  • Zeilen 34–39: [respond] wird vom Fenster aufgerufen: Es schließt das Fenster (Zeile 35) und löst dann das Promise mit der Antwort des Benutzers auf (Zeile 38).

Das ist der Vorteil des Promise: Der Code, der die Frage stellt, schreibt sie als Aufruf von [window.confirm()] und wartet mit [await] auf die Antwort, ohne Callback-Funktion.

3.7.2. Das Fenster

// =========================================================================
// 16-confirmation/src/app/confirmation/confirm-dialog.ts
// -------------------------------------------------------------------------
// Der modale Dialog, EINMAL in der Wurzelkomponente platziert:
//   - dieselben Bootstrap-Klassen wie bei einem echten Modal (.modal, .modal-backdrop),
//     "statisch" angezeigt (show d-block): das JavaScript von
//     Bootstrap wird nicht benötigt;
//   - Tastatur: Escape = Nein; der Fokus wird beim Öffnen auf den Button "No" (die
//     am wenigsten gefährliche Wahl) gesetzt.
// '(document:keydown.escape)' in host: ein Ereignis, auf das am gesamten
// DOCUMENT gehört wird und nicht am Element der Komponente.
// =========================================================================

import { Component, effect, ElementRef, inject, viewChild } from '@angular/core';
import { ConfirmationService } from './confirmation.service';

@Component({
  selector: 'app-confirm-dialog',
  host: { '(document:keydown.escape)': 'confirmation.message() !== null && confirmation.respond(false)' },
  template: `
    @if (confirmation.message(); as message) {
      <div class="modal-backdrop fade show"></div>
      <div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true"
           (click)="$event.target === $event.currentTarget && confirmation.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)="confirmation.respond(false)"></button>
            </div>
            <div class="modal-body">
              <p class="mb-0">{{ message }}</p>
            </div>
            <div class="modal-footer">
              <button #noButton type="button" class="btn btn-secondary" (click)="confirmation.respond(false)">No, go back</button>
              <button type="button" class="btn btn-danger" (click)="confirmation.respond(true)">Yes, confirm</button>
            </div>
          </div>
        </div>
      </div>
    }
  `,
})
export class ConfirmDialog {
  protected readonly confirmation = inject(ConfirmationService);
  private readonly noButton = viewChild<ElementRef<HTMLButtonElement>>('noButton');

  constructor() {
    // beim Öffnen erscheint der Button "No": er erhält den Fokus
    effect(() => this.noButton()?.nativeElement.focus());
  }
}
  • Zeile 19: [document:keydown.escape]: Das Ereignis wird auf dem gesamten Dokument abgehört, nicht auf dem Element der Komponente. Die Esc-Taste antwortet mit „Nein“, wenn eine Frage gestellt wurde;
  • Zeile 21: Das Fenster erscheint nur, wenn eine Nachricht angezeigt werden muss; [as message] weist dem Wert des Signals einen Namen zu;
  • Zeilen 22–23: Die Klassen eines echten [Bootstrap]-Modals, direkt angezeigt ([show d-block]): Das von [JavaScript] aus [Bootstrap] ist überflüssig, da [Angular] die Anzeige steuert;
  • Zeile 24: Ein Klick neben das Dialogfenster (auf den grauen Hintergrund) antwortet mit „Nein“. [$event.target === $event.currentTarget]: Der Klick erfolgte auf das Element [.modal] selbst, nicht auf eines seiner Kindelemente;
  • Zeilen 35–36: die beiden Antworten. Die Schaltfläche „Nein“ trägt die Template-Variable [#noButton];
  • Zeile 46: [viewChild] (Beispiel 13) liefert das mit [#noButton] markierte Element als Signal: Es ist gleich [undefined] , solange das Fenster geschlossen ist;
  • Zeile 50: ein Effect, der von diesem Signal abhängt: Bei jedem Öffnen des Fensters erscheint die Schaltfläche „Nein“, das Signal ändert sich, und die Schaltfläche erhält den Fokus. Wir haben „Nein“ gewählt, die am wenigsten gefährliche Antwort: Ein versehentliches Drücken der Eingabetaste löscht nichts.

3.7.3. Verwendung

// =========================================================================
// 16-confirmation/src/app/app.ts - den Bestätigungsdialog verwenden
// -------------------------------------------------------------------------
// Dieselbe Seite wie Beispiel 21 des NestJS-Kurses (Links, Buttons, Bestätigung),
// aber ohne Roundtrip zu einem Server.
// =========================================================================

import { Component, inject, signal } from '@angular/core';
import { ConfirmationService } from './confirmation/confirmation.service';
import { ConfirmDialog } from './confirmation/confirm-dialog';

interface Contact {
  id: number;
  name: string;
}

@Component({
  selector: 'app-root',
  imports: [ConfirmDialog],
  templateUrl: './app.html',
})
export class App {
  private readonly confirmation = inject(ConfirmationService);
  protected readonly contacts = signal<Contact[]>([
    { id: 1, name: 'Jean MARTIN' },
    { id: 2, name: 'Alice DURAND' },
    { id: 3, name: 'Luc GERMAN' },
  ]);
  protected readonly message = signal('');

  // eine asynchrone Methode: sie "wartet" auf die Antwort des Benutzers
  protected async remove(c: Contact): Promise<void> {
    if (!(await this.confirmation.confirm(`Delete the contact ${c.name}?`))) {
      this.message.set('Deletion cancelled.');
      return;
    }
    this.contacts.update((list) => list.filter((x) => x.id !== c.id));
    this.message.set(`${c.name} has been deleted.`);
  }

  protected async removeAll(): Promise<void> {
    if (await this.confirmation.confirm(`Delete the ${this.contacts().length} contacts?`)) {
      this.contacts.set([]);
      this.message.set('All the contacts have been deleted.');
    }
  }
}
  • Zeile 19: Die Root-Komponente importiert das Fenster, das sie in ihrem Template platzieren wird;
  • Zeile 23: Sie fordert den Service an;
  • Zeilen 32–39: eine Methode mit dem Namen [async]. In Zeile 33 hält [await] die Ausführung an, bis der Benutzer antwortet; währenddessen bleibt die Anwendung aktiv. Der Rest der Methode wird nur ausgeführt, wenn die Antwort „Ja“ lautet;
  • Zeilen 41–46: Dasselbe Prinzip gilt für das Löschen aller Kontakte.
<div class="container py-4" style="max-width: 640px">
  <h1 class="h3 mb-3">Example 16 - a confirmation dialog</h1>
  <ul class="list-group mb-3">
    @for (c of contacts(); track c.id) {
      <li 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>
    } @empty {
      <li class="list-group-item text-muted">No contact.</li>
    }
  </ul>
  <button class="btn btn-danger" [disabled]="contacts().length === 0" (click)="removeAll()">Delete all</button>
  @if (message()) {
    <p class="alert alert-info mt-3">{{ message() }}</p>
  }
</div>
<!-- der Dialog, EINMAL für die ganze Anwendung -->
<app-confirm-dialog />
  • Zeilen 4–11: Auf [@for] kann ein [@empty]-Block folgen, der angezeigt wird, wenn die Liste leer ist;
  • Zeile 13: Die Schaltfläche ist deaktiviert, wenn nichts mehr zu löschen ist;
  • Zeile 19: das Fenster, einmal für die gesamte Anwendung platziert. Jede Komponente kann es dann öffnen, indem sie einfach den Service aufruft.

[npm start 16-confirmation]; klicken Sie auf die Schaltfläche [Delete] bei Alice DURAND:

Image

Mit [Vue.js] wurden das Fenster und sein Zustand von einem „Composable“ bereitgestellt; mit [Angular] ist es ein Service. Das Prinzip ist dasselbe: ein geteilter Zustand in einem Signal, den mehrere Komponenten lesen und ändern.