AngularAtlased. 22.2

Cap. 01Start03 / 75

Decizii rapide

„Unde pun asta?”, „Signal sau Observable?”, „Shared sau feature?” — răspunsuri scurte la întrebările de zi cu zi.

arhitectură ~0 min de citit

Întrebările pe care ți le pui de zece ori pe zi, cu răspunsul scurt și link către pagina care o explică pe larg. Caută după un cuvânt sau filtrează pe categorie.

Principiile din spatele tuturor răspunsurilor

  1. Cât mai aproape de utilizare

    Tipuri, componente și stare stau lângă codul care le folosește; le ridici abia când apare un consumator nou.

  2. O singură sursă de adevăr

    Ce se poate calcula se derivă (computed), nu se stochează.

  3. Unealta cea mai simplă care rezolvă problema

    @switch înaintea componentelor dinamice, serviciu cu semnale înaintea NgRx, duplicare înaintea abstracției greșite.

  4. Imutabilitate

    Referințe noi pentru date noi — semnalele și OnPush depind de asta.

Întrebări și răspunsuri

41 din 41 întrebări

01

Componente

7

Componenta mea e smart sau dumb?

Dacă injectează store-uri / API / Router → smart (pagină sau container). Dacă primește totul prin input și emite output → dumb. Paginile rutate sunt smart; restul, cât mai multe dumb.

Smart vs Dumb

Când o fac generică (<T>)?

Când ai deja 2–3 utilizări cu ACELAȘI comportament pe date diferite (tabel, select, listă) și API-ul nu conține termeni de domeniu. Altfel rămâne specifică.

Componente generice <T>

Când o fac dinamică?

Doar când nu știi la compilare ce componentă apare (config, CMS, plugin-uri, dashboard). Pentru 2–5 variante cunoscute folosește @switch.

Componente dinamice

input + output sau model()?

model() pentru valori „de control” (toggle, slider, tab activ). input + output când părintele trebuie să decidă/valideze sau evenimentul are semantică (save, delete).

model() — two-way binding

ng-content sau ng-template?

ng-content pentru conținut static afișat o dată. ng-template când conținutul trebuie creat lazy, repetat sau primește date (context).

Content projection

Componentă sau directivă?

Directivă dacă adaugi doar comportament unui element existent (tooltip, autofocus). Componentă dacă ai markup sau stiluri proprii.

Directive & host composition

Proiecție sau input-uri pentru conținut?

Input-uri când componenta controlează aspectul (consistență). Proiecție când părintele are nevoie de markup liber (dialoguri, carduri).

Content projection
02

Arhitectură

7

Mut componenta în shared?

Doar dacă e folosită ACUM în 2+ feature-uri, nu are termeni de domeniu, nu injectează date și se comportă la fel peste tot. Altfel stă în features/x/ui.

Shared vs feature

Interfață inline sau fișier separat?

Folosită de un singur fișier → inline. Tip de input/output → exportat din fișierul componentei. Folosită de mai multe fișiere din feature → features/x/models. Între feature-uri → API public al proprietarului.

Interfețe & modele

Fac DTO separat de model?

Da, dacă API-ul are alte convenții, nu e controlat de tine sau UI-ul are câmpuri derivate. Nu, pentru CRUD simplu cu tipuri generate deja „curate”.

Interfețe & modele

Ce pun în core?

Lucruri folosite o dată la nivel de aplicație sau infrastructură: auth, layout (shell), ErrorHandler, interceptori, servicii transversale.

Structura de foldere

Pot importa un feature din altul?

Ideal nu. Comunică prin URL, prin un store din core sau prin shared. Dacă e inevitabil: doar prin API-ul public (index.ts) al celuilalt feature.

Barrels, aliasuri & granițe

Barrel (index.ts) peste tot?

Nu. Doar la granița unui feature/librării, ca API public. În interior importă fișierele direct.

Barrels, aliasuri & granițe

Enum sau union de string-uri?

Union + obiect as const. Mai simplu, tree-shakable, ușor de iterat în template.

Interfețe & modele
03

Stare & date

7

Când folosesc effect()?

Doar pentru efecte spre exterior: localStorage, logging, librării imperative, DOM. Niciodată ca să setezi alt semnal (→ computed / linkedSignal).

effect() — când DA, când NU

Signal sau Observable?

Signal pentru stare afișată. Observable pentru fluxuri de evenimente în timp (websocket, drag, operatori complecși). Puntea: toSignal / toObservable.

Signals ↔ RxJS

Cum iau date de la server?

Citire reactivă → httpResource (sau resource / rxResource). Scriere (POST/PUT/DELETE) → HttpClient, apoi update/reload pe resursă.

resource, rxResource, httpResource

Unde țin starea?

Cât mai jos: componentă → store de feature (providers pe rută/pagină) → global (@Service în root). Filtre partajabile → URL.

State management cu signals

Am nevoie de NgRx?

De obicei nu: un serviciu cu semnale ajunge. NgRx SignalStore dacă vrei convenții/plugin-uri; NgRx Store dacă ai nevoie de log de acțiuni și time-travel.

State management cu signals
04

Template

5

Metodă, pipe sau computed în template?

computed pentru calcule specifice componentei; pipe pur pentru formatări refolosite; metodă doar pentru lucruri triviale (rulează la fiecare randare).

Pipes: când și cum

Ce pun la track în @for?

Un id stabil (track item.id). $index doar pentru liste statice. Identitatea (track item) doar dacă obiectele nu sunt recreate.

Control flow: @if, @for, @switch

ngClass sau [class]?

[class.x] / [class] — nativ, fără import, mai rapid. Migrare: ng g @angular/core:ngclass-to-class.

Class & style bindings
05

DI

5

@Service() sau @Injectable()?

Cod nou în v22: @Service() (singleton auto-provided, doar inject()). @Injectable dacă ai DI prin constructor sau suport pentru versiuni vechi.

inject() & @Service()

Unde furnizez serviciul?

Root dacă starea trebuie să supraviețuiască navigării. Rută/pagină pentru stare de feature. Componentă pentru o instanță per componentă (wizard, editor).

Providers & ierarhia de injectori

Clasă sau InjectionToken?

Clasă când ai logică/metode. InjectionToken pentru valori: config, URL-uri, funcții, plugin-uri (multi).

InjectionToken & provideX()

Interfață pentru serviciu (IUserService)?

Nu. Dacă ai nevoie de implementări multiple sau mock-uri: clasă abstractă ca token, cu @Service({ factory }) pentru implementarea implicită.

inject() & @Service()
06

Formulare & routing

6

Signal Forms sau Reactive Forms?

Formulare noi în v22 → Signal Forms. Cele existente pe Reactive rămân; migrezi treptat cu SignalFormControl / compatForm.

Signal Forms — bazele

Control custom: FormValueControl sau CVA?

FormValueControl pentru Signal Forms (un model() + input-uri opționale). ControlValueAccessor pentru Reactive / template-driven.

Controale custom de formular

Resolver sau httpResource?

Resolver pentru date mici, obligatorii. httpResource + skeleton pentru liste și dashboard-uri (navigare instant).

Guards & resolvers

canMatch sau canActivate?

canMatch pentru zone restricționate (nu descarcă chunk-ul). canActivate pentru verificări la intrare pe o rută care există pentru toți.

Guards & resolvers

Rută separată sau stare în pagină?

Rută dacă ecranul trebuie să aibă link propriu (partajabil, back button). Stare locală pentru dialoguri, dropdown-uri, pași efemeri.

Routing modern & lazy loading

Cum citesc parametrii de rută?

withComponentInputBinding() + input() în componenta rutată. Fără ActivatedRoute și subscribe.

Routing modern & lazy loading
07

Calitate

4

De ce nu se actualizează UI-ul?

Aproape sigur: un câmp simplu modificat asincron (setTimeout, subscribe) într-o aplicație zoneless/OnPush, sau un obiect mutat. Treci pe semnale și update-uri imutabile.

Change detection

Unde tratez erorile?

Previzibile → local (resource.error()). Transversale (401/500) → interceptor. Randare a unei zone → @boundary. Restul → ErrorHandler global.

Erori: @boundary & ErrorHandler

Ce testez și cum?

Store-uri și mapperi: unitar, fără DOM. Componente dumb: createComponent + bindings. Pagini: store fals + HttpTestingController. Fluxuri: e2e.

Testare cu Vitest

Componente proprii accesibile?

Construiește-le peste Angular Aria (headless): tastatură, focus și ARIA corecte, stilul e al tău.

Angular Aria

Cap. 01 · 0 din 4 terminate

Ai terminat lecția?

Marcheaz-o și apare pe harta ta: în cuprins și pe prima pagină.

Se marchează singură după ce citești toată lecția.

  1. Ce e nou în Angular 21 & 22
  2. Prima ta aplicație, pas cu pas
  3. Decizii rapide
  4. Întrebări de interviu Angular
Vezi toată harta ta

Toate cele 75 de pagini · scrie ca să filtrezi

  • 01Ce e nou în Angular 21 & 22Toate schimbările importante din v21 și v22, pe scurt, cu link către pagina care le explică.Start
  • 01Prima ta aplicație, pas cu pasO listă de lecturi construită de la o componentă goală la o aplicație terminată — signals, @for, input-uri și output-uri, un serviciu și un formular, pas cu pas.Start
  • 01Decizii rapide„Unde pun asta?”, „Signal sau Observable?”, „Shared sau feature?” — răspunsuri scurte la întrebările de zi cu zi.Start
  • 01Întrebări de interviu Angular60 de întrebări reale de interviu pentru junior, mid și senior, cu răspunsul de dat, întrebarea care urmează și greșelile de evitat. Plus o simulare de interviu.Start
  • 02Standalone & bootstrapCum pornește o aplicație fără NgModule: bootstrapApplication, app.config.ts, imports în componentă.Fundamente moderne
  • 02Data binding și evenimenteInterpolare, binding pe proprietăți și pe atribute, evenimente cu $event și filtre de taste și cum e construit [( )] — ce intră în DOM și ce se întoarce.Fundamente moderne
  • 02Control flow: @if, @for, @switchSintaxa de blocuri care înlocuiește *ngIf/*ngFor/ngSwitch, cu track, @empty și verificare exhaustivă.Fundamente moderne
  • 02@let și expresiile noi din templateVariabile locale cu @let, arrow functions, spread, regex, instanceof, comentarii în tag-uri.Fundamente moderne
  • 02@defer — lazy loading în templateÎncarci componente grele doar când e nevoie: triggere, prefetch, placeholder, loading, error.Fundamente moderne
  • 02Class & style bindingsDe ce [class.x] și [style.x] au înlocuit ngClass și ngStyle (cu migrare automată din v21).Fundamente moderne
  • 02Stilurile componentelor și încapsularea:host, cele trei moduri de încapsulare, teme cu variabile CSS și de ce ::ng-deep e ultima soluție.Fundamente moderne
  • 02Pipes: când și cumPipe pur vs impur, pipe custom și cum alegi între pipe, computed() și o metodă.Fundamente moderne
  • 03signal() și computed()Primitivele reactive: stare scriibilă, stare derivată, egalitate, untracked și reguli de imutabilitate.Signals & reactivitate
  • 03effect() — când DA, când NUEfecte secundare sincronizate cu semnale: localStorage, logging, API-uri imperative. Și capcanele lor.Signals & reactivitate
  • 03linkedSignal() — stare derivată editabilăUn semnal care se resetează când se schimbă sursa, dar pe care îl poți și seta manual.Signals & reactivitate
  • 03resource, rxResource, httpResourceDate asincrone ca semnale: status, value, error, reload, anulare automată. Stabile din v22.Signals & reactivitate
  • 03debounced() — semnale cu întârziereVarianta „debounce” a unui semnal, fără RxJS. Perfect pentru căutare.Signals & reactivitate
  • 03Liste: căutare, filtrare, sortare, paginareUn lanț de computed-uri care recalculează doar ce s-a schimbat, cu filtrele ținute în URL, ca un link să redeschidă aceeași vedere.Signals & reactivitate
  • 03Observables de la zeroCe e un Observable, subscribe și unsubscribe, operatorii pe care îi folosești în fiecare săptămână, cold vs hot — și când ajunge un signal.Signals & reactivitate
  • 03Signals ↔ RxJStoSignal, toObservable, takeUntilDestroyed, outputFromObservable — și când RxJS rămâne alegerea bună.Signals & reactivitate
  • 04input() și output()Inputuri ca semnale (required, transform, alias) și outputuri tipizate. Data down, events up.Componente: comunicare
  • 04model() — two-way bindingBanana-in-a-box [( )] cu un singur API. Când îl folosești și când e mai bine input + output.Componente: comunicare
  • 04viewChild & contentChildInterogări ca semnale: viewChild, viewChildren, contentChild, contentChildren, opțiunea read.Componente: comunicare
  • 04Lifecycle & DestroyRefCe hook-uri mai contează în era signals, afterNextRender, DestroyRef și ngOnChanges tipizat.Componente: comunicare
  • 04Content projectionng-content cu select, sloturi multiple, conținut implicit și capcana proiecției condiționale.Componente: comunicare
  • 04ng-template & ngTemplateOutletTemplate-uri ca valori: render props în Angular, context tipizat și personalizare de componente.Componente: comunicare
  • 05Smart vs DumbContainer vs presentational: cine ține starea, cine doar afișează, și cum le împarți corect.Design de componente
  • 05Componente generice <T>Un DataTable<T> sau Select<T> tipizat corect, cu template-uri pentru celule.Design de componente
  • 05Componente dinamiceNgComponentOutlet, createComponent cu inputBinding/outputBinding și un dashboard construit din config.Design de componente
  • 05Directive & host compositionDirective atribut, metadata host: {} și Directive Composition API (hostDirectives).Design de componente
  • 05Controale custom de formularFormValueControl (Signal Forms) vs ControlValueAccessor: un rating cu stele, în ambele variante.Design de componente
  • 05Change detectionOnPush e implicit din v22, zone.js lipsește din v21. Ce declanșează randarea și cum să nu te arzi.Design de componente
  • 06inject() & @Service()Noul decorator @Service() din v22, inject() vs constructor și contextul de injecție.Dependency Injection
  • 06Providers & ierarhia de injectoriRoot vs rută vs componentă, useClass/useValue/useFactory/useExisting și modificatorii optional/self/skipSelf.Dependency Injection
  • 06InjectionToken & provideX()Configurare tipizată, funcții provideFeature(), makeEnvironmentProviders și inițializatori.Dependency Injection
  • 06injectAsync() — servicii lazyÎncarci un serviciu greu abia când ai nevoie de el, cu prefetch la idle.Dependency Injection
  • 07Structura de folderecore / shared / features, ce intră în fiecare și cum arată un feature pe dinăuntru.Arhitectura aplicației
  • 07Shared vs featureCând muți o componentă în shared și (mai ales) când NU. Checklist concret.Arhitectura aplicației
  • 07Interfețe & modeleInterfață inline sau fișier separat? DTO vs model de domeniu, type vs interface, unde le pui.Arhitectura aplicației
  • 07State management cu signalsStore-uri simple pe semnale, facade, stare locală vs globală și când îți trebuie NgRx.Arhitectura aplicației
  • 07Style guide & namingConvențiile oficiale actuale: nume de fișiere fără sufixe, protected, readonly, ordinea membrilor.Arhitectura aplicației
  • 07Barrels, aliasuri & granițeindex.ts, path aliases, API public pe feature și reguli de dependență care se pot verifica automat.Arhitectura aplicației
  • 07Erori: @boundary & ErrorHandlerNoul bloc @boundary din v22.2, ErrorHandler global, erori HTTP și erori din resource.Arhitectura aplicației
  • 08Routing modern & lazy loadingloadComponent, rute copil, parametri ca input-uri și moștenirea parametrilor (default nou în v22).Routing
  • 08Guards & resolverscanActivate, canMatch, canDeactivate și resolve ca funcții, cu redirect prin UrlTree / RedirectCommand.Routing
  • 09Signal Forms — bazeleFormulare construite pe semnale: form(), [formField], validare prin schemă. Stabile din v22.Formulare
  • 09Signal Forms — avansatValidare custom și cross-field, async/HTTP cu debounce, liste dinamice, disabled/hidden, scheme reutilizabile.Formulare
  • 09Reactive Forms tipizateFormGroup tipizat, nonNullable, FormArray — și cum conviețuiesc cu Signal Forms.Formulare
  • 10HttpClient, interceptors & API layerHttpClient fără setup (v21), Fetch implicit (v22), interceptori funcționali și stratul de API cu mapare DTO.HTTP & date
  • 11Performanță — checklistCe chiar contează: OnPush + signals, track, @defer, lazy routes, imagini, bundle și hidratare.Calitate & performanță
  • 11Testare cu VitestVitest e runner-ul implicit din v21. TestBed, componente cu semnale, servicii, HTTP și harness-uri.Calitate & performanță
  • 11DevTools: cum te uiți în aplicațieChrome DevTools și Angular DevTools pas cu pas: ce arată fiecare panou, cu exerciții care merg chiar pe site-ul ăsta.Calitate & performanță
  • 11Angular AriaComponente headless, accesibile, pe care le stilizezi cum vrei: tabs, accordion, menu, listbox...Calitate & performanță
  • 12SSR, prerender & render modesCând randezi pe server, când la build și când doar în browser: RenderMode pe rută, app.routes.server.ts și costurile reale.SSR & hidratare
  • 12Hidratare: event replay & incrementalCum preia browserul HTML-ul de pe server fără să-l refacă: hidratare completă, event replay, @defer (hydrate on …) și erorile de nepotrivire.SSR & hidratare
  • 12Cod compatibil cu serverulwindow nu există pe server: PLATFORM_ID, afterNextRender, DOCUMENT, TransferState, cache-ul HTTP și PendingTasks.SSR & hidratare
  • 13Micro frontendsCând merită să spargi o aplicație în mai multe deploy-uri și când e doar complexitate: Native Federation, Module Federation, iframes, Web Components.Arhitectură la scară
  • 13Web Components cu Angular ElementscreateCustomElement: o componentă Angular folosită ca tag HTML oriunde, plus comunicarea între aplicații prin evenimente și BroadcastChannel.Arhitectură la scară
  • 13Monorepo, librării & granițeUn workspace cu mai multe aplicații și librării: ng generate library, Nx, entry points secundare, publicare și reguli de dependență.Arhitectură la scară
  • 13Arhitectură hexagonală (ports & adapters)Domeniul fără Angular, porturi ca clase abstracte și adaptoare interschimbabile: HTTP, localStorage sau in-memory, fără să atingi UI-ul.Arhitectură la scară
  • 14Semnalele pe dinăuntruGraful reactiv: producători și consumatori, push-pull, de ce computed e lazy și glitch-free, problema diamantului și când rulează efectele.Reactivitate avansată
  • 14RxJS avansat: operatori de ordin superiorswitchMap, mergeMap, concatMap și exhaustMap pe o diagramă live, plus retry cu backoff, shareReplay și cum eviți scurgerile.Reactivitate avansată
  • 14NgRx SignalStoreState management la scară pe semnale: withState, withComputed, withMethods, rxMethod, entități și hooks — și când un store simplu e suficient.Reactivitate avansată
  • 14Mașini de stări cu signalsFără stări imposibile: o mașină tipizată pe signals, cu tranziții, guards și diagrama stărilor, live.Reactivitate avansată
  • 15WebSockets: timp real care rezistă rețeleiUn socket tipizat ca signals: reconectare cu backoff și jitter, heartbeat, coadă de mesaje cât ești offline și siguranță la SSR.Timp real și offline
  • 15Actualizări optimiste și rollbackInterfață instantanee, dar onestă: snapshot și rollback, răspunsuri sosite în altă ordine, chei de idempotență.Timp real și offline
  • 15Offline-first: Service Worker și cacheService Worker-ul Angular: strategii de cache, anunțarea versiunilor noi și o coadă pentru modificările făcute offline.Timp real și offline
  • 16Web WorkersCalcule grele fără să blochezi interfața: un worker real în pagină, comunicare prin mesaje și când nu merită.UI & performanță avansată
  • 16Liste uriașe: virtual scroll100.000 de rânduri fără lag: CDK virtual scroll, itemSize, trackBy și alternativele (paginare, infinite scroll).UI & performanță avansată
  • 16Animații moderne & View Transitionsanimate.enter și animate.leave în locul @angular/animations (depreciat), tranziții CSS și View Transitions la navigare.UI & performanță avansată
  • 16Memory leaks: cum le găsești și le repariSubscripții, timere și listeneri care trăiesc mai mult decât componenta lor — cum îi vezi în DevTools și cum îi închizi.UI & performanță avansată
  • 17Securitate: XSS, sanitizare & CSPCe face Angular automat împotriva XSS, când devine periculos bypassSecurityTrust, plus CSP cu nonce, Trusted Types și XSRF.Securitate & globalizare
  • 17Autentificare: token-uri & refreshUn interceptor care atașează token-ul, reîmprospătează o singură dată la 401 și reia cererile din coadă — plus unde ții token-ul.Securitate & globalizare
  • 17OAuth 2.1 și OpenID Connect cu PKCEFluxul authorization code cu PKCE, pas cu pas: verifier și challenge, state și nonce, ID token-ul și de ce un BFF e mai sigur.Securitate & globalizare
  • 17Internaționalizare (i18n)$localize, atributul i18n, ICU plural/select, build per limbă vs. traduceri la runtime și formatarea după locale.Securitate & globalizare