Préparation entretien · Angular 2026

Décroche le poste, sans bachoter dans le vide.

Les 53 questions qu'on m'a vraiment posées en entretien Angular, telles qu'on me les a posées, avec des réponses claires et à jour (zoneless, signals, control flow). Déplie, révise, recommence.

53questions
7thèmes
FR · ENbilingue
Angular 22à jour 2026

J'ai planté deux entretiens Angular senior sur la partie théorique, alors que je code en prod depuis des années. « En tant que senior, on s'attend à ce que tu répondes facilement à ces questions. » Alors j'ai gardé chaque question qu'on m'a posée, sans en inventer une seule. Voici les réponses que j'aurais aimé avoir.

Sara, fondatrice de NgDigest
53 questions

Fondamentaux JS/TS

6
Le langage du web : il tourne dans le navigateur, et côté serveur avec Node.js. Il est typé dynamiquement (le type d'une variable n'est vérifié qu'à l'exécution) et mono-thread : une seule chose à la fois, mais il gère l'asynchrone grâce à la boucle d'événements (callbacks, promesses, async/await). Il est multi-paradigme : on peut écrire en objet comme en fonctionnel. Les moteurs modernes ne l'interprètent pas « ligne par ligne » : ils le compilent à la volée (JIT). Pour une question Angular, ajoute que TypeScript est un sur-ensemble de JavaScript qui ajoute des types vérifiés à la compilation, puis disparaît : le navigateur exécute toujours du JavaScript.
Oui, mais pas comme Java ou C#. JavaScript est orienté objet par prototypes : chaque objet peut hériter directement d'un autre objet, sans passer par une classe. Le mot-clé class, arrivé en 2015, est une syntaxe plus lisible posée sur ce même mécanisme. C'est aussi un langage où les fonctions sont des valeurs comme les autres, donc on y écrit beaucoup de code fonctionnel (map, filter, fonctions pures). La réponse qui rassure : « oui, mais à prototypes, et on mélange souvent objet et fonctionnel ».
Un modèle pour fabriquer des objets qui ont la même forme : des propriétés (les données), des méthodes (le comportement) et un constructor appelé à la création. En TypeScript, on y ajoute des types et des modificateurs (private, readonly). En Angular, presque tout est une classe : un composant, un service, une directive, un pipe. Ce qui les rend « Angular », c'est le décorateur posé dessus (@Component, @Injectable…), qui dit au framework comment les utiliser.
Un objet concret créé à partir d'une classe, avec new. Si la classe est le moule, l'instance est le gâteau : chaque instance a ses propres valeurs, mais elles partagent les mêmes méthodes. Le point Angular qui fait la différence : on ne fait jamais new MonService() soi-même. C'est l'injection de dépendances qui crée les instances et décide combien il y en a (une seule pour toute l'appli avec providedIn: 'root', une par composant si on le fournit dans le composant).
Une classe implémente une interface quand elle fournit le code concret d'un contrat : l'interface dit quoi (les signatures), la classe dit comment. Exemple que tout le monde connaît : export class MonComposant implements OnInit t'oblige à écrire ngOnInit(). TypeScript vérifie le contrat à la compilation. Le détail qui montre que tu as compris : les interfaces disparaissent à l'exécution. C'est pour ça qu'on ne peut pas injecter une interface directement en Angular ; on passe par un InjectionToken ou une classe abstraite.
Le Document Object Model : la représentation en arbre de la page HTML que le navigateur construit, et l'API qui permet de la lire et de la modifier (querySelector, appendChild…). En Angular, on ne le manipule presque jamais à la main : on décrit l'interface dans le template, et Angular met à jour le vrai DOM quand l'état change. Attention à une confusion fréquente : Angular n'utilise pas de DOM virtuel comme React, il compile les templates en instructions qui modifient directement le DOM. Si tu dois vraiment toucher au DOM (focus, librairie tierce), fais-le après le rendu (afterNextRender), et souviens-toi qu'en rendu serveur il n'y a pas de document.

Angular Core

19
Une classe TypeScript décorée avec @Component, qui gère un morceau de l'interface. Il a trois parties : le sélecteur (la balise qui l'insère, app-user-card), le template (le HTML) et les styles. La classe porte l'état et les réactions aux actions de l'utilisateur ; elle reçoit des données par ses entrées et prévient son parent par ses sorties. Une appli Angular, c'est un arbre de composants.
Modern 20262026 : les composants sont standalone par défaut (plus besoin de NgModule), et on écrit les entrées et sorties avec input() et output() plutôt que @Input() et @Output().
Le composant smart (ou container) sait d'où viennent les données : il injecte les services ou le store, lance les appels et décide quoi faire des actions. Le composant dumb (ou presentational) ne fait qu'afficher ce qu'il reçoit en entrée et émettre des événements ; il n'injecte pas de service métier. Intérêt : les composants d'affichage sont réutilisables et faciles à tester, la logique est regroupée au même endroit. Exemple : une page « liste de produits » (smart) qui passe chaque produit à une app-product-card (dumb). Ne sois pas dogmatique : un petit composant autonome qui fait les deux, c'est parfois très bien.
Modern 20262026 : avec input() et output(), et OnPush par défaut depuis Angular 22, les composants d'affichage sont encore plus simples à écrire.
Oui, ils forment un arbre : chaque composant peut en afficher d'autres dans son template. Pour communiquer : du parent vers l'enfant avec les entrées (input()), de l'enfant vers le parent avec les sorties (output()), et dans les deux sens avec model() (liaison bidirectionnelle). Entre composants qui ne sont pas parent et enfant (deux « frères », deux pages), on passe par un service partagé ou un store. Il existe aussi la projection de contenu (<ng-content>), où le parent glisse son propre HTML dans l'enfant, et viewChild() pour qu'un parent accède à un enfant. Le bon réflexe à dire : passer par un service dès qu'on se retrouve à faire remonter une donnée sur trois niveaux.
Ce qu'on attend, c'est une liste concrète et la raison de chaque point. Structure : un dossier par fonctionnalité, un core/ pour ce qui est unique dans l'appli (intercepteurs, gardes), un shared/ pour le réutilisable, des routes chargées à la demande. Qualité : TypeScript en mode strict, ESLint et Prettier, des conventions écrites (nommage, BEM ou autre règle pour le CSS, format des commits). État : des services avec signals au départ, un store seulement si le besoin apparaît. Tests et CI dès le premier jour, même légers. Selon le projet : i18n, gestion des erreurs HTTP centralisée, environnements. Termine par ce que tu écris noir sur blanc : un README avec ces règles, pour que la cinquième personne qui arrive code comme la première.
Modern 20262026 : nouveau projet = standalone, zoneless et Vitest par défaut (Angular 21).
Je range par fonctionnalité, pas par type de fichier. Concrètement : core/ (services uniques, intercepteurs, gardes), shared/ (composants, pipes et directives réutilisables), puis features/<fonctionnalité>/ qui contient tout ce qui la concerne. Sur un projet plus gros, chaque fonctionnalité peut se découper en couches (domain, application, infrastructure, presentation). Pourquoi : on trouve le code là où on l'attend, une fonctionnalité se charge à la demande avec sa route, et on peut supprimer ou confier une fonctionnalité sans fouiller tout le projet. Le contre-exemple à citer : un dossier components/ avec 80 fichiers à plat.
Les plus courantes : par type (components/, services/, models/ : simple au début, ingérable ensuite), par fonctionnalité (le plus répandu en Angular), en couches à l'intérieur de chaque fonctionnalité (inspiré de la Clean Architecture et du DDD), et en monorepo avec Nx, où l'appli est découpée en librairies avec des règles sur qui peut importer quoi. Pour une librairie de composants d'interface, on croise aussi l'Atomic Design (atomes, molécules, organismes). Montre surtout que tu choisis selon la taille de l'équipe et du projet, pas par mode.
Une classe décorée avec @Injectable qui porte ce qui n'a rien à faire dans un composant : les appels HTTP, la logique métier réutilisable, un état partagé entre plusieurs écrans. Le composant demande le service (injection de dépendances) au lieu de le créer. Résultat : le composant reste centré sur l'affichage, et le service se teste seul.
Modern 20262026 : on l'injecte avec inject(UserService) plutôt que par le constructeur, et son état s'expose volontiers en signals.
Le service est enregistré dans l'injecteur racine : une seule instance pour toute l'application, disponible partout sans le déclarer ailleurs. Bonus : il est tree-shakable, donc s'il n'est jamais injecté, il n'est pas dans le bundle. Les autres options : le fournir dans les providers d'une route (une instance pour cette partie de l'appli) ou d'un composant (une instance par composant, utile pour un état local à un formulaire par exemple). providedIn: 'any' existe encore mais est déprécié depuis Angular 15.
Un principe simple : une classe ne crée pas elle-même ce dont elle a besoin, on le lui fournit de l'extérieur. En Angular, tu déclares ce dont tu as besoin et le framework te donne l'instance. Ce que ça apporte : en test, tu remplaces facilement le vrai service par un faux ; le composant ne dépend pas de la façon dont le service est construit ; et une même instance est partagée. Angular a des injecteurs hiérarchiques (racine, route, composant) : on cherche d'abord au plus près, puis on remonte. Pour injecter une valeur ou une interface, on utilise un InjectionToken.
Modern 20262026 : la fonction inject() a remplacé l'injection par constructeur dans la plupart des projets.
Un patron de conception qui garantit qu'une classe n'a qu'une seule instance, partagée par tous ceux qui l'utilisent. En Angular, c'est le cas de tout service providedIn: 'root' : un AuthService ou un panier d'achat partagé par toute l'appli. Le piège classique : si tu remets ce service dans les providers d'un composant, ce composant reçoit sa propre instance, et l'état n'est plus partagé. C'est un bug qu'on met longtemps à trouver.
Les quatre classiques : l'interpolation {{ valeur }} pour afficher du texte, le property binding [src]="url" (de la classe vers le template), l'event binding (click)="save()" (du template vers la classe) et le two-way binding [(ngModel)], qui n'est qu'un raccourci pour [ngModel] + (ngModelChange). Les « autres » qu'on attend souvent : [attr.aria-label] (attribut HTML sans propriété DOM), [class.active] et [style.width.px].
Modern 20262026 : pour tes propres composants, model() permet d'offrir un [(valeur)] sans écrire l'entrée et la sortie à la main.
En HTML, disabled est un attribut booléen : sa simple présence désactive le bouton. Donc <button disabled="false"> est… désactivé. En Angular, on lie la propriété : [disabled]="isSaving", et le bouton s'active ou se désactive selon la valeur. Deuxième piège, avec les formulaires réactifs : ne mets pas [disabled] sur un champ relié à un FormControl (Angular t'avertit en console). On désactive le contrôle lui-même avec control.disable(), ou à sa création.
Historiquement : *ngIf avec else et as (pour garder le résultat, par exemple user$ | async as user), *ngFor avec index, first, last, even, odd, count et surtout trackBy pour éviter de tout redessiner, et [ngSwitch].
Modern 20262026 : depuis Angular 17, on utilise le control flow intégré : @if / @else, @for avec un track obligatoire et les variables $index, $first, $last, $even, $odd, $count, un bloc @empty pour la liste vide, et @switch. *ngIf et *ngFor sont dépréciés depuis Angular 20, et ng update sait migrer le code.
[ngClass] accepte un objet ({ 'card--active': isActive, 'card--error': hasError }, la forme la plus courante), un tableau ou une chaîne. Pour une seule classe conditionnelle, [class.card--active]="isActive" est plus lisible. Évite d'appeler une méthode dans le binding ([ngClass]="getClasses()") : elle est rappelée à chaque détection de changement ; préfère une valeur calculée.
Modern 20262026 : le guide de style Angular recommande désormais les bindings [class] et [style] plutôt que NgClass et NgStyle, et une migration automatique existe.
Une classe qui ajoute un comportement à un élément existant, sans avoir son propre template. Deux familles : les directives d'attribut, qui changent l'apparence ou le comportement (ngClass, ou une directive maison appAutofocus, appTooltip), et les directives structurelles, qui ajoutent ou retirent des éléments du DOM (l'ancien *ngIf). Un composant, c'est en fait une directive avec un template. Pour en écrire une : @Directive({ selector: '[appAutofocus]' }), et on agit sur l'élément hôte.
Modern 20262026 : on déclare les écouteurs et bindings de l'hôte dans la propriété host du décorateur plutôt qu'avec @HostListener et @HostBinding.
Un pipe transforme une valeur pour l'affichage, directement dans le template : {{ price | currency:'EUR' }}. Les natifs à citer : date, currency, number, percent, uppercase, lowercase, titlecase, slice, keyvalue, json (pour déboguer) et surtout async, qui s'abonne à un Observable et se désabonne tout seul. Pour en créer un : une classe @Pipe({ name: 'truncate' }) avec une méthode transform(). Par défaut un pipe est pur : il ne se recalcule que si sa valeur d'entrée change (par référence), ce qui le rend très léger. Un pipe impur se recalcule à chaque cycle : à éviter. Détail apprécié : pour avoir des formats français (1 234,56 €), il faut enregistrer la locale fr.
On déclare un tableau de routes : chaque path est associé à un composant ({ path: 'users/:id', component: UserDetail }), et on le fournit avec provideRouter(routes). Quand l'URL change, le routeur affiche le bon composant dans le <router-outlet>, sans recharger la page. On navigue avec routerLink dans le template ou router.navigate() dans le code. Autour : les paramètres d'URL, les gardes (canActivate, canMatch) pour protéger une route, les resolvers pour charger des données avant l'affichage, et le chargement à la demande.
Modern 20262026 : avec withComponentInputBinding(), les paramètres de route arrivent directement dans les input() du composant.
L'emplacement où le routeur affiche le composant de la route active. Ton layout (en-tête, menu, pied de page) reste en place, et seul le contenu du <router-outlet> change quand on navigue. On peut en imbriquer : une route parente avec ses routes enfants affiche les enfants dans son propre <router-outlet>. Il existe aussi des outlets nommés, pour afficher une deuxième route en parallèle (un panneau latéral, par exemple).
Le principe : ne charger le code d'une partie de l'appli que quand l'utilisateur y va. Avec loadComponent: () => import('./admin/admin').then((m) => m.Admin) (ou loadChildren pour tout un groupe de routes), le build crée un fichier JavaScript séparé. Le bundle de départ est plus petit, donc la première page s'affiche plus vite. On peut ensuite précharger les routes en arrière-plan une fois la page affichée (withPreloading(PreloadAllModules)).
Modern 20262026 : @defer applique la même idée à un morceau de template (un graphique en bas de page, chargé quand il devient visible).

RxJS & Signals

6
Un flux de valeurs dans le temps. Il peut émettre zéro, une ou plusieurs valeurs, puis se terminer (complete) ou échouer (error). Il est paresseux : tant que personne ne s'abonne (subscribe), rien ne se passe. La comparaison qu'on attend : une Promise donne une seule valeur, démarre tout de suite et ne s'annule pas ; un Observable peut donner plusieurs valeurs, démarre à l'abonnement et s'annule en se désabonnant. Le piège concret : un appel HttpClient est un Observable « froid », donc deux | async sur le même Observable lancent deux requêtes.
Un Observable particulier sur lequel on peut aussi pousser des valeurs soi-même (next()), et qui les diffuse à tous ses abonnés en même temps. Les variantes à connaître : Subject (pas de valeur initiale, un nouvel abonné ne reçoit que les valeurs suivantes), BehaviorSubject (a une valeur initiale et donne tout de suite la dernière valeur à un nouvel abonné : idéal pour un état), ReplaySubject (rejoue les N dernières valeurs) et AsyncSubject (ne donne que la dernière valeur, à la fin). Bonne pratique : garder le Subject privé dans le service et n'exposer que asObservable(), pour que personne d'autre ne puisse émettre.
Ils sont partout dans les API historiques d'Angular. HttpClient renvoie des Observables. Le routeur expose paramMap et ses événements en Observables. Les formulaires réactifs ont valueChanges. Les anciens @Output() reposent sur un EventEmitter, qui est un Subject. Dans le template, on les lit avec le pipe async, qui s'abonne et se désabonne tout seul. L'exemple qui montre que tu sais t'en servir : une recherche avec valueChanges.pipe(debounceTime(300), distinctUntilChanged(), switchMap((terme) => this.api.search(terme))).
Modern 20262026 : pour l'état affiché, on convertit souvent un Observable en signal avec toSignal() ; RxJS reste le bon outil pour les flux d'événements.
Le schéma classique : un BehaviorSubject privé qui contient l'état, un Observable public en lecture (asObservable()), et des méthodes qui le modifient en créant une nouvelle valeur (this.items$.next([...this.items$.value, item])) plutôt qu'en mutant l'ancienne. Les composants lisent avec | async et n'ont jamais accès au next(). ReplaySubject(1) sert quand il n'y a pas de valeur initiale sensée.
Modern 20262026 : le même schéma s'écrit plus simplement avec un signal() privé, exposé avec asReadonly(), et des computed() pour les valeurs dérivées (le nombre d'articles, le total).
Ne fais pas une liste sans fin : cite-les par usage, avec un cas pour chacun. Transformer : map, filter, tap (effet de bord, debug). Enchaîner des appels : switchMap (annule l'appel précédent : recherche), concatMap (dans l'ordre : sauvegardes successives), mergeMap (en parallèle), exhaustMap (ignore les clics tant que l'appel est en cours : bouton « payer »). Saisie utilisateur : debounceTime, distinctUntilChanged. Combiner : combineLatest (plusieurs filtres), forkJoin (attendre plusieurs appels). Erreurs : catchError, retry. Partager : shareReplay. Arrêter : take, takeUntilDestroyed.
Oui, et c'est ce qu'on attend : le moins de subscribe() manuels possible. Dans le template, le pipe async s'abonne et se désabonne tout seul. Dans la classe, takeUntilDestroyed() coupe l'abonnement quand le composant est détruit. toSignal() fait pareil et transforme le flux en signal. L'ancienne méthode, encore très présente dans le code existant : un destroy$ = new Subject<void>(), takeUntil(this.destroy$) et un next() dans ngOnDestroy. Précision utile : un appel HttpClient se termine tout seul, mais se désabonner annule quand même la requête si on quitte la page avant la réponse.

Architecture & État

10
Réponds avec ton vécu, puis montre que tu sais choisir. Les options : un service avec un état (signals ou BehaviorSubject) suffit pour la majorité des applis. NgRx Store (actions, reducers, selectors, effects) se justifie quand beaucoup d'écrans partagent un état complexe et qu'on veut tracer chaque changement (outils de débogage, historique). NgRx SignalStore est un intermédiaire plus léger, basé sur les signals. Ce qui est mal vu : sortir NgRx pour une appli de trois pages. Ce qui est bien vu : expliquer le critère qui t'a fait choisir, et ce que ça a coûté (le code en plus, la formation de l'équipe).
Le client envoie une requête : une méthode (GET, POST, PUT, PATCH, DELETE), une URL qui désigne la ressource (/api/users/42), des en-têtes (Content-Type, Authorization) et parfois un corps en JSON. Le serveur répond avec un code de statut (200 OK, 201 créé, 400 requête invalide, 401 non connecté, 404 introuvable, 500 erreur serveur) et en général du JSON. En REST, chaque requête se suffit à elle-même : le serveur ne garde pas de session entre deux appels. En Angular : HttpClient (provideHttpClient()), des réponses typées, et des intercepteurs pour ajouter le jeton ou gérer les erreurs au même endroit.
Modern 20262026 : pour une lecture qui dépend d'un signal (un filtre, un id), httpResource() relance la requête tout seul et est stable depuis Angular 22.
Application Programming Interface : un contrat qui dit comment un programme peut en utiliser un autre (quelles demandes faire, sous quelle forme, et ce qu'on reçoit en retour) sans savoir comment il fonctionne à l'intérieur. Pour un dev front, c'est surtout l'API du back : des URL qui renvoient du JSON, en REST ou en GraphQL. Mais le navigateur aussi expose des API : le DOM, fetch, localStorage, la géolocalisation. Une bonne API est stable et documentée, et quand elle change, elle prévient (versions).
Les quatre opérations de base sur une donnée : Create, Read, Update, Delete. En REST : POST /users pour créer, GET /users ou GET /users/42 pour lire, PUT (remplacement complet) ou PATCH (modification partielle) sur /users/42 pour mettre à jour, DELETE /users/42 pour supprimer. Le détail qui fait la différence : GET, PUT et DELETE sont idempotents (les rejouer donne le même résultat), pas POST. C'est pour ça qu'on ne relance jamais automatiquement un POST en cas d'erreur réseau : on risquerait de créer deux commandes.
Du code qu'une autre personne comprend et modifie sans avoir peur de casser quelque chose. Le terme vient du livre de Robert C. Martin. Les principes concrets : des noms qui disent ce que fait la chose (calculateTotalPrice() plutôt que calc()), des fonctions courtes qui font une seule chose, pas de duplication, pas d'effet de bord caché, et des commentaires qui expliquent le pourquoi plutôt que le quoi. Côté Angular, des exemples parlent mieux : pas de logique dans les templates, des composants qui ne font pas tout, des conventions de nommage respectées partout. Le meilleur argument : un exemple de code que tu as rendu plus lisible, et ce que ça a changé pour l'équipe.
L'idée commune : le cœur métier ne dépend pas des détails techniques (framework, base de données, API). Les dépendances vont toujours vers le centre. L'architecture hexagonale (ports and adapters) le dit ainsi : le métier définit des ports (des interfaces : « j'ai besoin de récupérer des utilisateurs »), et des adaptateurs les implémentent (un adaptateur HTTP, un adaptateur de test en mémoire). Côté Angular : des modèles et des règles en TypeScript pur dans domain/, une interface de dépôt fournie par un InjectionToken, et l'implémentation HTTP dans infrastructure/. Avantages : la logique se teste sans Angular, et on peut changer de source de données. Inconvénient à reconnaître : plus de fichiers. Pour une petite appli, c'est souvent trop.
Une approche qui met le métier au centre de la conception, en travaillant avec les experts du domaine. Les notions clés : un langage commun (les mêmes mots dans les réunions et dans le code : si le métier dit « contrat », la classe s'appelle Contract), des contextes délimités (bounded contexts : « client » ne veut pas dire la même chose pour la facturation et pour le support), des entités (qui ont une identité), des objets valeur (définis par leurs valeurs, comme un montant avec sa devise) et des agrégats (un groupe d'objets modifiés ensemble selon des règles). Côté front, ça se traduit surtout par un dossier par contexte métier et des noms qui collent au métier.
Deux choses différentes, souvent mélangées. Les Web Components sont des standards du navigateur (custom elements, shadow DOM, templates) pour créer des balises réutilisables dans n'importe quel framework. Les micro-frontends sont une organisation : on découpe une grosse appli en parties développées et déployées séparément, chacune par une équipe (en Angular, souvent avec Module Federation ou Native Federation). Ce que ça apporte : des équipes autonomes. Ce que ça coûte : des versions de dépendances à aligner, un design à garder cohérent, plus de JavaScript à charger, un débogage plus difficile. La phrase qui montre du recul : c'est une réponse à un problème d'organisation (beaucoup d'équipes), rarement à un problème technique.
Un custom element, c'est une balise HTML que tu crées toi-même (customElements.define('user-card', ...)), utilisable comme n'importe quelle balise, dans n'importe quelle page. Angular Elements (@angular/elements) transforme un composant Angular en custom element avec createCustomElement() : ses entrées deviennent des propriétés et attributs, ses sorties des événements du DOM. Cas d'usage : intégrer un widget Angular dans un site qui n'est pas en Angular (un CMS, une appli React). La limite à mentionner : l'élément embarque le runtime d'Angular, donc c'est lourd pour un petit composant.
Trois pistes, à choisir selon le besoin. Des Web Components : écrits avec Angular Elements (simple si l'équipe est Angular, mais lourd), ou plutôt avec un outil léger fait pour ça comme Lit ou Stencil, et utilisés dans les deux frameworks. Partager le design plutôt que les composants : des design tokens (couleurs, espacements, typo) et du CSS commun, chaque framework ayant sa propre implémentation des composants. Partager la logique : une librairie TypeScript sans framework (validation, formatage, appels API). Dans la vraie vie, on combine souvent les deux dernières : c'est moins magique que tout partager, mais beaucoup plus simple à maintenir.

Performance & Observabilité

2
C'est le mécanisme qui garde l'écran synchronisé avec l'état : quand une donnée change, Angular met à jour les bindings concernés. Historiquement, zone.js prévenait Angular après chaque événement (clic, timer, réponse HTTP), et Angular revérifiait tout l'arbre de composants. Avec la stratégie OnPush, un composant n'est revérifié que si une entrée change de référence, si un événement part de lui, si un async émet ou si un signal lu dans son template change. D'où l'importance de l'immutabilité : modifier un objet en place ne déclenche rien.
Modern 20262026 : les nouveaux projets sont zoneless depuis Angular 21 (ce sont les signals qui déclenchent la mise à jour) et, depuis Angular 22, OnPush est la stratégie par défaut. L'ancienne stratégie s'appelle maintenant Eager, et la migration l'ajoute aux composants existants pour qu'ils gardent leur comportement.
L'observabilité, c'est pouvoir comprendre ce qui se passe en production sans être sur la machine : des logs, des métriques et des traces. Côté front : un outil de suivi d'erreurs (Sentry, ou Datadog, New Relic) branché sur un ErrorHandler global, pour savoir quelle erreur touche combien d'utilisateurs ; la mesure de la performance réelle (les Core Web Vitals des vrais visiteurs, via un outil de RUM ou les rapports de Google) ; et en local, Lighthouse, l'onglet Performance de Chrome et le profileur d'Angular DevTools. Le point à ne pas oublier : ne pas envoyer de données personnelles dans les logs d'erreur.

Tests, Build & CI

7
Test-Driven Development : on écrit le test avant le code. Le cycle : un test qui échoue (rouge), le code minimum pour le faire passer (vert), puis on nettoie sans casser le test (refactor). Côté front, ça marche très bien pour la logique pure : un pipe, une fonction de calcul, un mapper, un service. C'est plus difficile sur l'interface, qui change souvent. Pour le mettre en place dans une équipe : commencer par un périmètre où c'est naturel (les règles métier), faire tourner les tests dans la CI à chaque merge request, et montrer l'exemple en revue de code. Sois honnête sur ta pratique : « je le fais sur la logique, pas sur chaque composant » est une très bonne réponse.
Pars de ce que tu as vraiment fait sur ton dernier projet, puis structure. Tests unitaires sur ce qui contient de la logique : services, stores, pipes, mappers, gardes. Tests de composants pour les interactions qui comptent (un clic, un formulaire invalide), de préférence en cherchant les éléments comme un utilisateur (par leur texte ou leur rôle) avec Testing Library. Quelques tests de bout en bout (Playwright ou Cypress) sur les parcours critiques : connexion, paiement, formulaire principal. Et dis ce que tu ne testes pas : le framework lui-même, ou un composant d'affichage sans logique.
Modern 20262026 : Vitest est le lanceur de tests par défaut des nouveaux projets depuis Angular 21 ; Karma est déprécié.
Un test unitaire vérifie un petit morceau isolé (une fonction, un service, un composant) en remplaçant ses dépendances par des faux : il tourne en millisecondes, on en a beaucoup, et quand il casse on sait exactement où. Un test end-to-end pilote un vrai navigateur sur l'application complète, comme un utilisateur : il prouve que tout fonctionne ensemble, mais il est lent, plus fragile, et quand il casse il faut chercher pourquoi. D'où la pyramide : beaucoup d'unitaires, des tests d'intégration au milieu, peu de bout en bout, réservés aux parcours qui ne doivent jamais casser.
Peu de tests, mais sur les parcours critiques. Des sélecteurs stables qui ne dépendent pas du style (voir la question suivante). Des tests indépendants : chacun prépare ses propres données et peut tourner seul, dans n'importe quel ordre. Jamais d'attente fixe (wait(5000)) : on attend une condition (un élément visible, une requête terminée), ce que Playwright et Cypress font déjà en réessayant les assertions. Un choix clair entre vrai back et réponses simulées. Et ils tournent dans la CI, avec captures d'écran ou vidéo en cas d'échec : un test E2E qu'on ne lance qu'à la main finit par ne plus être lancé du tout.
Un attribut dédié aux tests, data-cy ou data-testid : cy.get('[data-cy="submit"]'). Il ne bouge pas quand on change le style ou la structure HTML, et il dit clairement « cet élément est utilisé par un test ». À éviter : les classes CSS (.btn-primary), les sélecteurs de position (div > p:nth-child(2)) et le texte affiché si l'appli est traduite.
Modern 20262026 : la pratique s'est déplacée vers les sélecteurs accessibles, qui cherchent un élément comme un utilisateur le ferait (getByRole('button', { name: 'Envoyer' }) avec Playwright ou Testing Library). Bonus : si le test ne trouve pas le bouton par son rôle, c'est souvent qu'il y a un problème d'accessibilité.
Réponse honnête et juste : en Angular, on ne configure presque jamais Webpack à la main. C'est l'Angular CLI qui s'occupe du build : ng serve en local (serveur de dev qui recompile à chaque sauvegarde), ng build pour la production, et les réglages passent par angular.json (environnements, budgets de taille, assets). Ce que le build fait pour toi : regrouper les fichiers, minifier, supprimer le code inutilisé (tree shaking), découper en morceaux pour le chargement à la demande. On ne touche à Webpack que pour un besoin particulier, avec un builder personnalisé.
Modern 20262026 : depuis Angular 17, le builder par défaut repose sur esbuild et Vite, nettement plus rapides ; Webpack n'est plus là que dans les anciens projets.
La question est ambiguë, et le bon réflexe est de demander ce que la personne entend par là. Les deux sens les plus probables. Dans GitLab CI, le mot-clé tags d'un job indique quel runner (quelle machine) doit l'exécuter : par exemple un runner avec Docker, ou un runner interne qui a accès au réseau de l'entreprise. Et les tags Git (v2.3.0) servent souvent à déclencher une pipeline de livraison : on construit, on teste et on déploie la version taguée. Autour, tu peux rappeler l'enchaînement d'une pipeline front : installation, lint, tests, build, déploiement.

Soft skills & Lead

3
Il n'y a pas de bonne réponse, il y a une réponse honnête et cohérente avec ton CV. Dis où tu apportes le plus (par exemple : « mon cœur, c'est le front, et je suis autonome pour faire évoluer une API quand une fonctionnalité le demande »), puis donne un exemple concret. Ce que la personne vérifie, c'est que le poste te correspond : si tu dis 90 % front pour un poste annoncé full stack, mieux vaut que ce soit dit maintenant que découvert dans trois mois.
Raconte une situation réelle plutôt qu'une méthode générale : qui, sur quel projet, ce que tu as fait. Les pratiques qui parlent : un accueil préparé (un README à jour, un premier ticket simple pour livrer vite), du pair programming sur les premières fonctionnalités, des revues de code qui expliquent au lieu de juste corriger, des tickets de plus en plus autonomes, et le junior qui présente lui-même ce qu'il a fait. Termine par le résultat : ce que la personne savait faire seule au bout de quelques semaines.
C'est rarement mesuré au chiffre près, et c'est acceptable de le dire. Ce que tu peux observer : moins d'allers-retours en revue de code, des types de tickets que la personne prend seule alors qu'elle ne pouvait pas avant, moins de questions sur les mêmes sujets, le jour où elle relit le code des autres. Ajoute les retours directs (points réguliers, ce que la personne en dit). N'invente pas de pourcentage : un intervieweur creuse, et un exemple vrai vaut mieux qu'un chiffre fragile.
Lead magnet · GratuitBientôt

Le pack entretien Angular, en PDF

Les 53 questions + réponses, mises en page pour réviser hors-ligne (train, salle d'attente, veille d'entretien). Contre ton email, rien de plus.

Le pack PDF arrive très bientôt, reviens vite.

Voir les ressources