Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Angular

Communication entre composant angular

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 cop...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À 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.
  1. 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 avec contentChildren()
    • Choisir le bon moyen de communication selon la situation
  1. 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.

Six façons de faire communiquer des composants Angular

  • Pour suivre ce chapitre, continuez dans le projet premiers-pas-angular et créez un dossier src/app/communication/. Tous les exemples ont été testés avec Angular 22 : les composants y sont OnPush par défaut et l'application fonctionne sans Zone.js, d'où l'usage systématique des signals.
  1. 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…).
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

Les options de input() : obligatoire, alias, transformation et valeur par défaut

  • input.required<string>() rend l'entrée obligatoire: oublier titre sur 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: numberAttribute convertit le texte heures="40" en nombre ; booleanAttribute transforme l'attribut seul nouveau en true.
  • Parce qu'une entrée est un signal, le computed prixTTC se 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.
  1. 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 avec emit(valeur).
    • Le parent l'écoute comme un événement natif : (envoyer)="ajouter($event)". $event contient 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…).
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

Une sortie : l'enfant émet, le parent réagit

  • output<void>() déclare une sortie sans donnée : on l'émet avec annuler.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éfixe on.
  1. 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).
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)

model() : une valeur partagée dans les deux sens

  • [(quantite)]="places" est un raccourci pour [quantite]="places()" (quantiteChange)="places.set($event)": Angular crée automatiquement la sortie quantiteChange.
  • 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 un model(). Sur une simple input(): NG8007: The property and event halves of the two-way binding 'simple' are not bound to the same target. Lié à un computed: TS2322: Type 'Signal<number>' is not assignable to type 'number'.
  1. 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

Travailler sur une copie locale de l'entrée avec linkedSignal

  • { ...this.contact() } crée un nouvel objet: modifier le brouillon ne touche jamais l'entrée.
  • modifie compare 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 : linkedSignal recré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 ses computed (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.
  1. Piloter un enfant : #ref et viewChild()

    • 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 #m posée sur la balise de l'enfant ;
      • dans la classe, la requête viewChild.required(MinuteurSimple), qui renvoie un signal contenant l'instance.
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 computed du 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 un computed, une méthode ou afterNextRender().
  • 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.
  1. 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

Un service partagé entre deux composants sans lien

  • Le signal _liste est privé; les composants lisent liste, en lecture seule (asReadonly()), et passent par la méthode basculer() 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.
  1. 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 />. Avec select, 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

La projection de contenu avec ng-content

  • select="[titre]" reçoit les éléments portant l'attribut titre; le <ng-content /> sans select reç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 composants Etape projeté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.
  1. Quel moyen choisir ?

    • Commencez toujours par le plus simple : input() et output(). 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 copie linkedSignal() 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-content quand 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 fonctions input() et output() sont recommandées : elles produisent des signals.
  1. Aide-mémoire

Aide-mémoire : quel moyen de communication choisir

  1. Activité 1 : une liste de tâches découpée en composants

    • Générer deux composants dans act-communication/:
      • app-tache-item affiche une tâche ({ id, titre, faite, priorite }) reçue par input.required: une case à cocher, le titre (barré si la tâche est faite) et un badge « urgent ». Il émet basculer et supprimer avec l'identifiant de la tâche ;
      • app-liste-taches possède le signal des tâches : un champ #titre et une case #urgent pour 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).

Résultat attendu de l'activité 1 : la liste de tâches

  • Pourquoi l'enfant émet-il l'identifiant plutôt que de modifier tache().faite lui-même ?
  • Ajouter une tâche urgente puis la cocher : pourquoi le compteur « urgente(s) » diminue-t-il ?
  1. Activité 2 : un panier avec un sélecteur de quantité réutilisable

    • Créer le composant app-quantite: valeur = model(1), deux entrées min (0) et max (9), et deux boutons − et + désactivés aux limites.
    • Le parent app-panier-quantites affiche 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.

Résultat attendu de l'activité 2 : le panier avec ses sélecteurs

  • 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 ?
  1. Activité 3 : un carnet de contacts avec fiche d'édition

    • Construire un parent app-carnet qui possède la liste des contacts ({ id, nom, email, ville }) et l'identifiant du contact choisi. Il relie deux enfants :
      • app-liste-contacts reçoit les contacts et l'identifiant choisi, met la ligne choisie en surbrillance et émet choisir au clic ;
      • app-fiche-contact reçoit le contact choisi et travaille sur un brouillon linkedSignal: 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é. ».

Résultat attendu de l'activité 3 : le carnet de contacts

  • 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 » ?
  1. 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, deux computed nombre et total, et trois méthodes ajouter(p) (incrémente si le produit est déjà présent), retirer(id) et vider().
    • 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.

Résultat attendu de l'activité 4 : la boutique et son panier partagé

  • Ajouter 2 cahiers et une clé USB : vérifier le badge « 3 · 31,50 DT ».
  • Ajouter providers: [PanierBoutique] dans app-vitrine: que devient le badge quand on ajoute un produit ? Pourquoi ?
  1. Activité 5 : des onglets par projection de contenu

    • Créer deux composants qui s'utilisent ensemble :
      • app-onglet: entrées titre (obligatoire) et icone. 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), un computed courant, 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.

Résultat attendu de l'activité 5 : les onglets

  • 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/).
  1. 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
  1. À 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.
    • #ref et viewChild() permettent au parent d'appeler les méthodes publiques d'un enfant.
    • Un service (@Service() + inject()) partage un état entre composants éloignés ; providers crée une instance isolée.
    • <ng-content> (avec select et contenu par défaut) laisse le parent fournir le contenu ; contentChildren() le découvre.
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é ?