~7 min de lecture

Ton ngOnChanges a survécu à la migration signals : 4 usages que je recadre en code review

La PR avait l'air exemplaire. Les @Input() migrés vers input(), le control flow moderne, ChangeDetectionStrategy.OnPush partout. Et au milieu du composant, un ngOnChanges de quarante lignes, intact, avec son if par input et ses accès changes['user']. Réponse de l'auteur en review : "il marche, pourquoi y toucher ?"

Parce qu'il marche, justement. C'est le problème. ngOnChanges continue de se déclencher avec les signal inputs (vérifié sur Angular 22.3.0 : deux setInput(), deux appels du hook, SimpleChanges rempli). Ta migration vers input() ne l'a donc pas neutralisé : le vieux code impératif tourne toujours, en parallèle du graphe réactif (les signals et tout ce qui en dérive) que tu viens d'installer. Deux mondes qui calculent la même chose, chacun à sa façon, jusqu'au jour où ils divergent.

En mission, je ne demande jamais de supprimer un ngOnChanges "parce que c'est vieux". Je demande ce qu'il fait. Et en pratique, la réponse tombe dans quatre usages, chacun avec un équivalent déclaratif qui supprime une classe de bugs entière. Les voilà, du plus fréquent au plus rare.

Valable à partir d'Angular 19, où les signal inputs sont stables. linkedSignal() est en developer preview en v19 et stable depuis la v20. resource() n'est stable qu'en v22, et l'extrait de l'usage 3 suppose même une v20.2 minimum : l'option params date de la v20 (elle s'appelait request en v19) et l'alias as sur un @else if n'est accepté que depuis la 20.2. Exemples testés sur Angular 22.3.0.

Pourquoi ngOnChanges est une question, pas une réponse

Avant les quatre usages, un rappel de ce que le hook coûte, même quand il "marche" :

  • SimpleChanges non paramétré est typé avec des any. C'est un dictionnaire indexé par chaîne, dont chaque entrée expose previousValue et currentValue typés any : le compilateur ne vérifie ni les clés ni les valeurs. Depuis la v21, la forme générique SimpleChanges<MonComposant> corrige les deux, mais je ne l'ai encore jamais croisée en mission, et elle ne règle rien de la suite de cette liste.
  • Les clés sont des chaînes. Renomme l'input user en profile et changes['user'] ne correspond plus. Pas d'erreur de compilation avec la forme non paramétrée, pas d'erreur au runtime : la branche ne s'exécute tout simplement plus.
  • Un seul hook pour tous les inputs. D'où la forêt de if (changes['x']) qui transforme chaque ajout d'input en relecture complète du hook.
  • Il n'est pas déprécié. Donc aucun warning ne viendra te prévenir : c'est à la review de poser la question.

La question, donc : lequel de ces quatre usages ton ngOnChanges cache-t-il ?

Usage 1 : la copie locale d'un input

Le grand classique. Le composant reçoit une donnée, mais doit pouvoir la modifier localement : un brouillon éditable, une sélection, un tri. Alors on copie l'input dans une propriété à chaque changement :

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

@Component({
  selector: 'app-user-card',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `<input [value]="draftName" (input)="onEdit($event)" />`,
})
export class UserCard implements OnChanges {
  readonly user = input.required<User>();

  draftName = '';

  ngOnChanges(changes: SimpleChanges): void {
    if (changes['user']) {
      this.draftName = changes['user'].currentValue.name;
    }
  }

  onEdit(event: Event): void {
    this.draftName = (event.target as HTMLInputElement).value;
  }
}

Deux sources de vérité (user().name et draftName), une synchronisation manuelle entre les deux, et une propriété de classe ordinaire qui vit hors du graphe réactif. C'est exactement le cas d'usage pour lequel linkedSignal() existe : un état local modifiable qui se réinitialise quand sa source change.

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

@Component({
  selector: 'app-user-card',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `<input [value]="draftName()" (input)="onEdit($event)" />`,
})
export class UserCard {
  readonly user = input.required<User>();

  readonly draftName = linkedSignal(() => this.user().name);

  onEdit(event: Event): void {
    this.draftName.set((event.target as HTMLInputElement).value);
  }
}

Le hook disparaît, l'interface OnChanges aussi, et le reset au changement de user est garanti par construction au lieu de dépendre d'un if bien écrit. Les subtilités de linkedSignal() (forme longue, cas de la sélection et de la pagination) sont détaillées dans le guide complet. Et si ce composant en est encore aux @Input() recopiés par la classe, le même cas est traité sous l'angle migration dans l'article sur le schematic signal inputs.

Usage 2 : la dérivation

Deuxième usage le plus courant : le hook ne garde pas d'état modifiable, il recalcule une valeur à partir d'un ou plusieurs inputs.

export class ProductList implements OnChanges {
  readonly items = input.required<Product[]>();
  readonly query = input('');

  filtered: Product[] = [];

  ngOnChanges(): void {
    const q = this.query().toLowerCase();
    this.filtered = this.items().filter((p) =>
      p.name.toLowerCase().includes(q),
    );
  }
}

Celui-là est le plus simple à recadrer, parce que la réponse tient en un mot : computed().

export class ProductList {
  readonly items = input.required<Product[]>();
  readonly query = input('');

  readonly filtered = computed(() => {
    const q = this.query().toLowerCase();
    return this.items().filter((p) => p.name.toLowerCase().includes(q));
  });
}

Au passage, toute une famille de questions disparaît. Avec ngOnChanges, quand items et query changent dans le même cycle, le hook n'est appelé qu'une fois, et c'est à toi de t'assurer que ton code recalcule tout ce qu'il faut dans tous les cas de figure. Avec computed(), la question n'existe plus : la dérivation déclare ses dépendances en les lisant, et se recalcule à la demande quand l'une d'elles a changé.

Si ton réflexe était plutôt effect() + signal pour ce cas, c'est un des détournements catalogués dans les pièges d'effect : une dérivation pure n'a pas besoin d'effet.

Usage 3 : le chargement déclenché par un changement d'input

Le plus dangereux des quatre. L'input change, le composant doit recharger quelque chose :

export class UserDetail implements OnChanges {
  private readonly http = inject(HttpClient);

  readonly userId = input.required<string>();

  user: User | null = null;

  ngOnChanges(changes: SimpleChanges): void {
    if (changes['userId']) {
      this.http
        .get<User>(`/api/users/${this.userId()}`)
        .subscribe((user) => (this.user = user));
    }
  }
}

Compte les bugs : une race condition dès que l'utilisateur navigue vite (la réponse lente écrase la réponse fraîche) ; aucun état de chargement ni d'erreur ; une requête jamais annulée, ni au changement d'input suivant ni à la destruction du composant ; et une assignation de propriété de classe ordinaire dont rien ne garantit qu'elle rafraîchisse la vue en OnPush.

Depuis Angular 22, la réponse stable à "un fetch piloté par un signal" s'appelle resource() :

export class UserDetail {
  readonly userId = input.required<string>();

  readonly user = resource({
    params: () => this.userId(),
    loader: async ({ params: id, abortSignal }) => {
      const res = await fetch(`/api/users/${id}`, { signal: abortSignal });
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json() as Promise<User>;
    },
  });
}
@if (user.isLoading()) {
  <app-spinner />
} @else if (user.error()) {
  <app-error-state />
} @else if (user.value(); as u) {
  <app-user-profile [user]="u" />
}

Rechargement à chaque changement d'userId, annulation de la requête en cours, états isLoading / error / value fournis : tout ce que le ngOnChanges faisait mal ou ne faisait pas est pris en charge. Et la race condition est traitée deux fois plutôt qu'une : resource() ignore de lui-même une réponse devenue périmée, et l'abortSignal passé au fetch coupe en plus la requête réseau qui ne sert plus à rien. La démonstration complète est ici.

Si ton app passe par HttpClient et ses intercepteurs plutôt que par fetch, httpResource() (stable en v22 lui aussi) joue le même rôle en s'appuyant dessus.

De la v19 à la v21, resource() existe mais reste marqué expérimental, et l'extrait ci-dessus ne compile pas tel quel avant la v20.2, comme dit plus haut : en v19, remplace params par request, et déplace l'alias dans un @if imbriqué : } @else { @if (user.value(); as u) { ... } } (sans alias, le template refuse user.value() en [user], l'appel de signal pouvant encore rendre undefined). En 20.0 et 20.1, params existe déjà : seul l'alias est à déplacer. Sur ces versions, vérifie le changelog avant de t'appuyer dessus en prod.

Usage 4 : l'archéologie dans SimpleChanges

Le plus rare, mais le plus révélateur : le hook qui fouille previousValue, currentValue et firstChange pour reconstituer une histoire.

export class Carousel implements OnChanges {
  readonly page = input.required<number>();

  direction: 'forward' | 'back' = 'forward';

  ngOnChanges(changes: SimpleChanges): void {
    const change = changes['page'];
    if (change && !change.firstChange) {
      this.direction =
        change.currentValue >= change.previousValue ? 'forward' : 'back';
    }
  }
}

La forme longue de linkedSignal(), celle qui prend un objet { source, computation } au lieu d'une simple fonction de calcul, donne accès à la valeur précédente de la source, ce qui exprime la même intention sans dictionnaire ni garde firstChange :

export class Carousel {
  readonly page = input.required<number>();

  readonly direction = linkedSignal<number, 'forward' | 'back'>({
    source: this.page,
    computation: (page, previous) =>
      previous === undefined || page >= previous.source ? 'forward' : 'back',
  });
}

Le cas initial n'est plus un flag à tester mais un undefined que le compilateur t'oblige à traiter.

Et si tu croises un ngOnChanges qui stocke le dictionnaire changes de côté pour le relire plus tard, recadre-le aussi, parce que ce geste n'a pas un comportement mais deux. Mesuré sur Angular 22.3.0, et ce n'est pas propre aux signal inputs : Angular conserve le SimpleChanges du premier appel comme mémoire interne des valeurs précédentes, et réécrit ses entrées à chaque changement suivant. Stocké au premier appel, changes n'est donc pas une photo mais un miroir de l'état courant ; stocké à n'importe quel appel ultérieur, il reste figé. Une règle pareille n'a pas sa place dans la tête d'un relecteur, et c'est tout l'intérêt des signals : elle disparaît avec le hook.

Ce qu'un ngOnChanges a encore le droit de faire

Soyons honnêtes : rien n'interdit le hook. Si ta codebase est encore en @Input(), qu'elle soit en Angular 17 ou dans une version récente qui n'a jamais migré, ngOnChanges reste l'outil prévu pour réagir aux inputs. Le recadrage ci-dessus attendra ta migration vers les signal inputs, et le schematic cité plus haut peut en faire une partie.

Mais dans un composant déjà en signal inputs, un ngOnChanges qui traîne est un symptôme : celui d'une migration qui a changé la déclaration des inputs sans repenser ce qui en découle. Le hook continue de tourner, en silence, et chaque nouvelle feature devra choisir son monde : impératif ou réactif.

Récap : la grille de lecture en review

Ce que fait le ngOnChanges Remplaçant Stable depuis
Copie un input dans un état local modifiable linkedSignal() v20
Dérive une valeur d'un ou plusieurs inputs computed() v17
Charge une donnée quand un input change resource() v22
Compare previousValue / currentValue linkedSignal() forme longue v20

La prochaine fois qu'un ngOnChanges passe dans ta review, ne commente pas "à migrer vers signals". Pose la vraie question : copie, dérivation, chargement, ou archéologie ? La réponse te donne le remplaçant, le remplaçant supprime le hook, et le hook supprimé emporte avec lui ses clés en chaîne, ses any et sa forêt de if.

📧 Reste informé(e) !

Reçois les derniers articles et conseils EasyAngularKit directement dans ta boîte mail.

S'inscrire gratuitement

AngularKit

Suite d'outils pour développeurs Angular francophones. Apprends, modernise tes réflexes, audite ta codebase.

Produits

Contact

Légal

© 2026 AngularKit. Tous droits réservés.