À propos de ce cours
Les données descendent par les entrées input() et les événements remontent par les sorties output(). model() partage une valeur dans les deux sens avec [( )], et linkedSignal() permet d’éditer une copie d’un objet reçu sans le modifier. Le parent pilote un enfant avec #ref ou viewChild(). Un service @Service() injecté avec inject() partage un état entre composants sans lien. Enfin, et contentChildren() laissent le parent fournir le contenu. Le cours se termine par un aide-mémoire pour choisir le bon moyen, 5 activités corrigées et les erreurs fréquentes.
-
Objectifs
- Transmettre des données d'un parent à un enfant avec
input(): entrée obligatoire, valeur par défaut, alias et transformation - Faire remonter des événements d'un enfant vers son parent avec
output() - Partager une valeur dans les deux sens avec
model()et la syntaxe[( )] - Modifier une entrée sans la toucher, grâce à une copie locale
linkedSignal() - Piloter un enfant depuis le parent (
#ref,viewChild()) et partager un état entre composants éloignés avec un service - Laisser le parent fournir du contenu avec
<ng-content>et le découvrir aveccontentChildren() - Choisir le bon moyen de communication selon la situation
- Transmettre des données d'un parent à un enfant avec
-
Présentation
- Une application Angular est un arbre de composants. Chacun est isolé : ses signals et ses méthodes ne sont pas visibles des autres. Pour construire une page, il faut donc les faire communiquer.
- Dans « Les composants Angular », vous avez découpé une page en composants. Ce chapitre montre comment ils échangent des données : du parent vers l'enfant, de l'enfant vers le parent, dans les deux sens, et entre composants sans lien direct.
- La règle d'or est le flux de données à sens unique: les données descendent (entrées), les événements remontent (sorties). Le composant qui possède une donnée est le seul à la modifier.

- Pour suivre ce chapitre, continuez dans le projet
premiers-pas-angularet créez un dossiersrc/app/communication/. Tous les exemples ont été testés avec Angular 22 : les composants y sontOnPushpar défaut et l'application fonctionne sans Zone.js, d'où l'usage systématique des signals.
-
Du parent vers l'enfant :
input()- Une entrée est une propriété de l'enfant que le parent remplit depuis son template. On la déclare avec la fonction
input(), qui renvoie un signal en lecture seule: l'enfant la lit avec des parenthèses,titre(). - Côté parent, on la remplit comme un attribut (valeur texte fixe) ou avec le property binding
[prix]="…"(expression, signal, nombre…).
- Une entrée est une propriété de l'enfant que le parent remplit depuis son template. On la déclare avec la fonction
import { Component, booleanAttribute, computed, input, numberAttribute, signal } from '@angular/core';
import { DecimalPipe } from '@angular/common';
// Composant enfant : il reçoit ses données par des entrées
@Component({
selector: 'app-carte-formation',
imports: [DecimalPipe],
template: `
<h4>{{ titre() }} @if (nouveau()) { <span class="badge">Nouveau</span> }</h4>
<p>{{ heures() }} h · {{ prixTTC() | number: '1.2-2' }} DT TTC · niveau {{ niveau() }}</p>
`,
styles: `:host { display: block; border: 1px solid #cbd5e1; border-radius: 8px; padding: 4px 12px; margin: 6px 0; }
h4 { margin: 6px 0; } p { margin: 0 0 6px; } .badge { background: #dcfce7; color: #166534; font-size: 12px; padding: 1px 8px; border-radius: 10px; }`,
})
export class CarteFormation {
readonly titre = input.required<string>(); // obligatoire
readonly prixHT = input.required<number>({ alias: 'prix' }); // nom public : prix
readonly heures = input(20, { transform: numberAttribute }); // "40" → 40
readonly nouveau = input(false, { transform: booleanAttribute }); // attribut seul → true
readonly niveau = input<'débutant' | 'avancé'>('débutant'); // valeur par défaut
protected readonly prixTTC = computed(() => this.prixHT() * 1.19);
}
// Composant parent : il fournit les données
@Component({
selector: 'app-entrees',
imports: [CarteFormation],
template: `
<app-carte-formation titre="Angular" heures="40" [prix]="prixAngular()" nouveau />
<app-carte-formation titre="TypeScript" [prix]="300" niveau="avancé" />
<button (click)="prixAngular.update((p) => p + 100)">Augmenter le prix d'Angular</button>
`,
})
export class Entrees {
protected readonly prixAngular = signal(450);
}
Angular Nouveau
40 h · 535,50 DT TTC · niveau débutant
TypeScript
20 h · 357,00 DT TTC · niveau avancé
(Augmenter le prix d'Angular) 40 h · 654,50 DT TTC · niveau débutant

input.required<string>()rend l'entrée obligatoire: oubliertitresur la balise est une erreur de compilation (NG8008: Required input 'titre' from component CarteFormation must be specified.).input(20)fournit une valeur par défaut et en déduit le type (number).alias: 'prix'sépare le nom public (dans le template du parent) du nom interne (prixHT).transform: numberAttributeconvertit le texteheures="40"en nombre ;booleanAttributetransforme l'attribut seulnouveauentrue.- Parce qu'une entrée est un signal, le
computedprixTTCse recalcule quand le parent change le prix : 450 × 1,19 = 535,50, puis 550 × 1,19 = 654,50. - Attention : une entrée est en lecture seule.
this.titre.set('…')est refusé (TS2339: Property 'set' does not exist on type 'InputSignal<string>'.) : c'est le parent qui possède la donnée.
-
De l'enfant vers le parent :
output()- Une sortie permet à l'enfant d'annoncer qu'il s'est passé quelque chose. On la déclare avec
output<T>()et on la déclenche avecemit(valeur). - Le parent l'écoute comme un événement natif :
(envoyer)="ajouter($event)".$eventcontient la valeur émise. - L'enfant ne décide rien: il signale. C'est le parent qui choisit quoi faire (ajouter l'avis, fermer le formulaire…).
- Une sortie permet à l'enfant d'annoncer qu'il s'est passé quelque chose. On la déclare avec
import { Component, output, signal } from '@angular/core';
export interface Avis {
auteur: string;
note: number;
}
// Composant enfant : il annonce ce qui se passe, sans rien décider
@Component({
selector: 'app-formulaire-avis',
template: `
<input #auteur placeholder="Votre prénom" />
<select #note>
@for (n of [5, 4, 3, 2, 1]; track n) { <option [value]="n">{{ n }} ★</option> }
</select>
<button (click)="publier(auteur, note)">Publier</button>
<button (click)="annuler.emit()">Annuler</button>
`,
})
export class FormulaireAvis {
readonly envoyer = output<Avis>();
readonly annuler = output<void>();
protected publier(auteur: HTMLInputElement, note: HTMLSelectElement): void {
if (!auteur.value.trim()) return;
this.envoyer.emit({ auteur: auteur.value.trim(), note: Number(note.value) });
auteur.value = '';
}
}
// Composant parent : il décide quoi faire des événements reçus
@Component({
selector: 'app-sorties',
imports: [FormulaireAvis],
template: `
@if (ouvert()) {
<app-formulaire-avis (envoyer)="ajouter($event)" (annuler)="ouvert.set(false)" />
} @else {
<button (click)="ouvert.set(true)">Donner mon avis</button>
}
<ul>
@for (a of avis(); track $index) { <li>{{ a.auteur }} : {{ a.note }} ★</li> }
</ul>
`,
})
export class Sorties {
protected readonly ouvert = signal(true);
protected readonly avis = signal<Avis[]>([{ auteur: 'Amira', note: 5 }]);
protected ajouter(a: Avis): void {
this.avis.update((liste) => [...liste, a]);
}
}
Amira : 5 ★
(Sami, 4 ★, Publier) Amira : 5 ★ · Sami : 4 ★ (le champ se vide)
(Annuler) le formulaire disparaît, le bouton « Donner mon avis » le rouvre

output<void>()déclare une sortie sans donnée : on l'émet avecannuler.emit().- Une sortie n'a pas de valeur courante : ce n'est pas un signal, c'est un simple canal d'événements.
- Nommez les sorties par l'action (
envoyer,supprimer,choisir), sans préfixeon.
-
Dans les deux sens :
model()et[( )]- Certains composants modifient eux-mêmes la valeur qu'ils reçoivent : un sélecteur de quantité, un interrupteur, une note en étoiles…
model()combine une entrée et une sortie : c'est un signal modifiable par l'enfant, dont chaque changement est renvoyé au parent. - Le parent utilise la syntaxe « banane dans une boîte »
[(quantite)]="places", déjà rencontrée avec[(ngModel)], en lui passant directement son signal (sans parenthèses).
- Certains composants modifient eux-mêmes la valeur qu'ils reçoivent : un sélecteur de quantité, un interrupteur, une note en étoiles…
import { Component, computed, input, model, signal } from '@angular/core';
// Composant enfant : la quantité est un model(), lue ET modifiée par l'enfant
@Component({
selector: 'app-selecteur-quantite',
template: `
<button (click)="changer(-1)" [disabled]="quantite() <= min()">−</button>
<strong>{{ quantite() }}</strong>
<button (click)="changer(1)" [disabled]="quantite() >= max()">+</button>
`,
styles: `strong { display: inline-block; width: 36px; text-align: center; }`,
})
export class SelecteurQuantite {
readonly quantite = model(1);
readonly min = input(1);
readonly max = input(10);
protected changer(n: number): void {
this.quantite.update((q) => Math.min(this.max(), Math.max(this.min(), q + n)));
}
}
// Composant parent : [( )] relie son signal au model() de l'enfant
@Component({
selector: 'app-double-sens',
imports: [SelecteurQuantite],
template: `
Places : <app-selecteur-quantite [(quantite)]="places" [max]="12" />
<button (click)="places.set(10)">Groupe (10)</button>
<p>{{ places() }} place(s) × 120 DT = {{ total() }} DT</p>
<p>Forme longue : <app-selecteur-quantite [quantite]="places()" (quantiteChange)="places.set($event)" /></p>
`,
})
export class DoubleSens {
protected readonly places = signal(2);
protected readonly total = computed(() => this.places() * 120);
}
Places : − 2 + 2 place(s) × 120 DT = 240 DT
(+ deux fois) 4 place(s) × 120 DT = 480 DT (les deux sélecteurs affichent 4)
(Groupe (10)) 10 place(s) × 120 DT = 1200 DT (le « + » du 2e sélecteur est désactivé : max 10)

[(quantite)]="places"est un raccourci pour[quantite]="places()" (quantiteChange)="places.set($event)": Angular crée automatiquement la sortiequantiteChange.- La forme longue est utile quand le parent veut intercepter le changement (vérifier, journaliser, modifier une ligne d'un tableau).
- Attention :
[(x)]n'est possible que sur unmodel(). Sur une simpleinput():NG8007: The property and event halves of the two-way binding 'simple' are not bound to the same target.Lié à uncomputed:TS2322: Type 'Signal<number>' is not assignable to type 'number'.
-
Modifier une entrée : travailler sur une copie avec
linkedSignal()- Un formulaire d'édition reçoit un objet en entrée, mais ne doit pas le modifier directement : l'utilisateur peut annuler, et le parent ne doit être prévenu qu'à l'enregistrement.
- La solution : une copie locale (un brouillon) créée avec
linkedSignal(). Elle est modifiable, et elle est recréée automatiquement chaque fois que le parent transmet un nouvel objet.
import { Component, computed, input, linkedSignal, output, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
export interface Contact {
nom: string;
email: string;
}
// Composant enfant : il modifie une COPIE de l'entrée, puis émet le résultat
@Component({
selector: 'app-editeur-contact',
imports: [FormsModule],
template: `
<input [ngModel]="brouillon().nom" (ngModelChange)="modifier({ nom: $event })" />
<input [ngModel]="brouillon().email" (ngModelChange)="modifier({ email: $event })" />
<button (click)="enregistrer.emit(brouillon())" [disabled]="!modifie()">Enregistrer</button>
<button (click)="brouillon.set(contact())" [disabled]="!modifie()">Annuler</button>
`,
})
export class EditeurContact {
readonly contact = input.required<Contact>();
readonly enregistrer = output<Contact>();
// Une copie locale, recréée à chaque nouveau contact reçu
protected readonly brouillon = linkedSignal(() => ({ ...this.contact() }));
protected readonly modifie = computed(
() => this.brouillon().nom !== this.contact().nom || this.brouillon().email !== this.contact().email,
);
protected modifier(changement: Partial<Contact>): void {
this.brouillon.update((b) => ({ ...b, ...changement }));
}
}
@Component({
selector: 'app-copie-locale',
imports: [EditeurContact],
template: `
<app-editeur-contact [contact]="contact()" (enregistrer)="contact.set($event)" />
<p>Contact du parent : {{ contact().nom }} – {{ contact().email }}</p>
`,
})
export class CopieLocale {
protected readonly contact = signal<Contact>({ nom: 'Amira Ben Ali', email: 'amira@exemple.tn' });
}
(nom modifié en « Amira B. ») Enregistrer et Annuler s'activent ; le parent affiche toujours « Amira Ben Ali »
(Annuler) le brouillon reprend la valeur du contact
(nom modifié puis Enregistrer) Contact du parent : Amira B. – amira@exemple.tn

{ ...this.contact() }crée un nouvel objet: modifier le brouillon ne touche jamais l'entrée.modifiecompare le brouillon à l'entrée : les boutons ne sont actifs que s'il y a quelque chose à enregistrer ou à annuler.- Quand le parent enregistre, il transmet un nouvel objet :
linkedSignalrecrée alors le brouillon à partir de lui. - Piège vérifié : écrire
this.contact().nom = 'Sami'compile sans erreur, car TypeScript n'interdit pas de muter l'objet. Mais le parent affiche « Sami » alors que sescomputed(par exemple une initiale) restent sur l'ancienne valeur, car le signal n'a pas changé de référence. Ne modifiez jamais un objet reçu en entrée.
-
Piloter un enfant :
#refetviewChild()- Parfois, le parent doit appeler une méthode de l'enfant : démarrer un minuteur, ouvrir un carrousel, vider un formulaire. Deux moyens, vus dans « Les variables de template dans Angular » :
- dans le template, une variable de référence
#mposée sur la balise de l'enfant ; - dans la classe, la requête
viewChild.required(MinuteurSimple), qui renvoie un signal contenant l'instance.
- dans le template, une variable de référence
- Parfois, le parent doit appeler une méthode de l'enfant : démarrer un minuteur, ouvrir un carrousel, vider un formulaire. Deux moyens, vus dans « Les variables de template dans Angular » :
import { Component, computed, signal, viewChild } from '@angular/core';
@Component({
selector: 'app-minuteur-simple',
template: `<strong>{{ secondes() }} s</strong>`,
})
export class MinuteurSimple {
readonly secondes = signal(0); // public : lisible par le parent
private id?: ReturnType<typeof setInterval>;
demarrer(): void {
this.arreter();
this.id = setInterval(() => this.secondes.update((s) => s + 1), 1000);
}
arreter(): void {
clearInterval(this.id);
}
}
// Le parent pilote l'enfant : depuis le template (#m) et depuis la classe (viewChild)
@Component({
selector: 'app-reference-enfant',
imports: [MinuteurSimple],
template: `
<app-minuteur-simple #m />
<button (click)="m.demarrer()">Démarrer</button>
<button (click)="m.arreter()">Arrêter</button>
<p>{{ message() }}</p>
`,
})
export class ReferenceEnfant {
private readonly minuteur = viewChild.required(MinuteurSimple);
protected readonly message = computed(() => (this.minuteur().secondes() >= 3 ? 'Plus de 3 secondes !' : 'En attente…'));
}
En attente…
(Démarrer, puis 3 secondes) 3 s Plus de 3 secondes !
(Arrêter) le compteur s'immobilise
- Seuls les membres publics de l'enfant sont accessibles (
demarrer(),secondes) ;id, privé, reste caché. - Le
computeddu parent lit le signal de l'enfant : il se met à jour à chaque seconde. - Attention : une requête n'a pas de valeur dans le constructeur (
NG8118). Lisez-la dans uncomputed, une méthode ouafterNextRender(). - Cette technique crée un lien fort entre le parent et l'enfant : préférez
input()/output()pour échanger des données, et réservez-la aux actions.
-
Entre composants éloignés : un service partagé
- Quand deux composants n'ont pas de lien parent-enfant (deux frères, ou deux composants très éloignés dans l'arbre), faire transiter les données par tous les intermédiaires devient vite pénible.
- On place alors l'état dans un service: une classe dont Angular crée une seule instance, que chaque composant obtient avec
inject(). Avec Angular 22, le décorateur@Service()déclare un service disponible dans toute l'application.
import { Component, Service, computed, inject, signal } from '@angular/core';
// Un service : une seule instance, partagée par tous les composants qui l'injectent
@Service()
export class FavorisService {
private readonly _liste = signal<string[]>([]);
readonly liste = this._liste.asReadonly(); // lecture seule pour les composants
readonly nombre = computed(() => this._liste().length);
basculer(titre: string): void {
this._liste.update((l) => (l.includes(titre) ? l.filter((t) => t !== titre) : [...l, titre]));
}
}
// Deux composants « frères », sans lien parent-enfant
@Component({
selector: 'app-catalogue',
template: `
@for (t of titres; track t) {
<button (click)="favoris.basculer(t)" [class.actif]="favoris.liste().includes(t)">★ {{ t }}</button>
}
`,
styles: `.actif { background: #f59e0b; border-color: #f59e0b; }`,
})
export class Catalogue {
protected readonly favoris = inject(FavorisService);
protected readonly titres = ['Angular', 'TypeScript', 'RxJS'];
}
@Component({
selector: 'app-barre-favoris',
template: `<p>Favoris ({{ favoris.nombre() }}) : {{ favoris.liste().join(', ') || 'aucun' }}</p>`,
})
export class BarreFavoris {
protected readonly favoris = inject(FavorisService);
}
@Component({
selector: 'app-service-partage',
imports: [Catalogue, BarreFavoris],
template: `<app-barre-favoris /><app-catalogue />`,
})
export class ServicePartage {}
Favoris (0) : aucun
(★ Angular, ★ RxJS) Favoris (2) : Angular, RxJS (les deux boutons sont orange)
(★ Angular) Favoris (1) : RxJS

- Le signal
_listeest privé; les composants lisentliste, en lecture seule (asReadonly()), et passent par la méthodebasculer()pour modifier. Le service garde le contrôle de son état. - Les deux composants injectent la même instance: un clic dans le catalogue met à jour la barre des favoris.
- Piège vérifié : ajouter
providers: [FavorisService]dans un composant lui donne (ainsi qu'à ses descendants) sa propre instance: ce groupe affiche « Favoris (0) » pendant que le reste de l'application en compte 1. Utile pour isoler, déroutant si c'est involontaire. - Dans un code plus ancien, vous trouverez
@Injectable({ providedIn: 'root' }): c'est l'équivalent de@Service(). Les services sont étudiés en détail dans le chapitre suivant.
-
Le parent fournit le contenu :
<ng-content>- Avec les entrées, le parent transmet des données. Avec la projection de contenu, il transmet du HTML (texte, liens, autres composants) que l'enfant place dans son propre cadre : un encadré, une carte, une fenêtre…
- L'enfant marque l'emplacement avec
<ng-content />. Avecselect, il crée plusieurs emplacements nommés.contentChildren()lui permet de découvrir les composants qu'on lui a projetés.
import { Component, contentChildren, input } from '@angular/core';
// Projection : le parent fournit le CONTENU, l'enfant fournit le cadre
@Component({
selector: 'app-encadre',
template: `
<div class="encadre" [class]="type()">
<div class="titre"><ng-content select="[titre]" /></div>
<ng-content />
<div class="pied"><ng-content select="[pied]">Aucune action.</ng-content></div>
</div>
`,
styles: `.encadre { border-left: 5px solid #3178c6; background: #eff6ff; padding: 6px 12px; margin: 6px 0; border-radius: 6px; }
.encadre.alerte { border-color: #dc2626; background: #fef2f2; } .titre { font-weight: 700; } .pied { font-size: 13px; color: #64748b; }`,
})
export class Encadre {
readonly type = input<'info' | 'alerte'>('info');
}
// contentChildren : l'enfant découvre les composants qu'on lui a projetés
@Component({ selector: 'app-etape', template: `<li><ng-content /></li>` })
export class Etape {}
@Component({
selector: 'app-liste-etapes',
template: `<p>{{ etapes().length }} étape(s)</p><ol><ng-content /></ol>`,
})
export class ListeEtapes {
protected readonly etapes = contentChildren(Etape);
}
@Component({
selector: 'app-projection',
imports: [Encadre, ListeEtapes, Etape],
template: `
<app-encadre>
<span titre>Information</span>
Le TP 2 est disponible.
<a pied href="#">Voir l'énoncé</a>
</app-encadre>
<app-encadre type="alerte">
<span titre>Attention</span>
Rendu avant vendredi.
</app-encadre>
<app-liste-etapes>
<app-etape>Créer le projet</app-etape>
<app-etape>Écrire le modèle</app-etape>
<app-etape>Tester</app-etape>
</app-liste-etapes>
`,
})
export class Projection {}
Information / Le TP 2 est disponible. / Voir l'énoncé (encadré bleu)
Attention / Rendu avant vendredi. / Aucune action. (encadré rouge, pied par défaut)
3 étape(s) 1. Créer le projet 2. Écrire le modèle 3. Tester

select="[titre]"reçoit les éléments portant l'attributtitre; le<ng-content />sansselectreçoit tout le reste.- Le contenu placé entre
<ng-content>et</ng-content>est affiché par défaut quand le parent ne fournit rien : « Aucune action. » dans le second encadré. contentChildren(Etape)est un signal contenant les composantsEtapeprojetés : la liste sait qu'elle en a 3.- Le contenu projeté appartient au parent: ses liaisons utilisent les signals du parent, pas ceux de l'enfant.
-
Quel moyen choisir ?
- Commencez toujours par le plus simple :
input()etoutput(). Ils rendent les dépendances visibles dans le template et gardent les composants réutilisables. - Passez à
model()quand l'enfant est un contrôle qui modifie une seule valeur ; à une copielinkedSignal()quand il édite un objet ; àviewChild()pour déclencher une action ; à un service dès que l'état est partagé par des composants éloignés ; àng-contentquand le parent doit choisir le contenu. - Dans un projet existant, vous rencontrerez l'ancienne écriture à décorateurs :
@Input() titre!: string;et@Output() envoyer = new EventEmitter<Avis>();. Elle fonctionne toujours, mais les fonctionsinput()etoutput()sont recommandées : elles produisent des signals.
- Commencez toujours par le plus simple :
-
Aide-mémoire

-
Activité 1 : une liste de tâches découpée en composants
- Générer deux composants dans
act-communication/:app-tache-itemaffiche une tâche ({ id, titre, faite, priorite }) reçue parinput.required: une case à cocher, le titre (barré si la tâche est faite) et un badge « urgent ». Il émetbasculeretsupprimeravec l'identifiant de la tâche ;app-liste-tachespossède le signal des tâches : un champ#titreet une case#urgentpour ajouter (bouton ou touche Entrée), trois filtres (Toutes, À faire, Faites), et un bilan « 2 à faire · 1 faite(s) · 1 urgente(s) ».
- L'enfant ne modifie jamais la tâche : le parent applique chaque changement en créant un nouveau tableau (
map,filter).
- Générer deux composants dans

- Pourquoi l'enfant émet-il l'identifiant plutôt que de modifier
tache().faitelui-même ? - Ajouter une tâche urgente puis la cocher : pourquoi le compteur « urgente(s) » diminue-t-il ?
-
Activité 2 : un panier avec un sélecteur de quantité réutilisable
- Créer le composant
app-quantite:valeur = model(1), deux entréesmin(0) etmax(9), et deux boutons − et + désactivés aux limites. - Le parent
app-panier-quantitesaffiche trois produits (livre 89,90 DT, clé USB 24,50 DT, casque 129 DT) avec leur stock. Chaque ligne utilise<app-quantite>avec[max]="l.stock":- comme la quantité est une propriété d'un objet du tableau, utiliser la forme longue
[valeur]="l.quantite" (valeurChange)="changer(l.id, $event)"; - afficher le sous-total de chaque ligne, le nombre d'articles et le total, avec une remise de 10 % à partir de 5 articles ;
- une ligne à 0 est grisée et barrée.
- comme la quantité est une propriété d'un objet du tableau, utiliser la forme longue
- Créer le composant

- Vérifier : au départ 138,90 DT ; en passant la clé USB à 5, on obtient 322,02 DT (remise appliquée) ; en ajoutant un casque, 438,12 DT.
- Pourquoi ne peut-on pas écrire
[(valeur)]="l.quantite"dans la boucle ?
-
Activité 3 : un carnet de contacts avec fiche d'édition
- Construire un parent
app-carnetqui possède la liste des contacts ({ id, nom, email, ville }) et l'identifiant du contact choisi. Il relie deux enfants :app-liste-contactsreçoit les contacts et l'identifiant choisi, met la ligne choisie en surbrillance et émetchoisirau clic ;app-fiche-contactreçoit le contact choisi et travaille sur un brouillonlinkedSignal: Enregistrer (actif si modifié et valide : nom de 2 caractères minimum, e-mail avec@), Annuler, et le message « modifications non enregistrées ».
- À l'enregistrement, le parent remplace le contact dans la liste et affiche « Contact « … » enregistré. ».
- Construire un parent

- Modifier la ville d'Amira, puis cliquer sur Sami sans enregistrer, puis revenir sur Amira : que constate-t-on ? Expliquer le rôle de
linkedSignal. - Les deux enfants ne se connaissent pas : par où passe l'information « contact choisi » ?
-
Activité 4 : une boutique dont le panier est un service
- Créer le service
@Service() PanierBoutique: un signal privé de lignes{ produit, quantite }, exposé en lecture seule, deuxcomputednombreettotal, et trois méthodesajouter(p)(incrémente si le produit est déjà présent),retirer(id)etvider(). - Créer trois composants indépendants qui injectent ce service :
app-badge-panier: « 🛒 3 · 31,50 DT » ;app-vitrine: trois produits (cahier 3,50 DT, stylo 1,20 DT, clé USB 24,50 DT) avec un bouton Ajouter;app-resume-panier: les lignes avec un bouton −, « Votre panier est vide. » si besoin, et Vider le panier.
- Assembler les trois dans
app-boutique-service, sans aucune entrée ni sortie.
- Créer le service

- Ajouter 2 cahiers et une clé USB : vérifier le badge « 3 · 31,50 DT ».
- Ajouter
providers: [PanierBoutique]dansapp-vitrine: que devient le badge quand on ajoute un produit ? Pourquoi ?
-
Activité 5 : des onglets par projection de contenu
- Créer deux composants qui s'utilisent ensemble :
app-onglet: entréestitre(obligatoire) eticone. Il injecte son conteneur (inject(Onglets)) et n'affiche son contenu (<ng-content />) que s'il est l'onglet courant ;app-onglets:index = model(0),liste = contentChildren(Onglet), uncomputedcourant, et une barre de boutons construite à partir des titres et icônes des onglets projetés.
- Le composant de démonstration écrit
<app-onglets [(index)]="choisi">avec trois onglets (Présentation, Programme, Inscription), affiche « Onglet ouvert (côté parent) : 1 / 3 » et propose un bouton Aller à l'inscription.
- Créer deux composants qui s'utilisent ensemble :

- Ajouter un quatrième onglet dans le template du parent : pourquoi la barre se met-elle à jour sans modifier
app-onglets? - Quels sont les trois moyens de communication utilisés dans cette activité ?
- Les corrigés des cinq activités, testés avec Angular 22, sont fournis dans l'archive de la leçon (dossier
corriges/).
-
Erreurs fréquentes
| Message ou symptôme | Cause | Solution |
|---|---|---|
NG8008: Required input 'titre' from component CarteFormation must be specified. |
Entrée input.required oubliée sur la balise |
Ajouter titre="…" ou [titre]="…" |
NG8002: Can't bind to 'prixx' since it isn't a known property of 'app-…'. |
Faute de frappe, entrée inexistante, ou nom interne utilisé à la place de l'alias | Vérifier le nom public de l'entrée (alias) |
TS2339: Property 'set' does not exist on type 'InputSignal<string>'. |
Tentative de modifier une entrée | Émettre une sortie, utiliser model() ou une copie linkedSignal() |
NG8007: The property and event halves of the two-way binding … are not bound to the same target. |
[(x)] sur une simple input() |
Déclarer x = model() dans l'enfant |
TS2322: Type 'Signal<number>' is not assignable to type 'number'. |
[(x)] lié à un computed (non modifiable) |
Lier un signal(), ou utiliser la forme longue |
NG8118: 'titre' is a required 'input' and does not have a value in this context. |
Entrée ou requête lue dans le constructeur | La lire dans un computed, un effect ou une méthode |
Le parent n'est pas prévenu, ses computed sont incohérents |
Objet reçu en entrée modifié sur place | Travailler sur une copie, émettre un nouvel objet |
| La sortie ne déclenche rien | (envoyer) écrit sur la mauvaise balise, ou emit() jamais appelé |
Écouter la sortie sur la balise de l'enfant |
| Deux composants ne partagent pas le même état | providers: [Service] dans un composant : instance séparée |
Retirer ce providers pour utiliser l'instance de l'application |
| Le contenu projeté n'apparaît pas | Aucun <ng-content> correspondant (sélecteur select différent) |
Vérifier l'attribut ou ajouter un <ng-content /> par défaut |
-
À retenir
- Les données descendent par les entrées (
input(),input.required()) et les événements remontent par les sorties (output()+emit()). - Une entrée est un signal en lecture seule : on peut l'utiliser dans un
computed, jamais la modifier. model()+[( )]partagent une valeur dans les deux sens ;linkedSignal()crée un brouillon local d'un objet reçu.#refetviewChild()permettent au parent d'appeler les méthodes publiques d'un enfant.- Un service (
@Service()+inject()) partage un état entre composants éloignés ;providerscrée une instance isolée. <ng-content>(avecselectet contenu par défaut) laisse le parent fournir le contenu ;contentChildren()le découvre.
- Les données descendent par les entrées (
Un composant bien conçu dit clairement ce qu'il attend (ses entrées) et ce qu'il annonce (ses sorties) : il reste simple à comprendre, à tester et à réutiliser.
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !