Fondamentaux JS/TS
6async/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.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 ».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.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).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.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@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.input() et output() plutôt que @Input() et @Output().app-product-card (dumb). Ne sois pas dogmatique : un petit composant autonome qui fait les deux, c'est parfois très bien.input() et output(), et OnPush par défaut depuis Angular 22, les composants d'affichage sont encore plus simples à écrire.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.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.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.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.@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.inject(UserService) plutôt que par le constructeur, et son état s'expose volontiers en signals.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.InjectionToken.inject() a remplacé l'injection par constructeur dans la plupart des projets.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.{{ 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].model() permet d'offrir un [(valeur)] sans écrire l'entrée et la sortie à la main.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.*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].@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.[class] et [style] plutôt que NgClass et NgStyle, et une migration automatique existe.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.host du décorateur plutôt qu'avec @HostListener et @HostBinding.{{ 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.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.withComponentInputBinding(), les paramètres de route arrivent directement dans les input() du composant.<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).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)).@defer applique la même idée à un morceau de template (un graphique en bas de page, chargé quand il devient visible).RxJS & Signals
6complete) 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.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.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))).toSignal() ; RxJS reste le bon outil pour les flux d'événements.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.signal() privé, exposé avec asReadonly(), et des computed() pour les valeurs dérivées (le nombre d'articles, le total).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.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
10BehaviorSubject) 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).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.httpResource() relance la requête tout seul et est stable depuis Angular 22.fetch, localStorage, la géolocalisation. Une bonne API est stable et documentée, et quand elle change, elle prévient (versions).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.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.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.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.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.Performance & Observabilité
2async é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.Eager, et la migration l'ajoute aux composants existants pour qu'ils gardent leur comportement.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
7wait(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.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.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é.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é.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.