~10 min de lecture

4 000 exécutions pour 20 lignes survolées : la fonction dans ton template que ta review laisse passer

TL;DR

  • Un binding de template n'est pas réévalué "quand la donnée change" : il est réévalué à chaque fois qu'Angular vérifie la vue. Avec une fonction, Angular ne peut pas savoir si le résultat a changé sans l'appeler. Donc il l'appelle. À chaque cycle.
  • Sur une liste de 200 lignes avec un formatTotal(invoice) par ligne, chaque événement dans le composant (une frappe, un survol) relance 200 appels. Survole 20 lignes : 4 000 exécutions pour afficher des totaux qui n'ont pas bougé.
  • Les getters ont le même problème, en plus sournois : {{ displayName }} ressemble à une lecture de propriété, mais c'est un appel de fonction.
  • Les corrections, par cas : computed() pour une dérivation d'état, un view model précalculé (les lignes déjà mises en forme pour l'affichage, calculées une seule fois) pour les transformations par ligne, une pure pipe pour un formatage réutilisé entre templates. @let, lui, ne fait que dédupliquer une expression dans un même cycle.
  • Deux appels de fonction restent légitimes dans un template : les handlers d'événements ((click)="save()", exécuté au clic, pas au cycle) et les lectures de signals (items() rend la valeur stockée, coût constant).

Le diff qui passe en review

Mission de ce trimestre, une app de facturation. Le composant qui arrive en review est propre : OnPush, signals, control flow moderne, du code que tout le monde approuve après une lecture en diagonale.

import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
import { Invoice, InvoiceApi } from './invoice-api';

@Component({
  selector: 'app-invoice-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <input
      [value]="query()"
      (input)="query.set($any($event.target).value)"
      placeholder="Search a customer..."
    />

    <table>
      @for (invoice of filtered(); track invoice.id) {
        <tr
          [class.highlighted]="invoice.id === hovered()"
          (mouseenter)="hovered.set(invoice.id)"
        >
          <td>{{ invoice.customer }}</td>
          <td>{{ formatTotal(invoice) }}</td>
        </tr>
      }
    </table>
  `,
})
export class InvoiceList {
  private readonly api = inject(InvoiceApi);

  readonly invoices = this.api.invoices; // Signal<Invoice[]>
  readonly query = signal('');
  readonly hovered = signal<string | null>(null);

  filtered(): Invoice[] {
    const q = this.query().toLowerCase();
    return this.invoices().filter((i) => i.customer.toLowerCase().includes(q));
  }

  formatTotal(invoice: Invoice): string {
    const total = invoice.lines.reduce(
      (sum, line) => sum + line.amount * line.quantity,
      0,
    );
    return new Intl.NumberFormat('fr-FR', {
      style: 'currency',
      currency: 'EUR',
    }).format(total);
  }
}

Deux fonctions appelées depuis le template : filtered() dans le @for, formatTotal(invoice) dans une interpolation. Aucune des deux n'a déclenché de commentaire en review. C'est normal : le code est correct.

Le problème n'est pas ce que ce code affiche. C'est le nombre de fois qu'il le calcule.

Pourquoi Angular rappelle tes fonctions

La mécanique tient en trois phrases. Quand Angular vérifie une vue, il réévalue chaque expression de binding et compare le résultat à la valeur précédente pour savoir s'il doit toucher le DOM. Pour {{ invoice.customer }}, c'est une lecture de propriété, coût négligeable. Pour {{ formatTotal(invoice) }}, Angular n'a aucun moyen de savoir si le résultat a changé sans exécuter la fonction : il l'exécute, à chaque vérification de la vue.

Reste à savoir quand la vue est vérifiée. Ça dépend de ton régime de change detection :

  • Zone.js + stratégie Eager (l'ancien Default, qui était le défaut avant qu'Angular 22 ne bascule sur OnPush) : tout événement écouté dans la zone Angular, timer ou réponse HTTP, n'importe où dans l'app, déclenche un tick global qui revérifie tous les composants Eager que le parcours (la descente d'Angular dans l'arbre des composants depuis la racine) atteint ; un ancêtre OnPush non marqué dirty (à revérifier) coupe le parcours pour tout son sous-arbre. C'est le pire cas : ton formatTotal tourne parce qu'un autre composant a reçu un mousemove.
  • Zone.js + OnPush (le défaut depuis Angular 22) : le composant n'est revérifié que s'il est marqué dirty, ce qui arrive quand un input est modifié, qu'un événement survient dans son sous-arbre, que markForCheck() est appelé (le pipe async le fait pour toi) ou qu'un signal lu dans le template change.
  • Zoneless (le défaut d'une app neuve depuis Angular 21) : un cycle n'est planifié que sur notification : écriture de signal, événement de template ou de host (un écouteur posé sur l'élément hôte du composant, via host: {...}), markForCheck(). Plus de cycles déclenchés par les timers, les promesses ou les écouteurs ajoutés à la main (addEventListener). Un événement de template ou de host ailleurs dans l'app déclenche encore un cycle : un composant OnPush non marqué dirty y échappe, avec les composants Eager placés sous lui.

OnPush et zoneless réduisent le nombre de fois où ton composant est revérifié. Mais aucun des deux ne change la règle de base : quand le composant est revérifié, toutes les expressions de sa vue sont réévaluées. Et chaque interaction dans le composant le marque dirty.

Déroule le scénario sur notre liste de 200 factures :

  • L'utilisateur survole une ligne : mouseenter est un événement de template, le composant est revérifié. formatTotal tourne 200 fois pour déplacer une classe CSS d'une ligne à une autre.
  • Il descend la souris le long de la liste, 20 lignes : 20 cycles, 4 000 appels. Chaque appel refait un reduce sur les lignes de la facture et instancie un Intl.NumberFormat : instancier puis formater coûte environ 75 fois plus cher qu'un format() sur une instance partagée (28,4 µs contre 0,37 µs par appel, mesuré sous Node 24).
  • Il tape 6 caractères dans la recherche : 6 cycles de plus, filtered() refait son filtre à chaque fois (jusque-là c'est voulu), et formatTotal repart pour chaque ligne encore affichée, alors que les totaux n'ont pas changé depuis le chargement.

Tu veux le constater plutôt que me croire ? Pose un compteur dans la classe :

export class InvoiceList {
  // ...
  private calls = 0;

  formatTotal(invoice: Invoice): string {
    console.log('formatTotal calls:', ++this.calls);
    // body unchanged
  }
}

Survole la liste et regarde la console s'emballer. Au passage, le compteur que tu lis vaut aussi pour la prod : la seconde passe que le mode dev ajoute pour détecter les erreurs NG0100 (ExpressionChangedAfterItHasBeenChecked) ne relit pas le template d'un composant OnPush comme celui-ci, donc tes compteurs ne doublent pas.

Le getter, même piège en costume de propriété

Variante que je croise encore plus souvent en mission, justement parce qu'elle ne se voit pas en review :

export class UserCard {
  readonly user = input.required<User>();

  get displayName(): string {
    return `${this.user().firstName} ${this.user().lastName}`.trim();
  }
}

Dans le template, {{ displayName }} a l'air d'une lecture de propriété. C'est un appel de fonction à chaque cycle, au même titre que formatTotal(invoice). Celui-ci est bon marché, mais le jour où quelqu'un y ajoutera un tri, un find dans une liste ou un formatage de date, personne ne repassera sur le template pour s'en apercevoir. En review, un getter consommé par un binding se traite comme un appel de fonction, parce que c'en est un. La correction est la même que pour filtered() : readonly displayName = computed(() => ...), et le template lit {{ displayName() }}.

La correction : déplacer le calcul là où il est mémoïsé

Le fix n'est pas "interdire les parenthèses dans les templates". C'est déplacer chaque calcul vers un endroit qui mémoïse, c'est-à-dire qui garde le résultat en cache et ne le recalcule que quand ses entrées changent. Il y a trois façons de le faire, pour trois cas différents.

1. Dérivation d'état : computed()

filtered() est dérivé de deux signals, invoices et query. C'est la définition d'un computed() (introduit en Angular 16, stable depuis la 17) : il ne recalcule que quand une de ses dépendances change, et sert la valeur en cache le reste du temps. Tu le retrouves corrigé sous le nom visible dans le code de la section suivante.

2. Transformation par ligne : le view model précalculé

Pour formatTotal, le computed() naïf ne suffit pas : le template appelle la fonction par ligne, il faut donc précalculer par ligne. On mappe les données vers ce que la vue affiche, une fois, au moment où les données changent :

import { ChangeDetectionStrategy, Component, computed, inject, signal } from '@angular/core';
import { InvoiceApi } from './invoice-api';

const EUR = new Intl.NumberFormat('fr-FR', {
  style: 'currency',
  currency: 'EUR',
});

interface InvoiceRow {
  id: string;
  customer: string;
  total: string;
}

@Component({
  selector: 'app-invoice-list',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <input
      [value]="query()"
      (input)="query.set($any($event.target).value)"
      placeholder="Search a customer..."
    />

    <table>
      @for (row of visible(); track row.id) {
        <tr
          [class.highlighted]="row.id === hovered()"
          (mouseenter)="hovered.set(row.id)"
        >
          <td>{{ row.customer }}</td>
          <td>{{ row.total }}</td>
        </tr>
      }
    </table>
  `,
})
export class InvoiceList {
  private readonly api = inject(InvoiceApi);

  readonly query = signal('');
  readonly hovered = signal<string | null>(null);

  private readonly rows = computed<InvoiceRow[]>(() =>
    this.api.invoices().map((invoice) => ({
      id: invoice.id,
      customer: invoice.customer,
      total: EUR.format(
        invoice.lines.reduce((sum, l) => sum + l.amount * l.quantity, 0),
      ),
    })),
  );

  readonly visible = computed(() => {
    const q = this.query().toLowerCase();
    return this.rows().filter((row) => row.customer.toLowerCase().includes(q));
  });
}

Note le découpage en deux computed() : il a une raison d'être. rows ne dépend que des factures : il ne recalcule que quand elles changent, c'est-à-dire quasi jamais. visible dépend de rows et de query : une frappe ne relance que le filtre, pas les 200 formatages. Si tout vivait dans un seul computed(), chaque frappe reformaterait toute la liste. Découper les computed() par dépendance, c'est choisir ce qui recalcule quand.

Refais passer le compteur : un survol n'exécute plus rien d'autre que des comparaisons row.id === hovered(). Le formatage a tourné une fois par facture, au chargement.

3. Formatage réutilisé entre templates : la pure pipe

Si le même formatage sert dans cinq composants, le view model duplique la logique. C'est le cas d'usage des pipes, et c'est une mémoïsation que tu utilises déjà sans le savoir : une pipe est pure par défaut, et Angular ne rappelle transform que quand la référence de l'entrée change. DatePipe et CurrencyPipe fonctionnent comme ça.

import { Pipe, PipeTransform } from '@angular/core';
import { Invoice } from './invoice-api';

const EUR = new Intl.NumberFormat('fr-FR', {
  style: 'currency',
  currency: 'EUR',
});

@Pipe({ name: 'invoiceTotal' })
export class InvoiceTotalPipe implements PipeTransform {
  transform(invoice: Invoice): string {
    return EUR.format(
      invoice.lines.reduce((sum, l) => sum + l.amount * l.quantity, 0),
    );
  }
}

Et dans le template : {{ invoice | invoiceTotal }}. Le survol ne relance plus le formatage : même référence de facture, même résultat servi depuis le cache de la pipe. La pipe ne corrige que le formatage, cela dit : le filtered() du composant d'origine reste une méthode à migrer vers un computed().

La contrepartie à connaître : la mémoïsation se fait par référence. Si tu mutes invoice.lines en place, la pipe ne recalcule pas.

Et @let dans tout ça ?

@let (stable depuis Angular 19) résout un problème voisin mais distinct : la même expression écrite trois fois dans un template est évaluée trois fois par cycle, @let la réduit à une évaluation par cycle. C'est une déduplication à l'intérieur d'un cycle, pas un cache entre cycles : au cycle suivant, l'expression est réévaluée. Pour une dérivation de présentation bon marché, un total par ligne compris, c'est l'outil qu'il faut, et j'y ai consacré un article entier. La frontière entre les deux approches, c'est le coût : tant que l'expression tient en quelques opérations, @let suffit et le view model serait de la cérémonie. Dès que le calcul par ligne devient cher, ou que la liste s'allonge, @let ne fait que diviser la facture par le nombre d'occurrences, là où computed() et la pure pipe la ramènent à zéro tant que la donnée ne change pas.

Les fonctions qui ont le droit de rester

Le but n'est pas d'éradiquer toute parenthèse du template :

  • Les handlers d'événements : (click)="save()" s'exécute au clic, pas au cycle de change detection. Aucun coût caché.
  • Les lectures de signals : items() est un appel de fonction, mais il ne fait que rendre la valeur stockée (ou, pour un computed() dont les dépendances n'ont pas bougé, la dernière valeur calculée), un coût négligeable par conception. C'est même le mécanisme qui permet à Angular de savoir quoi rafraîchir. Le problème n'a jamais été la parenthèse, c'est le travail derrière.
  • Le calcul trivial et assumé : un {{ isLast ? '' : ', ' }} ne mérite pas un computed(). Le critère, c'est le travail par appel multiplié par le nombre d'appels par cycle. Une concaténation dans un composant affiché une fois, personne ne la verra. La même dans un @for de 200 lignes, si.

Récap actionnable

En review, sur un template :

  1. Cherche les appels de fonction dans les interpolations et les property bindings, y compris dans les expressions de @for et de @if. Les handlers d'événements ne comptent pas.
  2. Cherche les getters consommés par le template : même piège, sans parenthèses visibles.
  3. Pour chaque appel trouvé, pose la question du cycle : "combien de fois par cycle, et qu'est-ce qui déclenche un cycle ici ?".
  4. Dérivation de signals du composant : computed().
  5. Transformation par élément de liste : view model précalculé dans un computed(), découpé par dépendance pour que la recherche ne repaye pas le formatage.
  6. Formatage partagé entre plusieurs composants : pure pipe, et les pipes standard (DatePipe, CurrencyPipe) sont déjà pures.
  7. Expression répétée dans un même template : @let, en sachant que c'est une déduplication par cycle, pas un cache.
  8. OnPush et zoneless réduisent le nombre de fois où ton composant est revérifié, pas le coût d'une revérification. Ils rendent l'anti-pattern moins visible, pas moins réel.

La fonction dans le template est l'anti-pattern parfait pour une review : invisible dans le diff, correct fonctionnellement, vert aux tests. Un garde-fou mécanique existe, la règle @angular-eslint/template/no-call-expression, mais elle est absente du preset template-recommended d'angular-eslint et elle a deux limites : sans allowList, elle crie sur chaque lecture de signal, et elle ne voit pas les getters. En pratique, c'est donc en review que ça se joue : cherche ce pattern à la main.

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