...
Pregătire interviuri

100 de întrebări de interviu Angular, cu răspunsuri

Întrebările despre Angular care apar des la interviurile tehnice, fiecare cu un răspuns scurt, explicația pe larg și ce urmărește intervievatorul. Citește-le sau exersează cu răspunsurile ascunse. Înveți de la zero cu Curs Angular: primele 15 lecții sunt gratuite.

Pagină coordonată de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

  • 100întrebări
  • 50junior
  • 35mid
  • 15senior
  • 138 minde citit
Întrebări de interviu Angular cu răspunsuri

La un interviu în care se verifică Angular, primele întrebări sunt de obicei despre fundamente: ce este o componentă standalone, cum funcționează binding-ul în template, ce sunt signals, cum se trimit datele între componente și ce face dependency injection. Urmează aproape mereu cod: ți se arată o componentă și ți se cere să spui de ce nu se actualizează ecranul sau unde e bug-ul, ori scrii live o listă, un formular reactiv sau o căutare care cheamă un API. Multe firme dau și o temă pentru acasă, o mică aplicație Angular cu rutare, formulare și HttpClient, pe care o discutați apoi împreună.

Diferența dintre junior și mid se vede în detalii. De la un junior se așteaptă să scrie corect componente cu input() și output(), să folosească @if, @for și signals, să facă un formular cu validare și să consume un API printr-un serviciu. De la un mid se așteaptă să explice când se verifică o componentă OnPush sau zoneless, să aleagă între switchMap, concatMap și exhaustMap, să înțeleagă ierarhia injectorilor și să scrie teste cu TestBed. Întrebările senior ating arhitectura: SSR și hidratare, organizarea unei aplicații mari, migrarea de la NgModule și zone.js la API-urile moderne.

Întrebările sunt grupate pe teme și ordonate de la junior la senior. Citește întâi răspunsul scurt și încearcă să-l spui cu voce tare, apoi compară cu explicația detaliată. Pentru întrebările cu cod, creează un proiect cu Angular CLI și rulează exemplele: un bug pe care l-ai reprodus singur îl recunoști mult mai ușor la interviu. Exemplele folosesc Angular modern (componente standalone, signals, control flow, aplicații zoneless), iar acolo unde comportamentul depinde de versiune, versiunea este menționată explicit.

Componente și template-uri

1 Junior

Ce este Angular și prin ce diferă un framework de o bibliotecă precum React?

Răspuns scurt: Angular este un framework complet de la Google pentru aplicații web din componente, scris în TypeScript. Spre deosebire de o bibliotecă, vine cu rutare, formulare, HTTP, DI, testare și CLI incluse și impune o structură.

O bibliotecă rezolvă o problemă, iar tu decizi cum o combini cu altele. React se ocupă de randarea interfeței; pentru rutare, formulare, cereri HTTP sau stare globală alegi singur pachete separate. Un framework îți dă scheletul și te cheamă el pe tine (inversiunea controlului): Angular creează componentele, le injectează dependențele, decide când actualizează ecranul.

Ce primești „din cutie” în Angular:

  • componente, directive și pipes, cu un compilator propriu pentru template-uri;
  • dependency injection, mecanismul prin care clasele își primesc serviciile;
  • @angular/router, @angular/forms (reactive și template-driven), HttpClient;
  • signals pentru reactivitate și integrare cu RxJS;
  • Angular CLI (ng new, ng generate, ng build, ng test, ng update), SSR, testare.

Avantajul: proiectele Angular seamănă mult între ele, așa că un developer nou se orientează repede, iar actualizările vin coordonat, cu migrări automate prin ng update. Dezavantajul: mai multe concepte de învățat la început și mai puține alegeri libere.

TypeScript
import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  template: `<h1>Salut, Angular!</h1>`,
})
export class App {}

Atenție la confuzia cu AngularJS (versiunea 1.x, JavaScript, scoasă din suport): Angular modern, de la versiunea 2 încoace, este alt framework, rescris complet.

Ce urmărește intervievatorul: Verifică dacă înțelegi ce aduce framework-ul și de ce echipele îl aleg. Greșeala tipică este confuzia dintre Angular și AngularJS.

2 Junior

Ce înseamnă o componentă standalone și ce rol aveau NgModule-urile în versiunile vechi?

Răspuns scurt: O componentă standalone își declară singură dependențele în imports, fără un NgModule. Standalone a apărut în v14, e stabil din v15 și implicit din v19; NgModule-urile încă funcționează, dar aplicațiile noi nu mai au nevoie de ele.

Până la v14, fiecare componentă trebuia declarată într-un NgModule, iar modulul spunea ce alte module sunt disponibile în template-urile lui:

TypeScript
@NgModule({
  declarations: [ListaProduse, CardProdus],
  imports: [CommonModule, RouterModule],
  exports: [ListaProduse],
})
export class ProduseModule {}

Problema: ca să afli ce poate folosi o componentă, trebuia să cauți modulul în care e declarată. Modulele mari ascundeau dependențe, iar erorile de tip „is not a known element” erau frecvente.

Cu standalone, componenta își spune singură ce folosește:

TypeScript
@Component({
  selector: 'app-lista-produse',
  imports: [CardProdus, CurrencyPipe, RouterLink],
  template: `...`,
})
export class ListaProduse {}

Istoric: v14 developer preview, v15 stabil, iar din v19 standalone: true este valoarea implicită, deci nu se mai scrie. Aplicația pornește cu bootstrapApplication(App, appConfig), iar serviciile globale se configurează în app.config.ts cu funcții provide...(), nu în AppModule.

La interviu e bine să știi și partea veche: în multe proiecte existente vei găsi module, forRoot()/forChild() și lazy loading pe module. Migrarea se face cu schematic-ul ng generate @angular/core:standalone, care convertește pe etape.

Ce urmărește intervievatorul: Verifică dacă știi și istoria, nu doar sintaxa nouă, pentru că mulți lucrează pe cod cu NgModule. Candidații uită adesea că din v19 standalone: true nu mai trebuie scris.

Eroarea, în practică:NG0304: 'app-card' is not a known elementComponent imported from "App" is not standalone

3 Junior

Explică cele patru forme de data binding din Angular: {{ }}, [ ], ( ) și [( )].

Răspuns scurt: Interpolarea {{ }} afișează text, property binding [prop] trimite o valoare spre o proprietate DOM sau un input, event binding (eveniment) ascultă evenimente, iar [(x)] combină primele două pentru legătură în ambele sensuri.

Direcția datelor este cheia:

  • interpolare {{ expresie }}: din clasă în template, ca text;
  • property binding [proprietate]="expresie": din clasă spre o proprietate a elementului DOM sau spre un input al unei componente;
  • event binding (eveniment)="instructiune": din template spre clasă;
  • two-way binding [(valoare)]: ambele sensuri, numit și „banana in a box”.
TypeScript
@Component({
  selector: 'app-root',
  imports: [FormsModule],
  template: `
    <h1>{{ titlu() }}</h1>
    <img [src]="poza()" [alt]="titlu()">
    <button [disabled]="trimis()" (click)="trimite()">Trimite</button>
    <input [(ngModel)]="nume">
    <p>Salut, {{ nume }}</p>
  `,
})
export class App {
  titlu = signal('Produs');
  poza = signal('/img/p.png');
  trimis = signal(false);
  nume = '';
  trimite() { this.trimis.set(true); }
}

Două detalii care apar la interviu. Property binding lucrează cu proprietăți DOM, nu cu atribute HTML. Pentru atribute fără proprietate corespondentă (de exemplu aria-label pe unele elemente sau colspan) folosești [attr.aria-label]. Apoi, [(x)] este doar zahăr sintactic pentru [x]="v" (xChange)="v = $event"; de aceea funcționează cu orice componentă care are un input x și un output xChange (sau un model()).

Interpolarea convertește rezultatul în șir și îl inserează ca text, deci HTML-ul din valoare este afișat literal, nu interpretat.

Ce urmărește intervievatorul: Verifică modelul mental al direcției datelor. Greșeala tipică este confuzia dintre atribut și proprietate DOM sau scrierea [src]="'{{ url }}'".

Eroarea, în practică:Can't bind to 'colspan' (known property of 'td')NG0303: Can't bind to 'nume' (property of app-card)

4 Junior

Ce aduce control flow-ul @if, @for, @switch față de *ngIf și *ngFor? Din ce versiune îl poți folosi?

Răspuns scurt: Este sintaxă integrată în compilator, fără import de directive, cu @else, @empty și track obligatoriu. A apărut în v17 (developer preview), e stabil din v18, iar *ngIf, *ngFor și *ngSwitch sunt marcate depreciate din v20.

Varianta veche folosea directive structurale din CommonModule:

HTML
<p *ngIf="useri.length > 0; else gol">{{ useri.length }} utilizatori</p>
<ng-template #gol><p>Niciun utilizator</p></ng-template>
<li *ngFor="let u of useri; trackBy: dupaId">{{ u.nume }}</li>

Varianta nouă:

HTML
@if (useri().length > 0) {
  <p>{{ useri().length }} utilizatori</p>
} @else {
  <p>Niciun utilizator</p>
}

@for (u of useri(); track u.id) {
  <li>{{ u.nume }}</li>
} @empty {
  <li>Lista este goală</li>
}

@switch (rol()) {
  @case ('admin') { <app-panou-admin /> }
  @default { <app-panou-user /> }
}

Avantaje concrete:

  • nu mai imporți NgIf/NgFor; compilatorul înțelege blocurile direct;
  • @else if și @empty fără ng-template separat;
  • track este obligatoriu, deci nu mai uiți optimizarea listelor;
  • verificarea de tipuri e mai bună (narrowing în @if, @switch cu verificare exhaustivă din versiunile recente);
  • performanță mai bună la @for, datorită unui algoritm de diff nou.

@if (user(); as u) păstrează rezultatul într-o variabilă locală, util cu valori care pot fi null. Proiectele vechi se convertesc automat cu ng generate @angular/core:control-flow.

Ce urmărește intervievatorul: Verifică dacă ești la zi cu sintaxa modernă, dar poți citi și codul vechi. Mulți candidați nu știu că track este obligatoriu în @for.

Eroarea, în practică:@for loop must have a "track" expressionUnrecognized block @iff

5 Junior

Ce face track în @for, de ce e obligatoriu și ce variabile implicite oferă blocul?

Răspuns scurt: track îi spune lui Angular cum identifică fiecare element, ca la schimbarea listei să mute, să adauge sau să șteargă doar nodurile DOM afectate. Blocul oferă $index, $first, $last, $even, $odd și $count.

Când un signal cu o listă primește o valoare nouă, Angular compară lista veche cu cea nouă. Fără identitate, ar trebui să distrugă și să recreeze tot DOM-ul, pierzând focusul din inputuri, starea componentelor copil și animațiile. Cu track, elementele cu aceeași cheie își păstrează nodul DOM.

HTML
@for (p of produse(); track p.id; let i = $index, ultim = $last) {
  <li [class.ultim]="ultim">{{ i + 1 }}. {{ p.nume }}</li>
} @empty {
  <li>Nu există produse.</li>
}

Ce alegi drept cheie:

  • un id stabil și unic din date (p.id), varianta corectă aproape mereu;
  • $index doar pentru liste statice care nu se reordonează și nu au stare internă; la ștergerea primului element, fiecare nod ar primi datele vecinului;
  • track p (identitatea obiectului) funcționează doar dacă păstrezi aceleași referințe; dacă reîncarci datele de la server, fiecare obiect e nou și tot DOM-ul se recreează.

Angular avertizează în consolă, în modul de dezvoltare, când găsește chei duplicate, pentru că atunci reconcilierea devine imprevizibilă.

Comparativ cu *ngFor, unde trackBy era opțional și primea o funcție, track primește direct o expresie și nu poate lipsi. Variabilele implicite se pot folosi direct ($index) sau cu alias prin let, util în @for-uri imbricate, unde $index se referă la bucla cea mai apropiată.

Ce urmărește intervievatorul: Verifică dacă înțelegi reconcilierea listelor, nu doar sintaxa. Greșeala tipică este track $index pe o listă din care se șterg elemente.

Eroarea, în practică:@for loop must have a "track" expressionNG0955: track expression resulted in duplicated keys

6 Junior

Ce poți și ce nu poți scrie într-o expresie de template Angular?

Răspuns scurt: Poți citi proprietăți și signals, apela metode, folosi operatori, pipes, ?. și ??. Nu poți face atribuiri în interpolare, nu poți folosi new, ++ sau variabile globale ca window și Math, care nu sunt în contextul componentei.

Expresiile din template sunt evaluate în contextul componentei: vezi doar membrii clasei, variabilele de template (#ref, @let, variabilele din @for) și $event în handler-e. De aceea {{ Math.round(pret) }} dă eroare de compilare; soluția este să expui ce îți trebuie în clasă sau să folosești un pipe.

TypeScript
@Component({
  selector: 'app-cos',
  imports: [DecimalPipe],
  template: `
    <p>{{ produs()?.nume ?? 'Fără nume' }}</p>
    <p>{{ total() | number: '1.2-2' }} lei</p>
    <p>{{ esteGol() ? 'Coș gol' : nrProduse() + ' produse' }}</p>
    <button (click)="cantitate.set(cantitate() + 1)">+</button>
  `,
})
export class Cos {
  produs = signal<{ nume: string } | null>(null);
  cantitate = signal(1);
  total = computed(() => this.cantitate() * 49.9);
  nrProduse = computed(() => this.cantitate());
  esteGol = computed(() => this.cantitate() === 0);
}

Reguli de reținut:

  • în handler-ele de evenimente poți apela metode și seta signals; în interpolări și property binding nu poți face atribuiri;
  • nu există new, ++, --, operatori pe biți;
  • versiunile recente au extins sintaxa: typeof (v19), template literals fără tag (v19.2), operatorii **, in și void (v20).

Recomandarea practică: expresiile rămân scurte. Logica de business stă în clasă, în computed sau într-un pipe pur, pentru că expresiile sunt reevaluate la fiecare verificare a componentei și sunt greu de testat.

Ce urmărește intervievatorul: Verifică dacă știi contextul de evaluare al template-ului. Mulți candidați încearcă Math, JSON sau console.log direct în template.

Eroarea, în practică:Parser Error: Unexpected tokenBindings cannot contain assignments

7 Junior

Cum aplici dinamic clase și stiluri? Mai ai nevoie de NgClass și NgStyle?

Răspuns scurt: Folosești [class.nume]="conditie", [class]="obiect", [style.prop] și [style.width.px]. Binding-ul nativ pe class și style acoperă aproape tot ce făceau NgClass și NgStyle, iar documentația îl recomandă în locul lor.

Variante pentru clase:

HTML
<li [class.activ]="selectat()">Unul</li>
<li [class]="{ activ: selectat(), dezactivat: blocat() }">Obiect</li>
<li [class]="['card', tema()]">Tablou</li>
<li class="card" [class.eroare]="areEroare()">Combinat</li>

Variante pentru stiluri:

HTML
<div [style.width.px]="latime()"></div>
<div [style.background-color]="culoare()"></div>
<div [style]="{ 'font-size': marime() + 'px', color: 'red' }"></div>

Sufixul de unitate (.px, .%, .rem) evită concatenarea manuală. Atributul static class="card" și binding-ul dinamic se combină: Angular adaugă și scoate doar clasele gestionate de binding, fără să le șteargă pe cele statice.

NgClass și NgStyle încă există și le vei găsi în cod vechi, dar binding-ul nativ nu cere import și este mai simplu. Diferența mai subtilă: cu [class]="obiect", dacă modifici obiectul pe loc (mutație), Angular nu observă schimbarea; trebuie să creezi un obiect nou. De aceea e comod să calculezi obiectul într-un computed.

Când componenta trebuie să-și stilizeze propriul element gazdă (de exemplu <app-card class="evidentiat"> controlat din interior), folosești proprietatea host din decorator: host: { '[class.evidentiat]': 'evidentiat()' }.

Ce urmărește intervievatorul: Verifică dacă știi variantele moderne. Greșeala tipică este concatenarea de șiruri pentru clase sau unități.

Eroarea, în practică:Can't bind to 'colspan' (known property of 'td')

8 Junior

Ce este o variabilă de referință în template (#nume) și la ce se referă ea?

Răspuns scurt: #nume creează o variabilă locală în template care indică elementul DOM, componenta de pe el sau, cu #nume="exportAs", o directivă. O folosești direct în template sau o citești în clasă cu viewChild.

Cel mai simplu caz: citești valoarea unui input fără să creezi stare în clasă.

HTML
<input #camp type="text" placeholder="Produs nou">
<button (click)="adauga(camp.value); camp.value = ''">Adaugă</button>

La ce se referă variabila:

  • pe un element HTML simplu: la elementul DOM (HTMLInputElement);
  • pe un element care este o componentă: la instanța componentei, deci poți apela metodele ei publice (#player și apoi player.porneste());
  • cu o valoare: la directiva care se exportă cu acel nume, de exemplu #f="ngForm" în formularele template-driven sau #m="ngModel" pentru un câmp;
  • pe <ng-template #sablon>: la un TemplateRef, pe care îl poți randa cu ngTemplateOutlet.

Variabila e vizibilă în tot template-ul, dar nu în interiorul altui bloc care creează propriul context în sens invers: o referință definită în @if nu se vede în afara blocului.

În clasă, aceeași referință se obține cu o interogare:

TypeScript
camp = viewChild<ElementRef<HTMLInputElement>>('camp');
focus() { this.camp()?.nativeElement.focus(); }

Atenție: accesul direct la DOM prin nativeElement ocolește Angular și nu funcționează la randarea pe server. Pentru citit valoarea unui câmp, de obicei e mai curat un formular sau un signal legat cu (input).

Ce urmărește intervievatorul: Verifică dacă știi cele trei ținte posibile ale unei referințe. Mulți candidați nu știu că pe o componentă primesc instanța, nu elementul.

Eroarea, în practică:NG8003: No directive found with exportAs 'ngForm'

9 Junior

Care sunt principalele lifecycle hooks? Ce pui în constructor și ce pui în ngOnInit?

Răspuns scurt: Ordinea principală: constructor, ngOnChanges, ngOnInit, ngAfterContentInit, ngAfterViewInit, ngOnDestroy. În constructor sau în inițializatorii de câmpuri pui doar injectarea și starea inițială; logica ce depinde de inputuri o pui în ngOnInit sau, cu signal inputs, în computed.

Ce se întâmplă pe rând:

  • constructor: clasa e creată, dependențele sunt disponibile prin inject(); inputurile clasice cu @Input() nu au încă valoare;
  • ngOnChanges: la fiecare schimbare a unui @Input() clasic, înainte de ngOnInit;
  • ngOnInit: o dată, după primele inputuri; locul tradițional pentru încărcarea datelor;
  • ngAfterContentInit / ngAfterViewInit: conținutul proiectat, respectiv view-ul propriu sunt gata; aici interogările de tip @ViewChild au valoare;
  • ngOnDestroy: curățare (abonamente, timere, listener-e).
TypeScript
export class DetaliiProdus implements OnInit, OnDestroy {
  private api = inject(ProduseApi);
  id = input.required<number>();
  private timer?: ReturnType<typeof setInterval>;

  ngOnInit() {
    this.timer = setInterval(() => console.log('verific stocul', this.id()), 5000);
  }
  ngOnDestroy() {
    clearInterval(this.timer);
  }
}

Cu Angular modern, multe hook-uri devin mai puțin necesare: ngOnChanges e înlocuit de computed și effect pe signal inputs, DestroyRef.onDestroy() sau takeUntilDestroyed() înlocuiesc adesea ngOnDestroy, iar pentru cod care trebuie să atingă DOM-ul după randare există afterNextRender() și afterEveryRender() (redenumit din afterRender în v20), care rulează doar în browser.

De ce nu în constructor: constructorul trebuie să fie ieftin și fără efecte secundare, ca testele să poată crea componenta controlat, iar inputurile clasice încă nu sunt setate acolo.

Ce urmărește intervievatorul: Verifică dacă știi ordinea hook-urilor și unde e sigur să folosești inputurile. Greșeala tipică este citirea unui @Input() în constructor.

Eroarea, în practică:NG0950: Input is required but no value is availableCannot read properties of undefined (nativeElement)

10 Junior

Cum funcționează proiecția de conținut cu <ng-content>, inclusiv cu mai multe sloturi?

Răspuns scurt: <ng-content> marchează locul în care apare conținutul pus de părinte între tagurile componentei. Cu select="..." (selector CSS) creezi mai multe sloturi; un <ng-content> fără select primește restul.

Proiecția îți permite componente de tip „ramă”: card, modal, panou, care nu știu dinainte ce conțin.

TypeScript
@Component({
  selector: 'app-card',
  template: `
    <article class="card">
      <header><ng-content select="[titlu]" /></header>
      <section><ng-content /></section>
      <footer><ng-content select="app-actiuni" /></footer>
    </article>
  `,
})
export class Card {}

Folosire:

HTML
<app-card>
  <h2 titlu>Comanda 42</h2>
  <p>Trei produse, livrare mâine.</p>
  <app-actiuni><button>Plătește</button></app-actiuni>
</app-card>

Detalii care contează:

  • select acceptă selectori CSS: tag, atribut, clasă;
  • conținutul este creat de părinte, în contextul lui: binding-urile se leagă de clasa părintelui, iar componentele proiectate sunt instanțiate chiar dacă <ng-content> ar fi într-un @if fals; nu poți „amâna” crearea conținutului proiectat cu @if;
  • <ng-content> nu poate fi repetat într-un @for ca să multiplici conținutul; pentru asta primești un TemplateRef și folosești ngTemplateOutlet;
  • din v18 poți scrie conținut implicit între <ng-content> și </ng-content>, afișat când părintele nu trimite nimic pentru acel slot.

În clasa componentei, accesezi conținutul proiectat cu contentChild() și contentChildren().

Ce urmărește intervievatorul: Verifică dacă poți construi componente reutilizabile. Puțini candidați știu că un @if în jurul lui <ng-content> nu împiedică instanțierea conținutului.

11 Junior

Ce este @let în template și când îl folosești?

Răspuns scurt: @let declară o variabilă locală, doar pentru citire, în template, de exemplu @let total = pret() * cantitate();. A apărut în v18.1 și e stabil din v19; e util ca să nu repeți o expresie sau un async pipe.

Înainte de @let, ca să refolosești rezultatul unei expresii în template aveai trucuri precum *ngIf="date$ | async as date", care ascundea și conținutul când valoarea era falsy (0, șir gol). Acum:

HTML
@let user = user$ | async;
@let nume = user?.nume ?? 'Vizitator';
@let total = pret() * cantitate();

<h2>Bun venit, {{ nume }}</h2>
<p>Total: {{ total }} lei</p>
@if (total > 500) {
  <p>Livrare gratuită pentru {{ nume }}.</p>
}

Reguli:

  • variabila este disponibilă după declarație, în blocul curent și în blocurile din interior;
  • nu o poți reatribui din template (total = 0 dă eroare);
  • este reevaluată la fiecare verificare a view-ului, ca orice expresie de template;
  • tipul este dedus automat, deci ai verificare de tipuri ca în cod.

Când nu e alegerea bună: dacă valoarea e folosită și în clasă sau are logică de business, locul ei este un computed în componentă. @let este pentru prezentare: o expresie lungă folosită de mai multe ori, rezultatul unui async pipe sau o variabilă intermediară într-un @for.

Un plus concret: un async pipe pus o singură dată într-un @let înseamnă un singur abonament, în loc de câte unul pentru fiecare apariție a expresiei.

Ce urmărește intervievatorul: Verifică dacă folosești sintaxa nouă cu discernământ. Greșeala tipică este mutarea logicii de business în template cu @let.

12 Mid

Care e diferența dintre componente, directive de atribut și directive structurale? Scrie o directivă care evidențiază elementul la hover.

Răspuns scurt: O componentă este o directivă cu template propriu. O directivă de atribut schimbă aspectul sau comportamentul unui element existent; una structurală adaugă sau scoate elemente din DOM printr-un TemplateRef.

Toate trei sunt clase marcate cu decoratori și potrivite pe elemente prin selector:

  • componentă (@Component): are template și stiluri, apare ca element nou (<app-card>);
  • directivă de atribut (@Directive, selector [appEvidentiaza]): fără template, adaugă comportament unui element;
  • directivă structurală: primește un TemplateRef și un ViewContainerRef și decide de câte ori se randează șablonul; *ngIf și *ngFor erau astfel de directive. Azi, pentru condiții și liste, folosești @if/@for, dar directivele structurale proprii au sens pentru lucruri ca „afișează doar pentru rolul X”.

Directiva de hover, cu proprietatea host, recomandată în locul lui @HostBinding/@HostListener:

TypeScript
import { Directive, input, signal } from '@angular/core';

@Directive({
  selector: '[appEvidentiaza]',
  host: {
    '(mouseenter)': 'activ.set(true)',
    '(mouseleave)': 'activ.set(false)',
    '[style.background-color]': "activ() ? culoare() : ''",
  },
})
export class Evidentiaza {
  culoare = input('yellow', { alias: 'appEvidentiaza' });
  activ = signal(false);
}
HTML
<p appEvidentiaza="lightblue">Treci cu mouse-ul</p>

Directiva se importă în imports ca orice componentă standalone. Alias-ul pe input permite sintaxa compactă, în care valoarea atributului e chiar configurarea. Avantajul față de manipularea directă a DOM-ului cu ElementRef: Angular gestionează binding-urile și funcționează corect și la randarea pe server.

O directivă poate fi aplicată și din interiorul unei componente, prin hostDirectives, ca să compui comportamente fără moștenire.

Ce urmărește intervievatorul: Verifică dacă știi ierarhia conceptelor și poți scrie o directivă reală. Mulți candidați manipulează DOM-ul direct, prin nativeElement.style.

Eroarea, în practică:NG0304: 'app-card' is not a known element

13 Mid

De ce pipe-ul de mai jos nu actualizează lista când adaugi un produs? Cum repari?

TypeScript
@Pipe({ name: 'scumpe' })
export class ScumpePipe implements PipeTransform {
  transform(lista: Produs[]): Produs[] {
    return lista.filter(p => p.pret > 100);
  }
}

// în componentă
produse: Produs[] = [];
adauga(p: Produs) { this.produse.push(p); }
HTML
@for (p of produse | scumpe; track p.id) { <li>{{ p.nume }}</li> }

Răspuns scurt: Pipe-ul este pur: Angular îl reapelează doar când referința argumentului se schimbă. push modifică același tablou, deci pipe-ul întoarce rezultatul vechi din memorie. Soluția: un tablou nou la fiecare schimbare, ideal ținut într-un signal.

Un pipe pur (implicit, pure: true) funcționează ca o funcție memoizată pe ultimul apel: dacă argumentele sunt aceleași referințe (comparație cu ===), Angular nu mai apelează transform. Asta face pipe-urile pure foarte ieftine, dar presupune date imutabile.

Reparația corectă este imutabilitatea:

TypeScript
produse = signal<Produs[]>([]);
adauga(p: Produs) {
  this.produse.update(lista => [...lista, p]);
}
HTML
@for (p of produse() | scumpe; track p.id) { <li>{{ p.nume }}</li> }

Acum fiecare adăugare produce un tablou nou, pipe-ul vede altă referință și recalculează. Bonus: într-o aplicație zoneless sau cu OnPush, signal-ul este și cel care anunță că view-ul trebuie actualizat; un push pe un câmp simplu nu ar fi declanșat deloc o actualizare.

Alternativa greșită ar fi pure: false: un pipe impur este apelat la fiecare verificare a view-ului, deci filtrarea rulează de foarte multe ori. Pipe-urile impure au sens doar pentru valori care se schimbă în afara referinței, cum face async pipe-ul, care urmărește un Observable.

În cod modern, pentru filtrare care ține de o singură componentă, un computed este adesea mai simplu decât un pipe:

TypeScript
scumpe = computed(() => this.produse().filter(p => p.pret > 100));

Pipe-ul rămâne util când aceeași transformare de prezentare se folosește în multe template-uri.

Ce urmărește intervievatorul: Verifică dacă înțelegi pipe-urile pure și imutabilitatea. Greșeala tipică este să „repari” cu pure: false, care ascunde problema și costă performanță.

Eroarea, în practică:NG8004: No pipe found with name 'lei'

14 Mid

Cum izolează Angular stilurile unei componente? Ce înseamnă ViewEncapsulation, :host și ::ng-deep?

Răspuns scurt: Implicit (Emulated), Angular adaugă atribute unice elementelor componentei și rescrie selectorii CSS, ca stilurile să nu iasă din componentă. :host țintește elementul gazdă, iar ::ng-deep, depreciat, dezactivează izolarea pentru un selector.

Cele trei moduri de ViewEncapsulation:

  • Emulated (implicit): la compilare, Angular adaugă atribute de tip _ngcontent-xyz pe elementele din template și transformă .titlu { } în .titlu[_ngcontent-xyz] { }. Stilurile nu afectează alte componente, iar stilurile globale ajung totuși în componentă;
  • ShadowDom: folosește Shadow DOM-ul real al browserului; izolare completă, dar stilurile globale (de exemplu ale unui framework CSS) nu mai intră;
  • None: stilurile devin globale; util rar, de exemplu pentru o temă.
TypeScript
@Component({
  selector: 'app-buton',
  template: `<button><ng-content /></button>`,
  styles: `
    :host { display: inline-block; }
    :host(.mare) button { font-size: 1.25rem; }
    :host-context(.tema-dark) button { background: #222; color: #fff; }
  `,
})
export class Buton {}

Elementul gazdă <app-buton> este implicit display: inline, de unde multe surprize de layout; :host { display: block } sau inline-block rezolvă.

::ng-deep aplică stilul și în componentele copil, ocolind izolarea. Este depreciat de mult timp, dar încă funcționează, pentru că nu există un înlocuitor complet. Alternative mai curate: variabile CSS (custom properties), care trec natural prin granițele componentelor, inputuri pentru variante (varianta="primar") sau stiluri globale cu un prefix clar.

Pentru stilizarea componentelor din biblioteci, variabilele CSS expuse de bibliotecă sunt calea recomandată.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum funcționează izolarea și de ce „scapă” uneori stilurile. Mulți candidați folosesc ::ng-deep peste tot, fără să știe ce face.

15 Senior

Cum creezi componente dinamic, când tipul lor se decide la rulare (de exemplu widget-uri dintr-o configurare primită de la server)?

Răspuns scurt: Folosești NgComponentOutlet în template sau ViewContainerRef.createComponent() în cod, cu setInput() ori, din v20, cu inputBinding/outputBinding. Pentru componente mari, le încarci leneș cu import() dinamic sau @defer.

Cazul tipic: un dashboard primește [{ tip: 'grafic', ... }, { tip: 'tabel', ... }] și trebuie să randeze componenta potrivită.

Varianta declarativă, cu NgComponentOutlet:

TypeScript
const WIDGETS: Record<string, Type<unknown>> = { grafic: Grafic, tabel: Tabel };

@Component({
  selector: 'app-dashboard',
  imports: [NgComponentOutlet],
  template: `
    @for (w of widgeturi(); track w.id) {
      <ng-container *ngComponentOutlet="WIDGETS[w.tip]; inputs: { config: w }" />
    }
  `,
})
export class Dashboard {
  WIDGETS = WIDGETS;
  widgeturi = input.required<WidgetConfig[]>();
}

Varianta imperativă, când ai nevoie de control (ordine, distrugere, ascultat outputuri):

TypeScript
private vcr = inject(ViewContainerRef);

async adauga(cfg: WidgetConfig) {
  const { Grafic } = await import('./grafic');
  const ref = this.vcr.createComponent(Grafic, {
    bindings: [
      inputBinding('config', () => cfg),
      outputBinding<string>('selectat', id => this.selectat.set(id)),
    ],
  });
  // înainte de v20: ref.setInput('config', cfg);
}

Puncte de discutat la nivel senior:

  • setInput sau inputBinding declanșează corect actualizarea, spre deosebire de atribuirea directă pe ref.instance, care ocolește mecanismul de inputuri;
  • componenta creată trebuie distrusă (ref.destroy() sau golirea containerului), altfel rămân abonamente;
  • maparea tip -> componentă trebuie să fie o listă albă, nu ceva luat direct din răspunsul serverului;
  • import() dinamic separă fiecare widget în propriul chunk, deci utilizatorul descarcă doar ce vede.

Ce urmărește intervievatorul: Verifică experiența cu cazuri reale de UI configurabil. Candidații slabi propun un @switch uriaș sau manipulare directă a DOM-ului.

Signals și reactivitate

16 Junior

Ce este un signal în Angular și cum îl creezi, citești și modifici?

Răspuns scurt: Un signal este un container reactiv pentru o valoare: îl creezi cu signal(valoare), îl citești apelându-l (contor()) și îl modifici cu set() sau update(). Angular știe exact ce citește fiecare signal și actualizează doar ce depinde de el.

TypeScript
import { Component, signal } from '@angular/core';

@Component({
  selector: 'app-contor',
  template: `
    <p>Valoare: {{ contor() }}</p>
    <button (click)="creste()">+1</button>
    <button (click)="contor.set(0)">Reset</button>
  `,
})
export class Contor {
  contor = signal(0);
  creste() {
    this.contor.update(v => v + 1);
  }
}

Trei operații:

  • citire: contor(). Apelul nu e un detaliu de sintaxă: în momentul citirii, Angular înregistrează cine citește (template-ul, un computed, un effect), deci știe ce trebuie actualizat la schimbare;
  • set: înlocuiește valoarea;
  • update: calculează valoarea nouă din cea veche, util pentru contoare și liste.

De ce contează: într-o aplicație zoneless (implicit pentru proiectele noi din v21), Angular nu mai „ghicește” când s-a schimbat ceva. Schimbarea unui signal citit în template este unul dintre semnalele care programează o actualizare a ecranului, doar pentru componentele afectate.

Signals au apărut în v16 (developer preview), iar signal și computed sunt stabile din v17. Tipul se deduce din valoarea inițială; pentru valori care pot lipsi, îl scrii explicit: signal<User | null>(null).

O greșeală frecventă la început: {{ contor }} fără paranteze afișează funcția, nu valoarea, iar verificarea strictă a template-urilor semnalează de obicei asta.

Ce urmărește intervievatorul: Verifică bazele reactivității moderne în Angular. Greșeala tipică este uitarea parantezelor la citire sau modificarea valorii prin atribuire directă.

Eroarea, în practică:NG8109: is a function and should be invoked

17 Junior

Ce face computed()? Ce afișează codul de mai jos și de câte ori rulează funcția din computed?

TypeScript
const pret = signal(100);
const reducere = signal(false);
const final = computed(() => {
  console.log('calculez');
  return reducere() ? pret() * 0.9 : pret();
});

console.log(final());
console.log(final());
pret.set(200);
pret.set(300);
console.log(final());

Răspuns scurt: Afișează calculez, 100, 100, calculez, 300. computed e leneș și memoizat: calculează doar când e citit și doar dacă o dependență s-a schimbat de la ultimul calcul, deci cele două set succesive produc un singur recalcul.

Un computed este un signal derivat, doar pentru citire. Trei proprietăți explică rezultatul:

  • leneș: nu calculează la creare, ci la prima citire, de unde primul calculez;
  • memoizat: a doua citire, fără schimbări, întoarce valoarea din memorie, fără log;
  • marcare, nu recalculare imediată: pret.set(200) doar marchează final ca „murdar”. Nimeni nu îl citește, deci nu se calculează. După pret.set(300), următoarea citire calculează o singură dată, cu valoarea curentă 300.

Dependențele sunt dinamice: se înregistrează doar signal-urile citite efectiv la ultima execuție. Aici sunt citite ambele. Într-un cod ca cond() ? a() : b(), cât timp cond() e adevărat, schimbarea lui b nu provoacă recalcul.

Alte reguli:

  • nu poți apela set pe un computed; dacă ai nevoie de o valoare derivată care poate fi și suprascrisă, folosești linkedSignal;
  • funcția trebuie să fie pură: fără cereri HTTP, fără scris în alte signal-uri;
  • dacă rezultatul nou este egal cu cel vechi (Object.is), consumatorii nu sunt notificați.

În componente, computed înlocuiește metodele apelate din template ({{ total() }} pe o metodă se execută la fiecare verificare, pe un computed doar la schimbare) și o mare parte din codul din ngOnChanges.

Ce urmărește intervievatorul: Verifică dacă înțelegi evaluarea leneșă și memoizarea. Candidații spun des că computed rulează la fiecare set.

Eroarea, în practică:NG0600: Writing to signals not allowed in computedNG0600: Writing to signals while rendering template

18 Junior

De ce lista de mai jos nu se actualizează pe ecran după click? Cum repari?

TypeScript
@Component({
  selector: 'app-sarcini',
  template: `
    <button (click)="adauga()">Adaugă</button>
    <p>{{ sarcini().length }} sarcini</p>
  `,
})
export class Sarcini {
  sarcini = signal<string[]>([]);
  adauga() {
    this.sarcini().push('Sarcină nouă');
  }
}

Răspuns scurt: sarcini().push() modifică tabloul pe loc, fără să treacă prin set/update, așa că signal-ul nu află nimic și nu își anunță consumatorii. Repari cu this.sarcini.update(l => [...l, 'Sarcină nouă']).

Un signal anunță schimbarea doar când îi dai o valoare nouă prin set sau update. Mai mult, compară valoarea nouă cu cea veche cu Object.is. Dacă modifici obiectul din interior, referința rămâne aceeași, deci chiar și un this.sarcini.set(this.sarcini()) după push nu ar notifica nimic.

Varianta corectă, imutabilă:

TypeScript
adauga() {
  this.sarcini.update(lista => [...lista, 'Sarcină nouă']);
}
sterge(index: number) {
  this.sarcini.update(lista => lista.filter((_, i) => i !== index));
}
bifeaza(id: number) {
  this.produse.update(lista =>
    lista.map(p => (p.id === id ? { ...p, gata: !p.gata } : p)));
}

De ce e important în special în Angular modern: într-o aplicație zoneless, notificarea signal-ului este cea care programează actualizarea ecranului. În aplicațiile vechi cu zone.js, click-ul declanșa oricum o verificare a întregului arbore, iar mutația „funcționa” din întâmplare; la migrarea spre OnPush sau zoneless, astfel de bug-uri ies la suprafață.

Dacă vrei totuși să lucrezi cu mutații (rar justificat, de exemplu un obiect foarte mare), poți crea signal-ul cu o funcție de egalitate care întoarce mereu false (equal: () => false) și apoi apelezi set cu aceeași referință. Dar imutabilitatea este standardul, pentru că face și computed, pipe-urile pure și track să funcționeze previzibil.

Ce urmărește intervievatorul: Verifică dacă înțelegi cum detectează un signal schimbarea. Este bug-ul cel mai frecvent la cei care trec la signals.

19 Junior

Ce este effect(), când îl folosești și când nu?

Răspuns scurt: effect() rulează o funcție de fiecare dată când se schimbă signal-urile citite în ea, pentru efecte secundare: salvare în localStorage, logare, sincronizare cu o bibliotecă externă. Nu îl folosești ca să calculezi alte stări; pentru asta există computed și linkedSignal.

TypeScript
@Component({ selector: 'app-setari', template: `...` })
export class Setari {
  tema = signal<'light' | 'dark'>(
    (localStorage.getItem('tema') as 'light' | 'dark') ?? 'light');

  constructor() {
    effect(() => {
      localStorage.setItem('tema', this.tema());
    });
  }
}

Cum se comportă un efect:

  • rulează cel puțin o dată, apoi la fiecare schimbare a dependențelor citite;
  • rulează asincron, programat de Angular, nu sincron la fiecare set; mai multe set succesive produc o singură execuție;
  • trebuie creat într-un context de injecție (constructor, inițializator de câmp) sau cu opțiunea injector, pentru că este legat de durata de viață a componentei sau a serviciului și se distruge automat odată cu ele;
  • primește onCleanup, pentru a anula ceva înainte de următoarea rulare (un timer, un abonament).

Anti-pattern-ul clasic:

TypeScript
// greșit: stare derivată prin effect
effect(() => this.total.set(this.pret() * this.cantitate()));
// corect
total = computed(() => this.pret() * this.cantitate());

Varianta cu efect produce o randare suplimentară, poate crea bucle și ascunde fluxul datelor. Regula din documentație: efectele sunt pentru ieșirea din lumea signals spre ceva extern.

Istoric: effect a fost developer preview până în v20, când a devenit stabil. În v19 s-a schimbat momentul execuției (efectele din componente rulează în timpul detectării schimbărilor) și a dispărut opțiunea allowSignalWrites: scrierea în signals din efecte e permisă, dar tot descurajată.

Ce urmărește intervievatorul: Verifică dacă știi unde se termină computed și unde începe effect. Greșeala tipică este folosirea efectelor ca să copiezi stare dintr-un signal în altul.

Eroarea, în practică:NG0203: effect() only in an injection contextNG0602: effect() called in a reactive context

20 Junior

Într-o aplicație zoneless, de ce textul de mai jos nu se schimbă pe ecran după 2 secunde, deși valoarea din clasă se schimbă?

TypeScript
@Component({
  selector: 'app-mesaj',
  template: `<p>{{ mesaj }}</p>`,
})
export class Mesaj {
  mesaj = 'Se încarcă...';
  constructor() {
    setTimeout(() => (this.mesaj = 'Gata!'), 2000);
  }
}

Răspuns scurt: Fără zone.js, Angular nu mai află automat că un setTimeout s-a terminat. Atribuirea unui câmp simplu nu notifică pe nimeni, deci nu se programează nicio actualizare. Soluția: mesaj = signal('Se încarcă...') și this.mesaj.set('Gata!').

Cu zone.js (modelul clasic), Angular modifica (monkey-patch) API-urile asincrone ale browserului: setTimeout, addEventListener, Promise, XHR. După orice callback asincron, pornea o verificare a întregului arbore de componente, iar câmpul schimbat apărea pe ecran.

În modul zoneless (provideZonelessChangeDetection(), stabil din v20.2 și implicit pentru aplicațiile noi din v21), Angular programează o actualizare doar când primește un semnal explicit:

  • un signal citit în template își schimbă valoarea;
  • un eveniment legat în template ((click)) a fost tratat;
  • async pipe-ul primește o valoare nouă;
  • se apelează ChangeDetectorRef.markForCheck() sau se setează un input prin setInput.

setTimeout nu e pe listă, deci câmpul se schimbă în memorie, dar ecranul rămâne la vechea valoare. Corect:

TypeScript
export class Mesaj {
  mesaj = signal('Se încarcă...');
  constructor() {
    setTimeout(() => this.mesaj.set('Gata!'), 2000);
  }
}
HTML
<p>{{ mesaj() }}</p>

Aceeași problemă apare la date venite dintr-un subscribe scris manual, din WebSocket sau din biblioteci externe. Regula practică: orice stare afișată în template stă într-un signal (sau vine printr-un async pipe).

Interesant de spus la interviu: același cod ar fi funcționat cu zone.js chiar și cu ChangeDetectionStrategy.Default, dar ar fi eșuat și acolo cu OnPush. Signals fac componenta corectă în toate modurile.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre zone.js și zoneless, care contează mult în proiectele noi. Candidații vin adesea cu obiceiuri din aplicațiile cu zone.js.

21 Mid

Ce problemă rezolvă linkedSignal? Dă un exemplu în care nici signal, nici computed nu sunt suficiente.

Răspuns scurt: linkedSignal este o stare care se recalculează automat când se schimbă sursa, dar poate fi și setată manual. E potrivit pentru o selecție care trebuie resetată când se schimbă lista de opțiuni. A apărut în v19 și e stabil din v20.

Scenariu: utilizatorul alege un produs, apoi o mărime. Când schimbă produsul, mărimea aleasă trebuie să revină la prima mărime disponibilă, dar între timp utilizatorul trebuie să poată alege liber.

  • cu computed, nu poți seta mărimea din click;
  • cu signal simplu, trebuie un effect care resetează mărimea la schimbarea produsului, adică exact anti-pattern-ul „stare copiată prin efect”.
TypeScript
produs = signal<Produs>(TRICOU);
marimi = computed(() => this.produs().marimi);

marimeAleasa = linkedSignal(() => this.marimi()[0]);

alege(m: string) {
  this.marimeAleasa.set(m);
}

Când marimi() se schimbă, marimeAleasa se recalculează; până atunci, set funcționează normal.

Forma extinsă îți dă acces la valoarea anterioară, ca să păstrezi selecția dacă încă e validă:

TypeScript
marimeAleasa = linkedSignal<string[], string>({
  source: this.marimi,
  computation: (noi, anterior) =>
    anterior && noi.includes(anterior.value) ? anterior.value : noi[0],
});

Aici, dacă mărimea M există și la noul produs, rămâne aleasă.

Alte cazuri tipice: pagina curentă care revine la 1 când se schimbă filtrul, un câmp de editare pornit din valoarea primită ca input, dar editabil local. Ultimul caz apare des: input() e doar pentru citire, iar linkedSignal(() => this.valoare()) îți dă o copie locală modificabilă care se resincronizează când părintele trimite altă valoare.

Ce urmărește intervievatorul: Verifică dacă știi instrumentul potrivit pentru starea dependentă și eviți efectele. Mulți candidați rezolvă cu effect + set.

22 Mid

Ce face untracked() și când ai nevoie de el într-un effect sau computed?

Răspuns scurt: untracked(() => ...) citește signal-uri fără să le înregistreze ca dependențe. Îl folosești când un efect trebuie să reacționeze doar la unele valori, iar pe altele doar să le citească, de exemplu un log care include utilizatorul curent, dar trebuie declanșat doar de schimbarea paginii.

Orice signal citit într-un effect sau computed devine dependență. Uneori asta e prea mult:

TypeScript
constructor() {
  effect(() => {
    const pagina = this.paginaCurenta();
    const user = untracked(() => this.user());
    this.analytics.trimite('vizualizare', { pagina, user: user?.id });
  });
}

Efectul rulează la schimbarea paginii, nu și când se actualizează profilul utilizatorului.

Un caz mai subtil: funcțiile apelate dintr-un efect pot citi signal-uri fără să vezi asta în cod. Dacă un serviciu extern citește intern zece signal-uri, efectul tău devine dependent de toate. Împachetarea apelului în untracked limitează dependențele la ce ai citit explicit:

TypeScript
effect(() => {
  const id = this.idSelectat();
  untracked(() => this.serviciu.incarca(id));
});

Tot untracked te protejează de bucle: dacă efectul citește și scrie același signal, fără untracked s-ar reprograma la nesfârșit.

În computed este rar necesar și adesea indică o problemă de design: un computed care ignoră o dependență pe care o citește poate afișa valori învechite.

Un truc des întrebat: dacă vrei ca efectul să depindă de un signal pe care nu îl folosești efectiv, îl citești pur și simplu la începutul funcției (this.reincarca();). Citirea este cea care creează dependența, nu folosirea valorii.

Ce urmărește intervievatorul: Verifică dacă înțelegi urmărirea dinamică a dependențelor. Greșeala tipică este un efect care rulează mult mai des decât trebuie, din cauza citirilor ascunse.

Eroarea, în practică:NG0602: effect() called in a reactive context

23 Mid

Cum construiești un serviciu de stare cu signals, astfel încât componentele să poată citi starea, dar să nu o poată modifica direct?

Răspuns scurt: Ții signal-ul modificabil private, expui în afară asReadonly() și valori derivate cu computed, iar modificările se fac doar prin metode ale serviciului. Așa toate schimbările trec printr-un singur loc.

TypeScript
export interface Articol { id: number; nume: string; pret: number; cantitate: number; }

@Injectable({ providedIn: 'root' })
export class CosStore {
  private readonly _articole = signal<Articol[]>([]);

  readonly articole = this._articole.asReadonly();
  readonly total = computed(() =>
    this._articole().reduce((s, a) => s + a.pret * a.cantitate, 0));
  readonly numar = computed(() =>
    this._articole().reduce((s, a) => s + a.cantitate, 0));

  adauga(p: Omit<Articol, 'cantitate'>) {
    this._articole.update(lista => {
      const existent = lista.find(a => a.id === p.id);
      return existent
        ? lista.map(a => (a.id === p.id ? { ...a, cantitate: a.cantitate + 1 } : a))
        : [...lista, { ...p, cantitate: 1 }];
    });
  }
  sterge(id: number) {
    this._articole.update(lista => lista.filter(a => a.id !== id));
  }
}

În componente:

TypeScript
export class Antet {
  cos = inject(CosStore);
}
// template: {{ cos.numar() }} produse, {{ cos.total() }} lei

De ce așa:

  • asReadonly() întoarce un Signal, fără set/update, deci compilatorul oprește modificările din afară;
  • toată logica de business stă în metode testabile, nu împrăștiată prin componente;
  • computed asigură că derivatele nu pot ieși din sincron cu sursa;
  • providedIn: 'root' face serviciul unic în aplicație.

Pentru aplicații mari, aceeași idee există ca bibliotecă (de exemplu NgRx SignalStore), cu extensii pentru efecte și entități. Pentru majoritatea aplicațiilor, un serviciu ca cel de mai sus este suficient și ușor de înțeles de orice coleg.

Ce urmărește intervievatorul: Verifică dacă știi să încapsulezi starea partajată. Candidații expun adesea signal-ul modificabil public și pierd controlul asupra schimbărilor.

24 Mid

Cum încarci date cu resource() sau httpResource()? Ce avantaje au față de un subscribe scris manual?

Răspuns scurt: httpResource(() => url) face cererea automat și o refăce când se schimbă signal-urile din URL, expunând value(), isLoading(), error() și hasValue(). resource() face același lucru pentru orice funcție cu Promise. Au apărut experimental în v19 și v19.2.

Varianta clasică cere mult cod de mână: un signal pentru date, unul pentru încărcare, unul pentru eroare, abonament, anularea cererii vechi când utilizatorul schimbă repede id-ul. Resursele fac asta declarativ:

TypeScript
@Component({
  selector: 'app-profil',
  template: `
    @if (user.isLoading()) { <p>Se încarcă...</p> }
    @else if (user.error()) { <p>Nu am putut încărca profilul.</p> }
    @else if (user.hasValue()) { <h2>{{ user.value().nume }}</h2> }
    <button (click)="id.set(id() + 1)">Următorul</button>
  `,
})
export class Profil {
  id = signal(1);
  user = httpResource<User>(() => `/api/useri/${this.id()}`);
}

Pentru surse care nu sunt HttpClient:

TypeScript
vreme = resource({
  params: () => ({ oras: this.oras() }),
  loader: ({ params, abortSignal }) =>
    fetch(`/api/vreme?oras=${params.oras}`, { signal: abortSignal }).then(r => r.json()),
});

Avantaje:

  • refacerea automată la schimbarea parametrilor, cu anularea cererii anterioare;
  • stările de încărcare și eroare vin gata făcute, ca signals;
  • reload() pentru reîncărcare manuală, iar value poate fi setată local (actualizare optimistă);
  • dacă funcția de parametri întoarce undefined, cererea nu pleacă, util când lipsește încă id-ul.

Atenție la versiune: în v19 opțiunea se numea request, redenumită params în v20. API-ul a fost marcat experimental la lansare, deci verifică statutul în versiunea proiectului. Resursele sunt gândite pentru citire; pentru POST, PUT, DELETE rămâi la HttpClient.

Ce urmărește intervievatorul: Verifică dacă știi abordarea modernă de încărcare a datelor și limitele ei. Mulți candidați nu știu că resursele sunt pentru citire, nu pentru mutații.

25 Senior

Signals sau RxJS? Cum decizi ce folosești într-o aplicație Angular modernă?

Răspuns scurt: Signals pentru stare: valori curente afișate în UI și derivate din ele. RxJS pentru evenimente în timp și orchestrare asincronă: debounce, anulare, retry, combinarea fluxurilor. La graniță folosești toSignal și toObservable.

Diferența de fond: un signal are mereu o valoare curentă și este sincron; un Observable este un flux de evenimente în timp, eventual fără valoare curentă, cu început, sfârșit și erori.

Signals se potrivesc pentru:

  • starea componentei și a serviciilor (filtre, selecții, coș, utilizator logat);
  • valori derivate (computed);
  • tot ce citește template-ul, pentru că se integrează direct cu detectarea schimbărilor.

RxJS rămâne mai bun pentru:

  • operatori de timp: debounceTime, throttleTime, interval;
  • concurență: switchMap (anulare), exhaustMap (ignoră click-uri repetate), concatMap (ordine);
  • fluxuri care chiar sunt evenimente: WebSocket, evenimentele routerului, valueChanges din formulare;
  • retry cu backoff, timeout, combinarea mai multor surse asincrone.

Un exemplu care le combină corect:

TypeScript
termen = signal('');
rezultate = toSignal(
  toObservable(this.termen).pipe(
    debounceTime(300),
    distinctUntilChanged(),
    switchMap(t => (t ? this.api.cauta(t) : of([])))
  ),
  { initialValue: [] }
);

Starea (termenul și rezultatele) e în signals, orchestrarea (debounce, anularea) în RxJS.

Ce greșeli văd în proiecte: tot codul rescris în signals, cu efecte care imită switchMap și au race conditions; sau BehaviorSubject peste tot, cu subscribe manual și dezabonări uitate. La nivel de echipă, ajută o convenție clară: serviciile expun stare ca signals, iar RxJS se folosește intern, unde aduce valoare. Tendința framework-ului merge spre signals (inputuri, interogări, resurse, Signal Forms), dar HttpClient, routerul și interceptori se bazează încă pe Observable.

Ce urmărește intervievatorul: Verifică judecata arhitecturală, nu sintaxa. Răspunsurile extreme („doar signals” sau „signals sunt inutile”) sunt semnale de alarmă.

Eroarea, în practică:x.subscribe is not a function (signal)

26 Senior

Cum funcționează signals „pe dedesubt”? Explică graful de dependențe și modelul push-pull.

Răspuns scurt: Fiecare signal este un producător, iar fiecare computed, efect sau template care îl citește devine consumator, înregistrat automat la citire. La set se propagă doar marcajul „murdar” (push), iar valorile se recalculează leneș, la citire (pull), fără stări intermediare inconsistente.

Angular ține un graf reactiv. Când un consumator rulează (un computed, un efect sau funcția care randează un template), există un „consumator activ” global. Orice signal citit în acel moment se adaugă ca muchie producător -> consumator. Așa apar dependențele dinamice: se înregistrează doar ce a fost citit efectiv la ultima rulare.

La scriere:

  • push: set crește versiunea signal-ului și marchează consumatorii (și consumatorii lor) ca posibil învechiți; nu se calculează nimic încă;
  • pull: când cineva citește un computed marcat, acesta verifică versiunile producătorilor; dacă s-au schimbat, recalculează, altfel întoarce valoarea din memorie.

Consecințe practice:

  • fără glitch-uri: într-un „diamant” (a -> b și c -> d), d nu vede niciodată b nou cu c vechi, pentru că totul se evaluează la citire, în ordine;
  • costul este proporțional cu ce se folosește: un computed necitit nu consumă nimic;
  • egalitate: dacă un computed produce o valoare egală cu cea veche, propagarea se oprește acolo;
  • un computed nu își ține consumatorii în viață: când componenta dispare, legăturile ei din graf se rup.

Pentru template-uri, consumatorul este view-ul componentei. Când un signal citit acolo se schimbă, Angular marchează doar acel view pentru actualizare, iar strămoșii doar ca „au copii de actualizat”. De aici câștigul față de modelul clasic, în care se verifica tot arborele.

Implementarea grafului e în pachetul de bază al framework-ului și e aproape de propunerea TC39 pentru signals în JavaScript, care e încă în fază de propunere.

Ce urmărește intervievatorul: Verifică înțelegerea profundă a reactivității și a costurilor ei. Un candidat senior trebuie să explice de ce nu apar valori intermediare inconsistente.

Eroarea, în practică:NG0600: Writing to signals not allowed in computed

Comunicarea între componente

Exersează capitolul cu exerciții reale: Curs Angular →
27 Junior

Cum trimiți date de la părinte la copil cu input()? Prin ce diferă de @Input()?

Răspuns scurt: Declari în copil nume = input<string>() sau input.required<string>(), iar părintele scrie <app-copil [nume]="valoare" />. Spre deosebire de @Input(), input() întoarce un signal doar pentru citire, deci poți deriva valori cu computed. E stabil din v19.

TypeScript
@Component({
  selector: 'app-card-produs',
  template: `
    <h3>{{ produs().nume }}</h3>
    <p>{{ pretAfisat() }}</p>
  `,
})
export class CardProdus {
  produs = input.required<Produs>();
  moneda = input('lei');
  pretAfisat = computed(() => `${this.produs().pret} ${this.moneda()}`);
}
HTML
<app-card-produs [produs]="p" moneda="EUR" />

Diferențe față de decorator:

  • signal: citești this.produs(); orice computed sau template care îl folosește se actualizează automat, fără ngOnChanges;
  • readonly: copilul nu poate scrie în input; dacă are nevoie de o copie editabilă, folosește linkedSignal sau model();
  • required verificat la compilare: dacă părintele uită [produs], primești eroare în template, nu undefined la rulare;
  • valoarea implicită definește tipul (input('lei') este InputSignal<string>).

Codul vechi arată așa:

TypeScript
@Input({ required: true }) produs!: Produs;
@Input() moneda = 'lei';

Atenție la input.required: valoarea nu există în constructor sau în inițializatorii de câmpuri. Citirea ei acolo aruncă o eroare (NG0950). O citești în template, în computed, în efecte sau din ngOnInit încolo.

Atributul static moneda="EUR" fără paranteze trimite șirul literal; [moneda]="m" evaluează expresia.

Ce urmărește intervievatorul: Verifică dacă folosești API-ul modern și înțelegi avantajele lui. Greșeala tipică este citirea unui input.required în constructor.

Eroarea, în practică:NG0303: Can't bind to 'nume' (property of app-card)NG0950: Input is required but no value is available

28 Junior

Cum trimite un copil evenimente spre părinte cu output()?

Răspuns scurt: Declari sterge = output<number>() și apelezi this.sterge.emit(id); părintele ascultă cu (sterge)="eliminaProdus($event)". output() înlocuiește @Output() + EventEmitter, are aceeași sintaxă în template și e stabil din v19.

TypeScript
@Component({
  selector: 'app-rand-produs',
  template: `
    <span>{{ produs().nume }}</span>
    <button (click)="sterge.emit(produs().id)">Șterge</button>
  `,
})
export class RandProdus {
  produs = input.required<Produs>();
  sterge = output<number>();
}
TypeScript
@Component({
  selector: 'app-lista',
  imports: [RandProdus],
  template: `
    @for (p of produse(); track p.id) {
      <app-rand-produs [produs]="p" (sterge)="elimina($event)" />
    }
  `,
})
export class Lista {
  produse = signal<Produs[]>([]);
  elimina(id: number) {
    this.produse.update(l => l.filter(p => p.id !== id));
  }
}

Ce trebuie să știi:

  • $event este valoarea dată lui emit;
  • copilul nu modifică datele părintelui, ci anunță intenția; părintele, care deține lista, decide; așa fluxul datelor rămâne previzibil (date în jos, evenimente în sus);
  • evenimentele Angular din output() nu fac bubbling prin DOM ca evenimentele native; doar părintele direct le primește;
  • output() întoarce un OutputEmitterRef, nu un Observable. Dacă ai nevoie să îl tratezi ca flux, există outputToObservable(), iar pentru a expune un Observable existent ca output, outputFromObservable();
  • evită numele care coincid cu evenimente native (click, change), pentru că ar asculta și evenimentul DOM care urcă din copil.

Varianta veche: @Output() sterge = new EventEmitter<number>();, cu aceeași utilizare.

Ce urmărește intervievatorul: Verifică fluxul unidirecțional al datelor și sintaxa modernă. Greșeala tipică este copilul care modifică direct lista primită ca input.

29 Junior

Ce este model() și cum creezi o componentă care suportă [(valoare)]?

Răspuns scurt: model() este un input modificabil: copilul îl poate seta, iar schimbarea ajunge automat la părinte prin [(valoare)]. Înlocuiește perechea clasică de @Input() valoare și @Output() valoareChange. E stabil din v19.

O componentă de tip contor cu legătură în ambele sensuri:

TypeScript
@Component({
  selector: 'app-cantitate',
  template: `
    <button (click)="valoare.update(v => Math.max(0, v - 1))">-</button>
    <span>{{ valoare() }}</span>
    <button (click)="valoare.update(v => v + 1)">+</button>
  `,
})
export class Cantitate {
  valoare = model(1);
}
TypeScript
@Component({
  selector: 'app-root',
  imports: [Cantitate],
  template: `
    <app-cantitate [(valoare)]="cantitate" />
    <p>Total: {{ cantitate() * 25 }} lei</p>
  `,
})
export class App {
  cantitate = signal(1);
}

Ce se întâmplă:

  • model(1) creează un ModelSignal<number>, care se citește și se scrie ca un signal;
  • părintele poate lega direct un signal în [(valoare)]; Angular îl citește și îl actualizează automat;
  • în spate, model creează și un output numit valoareChange; de aceea funcționează și forma lungă [valoare]="x" (valoareChange)="x = $event";
  • model.required<T>() există pentru valori obligatorii.

Când nu e alegerea bună: dacă vrei ca părintele să păstreze controlul complet (de exemplu să valideze înainte să accepte valoarea), un input() plus un output() explicit e mai clar. model e potrivit pentru componente de formular simple: comutatoare, selectoare, câmpuri de cantitate. Pentru integrare completă cu formControlName, ai nevoie de ControlValueAccessor sau, cu Signal Forms, de interfața de câmp corespunzătoare.

Ce urmărește intervievatorul: Verifică dacă știi mecanismul din spatele „banana in a box”. Puțini candidați știu că [(x)] este doar [x] plus (xChange).

Eroarea, în practică:this.cantitate.set is not a functionCannot assign to 'pret' (read-only property)

30 Junior

Ce fac opțiunile transform și alias la input()? De ce <app-buton dezactivat> nu funcționează fără ele?

Răspuns scurt: transform convertește valoarea primită înainte să ajungă în input, iar alias schimbă numele public. Un atribut gol trimite șirul '', nu true; cu transform: booleanAttribute, prezența atributului devine true.

Problema: vrei sintaxa HTML familiară, ca la <button disabled>.

TypeScript
@Component({
  selector: 'app-buton',
  template: `<button [disabled]="dezactivat()"><ng-content /></button>`,
})
export class Buton {
  dezactivat = input(false);
}
HTML
<app-buton dezactivat>Trimite</app-buton>

Un atribut static fără valoare trimite șirul gol ''. Cu tipul boolean, compilatorul cu verificare strictă semnalează eroare, iar la rulare '' este falsy, deci butonul rămâne activ. Soluția:

TypeScript
import { booleanAttribute, numberAttribute, input } from '@angular/core';

export class Buton {
  dezactivat = input(false, { transform: booleanAttribute });
  coloane = input(1, { transform: numberAttribute });
  eticheta = input('', { alias: 'label' });
}
HTML
<app-buton dezactivat coloane="3" label="Salvează" />

booleanAttribute transformă '', 'true' și true în true, iar 'false' și null în false. numberAttribute transformă șirul '3' în numărul 3.

Poți scrie și transformări proprii, care trebuie să fie funcții pure:

TypeScript
taguri = input([], { transform: (v: string | string[]) => (Array.isArray(v) ? v : v.split(',')) });

alias e util pentru compatibilitate (redenumești intern fără să strici API-ul public) și la directive, unde inputul principal are numele selectorului. Ca regulă, aliasurile se folosesc cu măsură, pentru că fac codul mai greu de urmărit.

Ce urmărește intervievatorul: Verifică dacă știi să faci componente cu un API plăcut. Greșeala tipică este input<boolean>() folosit ca atribut gol.

31 Junior

Ce se întâmplă în codul de mai jos? De ce schimbarea făcută de copil apare și la părinte?

TypeScript
@Component({
  selector: 'app-editor',
  template: `<button (click)="redenumeste()">Redenumește</button>`,
})
export class Editor {
  user = input.required<{ nume: string }>();
  redenumeste() {
    this.user().nume = 'Ana';
  }
}

Răspuns scurt: Obiectele se transmit prin referință: copilul primește același obiect ca părintele, iar mutația îl modifică pentru toți. input este doar pentru citire la nivel de referință, nu și pentru proprietățile obiectului. Corect: copilul emite un eveniment, iar părintele creează un obiect nou.

input() împiedică doar this.user.set(...), care nici nu există. Nu face obiectul imutabil. Mutația this.user().nume = 'Ana' schimbă obiectul aflat în memoria părintelui.

Probleme care decurg de aici:

  • fluxul datelor devine ascuns: părintele nu știe că datele lui s-au schimbat, iar alte componente care folosesc același obiect se schimbă „singure”;
  • actualizarea ecranului e imprevizibilă: signal-ul părintelui are aceeași referință, deci computed-urile și componentele OnPush care depind de el nu sunt anunțate; în zoneless, textul poate să nu se schimbe deloc până la următoarea actualizare provocată de altceva;
  • bug-uri greu de reprodus, pentru că depind de ordinea în care se întâmplă actualizările.

Varianta corectă:

TypeScript
export class Editor {
  user = input.required<User>();
  redenumit = output<string>();
  redenumeste() {
    this.redenumit.emit('Ana');
  }
}
TypeScript
// în părinte
user = signal<User>({ id: 1, nume: 'Ion' });
laRedenumire(nume: string) {
  this.user.update(u => ({ ...u, nume }));
}

Pentru protecție la compilare, tipurile pot fi declarate Readonly<User> sau cu proprietăți readonly; TypeScript va refuza atunci atribuirea. Pentru formulare de editare, copilul își face o copie locală (de exemplu cu linkedSignal(() => ({ ...this.user() }))) și emite rezultatul la salvare.

Ce urmărește intervievatorul: Verifică înțelegerea referințelor și a fluxului unidirecțional. Este un bug foarte frecvent în aplicațiile reale.

32 Mid

Cum accesezi un element sau o componentă copil din clasă cu viewChild, viewChildren și contentChild? Când sunt disponibile?

Răspuns scurt: viewChild('ref') sau viewChild(Componenta) întoarce un signal cu elementul din propriul template; viewChildren întoarce o listă, iar contentChild caută în conținutul proiectat. Valorile apar după randarea view-ului și sunt undefined înainte; signal-ul se actualizează singur când elementul apare sau dispare.

TypeScript
@Component({
  selector: 'app-cautare',
  imports: [Lista],
  template: `
    <input #camp />
    @if (arataLista()) { <app-lista /> }
  `,
})
export class Cautare {
  camp = viewChild.required<ElementRef<HTMLInputElement>>('camp');
  lista = viewChild(Lista);
  arataLista = signal(false);

  constructor() {
    afterNextRender(() => this.camp().nativeElement.focus());
  }
}

Diferențe:

  • viewChild/viewChildren: elemente din template-ul propriu al componentei;
  • contentChild/contentChildren: elemente trimise de părinte prin <ng-content>;
  • selectorul poate fi o variabilă de template ('camp') sau un tip (componentă, directivă); opțiunea read alege ce primești (de exemplu ElementRef în loc de instanța componentei);
  • viewChild.required garantează tipul fără undefined, dar aruncă eroare dacă îl citești prea devreme.

Disponibilitate: interogările sunt rezolvate după crearea view-ului. În constructor nu au valoare. lista() de mai sus devine undefined când arataLista e fals și primește instanța când devine adevărat, fără nimic suplimentar de scris, pentru că e un signal.

Cu decoratorii vechi (@ViewChild) existau capcane: opțiunea static: true pentru acces în ngOnInit, ngAfterViewInit ca prim moment sigur și QueryList.changes pentru liste. Interogările ca signals (stabile din v19) elimină aceste detalii.

Regulă de bun-simț: dacă folosești viewChild ca să apelezi metode pe copil sau să-i citești starea, verifică dacă un input/output nu ar fi mai potrivit. Interogările sunt potrivite pentru focus, măsurători și integrarea cu biblioteci care cer un element DOM.

Ce urmărește intervievatorul: Verifică dacă știi diferența view/content și momentul în care interogările au valoare. Greșeala tipică este folosirea rezultatului în constructor.

Eroarea, în practică:NG0951: Child query result is requiredCannot read properties of undefined (nativeElement)

33 Mid

Două componente surori (un filtru și o listă) trebuie să împartă aceeași stare. Ce variante ai și pe care o alegi?

Răspuns scurt: Trei variante: starea ridicată în părintele comun, un serviciu cu signals furnizat la nivelul potrivit sau starea în URL. Pentru surori apropiate aleg părintele, pentru stare folosită în mai multe pagini un serviciu, pentru filtre partajabile URL-ul.

1. Ridicarea stării în părinte. Părintele deține signal-ul, filtrul îl modifică printr-un model() sau output, lista îl primește ca input:

HTML
<app-filtru [(termen)]="termen" />
<app-lista [termen]="termen()" />

Avantaj: fluxul se vede în template, componentele copil rămân simple și reutilizabile. Dezavantaj: dacă starea trebuie transmisă prin mai multe niveluri, ajungi la „prop drilling”.

2. Serviciu cu stare. Un serviciu cu signal privat și metode publice. Trucul important e unde îl furnizezi:

  • providedIn: 'root': o singură instanță în toată aplicația; potrivit pentru coș, utilizator, preferințe;
  • în providers din componenta părinte: fiecare instanță a părintelui are propria stare, iar copiii o primesc prin inject(); potrivit dacă ai două tabele independente pe aceeași pagină.
TypeScript
@Component({
  selector: 'app-pagina-produse',
  providers: [FiltruStore],
  imports: [Filtru, Lista],
  template: `<app-filtru /><app-lista />`,
})
export class PaginaProduse {}

3. URL-ul. Filtrele, sortarea și pagina stau în query params (?q=laptop&sort=pret). Utilizatorul poate trimite linkul, butonul Înapoi funcționează, iar componentele citesc starea din ActivatedRoute sau prin input binding de la router.

Criteriul de alegere: cât de departe sunt componentele în arbore, dacă starea trebuie să supraviețuiască navigării și dacă trebuie să fie partajabilă. O eroare frecventă este un serviciu global pentru orice, chiar și pentru stare care ține de o singură pagină; starea rămâne apoi „agățată” când revii pe pagină.

Ce urmărește intervievatorul: Verifică dacă știi mai multe soluții și criteriile de alegere. Candidații aleg des un serviciu global din reflex.

34 Mid

Cum rescrii cu signal inputs o componentă care folosește ngOnChanges pentru a reacționa la schimbarea unui input?

Răspuns scurt: Valorile derivate din inputuri devin computed, efectele secundare devin effect, iar încărcarea de date dependentă de input devine resource/httpResource sau toObservable + switchMap. ngOnChanges dispare aproape mereu.

Varianta veche:

TypeScript
export class GraficVanzari implements OnChanges {
  @Input() vanzari: Vanzare[] = [];
  @Input() an = 2024;
  total = 0;
  date: Vanzare[] = [];

  ngOnChanges(changes: SimpleChanges) {
    if (changes['vanzari'] || changes['an']) {
      this.date = this.vanzari.filter(v => v.an === this.an);
      this.total = this.date.reduce((s, v) => s + v.suma, 0);
    }
    if (changes['an']) {
      this.analytics.trimite('an-schimbat', this.an);
    }
  }
}

Problemele ei: verificări manuale pe chei de tip șir, stare care poate ieși din sincron, logică amestecată.

Varianta cu signals:

TypeScript
export class GraficVanzari {
  private analytics = inject(Analytics);
  vanzari = input<Vanzare[]>([]);
  an = input(2024);

  date = computed(() => this.vanzari().filter(v => v.an === this.an()));
  total = computed(() => this.date().reduce((s, v) => s + v.suma, 0));

  constructor() {
    effect(() => this.analytics.trimite('an-schimbat', this.an()));
  }
}

Câștiguri:

  • fiecare valoare derivată își declară singură dependențele; nu mai poți uita o cheie;
  • computed recalculează doar la nevoie și doar ce s-a schimbat;
  • efectul secundar este separat de calculul stării.

O diferență de comportament care merită spusă: ngOnChanges rula sincron înainte de verificarea view-ului; efectele rulează programat. Dacă un cod vechi depindea de această ordine, merită testat după migrare. Iar dacă la schimbarea inputului trebuie încărcate date, nu scrii subscribe într-un efect, ci folosești httpResource(() => /api/x/${this.id()}), care tratează și anularea cererii vechi.

Ce urmărește intervievatorul: Verifică dacă poți moderniza cod existent fără să introduci bug-uri. Greșeala tipică este mutarea întregului ngOnChanges într-un singur effect.

35 Mid

Cum lași părintele să personalizeze cum se randează fiecare rând dintr-o listă generică? Explică ng-template și ngTemplateOutlet cu context.

Răspuns scurt: Părintele trimite un <ng-template let-item>, componenta îl obține ca TemplateRef (prin contentChild sau input) și îl randează cu *ngTemplateOutlet="sablon; context: { $implicit: item }". Așa lista controlează când și de câte ori randează, iar părintele controlează cum arată.

<ng-content> nu poate fi repetat pentru fiecare element. Pentru o listă reutilizabilă ai nevoie de un șablon pe care componenta îl instanțiază de câte ori vrea, cu date diferite.

TypeScript
@Component({
  selector: 'app-lista-generica',
  imports: [NgTemplateOutlet],
  template: `
    @for (item of items(); track $index) {
      <li>
        <ng-container
          *ngTemplateOutlet="rand() ?? implicit; context: { $implicit: item, index: $index }" />
      </li>
    } @empty {
      <li>Nimic de afișat</li>
    }
    <ng-template #implicit let-item>{{ item }}</ng-template>
  `,
})
export class ListaGenerica<T> {
  items = input<T[]>([]);
  rand = contentChild<TemplateRef<{ $implicit: T; index: number }>>(TemplateRef);
}

Folosire:

HTML
<app-lista-generica [items]="useri()">
  <ng-template let-u let-i="index">
    <strong>{{ i + 1 }}. {{ u.nume }}</strong> ({{ u.email }})
  </ng-template>
</app-lista-generica>

Cum se leagă:

  • $implicit din context ajunge în variabila declarată fără valoare (let-u);
  • celelalte chei se leagă prin nume (let-i="index");
  • un <ng-template> nu se randează singur; e doar un șablon până când cineva îl instanțiază.

Pentru verificarea de tipuri în template-ul părintelui, poți adăuga o directivă cu metoda statică ngTemplateContextGuard, cum fac bibliotecile de componente. Acest pattern stă la baza tabelelor, listelor virtualizate și selectoarelor din biblioteci precum Angular CDK sau Angular Material.

Ce urmărește intervievatorul: Verifică dacă poți proiecta componente reutilizabile de nivel bibliotecă. Mulți candidați cunosc doar ng-content.

36 Senior

Echipa ta are un proiect mare, cu @Input, @Output, @ViewChild, *ngIf și NgModule-uri. Cum ai planifica trecerea la API-urile moderne?

Răspuns scurt: Incremental, pe etape mici și verificate: întâi actualizezi Angular la o versiune recentă, apoi rulezi pe rând migrările oficiale (standalone, control flow, inject, signal inputs, outputs, queries), fiecare într-un PR separat, cu teste și verificare manuală. Codul nou se scrie direct modern.

Un model de răspuns structurat:

1. Situația de pornire. Ce versiune avem, ce acoperire de teste, ce biblioteci terțe ar putea bloca actualizarea. Fără teste automate pe fluxurile principale, primul pas este un set minim de teste end-to-end.

2. Reguli pentru codul nou. Componentele noi sunt standalone, cu input(), output(), signals și control flow. Convenția se scrie în ghidul echipei și se verifică la code review, eventual cu reguli de lint. Așa nu crește datoria tehnică cât timp migrezi.

3. Migrările oficiale, una câte una. Angular are schematics pentru fiecare pas:

BASH
ng generate @angular/core:standalone
ng generate @angular/core:control-flow
ng generate @angular/core:inject
ng generate @angular/core:signal-input-migration
ng generate @angular/core:output-migration
ng generate @angular/core:signal-queries-migration

Fiecare rulează pe un director ales, deci poți migra feature cu feature. Un PR per migrare per zonă, cu build, teste și o verificare rapidă în browser.

4. Atenție la ce nu poate migra automat. De exemplu, un @Input care e scris și din interiorul componentei nu poate deveni input(); schematic-ul îl lasă neschimbat și raportează cazul. La fel, codul care depindea de ordinea lui ngOnChanges sau de detectarea schimbărilor cu zone.js necesită analiză manuală.

5. Zoneless la final. După ce starea afișată este în signals, poți testa provideZonelessChangeDetection() pe un mediu de test și urmări ecranele care nu se mai actualizează.

6. Comunicare. Explici echipei de ce (mai puțin cod, verificare de tipuri, performanță), faci o sesiune de prezentare și urmărești progresul pe un tablou simplu. Livrările de funcționalități continuă în paralel.

Ce urmărește intervievatorul: Verifică experiența de a schimba un sistem mare fără să-l oprești. Candidații slabi propun o rescriere completă sau o migrare „big bang”.

Servicii și dependency injection

37 Junior

Ce este dependency injection în Angular și ce face @Injectable({ providedIn: 'root' })?

Răspuns scurt: DI înseamnă că o clasă nu își creează singură dependențele, ci le cere, iar Angular i le furnizează. providedIn: 'root' înregistrează serviciul în injectorul aplicației: o singură instanță partajată, creată la prima cerere și eliminată din bundle dacă nu e folosit.

Fără DI, o componentă ar scrie new ProduseApi(new HttpClient(...)). Ar fi legată de o implementare concretă, greu de testat și ar crea instanțe noi peste tot.

Cu DI:

TypeScript
@Injectable({ providedIn: 'root' })
export class ProduseApi {
  private http = inject(HttpClient);
  lista() {
    return this.http.get<Produs[]>('/api/produse');
  }
}

@Component({ selector: 'app-produse', template: `...` })
export class Produse {
  private api = inject(ProduseApi);
}

Ce face providedIn: 'root':

  • serviciul este singleton la nivelul aplicației: toate componentele care îl injectează primesc aceeași instanță, deci poate ține stare partajată;
  • este creat leneș, la prima injectare;
  • este tree-shakable: dacă nimeni nu îl injectează, compilatorul îl scoate din bundle, spre deosebire de serviciile listate în providers ale unui NgModule.

Beneficiile DI la interviu:

  • testare: în teste înlocuiești ProduseApi cu o variantă falsă, fără să atingi componenta;
  • configurare: aceeași componentă poate primi implementări diferite în contexte diferite;
  • ciclu de viață: Angular decide când se creează și se distruge instanța.

Un serviciu nu are template; e locul pentru logica de business, accesul la API și starea partajată, ca componentele să rămână concentrate pe afișare.

Ce urmărește intervievatorul: Verifică dacă înțelegi de ce există DI, nu doar sintaxa. Mulți candidați nu știu că providedIn: 'root' face serviciul tree-shakable.

Eroarea, în practică:NG0201: No provider found for `ProduseService`

38 Junior

Care e diferența dintre inject() și injectarea prin constructor? Unde ai voie să apelezi inject()?

Răspuns scurt: Ambele cer aceeași dependență din același injector. inject() se poate folosi în inițializatori de câmpuri și în funcții (guards, interceptori, factory-uri), dar doar într-un context de injecție: la crearea clasei sau în funcții rulate de Angular. Apelat în ngOnInit sau într-un handler, aruncă eroarea NG0203.

Cele două forme, echivalente funcțional:

TypeScript
export class Comenzi {
  constructor(private api: ComenziApi, private router: Router) {}
}

export class Comenzi {
  private api = inject(ComenziApi);
  private router = inject(Router);
}

De ce documentația modernă preferă inject():

  • merge în funcții, nu doar în clase: guards, resolvers, interceptori funcționali și funcții ajutătoare reutilizabile;
  • moștenirea e mai simplă: clasa copil nu trebuie să repete parametrii constructorului părintelui;
  • tipurile se deduc fără decoratori de parametri (@Inject(TOKEN) devine inject(TOKEN));
  • opțiunile se scriu clar: inject(Logger, { optional: true }).

Contextul de injecție există:

  • în constructor și în inițializatorii câmpurilor unei clase create de Angular;
  • în funcțiile useFactory și în factory-ul unui InjectionToken;
  • în guards, resolvers, interceptori funcționali, pe care routerul și HttpClient îi rulează în context;
  • în interiorul lui runInInjectionContext(injector, () => ...).

Nu există în ngOnInit, în handler-e de click, în setTimeout sau după un await. Codul de mai jos aruncă NG0203:

TypeScript
ngOnInit() {
  const api = inject(ComenziApi);
}

Același lucru e valabil pentru funcțiile care folosesc intern inject(): toSignal, takeUntilDestroyed() fără argument, effect. Le apelezi la crearea clasei sau le dai explicit un injector / DestroyRef. Proiectele vechi se convertesc cu ng generate @angular/core:inject.

Ce urmărește intervievatorul: Verifică dacă știi regula contextului de injecție. Greșeala tipică este inject() sau toSignal() apelate în ngOnInit.

Eroarea, în practică:NG0203: effect() only in an injection contextinject() must be called from an injection context

39 Junior

Ce afișează pagina de mai jos? Câte instanțe de ContorService există?

TypeScript
@Injectable()
export class ContorService {
  valoare = signal(0);
}

@Component({
  selector: 'app-contor',
  providers: [ContorService],
  template: `<button (click)="c.valoare.update(v => v + 1)">{{ c.valoare() }}</button>`,
})
export class Contor {
  c = inject(ContorService);
}

@Component({
  selector: 'app-root',
  imports: [Contor],
  template: `<app-contor /><app-contor />`,
})
export class App {}

Răspuns scurt: Două instanțe: providers în componentă creează câte un serviciu pentru fiecare instanță a componentei. Un click pe primul buton crește doar primul contor. Cu providedIn: 'root' și fără providers, ar exista o singură instanță, iar ambele butoane ar afișa aceeași valoare.

Ce se întâmplă: fiecare <app-contor> are propriul element injector. providers: [ContorService] înseamnă „creează aici o instanță nouă”. Când Contor cere ContorService, Angular caută întâi în injectorul propriului element, o găsește și se oprește. Rezultatul: primul click arată 1 pe primul buton, iar al doilea rămâne la 0.

Comparație:

TypeScript
@Injectable({ providedIn: 'root' })
export class ContorService { valoare = signal(0); }

@Component({
  selector: 'app-contor',
  template: `...`,
})
export class Contor { c = inject(ContorService); }

Acum ambele componente primesc aceeași instanță din injectorul rădăcină, iar un click actualizează ambele butoane.

Durata de viață diferă și ea:

  • serviciul din providers al componentei se creează odată cu componenta și se distruge odată cu ea (ngOnDestroy din serviciu e apelat); starea se pierde când componenta dispare;
  • serviciul din root trăiește cât aplicația.

Când alegi fiecare variantă:

  • providers în componentă: stare care aparține unei instanțe (un formular în mai mulți pași, un tabel cu filtre proprii, un editor deschis de două ori);
  • providedIn: 'root': stare globală sau servicii fără stare (API, logare).

Copiii unei componente care are providers primesc și ei instanța acelei componente, deci un serviciu furnizat local poate fi starea comună a unui mic arbore de componente.

Ce urmărește intervievatorul: Verifică dacă înțelegi ierarhia injectorilor pe un exemplu concret. Mulți candidați cred că serviciile sunt mereu singleton.

40 Junior

Ce conține app.config.ts și cum pornește o aplicație Angular fără AppModule?

Răspuns scurt: main.ts apelează bootstrapApplication(App, appConfig), iar app.config.ts exportă un ApplicationConfig cu providers globali: provideRouter(routes), provideHttpClient(), detectarea schimbărilor, interceptori, hidratare. Ce făcea AppModule cu imports și providers se face acum cu funcții provide...().

Structura tipică a unei aplicații noi:

TypeScript
// main.ts
import { bootstrapApplication } from '@angular/platform-browser';
import { App } from './app/app';
import { appConfig } from './app/app.config';

bootstrapApplication(App, appConfig).catch(err => console.error(err));
TypeScript
// app.config.ts
import { ApplicationConfig, provideBrowserGlobalErrorListeners,
  provideZonelessChangeDetection } from '@angular/core';
import { provideRouter, withComponentInputBinding } from '@angular/router';
import { provideHttpClient, withFetch, withInterceptors } from '@angular/common/http';
import { routes } from './app.routes';
import { authInterceptor } from './auth.interceptor';

export const appConfig: ApplicationConfig = {
  providers: [
    provideBrowserGlobalErrorListeners(),
    provideZonelessChangeDetection(),
    provideRouter(routes, withComponentInputBinding()),
    provideHttpClient(withFetch(), withInterceptors([authInterceptor])),
  ],
};

De ce funcții provide...() în loc de module:

  • configurarea e explicită și citibilă într-un singur loc;
  • opțiunile sunt funcții with...(), care pot fi eliminate din bundle dacă nu le folosești;
  • nu mai există capcana forRoot() / forChild() din module.

Echivalentul vechi era @NgModule({ imports: [BrowserModule, HttpClientModule, RouterModule.forRoot(routes)], bootstrap: [AppComponent] }). Dacă ai o bibliotecă veche care exportă doar un modul, o poți folosi tot aici, cu importProvidersFrom(VecheaBibliotecaModule).

În proiectele generate cu versiunile recente ale CLI-ului, fișierele nu mai au sufixe (app.ts în loc de app.component.ts), conform ghidului de stil actualizat în v20, iar unele provider-e apar deja generate implicit.

Ce urmărește intervievatorul: Verifică dacă știi cum arată o aplicație modernă de la pornire. Candidații care au lucrat doar cu module caută AppModule și nu știu unde se pun interceptorii.

Eroarea, în practică:No provider for HttpClient

41 Junior

Cum afișezi prețuri în lei și date în format românesc cu pipes? Ce rol are LOCALE_ID?

Răspuns scurt: Folosești currency, number și date din @angular/common, după ce înregistrezi datele de localizare ro și setezi LOCALE_ID la 'ro' (și eventual DEFAULT_CURRENCY_CODE la 'RON'). LOCALE_ID este un token de DI pe care îl citesc pipes-urile.

Implicit, Angular folosește en-US: punct zecimal, luni în engleză, simbolul $. Pentru România:

TypeScript
// app.config.ts
import { registerLocaleData } from '@angular/common';
import localeRo from '@angular/common/locales/ro';
import { DEFAULT_CURRENCY_CODE, LOCALE_ID } from '@angular/core';

registerLocaleData(localeRo);

export const appConfig: ApplicationConfig = {
  providers: [
    { provide: LOCALE_ID, useValue: 'ro' },
    { provide: DEFAULT_CURRENCY_CODE, useValue: 'RON' },
  ],
};

În template:

HTML
<p>{{ 1234.5 | currency }}</p>
<p>{{ 1234.5 | currency: 'RON' : 'code' }}</p>
<p>{{ 0.256 | percent: '1.1-1' }}</p>
<p>{{ comanda.data | date: 'd MMMM yyyy' }}</p>
<p>{{ comanda.data | date: 'shortTime' }}</p>

Cu localizarea română, numerele folosesc virgula zecimală și punctul pentru mii, iar lunile apar în română. Formatul exact al simbolului monedei vine din datele CLDR incluse în Angular.

Detalii utile:

  • formatul '1.2-2' la number înseamnă minim o cifră întreagă, exact două zecimale;
  • date acceptă Date, timestamp sau șir ISO și un al treilea argument pentru fusul orar;
  • pipes-urile sunt pure, deci se recalculează doar când se schimbă valoarea, nu la fiecare verificare;
  • fiecare pipe trebuie importat în componenta standalone (CurrencyPipe, DatePipe).

Pentru aplicații multilingve reale există @angular/localize, care compilează câte o variantă a aplicației pe limbă, iar LOCALE_ID se setează automat la build.

Ce urmărește intervievatorul: Verifică experiența practică cu formatarea pentru utilizatori români. Mulți candidați formatează manual cu toFixed(2) + ' lei'.

Eroarea, în practică:NG0302: The pipe 'currency' could not be foundInvalidPipeArgument: Unable to convert into a date

42 Junior

Primești eroarea NullInjectorError: No provider for X. Ce înseamnă și cum o rezolvi?

Răspuns scurt: Angular a urcat prin toată ierarhia de injectori și nu a găsit nicio rețetă pentru X. Rezolvi adăugând un provider: providedIn: 'root' pe serviciu, funcția provide...() potrivită în app.config.ts sau providers în componentă ori în test.

Mesajul complet arată și lanțul căutării, de exemplu R3InjectorError(Standalone[App])[ProduseApi -> HttpClient -> HttpClient]. Se citește de la stânga la dreapta: App a cerut ProduseApi, care a cerut HttpClient, iar acesta lipsește. Ultimul element din lanț este cel fără provider.

Cauze frecvente și reparații:

  • serviciu scris cu @Injectable() fără providedIn și neadăugat nicăieri: adaugi providedIn: 'root' sau îl pui în providers acolo unde trebuie;
  • lipsește funcția de configurare a unei funcționalități: provideHttpClient() pentru HttpClient, provideRouter(routes) pentru Router și ActivatedRoute, provideAnimationsAsync() pentru animațiile unor biblioteci;
  • în teste: TestBed pornește cu un injector gol, deci trebuie să adaugi provideHttpClient(), provideHttpClientTesting(), provideRouter([]) sau înlocuiri cu useValue;
  • un InjectionToken fără factory și fără provider;
  • serviciul e furnizat doar în providers al unei componente, dar e cerut dintr-o componentă care nu e descendentă a ei sau dintr-un serviciu root (serviciile din root nu văd injectorii de element).
TypeScript
// test care aruncă NullInjectorError pentru HttpClient
TestBed.configureTestingModule({ imports: [Produse] });

// reparat
TestBed.configureTestingModule({
  imports: [Produse],
  providers: [provideHttpClient(), provideHttpClientTesting()],
});

Diferă de eroarea NG0203 (inject() în afara contextului de injecție): acolo problema nu e lipsa provider-ului, ci momentul apelului. Iar o eroare de tip „Circular dependency in DI” (NG0200) înseamnă că două servicii se cer reciproc; se rezolvă prin separarea responsabilităților, nu prin adăugare de provideri.

Ce urmărește intervievatorul: Verifică dacă poți citi un mesaj de eroare și găsi cauza. Candidații slabi adaugă servicii la întâmplare în providers până dispare eroarea.

Eroarea, în practică:NG0201: No provider found for `ProduseService`No provider found for `InjectionToken ...`

43 Mid

Cum caută Angular o dependență prin ierarhia de injectori? Ce fac opțiunile optional, self, skipSelf și host?

Răspuns scurt: Angular caută întâi în injectorii de element, urcând de la componentă spre strămoși, apoi în injectorii de mediu (rută, aplicație, platformă). Prima potrivire câștigă; dacă nu găsește nimic, aruncă NG0201. Opțiunile restrâng sau modifică această căutare.

Există două ierarhii:

  • element injectors: creați de providers din componente și directive, legați de arborele DOM;
  • environment injectors: injectorul aplicației (din bootstrapApplication), injectori creați pentru rute cu providers sau lazy loading, apoi injectorul platformei.

Ordinea de căutare pentru inject(X) într-o componentă: elementul propriu, părinții în arborele de componente, apoi injectorul de mediu al componentei și strămoșii lui. Prima instanță găsită e folosită.

Opțiunile lui inject():

TypeScript
// nu aruncă dacă lipsește, întoarce null
logger = inject(Logger, { optional: true });

// doar din injectorul propriului element
local = inject(FiltruStore, { self: true });

// sare peste propriul element, caută la părinți
parinte = inject(Meniu, { skipSelf: true, optional: true });

// se oprește la componenta gazdă (util în directive)
gazda = inject(FormGroupDirective, { host: true });

Unde contează în practică:

  • skipSelf: componente recursive, de exemplu un meniu cu submeniuri, în care fiecare nivel își caută părintele de același tip;
  • self: o directivă vrea doar serviciul de pe propriul element, nu altul moștenit;
  • optional: dependențe care pot lipsi, cu comportament implicit;
  • host: componentele de formular care caută containerul formularului fără să iasă din componenta gazdă.

Varianta veche folosea decoratori pe parametrii constructorului: @Optional(), @Self(), @SkipSelf(), @Host().

Pentru depanare, Angular DevTools arată arborele de injectori și de unde vine fiecare dependență, ceea ce ajută la erori de tip „am două instanțe ale aceluiași serviciu”.

Ce urmărește intervievatorul: Verifică înțelegerea mecanismului de rezolvare, nu doar a cazului simplu. Candidații de nivel mid ar trebui să poată explica de ce au apărut două instanțe ale unui serviciu.

44 Mid

Ce este un InjectionToken și de ce nu poți injecta direct o interfață TypeScript?

Răspuns scurt: Interfețele TypeScript dispar la compilare, deci la rulare nu există nimic după care Angular să caute. InjectionToken<T> creează o cheie reală, tipată, pentru valori care nu sunt clase: configurări, URL-uri, funcții. Poate avea și un factory care îl face disponibil implicit.

DI-ul din Angular folosește la rulare o cheie ca să găsească provider-ul. O clasă este o valoare JavaScript, deci poate fi cheie. O interfață sau un tip există doar pentru compilator:

TypeScript
interface ApiConfig { baseUrl: string; timeoutMs: number; }

// nu compilează: ApiConfig nu există la rulare
config = inject(ApiConfig);

Soluția:

TypeScript
export const API_CONFIG = new InjectionToken<ApiConfig>('API_CONFIG');

// app.config.ts
providers: [
  { provide: API_CONFIG, useValue: { baseUrl: '/api', timeoutMs: 8000 } },
]

// în serviciu
@Injectable({ providedIn: 'root' })
export class ProduseApi {
  private config = inject(API_CONFIG);
  private http = inject(HttpClient);
  lista() {
    return this.http.get<Produs[]>(`${this.config.baseUrl}/produse`);
  }
}

Varianta cu factory, fără provider separat și tree-shakable:

TypeScript
export const WINDOW = new InjectionToken<Window>('WINDOW', {
  providedIn: 'root',
  factory: () => inject(DOCUMENT).defaultView as Window,
});

Cazuri tipice pentru tokenuri:

  • configurări diferite pe medii (dezvoltare, test, producție);
  • obiecte globale (window, localStorage) învelite ca să poată fi înlocuite în teste și la randarea pe server;
  • puncte de extensie, cu multi: true, în care mai multe module adaugă valori la aceeași listă.

Descrierea ('API_CONFIG') apare în mesajele de eroare, deci merită să fie clară. Angular însuși expune multe tokenuri: DOCUMENT, LOCALE_ID, APP_ID.

Ce urmărește intervievatorul: Verifică dacă înțelegi diferența dintre tipurile de compilare și valorile de rulare. Greșeala tipică este încercarea de a injecta o interfață.

Eroarea, în practică:No provider found for `InjectionToken ...`NG0201: No provider found for `String`

45 Mid

Explică useClass, useValue, useFactory, useExisting și multi: true. Dă câte un exemplu realist.

Răspuns scurt: Sunt rețetele unui provider: useClass creează o clasă (eventual alta decât tokenul), useValue dă o valoare gata făcută, useFactory calculează valoarea cu o funcție, useExisting creează un alias spre alt token. multi: true adună mai mulți provideri sub același token, într-o listă.

TypeScript
providers: [
  // useClass: o implementare pentru o abstracție
  { provide: Stocare, useClass: StocareLocala },

  // useValue: configurare statică
  { provide: API_CONFIG, useValue: { baseUrl: '/api' } },

  // useFactory: alegere la rulare, cu dependențe injectate în factory
  {
    provide: Logger,
    useFactory: () => (isDevMode() ? new ConsoleLogger() : new RemoteLogger(inject(HttpClient))),
  },

  // useExisting: alias, aceeași instanță sub două chei
  { provide: AbstractNotificari, useExisting: NotificariToast },
]

Unde apar în practică:

  • useClass: o clasă abstractă Stocare folosită în cod, cu implementări diferite (localStorage în browser, memorie în teste sau pe server);
  • useValue: configurări și obiecte false în teste: { provide: ProduseApi, useValue: { lista: () => of([]) } };
  • useFactory: când valoarea depinde de mediu sau de alte servicii;
  • useExisting: când o clasă trebuie găsită și după tipul ei, și după o abstracție, fără două instanțe; diferența față de useClass e tocmai aceasta.

multi: true permite mai multor părți ale aplicației să contribuie la aceeași listă:

TypeScript
export const VALIDATORI_PAROLA = new InjectionToken<Validator[]>('VALIDATORI_PAROLA');
providers: [
  { provide: VALIDATORI_PAROLA, useValue: lungimeMinima, multi: true },
  { provide: VALIDATORI_PAROLA, useValue: areCifra, multi: true },
]
// inject(VALIDATORI_PAROLA) întoarce [lungimeMinima, areCifra]

Angular folosea acest mecanism pentru interceptori clasici (HTTP_INTERCEPTORS) și pentru APP_INITIALIZER, înlocuit din v19 de provideAppInitializer(() => ...).

Ce urmărește intervievatorul: Verifică dacă știi toate formele de provider și când alegi fiecare. Puțini candidați știu diferența dintre useClass și useExisting.

Eroarea, în practică:NG0201: No provider found for `String`ctx.produse.lista is not a function (useValue)

46 Senior

Un serviciu de stare marcat providedIn: 'root' a fost adăugat și în providers pe o rută încărcată leneș. Utilizatorii raportează că coșul „se golește” când intră în acea secțiune. De ce?

Răspuns scurt: O rută cu providers sau încărcată leneș primește propriul environment injector. Serviciul listat acolo creează o a doua instanță, folosită de toate componentele din acea secțiune, separată de cea din root. Soluția: scoți serviciul din providers și lași doar providedIn: 'root'.

Configurația cu problema:

TypeScript
export const routes: Routes = [
  {
    path: 'checkout',
    loadChildren: () => import('./checkout/routes').then(m => m.CHECKOUT_ROUTES),
    providers: [CosStore],
  },
];

Când routerul activează checkout, creează un environment injector copil pentru acea rută. Componentele din secțiune care fac inject(CosStore) găsesc întâi provider-ul din injectorul rutei, deci primesc o instanță nouă, goală. Restul aplicației folosește instanța din root, cu produsele adăugate. Pentru utilizator, coșul pare golit.

Cum depanezi:

  • Angular DevTools, la tabul de injectori, arată de unde vine instanța folosită de componentă;
  • un console.log temporar în constructorul serviciului arată că se creează de două ori.

Când sunt utile providers pe rută: pentru servicii care chiar trebuie să aparțină secțiunii, de exemplu starea unui flux de checkout care se resetează când pleci de acolo, sau configurări diferite pentru zona de administrare. În acest caz, serviciul nu are providedIn: 'root', ca să nu existe ambiguitate.

Atenție la o diferență: injectorul unei rute nu se distruge când utilizatorul pleacă de pe rută. Instanța rămâne până la sfârșitul aplicației, deci starea „pe secțiune” nu se resetează automat la navigare. Dacă ai nevoie de stare legată de durata de viață a paginii, o furnizezi în componenta rutei (providers în @Component), care se distruge la ieșire.

Același tip de bug exista în aplicațiile cu NgModule: un serviciu pus în providers ale unui modul încărcat leneș. Regula de echipă: serviciile globale doar cu providedIn: 'root', iar provider-ele locale sunt documentate explicit.

Ce urmărește intervievatorul: Verifică experiența cu ierarhia injectorilor în aplicații reale, cu lazy loading. Puțini candidați știu că injectorul rutei supraviețuiește navigării.

47 Senior

Cum scrii funcții reutilizabile care folosesc DI (de exemplu injectTitluPagina())? Ce sunt runInInjectionContext și DestroyRef?

Răspuns scurt: O funcție care apelează inject() merge în orice context de injecție, de exemplu la crearea unei componente. DestroyRef o lasă să curețe singură la distrugere, iar runInInjectionContext(injector, fn) rulează cod în contextul unui injector, mai târziu.

Pattern-ul de „funcții inject” compune comportamente fără moștenire și fără servicii mici pentru fiecare lucru:

TypeScript
export function injectTitluPagina(titlu: () => string) {
  const title = inject(Title);
  const destroyRef = inject(DestroyRef);
  const anterior = title.getTitle();

  effect(() => title.setTitle(`${titlu()} | Magazin`));
  destroyRef.onDestroy(() => title.setTitle(anterior));
}

export class PaginaProdus {
  produs = input.required<Produs>();
  constructor() {
    injectTitluPagina(() => this.produs().nume);
  }
}

Funcția folosește injectorul componentei care o apelează. DestroyRef reprezintă durata de viață a acelui context: pentru o componentă, distrugerea ei; pentru un serviciu din root, distrugerea aplicației. Așa funcționează intern și takeUntilDestroyed().

Dacă trebuie să creezi ceva dependent de DI mai târziu, de exemplu un efect la apăsarea unui buton, ai două variante:

TypeScript
private injector = inject(Injector);

porneste() {
  effect(() => console.log(this.stare()), { injector: this.injector });
  runInInjectionContext(this.injector, () => {
    const s = toSignal(this.api.flux$);
  });
}

Riscuri de discutat la nivel senior:

  • funcțiile inject ascund dependențe; numele lor (prefixul inject) și documentarea arată că trebuie apelate în context;
  • runInInjectionContext folosit des e un semn că structura codului luptă cu framework-ul;
  • assertInInjectionContext(injectTitluPagina) la începutul funcției dă un mesaj de eroare clar când cineva o apelează greșit.

Același mecanism stă în spatele guard-urilor și interceptorilor funcționali, rulați de Angular în contextul injectorului potrivit.

Ce urmărește intervievatorul: Verifică stăpânirea DI dincolo de servicii și capacitatea de a construi abstracții reutilizabile. Candidații de nivel senior ar trebui să știe ce reprezintă DestroyRef pentru fiecare tip de context.

Eroarea, în practică:inject() must be called from an injection context

RxJS și HttpClient

48 Junior

Ce este un Observable și prin ce diferă de un Promise?

Răspuns scurt: Un Observable este un flux care poate emite zero, una sau mai multe valori în timp, apoi se termină sau dă eroare. Spre deosebire de Promise, este leneș (pornește doar la subscribe), poate emite de mai multe ori și poate fi anulat prin dezabonare.

Comparația pe puncte:

  • număr de valori: un Promise se rezolvă o singură dată; un Observable poate emite oricâte valori (click-uri, mesaje WebSocket, tick-uri de timer);
  • lenea: un Promise pornește imediat ce e creat; un Observable nu face nimic până nu se abonează cineva, iar fiecare abonat pornește, de regulă, propria execuție;
  • anulare: un Promise nu se poate anula din afară; unsubscribe() oprește un Observable, iar la HttpClient asta anulează cererea HTTP;
  • operatori: RxJS oferă operatori pentru transformare, combinare, timp și concurență (map, debounceTime, switchMap, retry).
TypeScript
import { Observable } from 'rxjs';

const numere$ = new Observable<number>(abonat => {
  abonat.next(1);
  abonat.next(2);
  const id = setTimeout(() => {
    abonat.next(3);
    abonat.complete();
  }, 1000);
  return () => clearTimeout(id); // rulează la dezabonare
});

const ab = numere$.subscribe({
  next: v => console.log(v),
  error: e => console.error(e),
  complete: () => console.log('gata'),
});

Convenția $ la final marchează variabilele de tip Observable.

În Angular, Observable-urile apar la HttpClient, la evenimentele routerului, la valueChanges din formulare și în comunicarea cu servere în timp real. Când ai nevoie de un Promise (de exemplu într-o funcție async), folosești firstValueFrom(obs$) sau lastValueFrom(obs$); vechiul toPromise() este depreciat în RxJS 7.

Ce urmărește intervievatorul: Verifică dacă înțelegi modelul de flux, de bază pentru Angular. Greșeala tipică este să spui că un Observable e „un Promise cu mai multe valori”, uitând de lene și anulare.

Eroarea, în practică:Cererea HTTP nu pleacă fără subscribe()

49 Junior

De ce cererea de mai jos nu ajunge niciodată la server?

TypeScript
@Injectable({ providedIn: 'root' })
export class ProduseApi {
  private http = inject(HttpClient);
  sterge(id: number) {
    return this.http.delete(`/api/produse/${id}`);
  }
}

// în componentă
stergeProdus(id: number) {
  this.api.sterge(id);
  this.produse.update(l => l.filter(p => p.id !== id));
}

Răspuns scurt: Observable-urile din HttpClient sunt reci (cold): cererea pleacă doar la subscribe. Componenta apelează metoda, dar nu se abonează, deci nimic nu se trimite, iar lista locală se actualizează ca și cum ștergerea ar fi reușit.

Un Observable rece își pornește execuția pentru fiecare abonat. this.http.delete(...) doar descrie cererea; abia subscribe() o trimite. Codul de mai sus pare să funcționeze (produsul dispare din listă), dar la reîncărcarea paginii produsul revine.

Varianta corectă actualizează lista după răspunsul serverului:

TypeScript
stergeProdus(id: number) {
  this.api.sterge(id).subscribe({
    next: () => this.produse.update(l => l.filter(p => p.id !== id)),
    error: () => this.eroare.set('Nu am putut șterge produsul.'),
  });
}

Consecința inversă e la fel de importantă: fiecare subscribe trimite o cerere nouă. Dacă același Observable e folosit de două ori în template cu async, pleacă două cereri:

HTML
<p>{{ (produse$ | async)?.length }}</p>
@for (p of (produse$ | async) ?? []; track p.id) { ... }

Soluțiile: un singur @let produse = produse$ | async;, transformarea în signal cu toSignal, sau shareReplay când fluxul e partajat între componente.

Pentru cererile HTTP, dezabonarea nu e de obicei critică, pentru că Observable-ul se termină după răspuns. Dar dacă utilizatorul pleacă de pe pagină înainte de răspuns, dezabonarea (de exemplu cu takeUntilDestroyed) anulează cererea și evită actualizarea unei componente distruse.

Spre deosebire de rece, un Observable cald (hot) emite indiferent de abonați: evenimentele DOM, un Subject, evenimentele routerului. Cine se abonează târziu pierde valorile anterioare.

Ce urmărește intervievatorul: Verifică diferența cold/hot pe un bug real. Este o greșeală foarte frecventă la cei care vin din lumea fetch și Promise.

Eroarea, în practică:Cererea HTTP nu pleacă fără subscribe()

50 Junior

Cum faci cereri GET și POST tipate cu HttpClient și cum îl configurezi?

Răspuns scurt: Îl activezi cu provideHttpClient() în app.config.ts, îl injectezi și apelezi http.get<T>(url), post<T>(url, body), put, delete. Fiecare întoarce un Observable care emite răspunsul o dată și se termină. Tipul generic nu validează datele, doar le descrie.

TypeScript
// app.config.ts
providers: [provideHttpClient(withFetch())]
TypeScript
export interface Produs { id: number; nume: string; pret: number; }

@Injectable({ providedIn: 'root' })
export class ProduseApi {
  private http = inject(HttpClient);
  private url = '/api/produse';

  lista(cautare = '') {
    const params = new HttpParams().set('q', cautare).set('limit', 20);
    return this.http.get<Produs[]>(this.url, { params });
  }
  creeaza(p: Omit<Produs, 'id'>) {
    return this.http.post<Produs>(this.url, p);
  }
  actualizeaza(p: Produs) {
    return this.http.put<Produs>(`${this.url}/${p.id}`, p);
  }
}

Ce face HttpClient în plus față de fetch:

  • transformă automat corpul în JSON și înapoi;
  • aruncă eroare pe statusuri 4xx și 5xx, sub forma unui HttpErrorResponse; nu mai trebuie verificat response.ok;
  • suportă interceptori, testare cu HttpTestingController și anularea prin dezabonare;
  • observe: 'response' îți dă tot răspunsul, cu headere și status; reportProgress pentru upload.

withFetch() folosește intern API-ul fetch în loc de XMLHttpRequest și este recomandat pentru randarea pe server.

Atenție: get<Produs[]> este o promisiune de tip pentru compilator, nu o verificare. Dacă serverul trimite price în loc de pret, TypeScript nu află. Pentru API-uri nesigure, validarea la rulare (de exemplu cu o bibliotecă de scheme) se face într-un map în serviciu.

Regula de organizare: componentele nu cunosc URL-uri, ci apelează metodele unui serviciu de API, ușor de testat și de schimbat.

Ce urmărește intervievatorul: Verifică folosirea corectă a clientului HTTP și organizarea codului. Mulți candidați cred că tipul generic validează răspunsul.

Eroarea, în practică:Http failure response: 0 Unknown ErrorNo provider for HttpClient

51 Junior

Ce afișează codul de mai jos?

TypeScript
import { of, map, filter, tap } from 'rxjs';

of(1, 2, 3, 4, 5)
  .pipe(
    tap(v => console.log('intră', v)),
    filter(v => v % 2 === 1),
    map(v => v * 10)
  )
  .subscribe(v => console.log('iese', v));

Răspuns scurt: Pentru fiecare număr se afișează intră, iar pentru cele impare urmează imediat iese: intră 1, iese 10, intră 2, intră 3, iese 30, intră 4, intră 5, iese 50. Valorile trec pe rând prin tot lanțul, nu etapă cu etapă ca la tablouri.

Ieșirea completă:

intră 1
iese 10
intră 2
intră 3
iese 30
intră 4
intră 5
iese 50

Diferența față de [1,2,3,4,5].filter(...).map(...) pe tablouri este esențială: acolo fiecare metodă procesează tot tabloul și produce un tablou intermediar. Într-un Observable, fiecare valoare parcurge tot lanțul înainte să vină următoarea. Nu există colecții intermediare.

Ce face fiecare operator:

  • tap: efect secundar (logare, depanare), nu modifică valoarea;
  • filter: lasă să treacă doar valorile pentru care condiția e adevărată;
  • map: transformă valoarea.

pipe compune operatorii în ordine și întoarce un Observable nou; Observable-ul inițial rămâne neschimbat. Nimic nu rulează până la subscribe, deci fără ultima linie nu s-ar afișa nimic.

of(1, 2, 3, 4, 5) emite sincron, de aceea ordinea e deterministă. Cu surse asincrone (cereri, timere), aceeași logică se aplică pe măsură ce vin valorile.

Într-un serviciu Angular, același lanț arată de obicei așa:

TypeScript
active$ = this.http.get<Produs[]>('/api/produse').pipe(
  map(lista => lista.filter(p => p.activ))
);

Aici atenție: map din RxJS primește tot tabloul (o singură emisie), iar filter din interior este metoda de tablou. Confuzia dintre operatorul filter și Array.prototype.filter este o capcană frecventă.

Ce urmărește intervievatorul: Verifică modelul mental al fluxului de valori prin operatori. Candidații greșesc ordinea crezând că operatorii se aplică etapă cu etapă.

52 Junior

Care e diferența dintre Subject, BehaviorSubject și ReplaySubject?

Răspuns scurt: Toate sunt Observable-uri în care poți trimite valori cu next(). Subject nu ține minte nimic, BehaviorSubject cere o valoare inițială și dă ultima valoare oricărui abonat nou, iar ReplaySubject(n) retrimite ultimele n valori celor care vin târziu.

TypeScript
const s = new Subject<number>();
s.next(1);
s.subscribe(v => console.log('S', v));
s.next(2);
// S 2  (valoarea 1 s-a pierdut)

const b = new BehaviorSubject<number>(0);
b.next(1);
b.subscribe(v => console.log('B', v));
b.next(2);
// B 1, B 2  (abonatul primește imediat ultima valoare)
console.log(b.value); // 2, citire sincronă

const r = new ReplaySubject<number>(2);
r.next(1); r.next(2); r.next(3);
r.subscribe(v => console.log('R', v));
// R 2, R 3

Când le folosești:

  • Subject: evenimente fără stare, de tip „s-a întâmplat ceva” (un mesaj de notificare, un semnal de reîncărcare);
  • BehaviorSubject: stare cu valoare curentă (utilizatorul logat, filtrul activ); era soluția standard pentru stare partajată înainte de signals;
  • ReplaySubject: istoric scurt, de exemplu ultimele mesaje dintr-un chat pentru cine se conectează târziu.

Pattern-ul clasic într-un serviciu expune doar partea de citire:

TypeScript
private readonly _user = new BehaviorSubject<User | null>(null);
readonly user$ = this._user.asObservable();

În Angular modern, pentru stare cu valoare curentă se preferă un signal, care face același lucru mai simplu și se integrează direct cu template-ul. Subject rămâne util pentru evenimente și pentru a porni fluxuri RxJS, de exemplu un Subject de termeni de căutare urmat de debounceTime și switchMap.

Ce urmărește intervievatorul: Verifică dacă știi semantica fiecărui tip și când e potrivit. Greșeala tipică este un Subject simplu pentru stare, iar componentele care se abonează târziu nu primesc nimic.

53 Junior

Ce avantaje are async pipe-ul față de un subscribe scris în componentă?

Răspuns scurt: async se abonează singur, afișează ultima valoare, se dezabonează automat când componenta e distrusă și anunță detectarea schimbărilor, deci funcționează cu OnPush și zoneless. Cu subscribe manual trebuie să gestionezi singur dezabonarea și actualizarea ecranului.

Varianta manuală:

TypeScript
export class Comenzi implements OnInit {
  private api = inject(ComenziApi);
  comenzi: Comanda[] = [];
  ngOnInit() {
    this.api.lista().subscribe(c => (this.comenzi = c));
  }
}

Probleme: abonament care trebuie curățat pentru fluxuri care nu se termină, stare duplicată în câmp și, într-o aplicație zoneless sau cu OnPush, ecranul nu se actualizează, pentru că atribuirea unui câmp simplu nu anunță nimic.

Cu async:

TypeScript
@Component({
  selector: 'app-comenzi',
  imports: [AsyncPipe],
  template: `
    @if (comenzi$ | async; as comenzi) {
      @for (c of comenzi; track c.id) { <li>{{ c.numar }}</li> }
    } @else {
      <p>Se încarcă...</p>
    }
  `,
})
export class Comenzi {
  comenzi$ = inject(ComenziApi).lista();
}

Ce face pipe-ul:

  • se abonează la primul render și se dezabonează la distrugerea componentei;
  • dacă primește alt Observable, se dezabonează de la cel vechi;
  • la fiecare valoare nouă apelează markForCheck();
  • întoarce null până la prima valoare, de aceea tipul rezultatului include null.

Capcană: fiecare apariție a lui comenzi$ | async creează un abonament separat, deci o cerere HTTP separată. Soluția e un singur @if (...; as x) sau @let.

În cod modern, toSignal(obs$) este alternativa care dă un signal folosibil și în clasă, în computed. async rămâne potrivit când fluxul e folosit doar în template.

Ce urmărește intervievatorul: Verifică dacă știi să consumi Observable-uri fără scurgeri de memorie. Mulți candidați nu știu că mai multe async pe același flux înseamnă mai multe cereri.

Eroarea, în practică:InvalidPipeArgument for pipe 'AsyncPipe'

54 Mid

Explică diferența dintre switchMap, mergeMap, concatMap și exhaustMap. Dă un caz de utilizare pentru fiecare.

Răspuns scurt: Toți transformă fiecare valoare într-un Observable interior, dar diferă când vine o valoare nouă cât timp cel vechi rulează: switchMap anulează vechiul, mergeMap le rulează în paralel, concatMap le pune la coadă, exhaustMap ignoră valorile noi până termină.

Problema comună: ai un flux de evenimente (tastări, click-uri) și pentru fiecare pornești o cerere. Ce faci când vine un eveniment nou înainte să se termine cererea anterioară?

  • switchMap (anulează): căutare live, schimbarea produsului selectat, navigare. Contează doar rezultatul ultimei cereri; cele vechi sunt anulate, deci nu pot ajunge târziu și suprascrie rezultatul corect.
TypeScript
rezultate$ = this.termen$.pipe(switchMap(t => this.api.cauta(t)));
  • mergeMap (paralel): încărcarea independentă a mai multor fișiere sau trimiterea de evenimente de analiză. Ordinea răspunsurilor nu e garantată. Al doilea parametru limitează concurența: mergeMap(f => this.upload(f), 3).
  • concatMap (coadă, în ordine): salvări succesive ale aceluiași document, unde ordinea contează; a doua salvare pornește după ce s-a terminat prima.
TypeScript
this.modificari$.pipe(concatMap(m => this.api.salveaza(m))).subscribe();
  • exhaustMap (ignoră): butonul „Plătește” sau „Autentificare” apăsat de mai multe ori; cât timp prima cerere e în curs, click-urile noi sunt ignorate.
TypeScript
this.clickPlata$.pipe(exhaustMap(() => this.api.plateste(this.cos()))).subscribe();

Greșeala care costă cel mai mult: switchMap pe operații de scriere. Dacă utilizatorul apasă de două ori „Salvează”, prima cerere e anulată pe client, dar poate ajunge totuși la server; clientul nu mai află rezultatul. Pentru scrieri, alegi concatMap sau exhaustMap.

Un alt anti-pattern: subscribe în interiorul altui subscribe. Operatorii de mai sus există tocmai ca să elimine abonamentele imbricate.

Ce urmărește intervievatorul: Este întrebarea RxJS clasică la interviurile Angular. Candidații știu de obicei switchMap, dar nu pot spune de ce e periculos la operații de scriere.

Eroarea, în practică:Rezultate vechi peste cele noi (mergeMap)

55 Mid

Scrie o căutare live care trimite cereri doar după ce utilizatorul se oprește din scris, evită cererile duplicate și afișează doar rezultatul ultimei căutări.

Răspuns scurt: Lanțul clasic: debounceTime(300), map pentru trim, distinctUntilChanged(), apoi switchMap spre API, cu catchError în interiorul lui switchMap. Rezultatul se transformă în signal cu toSignal.

TypeScript
@Component({
  selector: 'app-cautare',
  imports: [ReactiveFormsModule],
  template: `
    <input [formControl]="termen" placeholder="Caută produse" />
    @if (eroare()) { <p class="eroare">Căutarea nu a funcționat.</p> }
    @for (p of rezultate(); track p.id) {
      <li>{{ p.nume }}</li>
    } @empty {
      <li>Niciun rezultat</li>
    }
  `,
})
export class Cautare {
  private api = inject(ProduseApi);
  termen = new FormControl('', { nonNullable: true });
  eroare = signal(false);

  rezultate = toSignal(
    this.termen.valueChanges.pipe(
      debounceTime(300),
      map(t => t.trim()),
      distinctUntilChanged(),
      switchMap(t => {
        this.eroare.set(false);
        if (t.length < 2) return of([]);
        return this.api.cauta(t).pipe(
          catchError(() => {
            this.eroare.set(true);
            return of([]);
          })
        );
      })
    ),
    { initialValue: [] as Produs[] }
  );
}

De ce fiecare piesă:

  • debounceTime(300): emite doar după 300 ms fără tastare; scrisul „laptop” produce o cerere, nu șase;
  • distinctUntilChanged: dacă utilizatorul scrie și șterge un caracter, termenul final e același și nu se trimite din nou;
  • switchMap: anulează cererea anterioară, deci un răspuns lent pentru „lap” nu poate suprascrie rezultatul pentru „laptop”;
  • catchError în interior: o eroare transformă doar cererea curentă în listă goală; fluxul exterior rămâne viu și căutarea funcționează în continuare;
  • toSignal: se ocupă de abonare și dezabonare și integrează rezultatul cu template-ul.

Limita de 2 caractere evită cereri inutile pentru termeni prea scurți. Pentru o experiență completă, poți adăuga un signal de încărcare setat înainte de cerere și resetat cu finalize.

Ce urmărește intervievatorul: Verifică dacă poți combina corect operatorii pentru o problemă reală. Greșeala tipică este catchError pus la final, care oprește definitiv căutarea după prima eroare.

Eroarea, în practică:Rezultate vechi peste cele noi (mergeMap)

56 Mid

De ce, după prima eroare de rețea, butonul „Reîncarcă” nu mai face nimic? Cum repari?

TypeScript
reincarca$ = new Subject<void>();

produse = toSignal(
  this.reincarca$.pipe(
    startWith(undefined),
    switchMap(() => this.http.get<Produs[]>('/api/produse')),
    catchError(() => of([]))
  ),
  { initialValue: [] }
);

Răspuns scurt: O eroare termină Observable-ul în care ajunge. catchError pus pe fluxul exterior înlocuiește tot fluxul cu of([]), care emite o dată și se termină, deci noile valori din reincarca$ nu mai sunt ascultate. Mutând catchError în interiorul lui switchMap, doar cererea eșuată e înlocuită.

Contractul unui Observable: după error sau complete nu mai urmează nicio valoare. Lanțul de mai sus: 1. cererea HTTP dă eroare; 2. eroarea trece prin switchMap și ajunge la fluxul exterior; 3. catchError o prinde și continuă cu of([]), care emite [] și se termină; 4. abonamentul la reincarca$ a fost deja închis de eroare; click-urile noi apelează next() pe un Subject pe care nu-l mai ascultă nimeni.

Varianta corectă izolează eroarea la nivelul cererii:

TypeScript
produse = toSignal(
  this.reincarca$.pipe(
    startWith(undefined),
    switchMap(() =>
      this.http.get<Produs[]>('/api/produse').pipe(
        retry({ count: 2, delay: 1000 }),
        catchError(err => {
          this.eroare.set(mesajPentru(err));
          return of([] as Produs[]);
        })
      )
    )
  ),
  { initialValue: [] as Produs[] }
);

Acum eroarea închide doar Observable-ul interior, înlocuit cu of([]); fluxul exterior rămâne activ.

Câteva reguli despre erori în RxJS:

  • catchError trebuie să întoarcă un Observable: o valoare de rezervă (of(...)), EMPTY (nu emite nimic) sau throwError(() => err) ca să propagi mai departe;
  • retry reîncearcă abonarea la sursă; pentru HTTP înseamnă o cerere nouă. Merită folosit doar pentru erori temporare, nu pentru 400 sau 403, iar opțiunea delay poate primi și o funcție pentru backoff exponențial;
  • erorile neprinse dintr-un toSignal sunt aruncate la citirea signal-ului, ceea ce poate strica randarea componentei.

Ce urmărește intervievatorul: Verifică înțelegerea contractului Observable și a propagării erorilor. Este un bug real, frecvent în aplicațiile cu reîncărcare manuală.

Eroarea, în practică:Http failure response: 404 Not Found

57 Mid

Când trebuie să te dezabonezi într-o componentă Angular și ce variante ai? Ce face takeUntilDestroyed()?

Răspuns scurt: Te dezabonezi de la orice flux care nu se termină singur (interval, valueChanges, evenimente de router, Subject-uri din servicii). Variantele moderne: async pipe, toSignal și takeUntilDestroyed(), care încheie fluxul automat la distrugerea componentei sau serviciului.

Abonamentul ține în viață callback-ul, iar callback-ul ține referința la componentă. Dacă sursa trăiește mai mult decât componenta (un serviciu din root, un timer), componenta distrusă rămâne în memorie și codul ei continuă să ruleze: scurgere de memorie și efecte duble după fiecare navigare.

Ce se termină singur și ce nu:

  • se termină: cererile HttpClient, of, from pe tablouri, timer cu o singură emisie; dezabonarea e opțională, dar utilă ca să anulezi o cerere lentă;
  • nu se termină: interval, fromEvent, valueChanges, router.events, Subject-urile din servicii, WebSocket.
TypeScript
export class Monitor {
  private api = inject(StatusApi);
  status = signal<Status | null>(null);

  constructor() {
    interval(10_000)
      .pipe(
        switchMap(() => this.api.status()),
        takeUntilDestroyed()
      )
      .subscribe(s => this.status.set(s));
  }
}

takeUntilDestroyed() folosește DestroyRef din contextul de injecție, deci fără argument se apelează doar în constructor sau în inițializatori. În altă parte îi dai explicit DestroyRef:

TypeScript
private destroyRef = inject(DestroyRef);
ngOnInit() {
  this.form.valueChanges.pipe(takeUntilDestroyed(this.destroyRef)).subscribe(...);
}

Poziția contează: takeUntilDestroyed se pune ultimul în pipe, ca să nu rămână operatori care creează abonamente interioare după el.

Variantele vechi, întâlnite în cod existent: un Subject destroy$ cu takeUntil(this.destroy$) și next() + complete() în ngOnDestroy, sau păstrarea Subscription și unsubscribe(). Cea mai bună variantă rămâne să nu te abonezi manual deloc: async, toSignal și httpResource gestionează singure ciclul de viață.

Ce urmărește intervievatorul: Verifică dacă înțelegi cauzele scurgerilor de memorie în Angular. Greșeala tipică este fie dezabonare peste tot din reflex, fie deloc.

Eroarea, în practică:NG0203: takeUntilDestroyed() în ngOnInitAbonament care continuă după distrugere

58 Mid

Care e diferența dintre forkJoin, combineLatest, withLatestFrom și zip? De ce un forkJoin poate să nu emită niciodată?

Răspuns scurt: forkJoin emite o dată, după ce toate sursele se termină; combineLatest emite la fiecare schimbare, după ce fiecare sursă a emis măcar o dată; withLatestFrom emite doar la sursa principală; zip împerechează după poziție. O sursă care nu se termină blochează forkJoin.

forkJoin: echivalentul lui Promise.all. Ideal pentru cereri HTTP independente necesare unei pagini:

TypeScript
pagina$ = forkJoin({
  user: this.api.user(id),
  comenzi: this.api.comenzi(id),
  adrese: this.api.adrese(id),
});
// emite o dată { user, comenzi, adrese }

Capcane:

  • emite doar când toate se termină; dacă pui un valueChanges, un BehaviorSubject sau interval, nu emite niciodată;
  • dacă o sursă se termină fără nicio valoare (de exemplu EMPTY), forkJoin se termină fără să emită;
  • o eroare în oricare sursă distruge tot rezultatul; dacă vrei rezultate parțiale, pui catchError pe fiecare sursă.

combineLatest: stare derivată din mai multe fluxuri continue, de exemplu filtre și sortare:

TypeScript
vizibile$ = combineLatest([this.produse$, this.filtru$, this.sortare$]).pipe(
  map(([lista, f, s]) => aplica(lista, f, s))
);

Nu emite nimic până când fiecare sursă a emis cel puțin o dată, de unde problema clasică „pagina rămâne goală” când una dintre surse e un Subject fără valoare inițială; soluția este startWith sau un BehaviorSubject.

withLatestFrom: acțiune declanșată de un singur flux, care citește starea curentă a altora; de exemplu, la click pe „Salvează” iei valoarea curentă a formularului.

zip: împerechează a n-a valoare din fiecare sursă; rar folosit, util când răspunsurile vin în perechi sigure.

În cod cu signals, multe cazuri de combineLatest devin un simplu computed peste mai multe signals.

Ce urmărește intervievatorul: Verifică dacă știi semantica operatorilor de combinare. Bug-ul forkJoin cu o sursă care nu se termină apare foarte des.

Eroarea, în practică:forkJoin nu emite nimic

59 Mid

Cum scrii un interceptor HTTP care adaugă tokenul de autentificare și tratează centralizat erorile 401?

Răspuns scurt: Scrii o funcție HttpInterceptorFn care clonează cererea cu req.clone({ setHeaders: { Authorization: ... } }), o trimite cu next(req) și folosește catchError pentru 401, apoi o înregistrezi cu provideHttpClient(withInterceptors([...])). Cererea se clonează pentru că e imutabilă.

TypeScript
export const authInterceptor: HttpInterceptorFn = (req, next) => {
  const auth = inject(AuthService);
  const router = inject(Router);
  const token = auth.token();

  const esteApiulNostru = req.url.startsWith('/api/');
  const cerere = token && esteApiulNostru
    ? req.clone({ setHeaders: { Authorization: `Bearer ${token}` } })
    : req;

  return next(cerere).pipe(
    catchError((err: unknown) => {
      if (err instanceof HttpErrorResponse && err.status === 401) {
        auth.logout();
        router.navigate(['/login'], { queryParams: { inapoi: router.url } });
      }
      return throwError(() => err);
    })
  );
};
TypeScript
// app.config.ts
provideHttpClient(withInterceptors([authInterceptor, logInterceptor]))

Puncte importante:

  • HttpRequest este imutabil; clone creează o copie cu modificările, ca să nu existe efecte surprinzătoare când aceeași cerere e reîncercată;
  • tokenul se adaugă doar pentru domeniul propriu; trimiterea lui către servicii terțe este o scurgere de securitate;
  • eroarea se propagă mai departe cu throwError, ca apelantul să își poată afișa propriul mesaj;
  • ordinea din listă contează: cererile trec prin interceptori în ordinea dată, iar răspunsurile în ordine inversă;
  • interceptorul rulează în context de injecție, deci inject() funcționează.

Interceptorii clasici, sub formă de clase cu HTTP_INTERCEPTORS, funcționează doar dacă adaugi withInterceptorsFromDi().

Pentru reînnoirea tokenului (refresh), fluxul e mai delicat: la 401 ceri un token nou o singură dată, chiar dacă mai multe cereri au eșuat simultan, apoi le reiei pe toate. Dacă tokenul e într-un cookie HttpOnly, nu adaugi nimic în header, iar interceptorul se ocupă doar de erori.

Ce urmărește intervievatorul: Verifică experiența cu autentificarea într-o aplicație reală. Greșeala tipică este trimiterea tokenului către orice domeniu sau înghițirea erorii în interceptor.

Eroarea, în practică:Interceptor fără return next(req)HttpHeaders.set() nu adaugă antetul

60 Senior

Ce fac toSignal și toObservable? Ce capcane au (valoarea inițială, contextul de injecție, erorile)?

Răspuns scurt: toSignal(obs$) se abonează imediat și expune ultima valoare ca signal; toObservable(sig) emite valorile unui signal ca Observable. Capcane: toSignal dă undefined până la prima valoare dacă nu pui initialValue, trebuie creat în context de injecție, iar erorile fluxului sunt aruncate la citire.

TypeScript
export class Pagina {
  private route = inject(ActivatedRoute);
  private api = inject(ProduseApi);

  id = toSignal(this.route.paramMap.pipe(map(p => Number(p.get('id')))), {
    initialValue: 0,
  });

  categorie = signal('laptopuri');
  produse = toSignal(
    toObservable(this.categorie).pipe(switchMap(c => this.api.dinCategorie(c))),
    { initialValue: [] as Produs[] }
  );
}

Detalii care contează la toSignal:

  • tipul fără opțiuni este Signal<T | undefined>; initialValue elimină undefined; requireSync: true e pentru surse care emit sincron la abonare (BehaviorSubject, startWith) și aruncă eroare dacă nu emit;
  • se abonează imediat, la creare, nu la prima citire; un flux HTTP pornește cererea chiar dacă signal-ul nu e citit niciodată;
  • se dezabonează automat la distrugerea contextului (componentă sau serviciu); de aceea cere context de injecție, ori opțiunea injector, ori manualCleanup;
  • dacă fluxul dă eroare, citirea signal-ului aruncă acea eroare; tratezi erorile cu catchError înainte de toSignal;
  • nu crea toSignal într-o metodă apelată repetat: fiecare apel e un abonament nou.

La toObservable:

  • emite asincron, după stabilizarea signal-urilor (folosește intern un efect), deci mai multe set sincrone succesive produc o singură emisie, cu ultima valoare;
  • prima valoare este cea curentă la momentul rulării efectului.

Ambele au fost în developer preview mult timp și sunt stabile din v20, în @angular/core/rxjs-interop, alături de takeUntilDestroyed, outputFromObservable și rxResource.

Ce urmărește intervievatorul: Verifică stăpânirea graniței dintre signals și RxJS, unde apar multe bug-uri subtile. Candidații nu știu de obicei că toObservable sare peste valorile intermediare.

Eroarea, în practică:NG0203: toSignal() în afara injection contextNG0601: toSignal() requireSync

61 Senior

Mai multe componente cer aceeași listă de categorii și pleacă câte o cerere HTTP pentru fiecare. Cum implementezi un cache corect cu RxJS sau signals?

Răspuns scurt: Partajezi un singur flux în serviciu: shareReplay({ bufferSize: 1, refCount: false }) pe cerere, ca toți abonații să primească același răspuns, sau ții datele într-un signal/resursă în serviciul root. Trebuie gândite și invalidarea, erorile și reîncercarea.

Cauza: fiecare subscribe la un Observable rece trimite o cerere nouă. Soluția clasică:

TypeScript
@Injectable({ providedIn: 'root' })
export class CategoriiApi {
  private http = inject(HttpClient);
  private cache$?: Observable<Categorie[]>;

  lista(): Observable<Categorie[]> {
    this.cache$ ??= this.http.get<Categorie[]>('/api/categorii').pipe(
      shareReplay({ bufferSize: 1, refCount: false })
    );
    return this.cache$;
  }

  invalideaza() {
    this.cache$ = undefined;
  }
}

Ce face shareReplay: primul abonat pornește cererea, ceilalți se atașează la aceeași execuție, iar cei care vin după terminare primesc ultima valoare din buffer.

Opțiunea refCount contează:

  • refCount: false (cache pe toată durata aplicației): sursa nu e anulată când pleacă toți abonații; potrivit pentru date de referință;
  • refCount: true: când numărul de abonați ajunge la zero, abonamentul la sursă se închide; pentru fluxuri continue (WebSocket) evită scurgerile.

Probleme de tratat:

  • erorile: dacă cererea eșuează, shareReplay nu păstrează eroarea în buffer, iar un nou abonat repornește cererea; totuși, abonații existenți primesc eroarea. Merită un catchError care resetează cache-ul;
  • datele învechite: un cache fără expirare arată date vechi după modificări; invalidezi după POST/PUT sau adaugi o expirare;
  • utilizatori diferiți: la logout, cache-urile cu date personale trebuie golite.

Varianta cu signals: un serviciu root cu o resursă (httpResource(() => '/api/categorii')) sau un signal populat o dată și o metodă reincarca(). Componentele citesc același signal, deci o singură cerere. Pentru cerințe complexe (expirare, reîncercare la revenirea în tab), o bibliotecă dedicată de query caching poate merita.

Ce urmărește intervievatorul: Verifică dacă înțelegi multicasting-ul și problemele reale de cache. Candidații pun adesea shareReplay(1) fără să știe ce face refCount sau ce se întâmplă la erori.

Routing

Exersează capitolul cu exerciții reale: Curs Angular →
62 Junior

Cum configurezi rutarea într-o aplicație standalone? De ce folosești routerLink și nu href?

Răspuns scurt: Definești un tablou Routes cu path și component, îl dai la provideRouter(routes), pui <router-outlet /> unde apar paginile și navighezi cu routerLink. href reîncarcă toată aplicația de la server, în timp ce routerLink schimbă doar componenta afișată.

TypeScript
// app.routes.ts
export const routes: Routes = [
  { path: '', component: Acasa, title: 'Acasă' },
  { path: 'produse', component: ListaProduse, title: 'Produse' },
  { path: 'produse/:id', component: DetaliiProdus },
  { path: '**', component: NuExista },
];
TypeScript
// app.ts
@Component({
  selector: 'app-root',
  imports: [RouterOutlet, RouterLink, RouterLinkActive],
  template: `
    <nav>
      <a routerLink="/" routerLinkActive="activ" [routerLinkActiveOptions]="{ exact: true }">Acasă</a>
      <a routerLink="/produse" routerLinkActive="activ">Produse</a>
    </nav>
    <router-outlet />
  `,
})
export class App {}

Cu provideRouter(routes) în app.config.ts, aplicația devine SPA: routerul ascultă schimbările de URL prin History API și pune componenta potrivită în <router-outlet>.

De ce routerLink:

  • un <a href="/produse"> face o cerere nouă la server, reîncarcă JavaScript-ul și pierde toată starea (coș, formulare, cache);
  • routerLink interceptează click-ul, actualizează URL-ul fără reîncărcare și păstrează starea;
  • elementul rămâne un link adevărat (<a> cu href generat), deci funcționează deschiderea în tab nou și accesibilitatea.

routerLinkActive adaugă o clasă când ruta e activă. Pentru /, opțiunea exact: true e necesară, altfel linkul „Acasă” ar fi activ pe orice pagină, pentru că toate URL-urile încep cu /.

Pe server trebuie configurat ca orice URL necunoscut să servească index.html; altfel, reîncărcarea pe /produse/5 dă 404.

Ce urmărește intervievatorul: Verifică bazele SPA și ale routerului. Greșeala tipică este href în navigarea internă sau uitarea configurației serverului pentru reîncărcare.

Eroarea, în practică:NG04002: Cannot match any routes'router-outlet' is not a known element

63 Junior

De ce pagina de detalii de mai jos nu se actualizează când utilizatorul trece de la produsul 1 la produsul 2 printr-un link de pe aceeași pagină?

TypeScript
export class DetaliiProdus implements OnInit {
  private route = inject(ActivatedRoute);
  private api = inject(ProduseApi);
  produs = signal<Produs | null>(null);

  ngOnInit() {
    const id = Number(this.route.snapshot.paramMap.get('id'));
    this.api.dupaId(id).subscribe(p => this.produs.set(p));
  }
}

Răspuns scurt: Când doar parametrul se schimbă, routerul refolosește aceeași instanță a componentei, deci ngOnInit nu rulează din nou. snapshot e doar valoarea de la prima activare. Corect: asculți paramMap ca Observable sau primești id ca input cu withComponentInputBinding().

Routerul compară configurația rutei vechi cu cea nouă. /produse/1 și /produse/2 se potrivesc pe aceeași rută produse/:id, deci, din motive de performanță, componenta nu este distrusă și recreată; se schimbă doar parametrii din ActivatedRoute.

snapshot este o fotografie la un moment dat. Citit în ngOnInit, rămâne la 1.

Varianta reactivă cu paramMap:

TypeScript
export class DetaliiProdus {
  private route = inject(ActivatedRoute);
  private api = inject(ProduseApi);

  produs = toSignal(
    this.route.paramMap.pipe(
      map(p => Number(p.get('id'))),
      switchMap(id => this.api.dupaId(id))
    )
  );
}

switchMap anulează și cererea veche dacă utilizatorul schimbă repede produsul.

Varianta modernă, cu input binding:

TypeScript
// app.config.ts: provideRouter(routes, withComponentInputBinding())

export class DetaliiProdus {
  id = input.required<string>();
  produs = httpResource<Produs>(() => `/api/produse/${this.id()}`);
}

Parametrul de rută :id ajunge în inputul id și se actualizează la fiecare navigare, iar httpResource refăce cererea automat.

snapshot rămâne potrivit când știi sigur că pe acea rută nu se poate naviga spre ea însăși cu alți parametri. Ca regulă, folosirea snapshot în pagini de detalii este o sursă clasică de bug-uri, mai ales când pagina are linkuri spre „produse similare”.

Ce urmărește intervievatorul: Este un bug clasic de router. Verifică dacă știi că componenta este refolosită la schimbarea parametrilor.

Eroarea, în practică:Parametrul din rută nu se actualizează (snapshot)

64 Junior

Cum navighezi din cod și cum lucrezi cu query params (de exemplu ?sort=pret&pagina=2)?

Răspuns scurt: Injectezi Router și apelezi router.navigate(['/produse'], { queryParams: { sort: 'pret' } }) sau navigateByUrl('/login'). Citești query params din ActivatedRoute.queryParamMap sau ca inputuri cu withComponentInputBinding(); queryParamsHandling: 'merge' păstrează parametrii existenți.

Navigare din cod, de exemplu după salvarea unui formular:

TypeScript
export class EditareProdus {
  private router = inject(Router);
  private route = inject(ActivatedRoute);

  salvat(id: number) {
    this.router.navigate(['/produse', id]);
  }
  inapoiLaLista() {
    this.router.navigate(['..'], { relativeTo: this.route });
  }
}

navigate primește segmente (['/produse', id] devine /produse/5, cu id-ul codificat corect), navigateByUrl primește un URL complet. Ambele întorc un Promise cu true sau false, după cum navigarea a reușit (un guard o poate bloca).

Query params pentru filtre și sortare:

TypeScript
schimbaSortarea(sort: string) {
  this.router.navigate([], {
    relativeTo: this.route,
    queryParams: { sort, pagina: 1 },
    queryParamsHandling: 'merge',
  });
}

navigate([]) cu relativeTo rămâne pe aceeași pagină și schimbă doar parametrii. merge păstrează ceilalți parametri (de exemplu q), iar pentru a scoate unul îi dai valoarea null.

Citire:

TypeScript
sort = toSignal(this.route.queryParamMap.pipe(map(p => p.get('sort') ?? 'nume')), {
  initialValue: 'nume',
});

sau, cu withComponentInputBinding(), simplu sort = input<string>().

În template: <a routerLink="/produse" [queryParams]="{ sort: 'pret' }">.

De ce merită ținute filtrele în URL: linkul poate fi trimis cuiva, butonul Înapoi funcționează natural, iar reîncărcarea păstrează starea. Valorile din URL sunt mereu șiruri, deci le convertești și le validezi.

Ce urmărește intervievatorul: Verifică navigarea programatică și folosirea URL-ului ca stare. Candidații construiesc des URL-uri prin concatenare și pierd parametrii existenți.

65 Junior

Ce afișează aplicația pentru URL-ul /admin cu configurația de mai jos? Ce rol au pathMatch și ordinea rutelor?

TypeScript
export const routes: Routes = [
  { path: '', redirectTo: 'acasa' },
  { path: '**', component: NuExista },
  { path: 'acasa', component: Acasa },
  { path: 'admin', component: Admin },
];

Răspuns scurt: Afișează NuExista: routerul alege prima rută care se potrivește, iar ** se potrivește cu orice, deci rutele de după el nu sunt atinse niciodată. În plus, redirect-ul de pe calea goală are nevoie de pathMatch: 'full', altfel CLI-ul semnalează eroare.

Routerul parcurge rutele în ordine și se oprește la prima potrivire. Wildcard-ul ** se potrivește cu orice URL, deci trebuie să fie ultimul. Cu configurația de mai sus, /admin, /acasa și orice altceva ajung la pagina 404.

A doua problemă: pathMatch.

  • 'prefix' (implicit): ruta se potrivește dacă URL-ul începe cu calea respectivă;
  • 'full': tot URL-ul rămas trebuie să fie egal cu calea.

Orice URL începe cu calea goală, deci un redirect de pe '' cu prefix ar intercepta tot. De aceea Angular cere explicit pathMatch: 'full' pentru redirect-uri de pe calea goală și dă eroare de configurare altfel.

Configurația corectă:

TypeScript
export const routes: Routes = [
  { path: '', redirectTo: 'acasa', pathMatch: 'full' },
  { path: 'acasa', component: Acasa, title: 'Acasă' },
  { path: 'admin', component: Admin, canActivate: [esteAdmin] },
  { path: '**', component: NuExista, title: 'Pagina nu există' },
];

Detalii utile:

  • redirectTo poate fi și o funcție (din v18), care primește informații despre rută și poate decide dinamic unde redirecționează;
  • o pagină 404 în SPA este doar o componentă; pentru SEO, la randarea pe server trebuie trimis și statusul HTTP 404, altfel motoarele de căutare primesc 200;
  • pentru rutele încărcate leneș, ordinea se aplică și în interiorul fiecărui tablou children.

Ce urmărește intervievatorul: Verifică dacă știi algoritmul de potrivire al routerului. Greșeala tipică este wildcard-ul pus în mijlocul listei sau redirect-ul fără pathMatch: 'full'.

Eroarea, în practică:NG04002: Cannot match any routesNG04014: please provide 'pathMatch'

66 Junior

Cum încarci leneș o pagină sau o secțiune întreagă cu loadComponent și loadChildren? Ce câștigi?

Răspuns scurt: loadComponent: () => import('./admin').then(m => m.Admin) încarcă o componentă doar când utilizatorul intră pe rută; loadChildren încarcă un fișier cu un tablou de rute. Bundle-ul inițial devine mai mic, deci prima încărcare e mai rapidă.

TypeScript
export const routes: Routes = [
  { path: '', component: Acasa },
  {
    path: 'produse/:id',
    loadComponent: () => import('./produse/detalii').then(m => m.DetaliiProdus),
  },
  {
    path: 'admin',
    canMatch: [esteAdmin],
    loadChildren: () => import('./admin/admin.routes').then(m => m.ADMIN_ROUTES),
  },
];
TypeScript
// admin/admin.routes.ts
export const ADMIN_ROUTES: Routes = [
  { path: '', component: PanouAdmin },
  { path: 'useri', component: Useri },
];

Ce se întâmplă la build: import() dinamic este un punct de separare. Builder-ul pune componenta și tot ce importă doar ea într-un fișier JavaScript separat (chunk), descărcat la prima navigare spre rută. Codul din pagina de start nu mai conține editorul de produse, graficele din administrare sau bibliotecile mari folosite doar acolo.

Dacă fișierul are un export default, poți scrie mai scurt: loadComponent: () => import('./admin').

Ce trebuie verificat:

  • componenta încărcată leneș nu trebuie importată static în altă parte, altfel ajunge oricum în bundle-ul principal;
  • canMatch pe o rută leneșă împiedică și descărcarea codului pentru cine nu are acces;
  • prima navigare spre rută are o mică întârziere; o atenuezi cu o strategie de preîncărcare, de exemplu withPreloading(PreloadAllModules), care descarcă rutele leneșe în fundal după pornirea aplicației.

Pentru bucăți din aceeași pagină (un grafic sub fold, un editor deschis la click), instrumentul potrivit este @defer, nu routerul.

Ce urmărește intervievatorul: Verifică dacă știi tehnica principală de reducere a bundle-ului inițial. Mulți candidați importă static componenta și anulează efectul.

Eroarea, în practică:NG04014: The component must be standalone

67 Mid

Cum protejezi o rută cu un guard funcțional? Care e diferența dintre canActivate și canMatch și de ce un guard nu este o măsură de securitate?

Răspuns scurt: Scrii o funcție CanActivateFn care întoarce true, false sau un UrlTree (redirect) și o pui în canActivate pe rută. canMatch decide dacă ruta se potrivește deloc, deci poate împiedica descărcarea codului leneș. Guard-ul rulează în browser și poate fi ocolit; securitatea reală e pe server.

TypeScript
export const esteLogat: CanActivateFn = (route, state) => {
  const auth = inject(AuthService);
  const router = inject(Router);
  return auth.logat()
    ? true
    : router.createUrlTree(['/login'], { queryParams: { inapoi: state.url } });
};

export const esteAdmin: CanMatchFn = () => inject(AuthService).rol() === 'admin';
TypeScript
{ path: 'cont', component: Cont, canActivate: [esteLogat] },
{
  path: 'admin',
  canMatch: [esteAdmin],
  loadChildren: () => import('./admin/admin.routes').then(m => m.ADMIN_ROUTES),
},
{ path: 'admin', component: FaraAcces },

De ce UrlTree și nu router.navigate() + false: întoarcerea unui UrlTree (sau, din v18, a unui RedirectCommand) anulează navigarea curentă și pornește redirecționarea ca o singură operație, fără navigări concurente.

Tipurile de guard:

  • canActivate: ruta s-a potrivit, se decide dacă poate fi activată;
  • canActivateChild: pentru toți copiii unei rute;
  • canMatch: dacă întoarce false, routerul încearcă următoarea rută cu aceeași cale. Codul leneș nu se descarcă, iar exemplul de mai sus afișează o pagină de „acces interzis”; util și pentru variante ale aceleiași căi (alt dashboard pentru admin);
  • canDeactivate: părăsirea paginii, de exemplu cu un formular nesalvat.

Guard-ul poate întoarce și un Observable sau un Promise, util dacă trebuie verificată sesiunea la server.

Securitate: tot codul din browser poate fi citit și modificat. Guard-ul îmbunătățește experiența, dar datele din /api/admin trebuie protejate de server, care verifică fiecare cerere. Iar dacă codul paginii de administrare nu trebuie văzut deloc, canMatch pe o rută leneșă e mai potrivit decât canActivate.

Ce urmărește intervievatorul: Verifică dacă știi API-ul modern și limitele lui. Candidații prezintă des guard-urile ca securitate sau folosesc navigate în loc de UrlTree.

Eroarea, în practică:Class constructor AdminGuard cannot be invoked

68 Mid

Ce face withComponentInputBinding() și cum trimiți date statice sau rezolvate prin configurarea rutei (data, resolve, title)?

Răspuns scurt: Cu withComponentInputBinding(), routerul pune automat în inputurile componentei parametrii de rută, query params, data și rezultatele din resolve, potrivite după nume. title setează titlul tabului, iar resolver-ele încarcă date înainte de afișarea paginii.

TypeScript
// app.config.ts
provideRouter(routes, withComponentInputBinding())
TypeScript
export const produsResolver: ResolveFn<Produs> = route =>
  inject(ProduseApi).dupaId(Number(route.paramMap.get('id')));

export const routes: Routes = [
  {
    path: 'produse/:id',
    component: DetaliiProdus,
    resolve: { produs: produsResolver },
    data: { arataRecenzii: true },
    title: (route) => `Produs ${route.paramMap.get('id')}`,
  },
];
TypeScript
export class DetaliiProdus {
  id = input.required<string>();
  produs = input.required<Produs>();
  arataRecenzii = input(false);
  tab = input<string>();
}

Pentru /produse/5?tab=specificatii, componenta primește id = '5', tab = 'specificatii', arataRecenzii = true și produsul rezolvat. Fără ActivatedRoute în componentă, deci e mai ușor de testat și de refolosit.

Detalii de reținut:

  • toate valorile din URL sunt șiruri; folosești transform: numberAttribute dacă vrei număr;
  • dacă două surse au același nume, ordinea de prioritate este documentată (datele rutei suprascriu query params), deci evită conflictele de nume;
  • un input care nu mai e prezent în URL primește undefined.

Resolver vs încărcare în componentă: resolver-ul întârzie navigarea până vin datele, deci utilizatorul vede pagina veche și pare că nu se întâmplă nimic. Încărcarea în componentă (cu httpResource) arată imediat structura paginii cu indicator de încărcare. Resolver-ele sunt potrivite pentru date mici și critice, fără de care pagina nu are sens, sau ca să redirecționezi la 404 înainte de afișare.

title poate fi șir, funcție sau resolver; pentru reguli comune (sufixul „| Magazin”) există TitleStrategy.

Ce urmărește intervievatorul: Verifică dacă folosești routerul modern și înțelegi compromisul resolver vs încărcare în componentă. Mulți candidați nu știu de input binding.

Eroarea, în practică:input() pentru :id e undefined

69 Mid

Cum construiești un layout cu meniu lateral pentru o secțiune, folosind rute imbricate? Ce este o rută fără componentă?

Răspuns scurt: Ruta părinte are o componentă de layout cu propriul <router-outlet />, iar paginile secțiunii stau în children. O rută fără componentă grupează copii doar pentru a le aplica împreună guard-uri, providers, resolve sau un prefix de cale.

TypeScript
export const routes: Routes = [
  {
    path: 'cont',
    component: LayoutCont,
    canActivate: [esteLogat],
    children: [
      { path: '', redirectTo: 'profil', pathMatch: 'full' },
      { path: 'profil', component: Profil, title: 'Profil' },
      { path: 'comenzi', component: Comenzi, title: 'Comenzi' },
      { path: 'comenzi/:id', component: DetaliiComanda },
    ],
  },
];
TypeScript
@Component({
  selector: 'app-layout-cont',
  imports: [RouterOutlet, RouterLink, RouterLinkActive],
  template: `
    <aside>
      <a routerLink="profil" routerLinkActive="activ">Profil</a>
      <a routerLink="comenzi" routerLinkActive="activ">Comenzi</a>
    </aside>
    <main><router-outlet /></main>
  `,
})
export class LayoutCont {}

Cum funcționează: pentru /cont/comenzi, routerul afișează LayoutCont în outlet-ul aplicației și Comenzi în outlet-ul din layout. La trecerea de la profil la comenzi, layout-ul rămâne aceeași instanță; doar conținutul din <main> se schimbă, deci meniul își păstrează starea.

Linkurile fără / la început (routerLink="profil") sunt relative la ruta componentei care le conține, deci layout-ul nu trebuie să știe prefixul /cont.

Ruta fără componentă:

TypeScript
{
  path: 'admin',
  canActivateChild: [esteAdmin],
  providers: [AdminStore],
  children: [
    { path: 'useri', component: Useri },
    { path: 'rapoarte', component: Rapoarte },
  ],
}

Fără componentă, copiii se afișează direct în outlet-ul părintelui. Este o grupare logică: guard comun, serviciu comun, prefix comun.

Pentru panouri independente (de exemplu un chat lateral care are propriul URL), există și outlet-uri cu nume (<router-outlet name="lateral" />), dar sunt folosite rar, pentru că URL-urile devin greu de citit.

Ce urmărește intervievatorul: Verifică dacă poți structura navigarea unei aplicații reale. Greșeala tipică este repetarea meniului în fiecare pagină în loc de un layout cu rute copil.

70 Mid

Cum împiedici utilizatorul să părăsească accidental o pagină cu un formular nesalvat?

Răspuns scurt: Pentru navigarea internă folosești un guard canDeactivate, care întreabă componenta dacă are modificări nesalvate și cere confirmare. Pentru închiderea tabului sau reîncărcare, asculți evenimentul beforeunload al ferestrei. Sunt două mecanisme separate.

Guard-ul pentru navigarea în aplicație:

TypeScript
export interface AreModificari {
  areModificariNesalvate(): boolean;
}

export const confirmaIesirea: CanDeactivateFn<AreModificari> = component =>
  !component.areModificariNesalvate() ||
  confirm('Ai modificări nesalvate. Pleci fără să salvezi?');
TypeScript
{ path: 'produse/:id/editare', component: EditareProdus, canDeactivate: [confirmaIesirea] }
TypeScript
@Component({
  selector: 'app-editare-produs',
  host: { '(window:beforeunload)': 'laInchidere($event)' },
  template: `...`,
})
export class EditareProdus implements AreModificari {
  form = inject(FormBuilder).nonNullable.group({ nume: [''], pret: [0] });

  areModificariNesalvate() {
    return this.form.dirty;
  }
  laInchidere(e: BeforeUnloadEvent) {
    if (this.areModificariNesalvate()) e.preventDefault();
  }
  salveaza() {
    // după salvare reușită:
    this.form.markAsPristine();
  }
}

Puncte de discutat:

  • guard-ul este generic, prin interfață, deci se poate refolosi pe orice pagină de editare;
  • după salvare, formularul e marcat pristine, altfel guard-ul întreabă și după salvare;
  • beforeunload acoperă închiderea tabului, reîncărcarea și navigarea spre alt site; browserele afișează un mesaj standard și ignoră textul personalizat;
  • confirm() blochează și nu poate fi stilizat; într-o aplicație reală, guard-ul poate întoarce un Observable sau un Promise de la un dialog propriu (de exemplu din Angular Material);
  • butonul Înapoi al browserului declanșează tot guard-ul; dacă navigarea e anulată, routerul readuce URL-ul la pagina curentă.

O alternativă care reduce nevoia de confirmări este salvarea automată a ciornei, de exemplu în localStorage, la fiecare modificare.

Ce urmărește intervievatorul: Verifică grija pentru experiența utilizatorului și cunoașterea ambelor mecanisme. Candidații uită des de beforeunload sau de resetarea stării după salvare.

71 Senior

Cum ai organiza rutarea și încărcarea codului într-o aplicație mare, cu mai multe secțiuni și roluri de utilizator?

Răspuns scurt: Fiecare secțiune are propriul fișier de rute încărcat leneș, cu guard-uri canMatch pe roluri și provideri locali doar unde e nevoie. Adaugi o strategie de preîncărcare potrivită, ții starea de navigare în URL și verifici dimensiunea chunk-urilor cu bugete în build.

Un model de răspuns structurat:

1. Împărțirea pe secțiuni. Rutele principale sunt doar puncte de intrare leneșe:

TypeScript
export const routes: Routes = [
  { path: '', loadComponent: () => import('./acasa/acasa') },
  { path: 'magazin', loadChildren: () => import('./magazin/magazin.routes') },
  {
    path: 'admin',
    canMatch: [areRol('admin')],
    loadChildren: () => import('./admin/admin.routes'),
  },
  { path: '**', loadComponent: () => import('./nu-exista/nu-exista') },
];

Fiecare secțiune își deține rutele, componentele și serviciile, iar echipa care lucrează pe ea nu atinge fișierul central.

2. Guard-uri reutilizabile. O fabrică areRol(rol) care întoarce un CanMatchFn evită duplicarea. canMatch împiedică descărcarea codului pentru cine nu are acces.

3. Servicii. Serviciile globale cu providedIn: 'root'; doar cele care aparțin clar unei secțiuni în providers pe rută, documentat, știind că injectorul rutei nu se distruge la plecare.

4. Preîncărcare. PreloadAllModules e simplu, dar descarcă și ce utilizatorul nu va folosi. O strategie proprie poate preîncărca doar rutele marcate cu data: { preload: true } sau doar pe conexiuni rapide.

5. Măsurare. Bugete în angular.json care opresc build-ul dacă bundle-ul inițial depășește o limită stabilită de echipă; analiza chunk-urilor după fiecare schimbare mare de dependențe.

6. Detalii de produs. Titluri pe fiecare rută, withInMemoryScrolling({ scrollPositionRestoration: 'enabled' }) pentru revenirea la poziție, withViewTransitions() pentru tranziții, pagina 404 cu status corect la randarea pe server.

Aș menționa și compromisul: prea multe chunk-uri mici înseamnă multe cereri; granularitatea se alege după fluxurile reale ale utilizatorilor.

Ce urmărește intervievatorul: Verifică gândirea arhitecturală la scară. Candidații de nivel senior trebuie să lege rutarea de performanță, securitate și organizarea echipelor.

Formulare

72 Junior

Care e diferența dintre formularele template-driven și cele reactive? Când îl alegi pe fiecare?

Răspuns scurt: La template-driven, formularul e descris în HTML cu ngModel, iar Angular creează controalele în spate. La reactive, creezi explicit FormGroup și FormControl în clasă și le legi de template. Template-driven pentru formulare mici; reactive pentru validări complexe, câmpuri dinamice și testare.

Template-driven (FormsModule):

HTML
<form #f="ngForm" (ngSubmit)="trimite(f.value)">
  <input name="email" [(ngModel)]="email" required email />
  <button [disabled]="f.invalid">Trimite</button>
</form>

Avantaje: puțin cod, familiar pentru cine vine din HTML. Dezavantaje: logica e împrăștiată în template, controalele sunt create asincron, deci greu de accesat imediat din cod, iar testarea cere randarea template-ului.

Reactive (ReactiveFormsModule):

TypeScript
form = inject(FormBuilder).nonNullable.group({
  email: ['', [Validators.required, Validators.email]],
  parola: ['', [Validators.required, Validators.minLength(8)]],
});
HTML
<form [formGroup]="form" (ngSubmit)="trimite()">
  <input formControlName="email" />
  <input formControlName="parola" type="password" />
  <button [disabled]="form.invalid">Trimite</button>
</form>

Avantaje: structura și validarea sunt în TypeScript, cu tipuri (din v14), disponibile sincron; ai valueChanges pentru reacții; câmpurile dinamice (FormArray) și validările între câmpuri sunt naturale; testezi formularul fără DOM.

Criterii de alegere:

  • un câmp de căutare sau un formular de contact: template-driven e suficient;
  • formulare de business, cu multe reguli, câmpuri condiționale, pași multipli: reactive;
  • consecvența contează: în același proiect, echipa alege de obicei un stil principal.

Al treilea model, Signal Forms (@angular/forms/signals), apărut experimental în v21, construiește formularul peste un signal cu modelul de date. Merită cunoscut, dar în proiectele existente vei lucra aproape sigur cu reactive forms.

Ce urmărește intervievatorul: Verifică dacă știi ambele abordări și criteriile de alegere. Răspunsul „reactive e mereu mai bun” fără argumente e slab.

Eroarea, în practică:Can't bind to 'ngModel' (input)NG01350: ngModel with a parent formGroup

73 Junior

Formularul de mai jos aruncă o eroare în consolă și câmpul nu funcționează. De ce?

HTML
<form (ngSubmit)="trimite()">
  <input [(ngModel)]="nume" />
  <button>Trimite</button>
</form>

Răspuns scurt: Într-un <form>, fiecare ngModel trebuie să aibă atributul name (sau [ngModelOptions]="{ standalone: true }"), pentru că NgForm îl folosește ca cheie a controlului. În plus, componenta trebuie să importe FormsModule, altfel ngModel nu e recunoscut.

Când FormsModule este importat, Angular pune automat o directivă NgForm pe orice <form>. Aceasta adună toate ngModel-urile din interior într-un FormGroup. Fiecare control are nevoie de o cheie, iar cheia este atributul name. Fără el, primești eroarea care cere name sau opțiunea standalone.

Varianta corectă:

TypeScript
@Component({
  selector: 'app-contact',
  imports: [FormsModule],
  template: `
    <form #f="ngForm" (ngSubmit)="trimite(f)">
      <input name="nume" [(ngModel)]="nume" required minlength="2" #n="ngModel" />
      @if (n.invalid && n.touched) {
        <p class="eroare">Numele are cel puțin 2 caractere.</p>
      }
      <button [disabled]="f.invalid">Trimite</button>
    </form>
  `,
})
export class Contact {
  nume = '';
  trimite(f: NgForm) {
    console.log(f.value); // { nume: '...' }
    f.resetForm();
  }
}

Alte capcane frecvente la template-driven:

  • fără FormsModule în imports, eroarea este „Can't bind to 'ngModel' since it isn't a known property of 'input'”;
  • două câmpuri cu același name se suprascriu reciproc în valoarea formularului;
  • (ngSubmit) se folosește în loc de (submit), pentru că marchează formularul ca trimis (f.submitted) și previne reîncărcarea paginii;
  • validatorii HTML (required, minlength, email) sunt transformați de Angular în validatori proprii; formularul primește automat novalidate, deci mesajele native ale browserului nu mai apar;
  • un buton fără type într-un formular este implicit submit; pentru butoane auxiliare (de exemplu „Anulează”) scrii type="button".

Ce urmărește intervievatorul: Verifică experiența practică cu formularele template-driven. Eroarea cu name lipsă este una dintre primele pe care le întâlnește un începător.

Eroarea, în practică:Can't bind to 'ngModel' (input)NG01352: ngModel within a form tag needs name

74 Junior

Ce sunt formularele reactive tipate? Ce face nonNullable și ce se întâmplă la reset()?

Răspuns scurt: Din v14, FormControl, FormGroup și FormBuilder deduc tipul valorilor, deci form.value.email are tip, iar greșelile de nume sunt prinse la compilare. Implicit un control poate deveni null după reset(); cu nonNullable, reset() revine la valoarea inițială, iar tipul nu include null.

TypeScript
const fb = inject(FormBuilder);

form = this.fb.group({
  nume: [''],
  varsta: [18],
});
// form.value: Partial<{ nume: string | null; varsta: number | null }>

De unde vine null: istoric, reset() setează valoarea controalelor la null. Ca să fie corect, tipul include null. Rezultatul: verificări peste tot.

Cu nonNullable:

TypeScript
form = this.fb.nonNullable.group({
  nume: ['', Validators.required],
  varsta: [18, [Validators.min(18)]],
  newsletter: [false],
});

this.form.reset(); // nume = '', varsta = 18, newsletter = false
const v = this.form.getRawValue(); // { nume: string; varsta: number; newsletter: boolean }

Varianta fără builder: new FormControl('', { nonNullable: true }).

Două detalii care apar des:

  • form.value are tip Partial<...>, pentru că exclude controalele dezactivate; getRawValue() include tot și are tipul complet. Pentru trimiterea la server folosești de obicei getRawValue();
  • un control care chiar poate lipsi se declarează explicit: new FormControl<string | null>(null).

Tipurile prind la compilare form.controls.emial sau form.patchValue({ varsta: '18' }). Pentru cod vechi, migrarea automată la v14 a transformat formularele în UntypedFormGroup, care păstrează vechiul comportament fără tipuri; le poți converti treptat.

FormRecord acoperă cazul în care cheile nu sunt cunoscute dinainte, toate cu același tip de valoare.

Ce urmărește intervievatorul: Verifică dacă folosești formularele cu tipuri complete. Mulți candidați nu știu de unde vine null din tipuri sau diferența dintre value și getRawValue().

Eroarea, în practică:TS2345: 'Partial<...>' is not assignable

75 Junior

Cum afișezi mesaje de eroare la validare doar după ce utilizatorul a interacționat cu câmpul? Ce înseamnă touched, dirty și pristine?

Răspuns scurt: Afișezi eroarea când controlul e invalid și touched (utilizatorul a părăsit câmpul) sau după încercarea de trimitere. dirty înseamnă că valoarea a fost modificată de utilizator, pristine că nu, iar touched că a primit și a pierdut focusul.

Stările unui control:

  • valid / invalid / pending: rezultatul validatorilor (pending cât rulează un validator asincron);
  • pristine / dirty: utilizatorul a modificat sau nu valoarea din interfață; setarea din cod cu setValue nu o face dirty;
  • untouched / touched: câmpul a pierdut sau nu focusul măcar o dată.

Mesajele afișate imediat la deschiderea paginii, pe câmpuri goale, sunt frustrante. Regula obișnuită: arăți eroarea după ce utilizatorul a ieșit din câmp sau după ce a încercat să trimită.

TypeScript
@Component({
  selector: 'app-inregistrare',
  imports: [ReactiveFormsModule],
  template: `
    <form [formGroup]="form" (ngSubmit)="trimite()">
      <label for="email">Email</label>
      <input id="email" formControlName="email" [attr.aria-invalid]="arataEroare('email')" />
      @if (arataEroare('email')) {
        @if (form.controls.email.hasError('required')) { <p>Emailul este obligatoriu.</p> }
        @if (form.controls.email.hasError('email')) { <p>Emailul nu are un format valid.</p> }
      }
      <button>Creează cont</button>
    </form>
  `,
})
export class Inregistrare {
  form = inject(FormBuilder).nonNullable.group({
    email: ['', [Validators.required, Validators.email]],
  });

  arataEroare(nume: 'email') {
    const c = this.form.controls[nume];
    return c.invalid && c.touched;
  }

  trimite() {
    if (this.form.invalid) {
      this.form.markAllAsTouched();
      return;
    }
    // trimite datele
  }
}

markAllAsTouched() la trimitere face ca toate erorile să apară deodată. Butonul rămâne activ intenționat: un buton dezactivat nu explică de ce nu poți continua.

Angular adaugă automat clase CSS (ng-invalid, ng-touched, ng-dirty), deci poți stiliza fără cod: input.ng-invalid.ng-touched { border-color: red; }. Pentru accesibilitate, legi mesajul de câmp cu aria-describedby.

Ce urmărește intervievatorul: Verifică grija pentru experiența utilizatorului și cunoașterea stărilor controlului. Greșeala tipică este afișarea erorilor imediat sau dezactivarea butonului fără explicație.

Eroarea, în practică:Cannot read properties of null (reading 'hasError')

76 Junior

Scrie un validator propriu pentru un câmp și unul pentru grup care verifică dacă parola și confirmarea coincid.

Răspuns scurt: Un validator este o funcție ValidatorFn care primește controlul și întoarce null dacă e valid sau un obiect de erori. Validatorul pentru grup se pune pe FormGroup, citește ambele câmpuri și întoarce eroarea la nivel de grup.

Validator pentru un câmp, configurabil:

TypeScript
export function interzice(cuvant: string): ValidatorFn {
  return (control: AbstractControl): ValidationErrors | null => {
    const v = String(control.value ?? '').toLowerCase();
    return v.includes(cuvant) ? { interzis: { cuvant } } : null;
  };
}

Validator pentru grup:

TypeScript
export const paroleEgale: ValidatorFn = (grup: AbstractControl) => {
  const parola = grup.get('parola')?.value;
  const confirmare = grup.get('confirmare')?.value;
  return parola && confirmare && parola !== confirmare ? { paroleDiferite: true } : null;
};

Folosire:

TypeScript
form = inject(FormBuilder).nonNullable.group(
  {
    utilizator: ['', [Validators.required, interzice('admin')]],
    parola: ['', [Validators.required, Validators.minLength(8)]],
    confirmare: ['', Validators.required],
  },
  { validators: paroleEgale }
);
HTML
@if (form.hasError('paroleDiferite') && form.controls.confirmare.touched) {
  <p>Parolele nu coincid.</p>
}
@if (form.controls.utilizator.hasError('interzis')) {
  <p>Numele nu poate conține „{{ form.controls.utilizator.getError('interzis').cuvant }}”.</p>
}

De ce validatorul de confirmare stă pe grup: un validator pe câmpul confirmare nu ar rula din nou când se schimbă parola, deci eroarea ar rămâne învechită. Validatorul de grup rulează la orice schimbare din interior.

Reguli bune:

  • validatorul e o funcție pură, fără efecte secundare;
  • obiectul de erori conține date utile mesajului (cuvant, lungimea cerută);
  • validatorii care nu se ocupă de câmpuri goale întorc null pentru ele și lasă required să decidă, ca să nu apară două mesaje pentru aceeași problemă.

Ce urmărește intervievatorul: Verifică dacă poți extinde sistemul de validare. Greșeala tipică este validarea confirmării pe câmp, care nu se actualizează când se schimbă parola.

Eroarea, în practică:TS4111: comes from an index signature

77 Mid

Cum construiești un formular cu un număr variabil de câmpuri (de exemplu mai multe numere de telefon) cu FormArray?

Răspuns scurt: Declari un FormArray de controale sau grupuri, îl legi cu formArrayName, iterezi peste controls cu @for și folosești push() și removeAt() pentru a adăuga sau șterge rânduri. Fiecare element își păstrează propria validare.

TypeScript
@Component({
  selector: 'app-contacte',
  imports: [ReactiveFormsModule],
  template: `
    <form [formGroup]="form" (ngSubmit)="salveaza()">
      <input formControlName="nume" placeholder="Nume" />
      <div formArrayName="telefoane">
        @for (t of telefoane.controls; track t; let i = $index) {
          <div [formGroupName]="i">
            <select formControlName="tip">
              <option value="mobil">Mobil</option>
              <option value="fix">Fix</option>
            </select>
            <input formControlName="numar" />
            <button type="button" (click)="telefoane.removeAt(i)">Șterge</button>
          </div>
        }
      </div>
      <button type="button" (click)="adaugaTelefon()">Adaugă telefon</button>
      <button>Salvează</button>
    </form>
  `,
})
export class Contacte {
  private fb = inject(FormBuilder).nonNullable;

  form = this.fb.group({
    nume: ['', Validators.required],
    telefoane: this.fb.array([this.rand()]),
  });

  get telefoane() {
    return this.form.controls.telefoane;
  }

  rand() {
    return this.fb.group({
      tip: ['mobil'],
      numar: ['', [Validators.required, Validators.pattern(/^[0-9+ ]{6,15}$/)]],
    });
  }

  adaugaTelefon() {
    this.telefoane.push(this.rand());
  }

  salveaza() {
    console.log(this.form.getRawValue());
  }
}

Puncte de atenție:

  • track t folosește identitatea obiectului de control, stabilă cât timp rândul există; track $index ar amesteca starea rândurilor la ștergere;
  • butoanele de adăugare și ștergere au type="button", altfel trimit formularul;
  • la încărcarea datelor existente, construiești întâi atâtea rânduri câte vin de la server, apoi apelezi patchValue; patchValue nu creează elemente noi în FormArray;
  • validarea întregului tablou (de exemplu „cel puțin un telefon mobil”) se pune ca validator pe FormArray.

Ce urmărește intervievatorul: Verifică experiența cu formulare dinamice reale. Candidații uită des că patchValue nu adaugă elemente în FormArray.

Eroarea, în practică:Cannot find control with path: 'adrese -> 0 -> ...'NG01001: Cannot find form control at index: 1

78 Mid

Cum scrii un validator asincron care verifică la server dacă un nume de utilizator e liber, fără să trimiți o cerere la fiecare tastă?

Răspuns scurt: Scrii o funcție AsyncValidatorFn care întoarce un Observable cu null sau erori, o pui în asyncValidators și setezi updateOn: 'blur' sau adaugi o întârziere cu timer în validator. Cât rulează, controlul are starea pending.

TypeScript
export function utilizatorLiber(api: UseriApi): AsyncValidatorFn {
  return (control: AbstractControl): Observable<ValidationErrors | null> => {
    const nume = String(control.value ?? '').trim();
    if (nume.length < 3) return of(null);
    return timer(400).pipe(
      switchMap(() => api.exista(nume)),
      map(exista => (exista ? { ocupat: true } : null)),
      catchError(() => of(null))
    );
  };
}
TypeScript
export class Inregistrare {
  private api = inject(UseriApi);

  form = inject(FormBuilder).nonNullable.group({
    utilizator: ['', {
      validators: [Validators.required, Validators.minLength(3)],
      asyncValidators: [utilizatorLiber(this.api)],
    }],
  });
}
HTML
@if (form.controls.utilizator.pending) { <small>Verific disponibilitatea...</small> }
@if (form.controls.utilizator.hasError('ocupat')) { <small>Numele este deja folosit.</small> }

Cum funcționează:

  • validatorii asincroni rulează doar după ce cei sincroni trec, deci nu se trimite nimic pentru un câmp gol sau prea scurt;
  • la fiecare schimbare, Angular se dezabonează de la verificarea anterioară; de aceea timer(400) funcționează ca debounce: dacă utilizatorul tastează din nou în 400 ms, timerul vechi e anulat înainte să plece cererea;
  • Observable-ul trebuie să se termine; un flux care nu se termină lasă controlul în pending pentru totdeauna;
  • catchError decide ce faci la o eroare de rețea; aici câmpul e considerat valid, iar serverul verifică oricum la trimitere.

Alternativă simplă: updateOn: 'blur' pe control, ca validarea (și valoarea) să se actualizeze doar la ieșirea din câmp.

Formularul are status PENDING cât rulează validarea; dacă trimiterea e permisă doar pentru VALID, butonul de trimitere trebuie să țină cont de această stare.

Ce urmărește intervievatorul: Verifică validarea asincronă corectă și grija pentru numărul de cereri. Greșeala tipică este un Observable care nu se termină sau o cerere la fiecare tastă.

79 Mid

Care e diferența dintre setValue și patchValue? Când folosești emitEvent: false și cum reacționezi la schimbări cu valueChanges?

Răspuns scurt: setValue cere toate câmpurile grupului și aruncă eroare dacă lipsește unul; patchValue actualizează doar câmpurile primite. valueChanges emite la fiecare schimbare; emitEvent: false modifică valoarea fără să emită, util ca să eviți bucle între câmpuri care se actualizează reciproc.

TypeScript
form = inject(FormBuilder).nonNullable.group({
  nume: [''],
  pretFaraTva: [0],
  pretCuTva: [0],
});

// aruncă eroare: lipsesc câmpurile de preț
this.form.setValue({ nume: 'Laptop' });

// corect: doar ce primești
this.form.patchValue({ nume: 'Laptop' });

setValue e util când vrei garanția că ai trimis structura completă, de exemplu la încărcarea unei entități de la server; patchValue e potrivit pentru actualizări parțiale.

Reacția la schimbări, cu două câmpuri care se calculează reciproc:

TypeScript
constructor() {
  const { pretFaraTva, pretCuTva } = this.form.controls;

  pretFaraTva.valueChanges.pipe(takeUntilDestroyed()).subscribe(v =>
    pretCuTva.setValue(+(v * 1.21).toFixed(2), { emitEvent: false })
  );
  pretCuTva.valueChanges.pipe(takeUntilDestroyed()).subscribe(v =>
    pretFaraTva.setValue(+(v / 1.21).toFixed(2), { emitEvent: false })
  );
}

Fără emitEvent: false, schimbarea unui câmp l-ar schimba pe celălalt, care l-ar schimba din nou pe primul, la nesfârșit. Cota de TVA din exemplu este doar ilustrativă; într-o aplicație reală vine din configurare.

Alte opțiuni utile:

  • onlySelf: true: nu propagă validarea și valoarea spre părinte;
  • statusChanges: emite VALID, INVALID, PENDING, DISABLED;
  • din v18, form.events este un flux unificat cu evenimente de valoare, status, touched, pristine și submit;
  • disable() și enable() schimbă și valoarea vizibilă în form.value, pentru că acesta exclude controalele dezactivate.

Ca să folosești valoarea formularului într-un computed, o transformi în signal: toSignal(this.form.valueChanges, { initialValue: this.form.getRawValue() }).

Ce urmărește intervievatorul: Verifică experiența cu formulare care au logică între câmpuri. Candidații creează des bucle infinite de valueChanges.

Eroarea, în practică:NG01002: Must supply a value for form control

80 Senior

Cum faci o componentă proprie (de exemplu un selector de stele pentru rating) care să funcționeze cu formControlName și ngModel?

Răspuns scurt: Implementezi interfața ControlValueAccessor (writeValue, registerOnChange, registerOnTouched, opțional setDisabledState) și te înregistrezi ca provider pentru NG_VALUE_ACCESSOR cu useExisting și multi: true. Așa formularele Angular vorbesc cu componenta ta ca și cu un input nativ.

TypeScript
@Component({
  selector: 'app-rating',
  providers: [{ provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => Rating), multi: true }],
  template: `
    @for (s of stele; track s) {
      <button type="button"
        [class.plin]="s <= valoare()"
        [disabled]="dezactivat()"
        [attr.aria-label]="s + ' stele'"
        (click)="alege(s)"
        (blur)="onTouched()">★</button>
    }
  `,
})
export class Rating implements ControlValueAccessor {
  stele = [1, 2, 3, 4, 5];
  valoare = signal(0);
  dezactivat = signal(false);

  private onChange: (v: number) => void = () => {};
  onTouched: () => void = () => {};

  writeValue(v: number | null) {
    this.valoare.set(v ?? 0);
  }
  registerOnChange(fn: (v: number) => void) {
    this.onChange = fn;
  }
  registerOnTouched(fn: () => void) {
    this.onTouched = fn;
  }
  setDisabledState(d: boolean) {
    this.dezactivat.set(d);
  }

  alege(s: number) {
    this.valoare.set(s);
    this.onChange(s);
  }
}
HTML
<app-rating formControlName="nota" />

Fluxul:

  • formular -> componentă: writeValue la inițializare, setValue, reset;
  • componentă -> formular: apelezi funcția primită prin registerOnChange când utilizatorul schimbă valoarea; nu o apelezi în writeValue, altfel formularul devine dirty din cod;
  • touched: registerOnTouched, apelat la pierderea focusului;
  • disabled: setDisabledState, când controlul e dezactivat din cod.

useExisting (nu useClass) e esențial: formularul trebuie să vorbească cu aceeași instanță care e pe ecran. Valorile din writeValue și din signal-uri sunt afișate corect și în zoneless, pentru că starea e în signals.

Validarea internă se poate expune prin NG_VALIDATORS și interfața Validator. Pentru Signal Forms există un contract mai simplu, bazat pe un model() pentru valoare, dar pentru reactive forms CVA rămâne standardul.

Ce urmărește intervievatorul: Verifică dacă poți integra componente proprii în sistemul de formulare. Greșeala tipică este apelarea onChange în writeValue sau useClass în loc de useExisting.

Eroarea, în practică:NG01203: No value accessor for form control name

81 Senior

Ce sunt Signal Forms și cum se compară cu reactive forms? Le-ai folosi acum într-un proiect de producție?

Răspuns scurt: Signal Forms (@angular/forms/signals, experimental din v21) construiesc formularul peste un signal cu modelul de date: form(model, schema) dă câmpuri cu stare ca signals, iar [formField] le leagă de inputuri. Pentru producție decid după statutul API-ului în versiunea folosită.

Modelul de date este sursa de adevăr; formularul e o „vedere” peste el:

TypeScript
import { form, FormField, required, email, minLength } from '@angular/forms/signals';

@Component({
  selector: 'app-login',
  imports: [FormField, JsonPipe],
  template: `
    <input [formField]="f.email" type="email" />
    @if (f.email().touched() && f.email().invalid()) {
      <p>Introdu un email valid.</p>
    }
    <input [formField]="f.parola" type="password" />
    <button [disabled]="f().invalid()">Intră</button>
    <pre>{{ model() | json }}</pre>
  `,
})
export class Login {
  model = signal({ email: '', parola: '' });
  f = form(this.model, p => {
    required(p.email);
    email(p.email);
    minLength(p.parola, 6);
  });
}

Diferențe față de reactive forms:

  • sursa de adevăr: un signal cu obiectul tău, nu o structură de FormControl-uri paralelă cu modelul;
  • stare ca signals: valid(), touched(), errors() se folosesc direct în computed și template, fără valueChanges și abonamente;
  • schemă declarativă: validările, câmpurile condiționale sau dezactivate se descriu într-o funcție de schemă refolosibilă;
  • tipuri deduse din model, fără nonNullable și getRawValue.

Răspunsul la „le folosești în producție” arată maturitatea: un API experimental se poate schimba între versiuni minore. Pentru un proiect nou, mic, cu o echipă care actualizează des, poate fi o alegere rezonabilă, izolată în câteva formulare. Pentru un produs mare, aș rămâne la reactive forms până la stabilizare și aș urmări notele de lansare. În ambele cazuri, logica de validare ținută în funcții pure se mută ușor dintr-un sistem în altul.

Ce urmărește intervievatorul: Verifică dacă urmărești evoluția framework-ului și ai judecată în alegerea API-urilor noi. Entuziasmul fără discuția despre statutul experimental e un semnal slab.

Change detection și performanță

82 Junior

Ce este detectarea schimbărilor (change detection) și ce rol avea zone.js?

Răspuns scurt: Detectarea schimbărilor este procesul prin care Angular verifică binding-urile din template și actualizează DOM-ul când datele s-au schimbat. Zone.js intercepta operațiile asincrone (click, timer, cerere HTTP) și pornea automat o verificare a întregului arbore de componente după fiecare.

Angular compilează fiecare template într-o funcție care, la fiecare verificare, evaluează expresiile ({{ nume }}, [disabled]="..."), compară rezultatul cu valoarea anterioară și atinge DOM-ul doar unde diferă.

Întrebarea este când să pornească verificarea. În modelul clasic:

  • zone.js modifică (monkey-patch) API-urile asincrone ale browserului: addEventListener, setTimeout, Promise, XHR;
  • după orice callback asincron terminat, Angular află prin NgZone și rulează ApplicationRef.tick();
  • tick() parcurge tot arborele de componente, de sus în jos, cu strategia implicită (Default).

Avantajul: „funcționează singur”, chiar și cu câmpuri simple modificate oriunde. Dezavantaje:

  • verificări inutile: un mousemove sau un timer dintr-o bibliotecă externă declanșează verificarea întregii aplicații;
  • cost de pornire și de bundle pentru zone.js;
  • stack trace-uri greu de citit și incompatibilități cu async/await nativ;
  • bug-uri ascunse, pentru că totul pare să meargă până activezi OnPush.

Optimizările clasice erau ChangeDetectionStrategy.OnPush și rularea codului greu în afara zonei (ngZone.runOutsideAngular).

Direcția actuală este zoneless: Angular pornește o verificare doar când primește o notificare explicită (signal citit în template schimbat, eveniment din template, async pipe, markForCheck). Zoneless este stabil din v20.2 și implicit în aplicațiile noi din v21; aplicațiile vechi folosesc încă zone.js până la migrare.

Ce urmărește intervievatorul: Verifică dacă înțelegi mecanismul de bază al framework-ului și de ce se schimbă. Mulți candidați cred că Angular „urmărește” automat variabilele.

Eroarea, în practică:NG0100: ExpressionChangedAfterItHasBeenCheckedNG0908: Angular requires Zone.js

83 Junior

De ce este o problemă de performanță codul de mai jos și cum îl repari?

TypeScript
@Component({
  selector: 'app-cos',
  template: `<p>Total: {{ calculeazaTotal() }} lei</p>`,
})
export class Cos {
  articole = signal<Articol[]>([]);
  calculeazaTotal() {
    console.log('calculez');
    return this.articole().reduce((s, a) => s + a.pret * a.cantitate, 0);
  }
}

Răspuns scurt: O metodă apelată în template rulează la fiecare verificare a componentei, chiar dacă datele nu s-au schimbat. Cu un calcul costisitor sau o listă mare, asta încetinește aplicația. Soluția: total = computed(...), care se recalculează doar când se schimbă articole, sau un pipe pur.

Angular nu știe ce face o metodă. Ca să afle dacă rezultatul s-a schimbat, trebuie s-o apeleze la fiecare verificare a view-ului. În aplicațiile cu zone.js și strategia implicită, orice click, timer sau răspuns HTTP din aplicație verifică toate componentele, deci calculez apare în consolă de multe ori, fără legătură cu coșul.

Câteva apeluri ieftine nu contează. Problema apare când:

  • metoda face calcule pe liste mari, sortări, filtrări, formatări complicate;
  • metoda e apelată într-un @for cu sute de rânduri;
  • metoda creează obiecte sau tablouri noi la fiecare apel, ceea ce poate provoca actualizări inutile de DOM și, pentru inputuri, recalculări în copii.

Variantele corecte:

TypeScript
export class Cos {
  articole = signal<Articol[]>([]);
  total = computed(() => {
    console.log('calculez');
    return this.articole().reduce((s, a) => s + a.pret * a.cantitate, 0);
  });
}
HTML
<p>Total: {{ total() }} lei</p>

Acum calculez apare o dată la pornire și o dată la fiecare schimbare a coșului. Citirea total() între schimbări întoarce valoarea memorată.

Pentru transformări de prezentare folosite în mai multe locuri, un pipe pur dă același beneficiu: este recalculat doar când se schimbă referința argumentului.

Regula de bun-simț: în template stau citiri de signals, computed și pipes. Metodele apelate în template sunt acceptabile doar pentru operații banale, iar în handler-ele de evenimente ((click)="salveaza()") metodele sunt, evident, în regulă.

Ce urmărește intervievatorul: Verifică dacă știi costul expresiilor din template. Este una dintre cele mai frecvente probleme de performanță în aplicațiile Angular.

84 Junior

Ce face blocul @defer și ce declanșatori are? Prin ce diferă de lazy loading pe rute?

Răspuns scurt: @defer încarcă leneș o parte dintr-un template: componentele din bloc ajung într-un chunk separat, descărcat doar când e îndeplinit un declanșator (on viewport, on idle, on interaction, on timer, when conditie). Lazy loading pe rute amână o pagină întreagă; @defer amână o bucată din pagină.

HTML
<app-galerie [produs]="produs()" />

@defer (on viewport) {
  <app-recenzii [produsId]="produs().id" />
} @placeholder (minimum 300ms) {
  <div class="schelet">Recenzii</div>
} @loading (after 150ms; minimum 400ms) {
  <p>Se încarcă recenziile...</p>
} @error {
  <p>Recenziile nu au putut fi încărcate.</p>
}

@defer (on interaction(btnHarta)) {
  <app-harta-magazine />
} @placeholder {
  <button #btnHarta>Arată magazinele pe hartă</button>
}

Declanșatori:

  • on idle (implicit): când browserul e liber;
  • on viewport: când placeholder-ul intră în ecran;
  • on interaction / on hover: la click sau hover pe placeholder ori pe un element dat;
  • on timer(2s), on immediate;
  • when conditie(): când o expresie devine adevărată (o singură dată, nu se reverifică după aceea);
  • prefetch on idle: descarcă codul din timp, dar îl afișează abia la declanșatorul principal.

Blocurile secundare:

  • @placeholder: ce se vede înainte de declanșare;
  • @loading: în timpul descărcării; after evită clipirea pentru încărcări rapide;
  • @error: dacă descărcarea eșuează.

Condiția esențială: componentele din bloc trebuie să fie standalone și să nu fie folosite static în altă parte a aceluiași fișier, altfel compilatorul nu le poate separa și ajung oricum în bundle-ul principal.

@defer a apărut în v17 și e stabil din v18. Se potrivește pentru componente grele sub fold (grafice, hărți, editoare, comentarii). La randarea pe server, blocurile @defer randează placeholder-ul, iar cu hidratarea incrementală pot fi hidratate leneș.

Ce urmărește intervievatorul: Verifică dacă știi instrumentul modern de încărcare amânată. Greșeala tipică este folosirea componentei amânate și în afara blocului, ceea ce anulează separarea.

85 Mid

Ce face ChangeDetectionStrategy.OnPush? De ce componenta copil de mai jos nu afișează produsul nou adăugat?

TypeScript
@Component({
  selector: 'app-lista',
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `@for (p of produse; track p.id) { <li>{{ p.nume }}</li> }`,
})
export class Lista {
  @Input() produse: Produs[] = [];
}

// în părinte
adauga(p: Produs) { this.produse.push(p); }

Răspuns scurt: O componentă OnPush e verificată doar la referință nouă pe un input, la un eveniment din ea, la schimbarea unui signal citit în template sau la markForCheck. push păstrează referința, deci copilul nu e verificat. Soluția: tablou nou, ideal în signals.

Strategia implicită verifică o componentă la fiecare ciclu de detectare. OnPush sare peste componentă (și peste subarborele ei) dacă nu a fost marcată „murdară”. O componentă OnPush se marchează când:

  • un input primește o referință nouă (comparație cu ===), prin binding în template;
  • un eveniment legat în template-ul ei sau al unui copil este tratat;
  • un signal citit în template-ul ei își schimbă valoarea;
  • async pipe-ul primește o valoare (apelează intern markForCheck);
  • se apelează explicit ChangeDetectorRef.markForCheck().

În exemplu, părintele mută tabloul pe loc. Input-ul primește aceeași referință, deci Lista nu e marcată și afișează lista veche. Cu strategia implicită ar fi funcționat, ceea ce arată că bug-ul era ascuns de verificările excesive.

Reparația:

TypeScript
// părinte
produse = signal<Produs[]>([]);
adauga(p: Produs) {
  this.produse.update(l => [...l, p]);
}

// copil
export class Lista {
  produse = input<Produs[]>([]);
}
HTML
<app-lista [produse]="produse()" />

Cu signals, componenta e corectă indiferent de strategie, iar OnPush aduce câștigul: într-un arbore mare, Angular verifică doar ramurile afectate.

OnPush presupune o disciplină: date imutabile, stare în signals sau Observable consumat cu async. Codul care atribuie câmpuri din callback-uri (setTimeout, subscribe) nu se mai actualizează; e același tip de cod care se strică la trecerea la zoneless, de aceea OnPush peste tot este un pas bun înainte de migrare.

Ce urmărește intervievatorul: Verifică dacă înțelegi exact când se verifică o componentă OnPush. Este o întrebare de bază la interviurile Angular de nivel mid.

86 Mid

Ce înseamnă o aplicație zoneless, cum o activezi și ce trebuie verificat la migrarea unei aplicații existente?

Răspuns scurt: Zoneless înseamnă fără zone.js: Angular programează actualizarea ecranului doar la notificări explicite (signals din template, evenimente din template, async pipe, markForCheck). Se activează cu provideZonelessChangeDetection() și scoaterea zone.js din polyfills; e stabil din v20.2 și implicit în proiectele noi din v21.

Activarea:

TypeScript
// app.config.ts
providers: [provideZonelessChangeDetection()]

și eliminarea zone.js din polyfills în angular.json (și din configurarea testelor), apoi dezinstalarea pachetului. Înainte de v20, funcția se numea provideExperimentalZonelessChangeDetection.

Ce câștigi:

  • mai puțin JavaScript la pornire și fără monkey-patching al API-urilor browserului;
  • verificări doar când chiar s-a schimbat ceva;
  • stack trace-uri curate și async/await nativ;
  • compatibilitate mai bună cu micro-frontend-uri și biblioteci externe.

Ce se strică la migrare, de verificat sistematic:

  • câmpuri simple modificate în setTimeout, setInterval, subscribe, then, listener-e adăugate manual cu addEventListener; soluția: signals sau markForCheck();
  • cod care folosește NgZone.onStable sau onMicrotaskEmpty ca să afle când s-a terminat randarea; se înlocuiește cu afterNextRender;
  • teste care se bazau pe fakeAsync și tick din zone.js; se trec pe await fixture.whenStable() și timere false ale runner-ului de test;
  • biblioteci terțe care presupun zone.js; trebuie verificate versiunile compatibile.

Pași practici: 1. treci componentele pe OnPush și starea pe signals; o aplicație care funcționează complet cu OnPush este aproape pregătită; 2. activează zoneless într-un mediu de test și parcurge fluxurile principale; 3. caută locurile în care ecranul nu se actualizează și repară-le la sursă, nu cu detectChanges() presărat peste tot.

NgZone.run() și runOutsideAngular() rămân apelabile, dar devin fără efect real, deci codul vechi nu se strică doar din cauza lor.

Ce urmărește intervievatorul: Verifică dacă ești la zi cu modelul curent și știi riscurile migrării. Candidații spun des doar „e mai rapid”, fără să știe ce cod se strică.

Eroarea, în practică:NG0908: Angular requires Zone.jsNG0408: Both provideZoneChangeDetection and ...

87 Mid

Ce înseamnă eroarea ExpressionChangedAfterItHasBeenCheckedError și cum o repari corect?

Răspuns scurt: În dezvoltare, Angular verifică binding-urile de două ori; dacă a doua verificare dă altă valoare, aruncă această eroare. O valoare afișată s-a schimbat în timpul randării, de obicei din ngAfterViewInit sau dintr-un copil. Repari fluxul datelor, nu ascunzi eroarea.

Angular presupune un flux unidirecțional: de sus în jos, o singură trecere produce o imagine stabilă. În dezvoltare, după fiecare ciclu, rulează o a doua verificare care nu modifică nimic, doar compară. Dacă o expresie dă alt rezultat, înseamnă că ecranul afișat e deja greșit sau că o actualizare ar produce alta, la nesfârșit.

Cauze tipice:

TypeScript
export class Panou implements AfterViewInit {
  titlu = 'Se încarcă';
  ngAfterViewInit() {
    this.titlu = 'Gata'; // view-ul a fost deja verificat cu „Se încarcă”
  }
}
  • modificarea stării afișate în ngAfterViewInit sau ngAfterViewChecked;
  • un copil care, la inițializare, modifică o valoare a părintelui deja verificată (prin serviciu sau output emis sincron);
  • getter-e sau metode din template care întorc valori noi la fiecare apel (new Date(), Math.random(), un obiect nou).

Reparații corecte:

  • calculezi valoarea mai devreme (în constructor, ngOnInit) sau o derivezi cu computed;
  • treci starea în signals: o schimbare de signal în timpul randării programează corect o nouă trecere în loc să producă inconsistență; cu signals, eroarea apare mult mai rar;
  • pentru cod care chiar depinde de măsurarea DOM-ului, folosești afterNextRender și scrii rezultatul într-un signal;
  • restructurezi datele astfel încât părintele să dețină starea, nu copilul să o modifice.

Ce nu e bine: setTimeout(() => ...) sau cdr.detectChanges() adăugate doar ca să dispară mesajul. Ascund problema, adaugă o randare în plus și pot produce clipiri vizibile.

Eroarea nu apare în producție, pentru că a doua verificare rulează doar în dezvoltare. Dar bug-ul de fond, o valoare afișată inconsistent, rămâne și acolo.

Ce urmărește intervievatorul: Verifică înțelegerea fluxului unidirecțional al datelor. Candidații slabi repară cu setTimeout fără să știe de ce funcționează.

Eroarea, în practică:NG0100: ExpressionChangedAfterItHasBeenCheckedNG0100: Previous value for 'disabled'

88 Mid

Bundle-ul inițial al aplicației a crescut mult. Cum afli ce îl ocupă și cum îl reduci?

Răspuns scurt: Generezi build-ul cu --stats-json sau source maps și îl analizezi cu un instrument vizual, identifici dependențele mari și codul care putea fi încărcat leneș, apoi aplici rute leneșe, @defer, importuri mai precise și înlocuirea bibliotecilor grele. Bugetele din angular.json previn regresiile.

Pașii:

1. Măsoară. La ng build, CLI-ul afișează dimensiunea fiecărui fișier inițial și leneș. Pentru detalii:

BASH
ng build --stats-json
npx esbuild-visualizer --metadata dist/<proiect>/stats.json
# sau, cu source maps:
ng build --source-map
npx source-map-explorer dist/<proiect>/browser/*.js

Builder-ul application (bazat pe esbuild, implicit din v17) generează metadate compatibile cu analizoarele esbuild.

2. Cauze frecvente:

  • o pagină sau componentă grea importată static din ruta inițială;
  • biblioteci mari folosite într-un singur loc (grafice, editoare, exportare PDF);
  • biblioteci importate integral în loc de importuri punctuale;
  • module vechi care aduc multe componente, deși folosești una;
  • imagini sau JSON-uri mari incluse în cod.

3. Reduceri:

  • rute cu loadComponent/loadChildren;
  • @defer pentru componente grele din pagină;
  • import() dinamic pentru biblioteci folosite la o acțiune: const { jsPDF } = await import('jspdf');
  • importuri punctuale și biblioteci compatibile cu tree shaking (module ES);
  • componente standalone, ca bundler-ul să elimine ce nu folosești;
  • imagini prin NgOptimizedImage, care adaugă lazy loading și dimensiuni explicite.

4. Previne regresiile cu bugete:

JSON
"budgets": [
  { "type": "initial", "maximumWarning": "500kB", "maximumError": "1MB" },
  { "type": "anyComponentStyle", "maximumWarning": "4kB" }
]

Valorile se stabilesc de echipă, pornind de la situația curentă.

În final, măsori efectul real în browser (Lighthouse, tabul Network pe o conexiune lentă simulată), pentru că dimensiunea bundle-ului e doar un indicator; ce contează e timpul până la conținutul util.

Ce urmărește intervievatorul: Verifică dacă abordezi performanța prin măsurare, nu prin ghicit. Candidații propun des optimizări fără să fi analizat bundle-ul.

Eroarea, în practică:bundle initial exceeded maximum budget

89 Mid

O listă cu câteva mii de rânduri face pagina greoaie. Ce opțiuni ai în Angular?

Răspuns scurt: Întâi verifici track corect și componentele rândurilor (OnPush, signals, fără metode în template). Apoi reduci ce e în DOM: paginare, încărcare progresivă sau virtual scrolling cu cdk-virtual-scroll-viewport din Angular CDK, care randează doar rândurile vizibile.

Costul vine din două locuri: numărul de noduri DOM și munca făcută la fiecare verificare.

1. Igiena de bază.

  • track pe un id stabil; cu track $index sau cu obiecte recreate la fiecare încărcare, Angular recreează rânduri inutil;
  • componenta rândului cu OnPush și date primite prin inputuri;
  • niciun apel de metodă costisitoare în template-ul rândului; valorile calculate o dată, în computed sau în datele pregătite din serviciu;
  • filtrarea și sortarea într-un computed, nu în template.

2. Mai puține elemente în DOM.

  • paginare pe server: cea mai simplă și adesea cea mai bună pentru utilizator;
  • încărcare progresivă („Încarcă mai mult” sau la derulare, cu IntersectionObserver ori @defer (on viewport));
  • virtual scrolling pentru liste lungi pe care utilizatorul chiar le parcurge:
TypeScript
@Component({
  selector: 'app-tranzactii',
  imports: [ScrollingModule],
  template: `
    <cdk-virtual-scroll-viewport itemSize="48" class="lista">
      <div *cdkVirtualFor="let t of tranzactii(); trackBy: dupaId" class="rand">
        {{ t.data }} | {{ t.suma }} lei
      </div>
    </cdk-virtual-scroll-viewport>
  `,
  styles: `.lista { height: 600px; } .rand { height: 48px; }`,
})
export class Tranzactii {
  tranzactii = input.required<Tranzactie[]>();
  dupaId = (_: number, t: Tranzactie) => t.id;
}

Viewport-ul are înălțime fixă, iar itemSize trebuie să corespundă înălțimii reale a rândurilor.

Compromisuri ale virtualizării: căutarea cu Ctrl+F din browser găsește doar rândurile randate, rândurile cu înălțimi variabile cer strategii speciale, iar accesibilitatea (anunțarea numărului total de rânduri) trebuie tratată explicit.

Măsori înainte și după cu tabul Performance din Chrome și cu profiler-ul din Angular DevTools, ca să știi ce parte a costului ai redus.

Ce urmărește intervievatorul: Verifică dacă știi mai multe niveluri de optimizare, nu doar o bibliotecă. Candidații sar direct la virtual scroll fără să verifice track și costul fiecărui rând.

Eroarea, în practică:NG0956: track by identity re-created the collection

90 Senior

Cum funcționează SSR, prerendering-ul și hidratarea în Angular? Ce aduce hidratarea incrementală și ce probleme apar de obicei?

Răspuns scurt: SSR randează HTML-ul pe server la fiecare cerere, prerendering-ul îl generează la build, iar hidratarea refolosește DOM-ul primit în loc să-l recreeze. Hidratarea incrementală (stabilă din v20) hidratează blocuri @defer doar la nevoie. Problemele tipice: API-uri de browser pe server și DOM modificat manual.

Configurare: ng new --ssr sau ng add @angular/ssr. Rezultatul are o parte pentru browser și una pentru server (Node), plus configurarea modului de randare pe rute:

TypeScript
// app.routes.server.ts
export const serverRoutes: ServerRoute[] = [
  { path: '', renderMode: RenderMode.Prerender },
  { path: 'produse/:id', renderMode: RenderMode.Server },
  { path: 'cont/**', renderMode: RenderMode.Client },
];

Moduri:

  • Prerender (SSG): HTML generat la build; ideal pentru pagini care se schimbă rar;
  • Server (SSR): HTML la fiecare cerere; date proaspete, indexabile;
  • Client (CSR): fără randare pe server, pentru zone private.

Hidratarea (provideClientHydration()): în loc să șteargă HTML-ul de pe server și să randeze din nou, Angular atașează componentele și evenimentele la DOM-ul existent. Fără ea, pagina ar clipi. withEventReplay() reține click-urile făcute înainte de hidratare și le reia apoi. HttpClient transferă automat răspunsurile GET de pe server în pagină, ca să nu repete cererile în browser.

Hidratarea incrementală (withIncrementalHydration()): blocurile @defer sunt randate pe server, dar rămân „uscate” până la un declanșator:

HTML
@defer (hydrate on viewport) {
  <app-recenzii />
}

Codul lor nu se descarcă până atunci, deci pagina devine interactivă mai repede.

Probleme frecvente:

  • window, document, localStorage nu există pe server; folosești afterNextRender, inject(DOCUMENT) sau verificarea platformei;
  • manipularea directă a DOM-ului sau biblioteci care o fac produc nepotriviri la hidratare (eroarea NG0500); se exclud cu ngSkipHydration doar ca soluție temporară;
  • timere sau cereri care nu se termină împiedică serverul să considere aplicația stabilă și întârzie răspunsul;
  • datele specifice utilizatorului nu trebuie memorate în cache-ul paginilor prerandate.

Ce urmărește intervievatorul: Verifică experiența cu randarea pe server, importantă pentru SEO și performanță. Candidații de nivel senior trebuie să știe de unde vin erorile de hidratare.

91 Senior

Utilizatorii spun că o pagină Angular devine lentă după câteva minute de folosire. Cum investighezi, pas cu pas?

Răspuns scurt: Reproduci problema, apoi măsori: profiler-ul din Angular DevTools pentru detectarea schimbărilor, tabul Performance din Chrome pentru task-uri lungi și tabul Memory pentru scurgeri. „Lent după câteva minute” sugerează de obicei abonamente, timere sau listener-e neeliberate.

Un model de răspuns structurat:

1. Clarific și reproduc. Ce pagină, ce acțiuni, ce browser și dispozitiv, din ce versiune a aplicației. Încerc să reproduc local, pe un build de producție, nu în modul de dezvoltare, care e mai lent din cauza verificărilor suplimentare.

2. Formulez ipoteze din simptom. Faptul că degradarea apare în timp indică acumulare: memorie care crește, abonamente duplicate la fiecare navigare, setInterval neoprit, listener-e pe window neeliminate, liste care cresc fără limită.

3. Măsor memoria. În Chrome DevTools, tabul Memory: un heap snapshot, navighez de câteva ori dus-întors pe pagina suspectă, alt snapshot, compar. Dacă numărul de instanțe ale unei componente crește deși doar una e pe ecran, cineva încă ține referințe la cele distruse, de obicei un abonament la un serviciu root.

4. Măsor timpul de procesor. Profiler-ul din Angular DevTools arată câte cicluri de detectare rulează și ce componente costă. Multe cicluri fără interacțiune indică un timer sau un flux care declanșează verificări continuu. Tabul Performance din Chrome arată task-urile lungi și funcțiile care le ocupă.

5. Repar cauza. Abonamente cu takeUntilDestroyed sau toSignal, curățare cu DestroyRef.onDestroy, OnPush și computed în locul metodelor din template, limitarea listelor care cresc.

6. Verific și previn. Repet măsurarea și compar cifrele obținute înainte și după. Adaug un test sau o regulă de lint (de exemplu împotriva abonamentelor fără dezabonare) și notez cauza în descrierea PR-ului, ca echipa să învețe din ea.

Important de spus la interviu: nu ghicesc și nu aplic optimizări la întâmplare; fiecare schimbare e justificată de o măsurătoare.

Ce urmărește intervievatorul: Verifică metoda de depanare și cunoașterea instrumentelor. Candidații slabi propun direct „pun OnPush peste tot” fără investigație.

Eroarea, în practică:Abonament care continuă după distrugere

Testare, arhitectură și situații practice

Exersează capitolul cu exerciții reale: Curs Angular →
92 Junior

Cum scrii un test pentru o componentă cu TestBed? Ce se schimbă într-o aplicație zoneless?

Răspuns scurt: Configurezi TestBed cu imports: [Componenta] și provideri, creezi componenta cu TestBed.createComponent, declanșezi randarea (await fixture.whenStable() sau detectChanges()), apoi verifici DOM-ul prin fixture.nativeElement. În zoneless, aștepți stabilizarea în loc să te bazezi pe zone.js.

Componenta testată:

TypeScript
@Component({
  selector: 'app-contor',
  template: `
    <p>{{ valoare() }}</p>
    <button (click)="valoare.update(v => v + 1)">+</button>
  `,
})
export class Contor {
  valoare = signal(0);
}

Testul:

TypeScript
describe('Contor', () => {
  let fixture: ComponentFixture<Contor>;
  let el: HTMLElement;

  beforeEach(async () => {
    await TestBed.configureTestingModule({ imports: [Contor] }).compileComponents();
    fixture = TestBed.createComponent(Contor);
    el = fixture.nativeElement;
    await fixture.whenStable();
  });

  it('pornește de la 0', () => {
    expect(el.querySelector('p')?.textContent).toBe('0');
  });

  it('crește la click', async () => {
    el.querySelector('button')!.click();
    await fixture.whenStable();
    expect(el.querySelector('p')?.textContent).toBe('1');
  });
});

Ce trebuie reținut:

  • componenta standalone se pune în imports, nu în declarations;
  • testul verifică ce vede utilizatorul (textul din DOM), nu doar starea internă; așa testul rezistă la refactorizări;
  • după o interacțiune, aștepți actualizarea; în zoneless, await fixture.whenStable() este varianta recomandată, iar detectChanges() forțează sincron o verificare;
  • pentru inputuri: fixture.componentRef.setInput('produs', p), nu atribuire directă pe componentInstance.

Runner-ul de teste: proiectele vechi foloseau Karma cu Jasmine; Karma este depreciat, iar proiectele noi generate de CLI folosesc Vitest (implicit din v21). Sintaxa describe/it/expect e aproape aceeași, diferă în special spionii și timerele false (jasmine.createSpy vs vi.fn).

Ce urmărește intervievatorul: Verifică dacă poți scrie teste reale pentru componente. Greșeala tipică este verificarea stării interne în loc de DOM sau uitarea actualizării după click.

Eroarea, în practică:Expected '' to be ... (fără detectChanges)

93 Junior

Cum testezi un serviciu care face cereri HTTP, fără server real?

Răspuns scurt: Adaugi provideHttpClient() și provideHttpClientTesting() în TestBed, apelezi metoda serviciului, iar cu HttpTestingController verifici cererea așteptată (expectOne), îi dai un răspuns fals (flush) și la final confirmi că nu au rămas cereri neașteptate (verify).

TypeScript
describe('ProduseApi', () => {
  let api: ProduseApi;
  let http: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({
      providers: [provideHttpClient(), provideHttpClientTesting()],
    });
    api = TestBed.inject(ProduseApi);
    http = TestBed.inject(HttpTestingController);
  });

  afterEach(() => http.verify());

  it('cere lista de produse și întoarce datele', () => {
    let rezultat: Produs[] = [];
    api.lista('laptop').subscribe(r => (rezultat = r));

    const req = http.expectOne(r => r.url === '/api/produse');
    expect(req.request.method).toBe('GET');
    expect(req.request.params.get('q')).toBe('laptop');

    req.flush([{ id: 1, nume: 'Laptop', pret: 3000 }]);
    expect(rezultat.length).toBe(1);
  });

  it('propagă eroarea serverului', () => {
    let status = 0;
    api.lista().subscribe({ error: (e: HttpErrorResponse) => (status = e.status) });

    http.expectOne(r => r.url === '/api/produse')
      .flush('Eroare', { status: 500, statusText: 'Server Error' });
    expect(status).toBe(500);
  });
});

Ce verifici cu adevărat:

  • metoda, URL-ul, parametrii, headerele și corpul cererii (contractul cu serverul);
  • cum transformă serviciul răspunsul;
  • cum tratează erorile.

Ordinea din provideHttpClient contează: provideHttpClientTesting() vine după, ca să înlocuiască trimiterea reală. Dacă serviciul folosește interceptori, îi adaugi tot în provideHttpClient(withInterceptors([...])), ca să fie și ei testați.

verify() în afterEach prinde cereri trimise în plus, de exemplu două subscribe care pornesc două cereri. Pentru componente care folosesc serviciul, de obicei e mai simplu să înlocuiești serviciul cu o variantă falsă decât să simulezi HTTP-ul.

Ce urmărește intervievatorul: Verifică experiența cu testarea codului care comunică cu serverul. Candidații uită de verify() sau testează doar cazul fericit.

Eroarea, în practică:No provider for HttpTestingControllerExpected one matching request ..., found none

94 Junior

Ce comenzi Angular CLI folosești zilnic și cum arată structura unui proiect generat?

Răspuns scurt: ng new creează proiectul, ng serve pornește serverul de dezvoltare, ng generate creează componente, servicii, guards, ng build produce varianta de producție, ng test rulează testele, iar ng update actualizează versiunea cu migrări automate. Configurarea e în angular.json, codul în src/app.

Comenzile de bază:

BASH
ng new magazin --ssr=false --style=css
ng serve
ng generate component produse/lista-produse
ng g service produse/produse-api
ng g guard auth/este-logat --functional
ng build
ng test
ng update @angular/core @angular/cli
ng add @angular/material

Structura tipică într-un proiect recent:

angular.json        configurarea build-ului, serve, test, bugete
package.json        dependențe și scripturi
tsconfig.json       opțiunile TypeScript (strict activat implicit)
public/             fișiere statice (favicon, imagini)
src/
  index.html
  main.ts           bootstrapApplication(App, appConfig)
  styles.css        stiluri globale
  app/
    app.ts          componenta rădăcină
    app.html
    app.css
    app.config.ts   providers globali
    app.routes.ts   rutele

Detalii pe care le poți menționa:

  • din v20, ghidul de stil renunță la sufixe în numele fișierelor (app.ts, nu app.component.ts), iar CLI-ul generează astfel; în proiectele vechi vei vedea varianta lungă;
  • ng build produce implicit varianta de producție, cu optimizare, eliminarea codului nefolosit și nume de fișiere cu hash pentru cache;
  • ng serve folosește un server de dezvoltare bazat pe Vite, cu reîncărcare rapidă;
  • configurările pe medii se pot face cu fișiere environment (generate la cerere cu ng g environments) sau cu configurare încărcată la rulare;
  • ng add instalează o bibliotecă și rulează configurarea ei automată;
  • ng update rulează migrările de cod incluse în versiunea nouă, de aceea actualizările se fac cu el, nu manual în package.json.

Ce urmărește intervievatorul: Verifică familiaritatea cu instrumentele de zi cu zi. Candidații care au lucrat doar cu tutoriale nu știu de ng update și de rolul lui angular.json.

Eroarea, în practică:ng: command not found

95 Junior

Un coleg vine din React și trebuie să lucreze pe proiectul vostru Angular. Cum i-ai explica principalele diferențe?

Răspuns scurt: Pornesc de la ce știe: componente, stare, efecte, rutare. Arăt echivalențele (signal pentru useState, computed pentru useMemo, servicii cu DI pentru Context) și ce e nou: template-uri separate, dependency injection, CLI și convențiile proiectului.

Un model de răspuns structurat:

1. Pornesc de la ce știe. Componentele există în ambele, cu date care vin de la părinte și evenimente care urcă. Fac un tabel scurt de echivalențe:

  • props: input(); callback-uri ca props: output();
  • useState: signal(); useMemo: computed(); useEffect: effect(), folosit mai rar;
  • Context și store-uri: servicii injectate cu inject();
  • JSX: template HTML cu @if, @for și binding-uri;
  • React Router, TanStack Query: router-ul inclus, httpResource, HttpClient cu RxJS.

2. Explic diferența de model. În React, componenta e o funcție reapelată la fiecare randare, de aici regulile hook-urilor și closure-urile învechite. În Angular, clasa e creată o singură dată, iar signals anunță exact ce trebuie actualizat. Nu există reguli despre ordinea apelurilor, dar există reguli despre contextul de injecție.

3. Arăt ce e nou pentru el. Dependency injection și ierarhia de injectori, RxJS (doar operatorii pe care îi folosim efectiv), CLI-ul, structura proiectului și convențiile echipei.

4. Învățare prin practică. Îi dau un tichet mic, real, pe o zonă bine scrisă, și facem pair programming la prima componentă. Îi arăt un PR bun din proiect ca exemplu.

5. Verific înțelegerea. La primul code review explic de ce cer o schimbare, nu doar ce, și îl întreb ce i s-a părut ciudat; întrebările lui arată adesea și locuri neclare din proiect.

Evit să compar framework-urile în termeni de „mai bun”; scopul este să devină productiv repede.

Ce urmărește intervievatorul: Verifică abilitatea de a explica și de a lucra în echipă, plus înțelegerea ambelor modele. Răspunsurile care critică celălalt framework sunt un semnal slab.

96 Mid

Cum înlocuiești dependențele unei componente în teste? Arată un exemplu cu un serviciu fals și un spion.

Răspuns scurt: În TestBed dai un provider pentru același token cu useValue (un obiect fals) sau useClass, iar metodele le înlocuiești cu spioni (vi.fn() în Vitest, jasmine.createSpy în Jasmine). Apoi verifici atât DOM-ul, cât și apelurile făcute spre serviciu.

Componenta:

TypeScript
@Component({
  selector: 'app-produse',
  template: `
    @for (p of produse(); track p.id) {
      <li>{{ p.nume }} <button (click)="sterge(p.id)">x</button></li>
    }
  `,
})
export class Produse {
  private api = inject(ProduseApi);
  produse = toSignal(this.api.lista(), { initialValue: [] as Produs[] });
  sterge(id: number) {
    this.api.sterge(id).subscribe();
  }
}

Testul, cu Vitest:

TypeScript
describe('Produse', () => {
  const apiFals = {
    lista: vi.fn(() => of([{ id: 1, nume: 'Laptop', pret: 3000 }])),
    sterge: vi.fn(() => of(void 0)),
  };

  beforeEach(async () => {
    vi.clearAllMocks();
    await TestBed.configureTestingModule({
      imports: [Produse],
      providers: [{ provide: ProduseApi, useValue: apiFals }],
    }).compileComponents();
  });

  it('afișează produsele și cere ștergerea', async () => {
    const fixture = TestBed.createComponent(Produse);
    await fixture.whenStable();
    const el: HTMLElement = fixture.nativeElement;

    expect(el.querySelectorAll('li').length).toBe(1);
    el.querySelector('button')!.click();
    expect(apiFals.sterge).toHaveBeenCalledWith(1);
  });
});

Cu Jasmine, același lucru: jasmine.createSpyObj('ProduseApi', ['lista', 'sterge']) și spy.and.returnValue(of(...)).

Bune practici:

  • fals doar ce aparține altei unități (API, router, stocare); logica componentei se testează reală;
  • spionii se resetează între teste, altfel apelurile se acumulează;
  • pentru provideri ai unei singure componente, TestBed.overrideComponent sau overrideProvider permit înlocuirea fără să modifici configurarea globală;
  • pentru router, provideRouter([]) și RouterTestingHarness sunt preferabile unui Router complet fals.

Verificarea apelurilor are sens pentru efecte în afara componentei (o cerere de ștergere); pentru restul, verificarea DOM-ului e mai robustă.

Ce urmărește intervievatorul: Verifică izolarea testelor și folosirea DI în testare. Greșeala tipică este testarea cu serviciul real, care face cereri adevărate.

Eroarea, în practică:Expected spy ... but it was never called

97 Mid

Cum te protejează Angular de XSS? Când e periculos bypassSecurityTrustHtml?

Răspuns scurt: Angular tratează implicit toate valorile din template ca nesigure: interpolarea inserează text, iar binding-urile pe innerHTML, href sau src sunt sanitizate automat (sunt eliminate scripturile și URL-urile periculoase). bypassSecurityTrust... dezactivează această protecție și e periculos pentru orice conținut care vine de la utilizatori.

XSS (cross-site scripting) înseamnă că un atacator reușește să execute JavaScript în pagina altui utilizator, de exemplu printr-un comentariu care conține un script.

Ce face Angular automat:

  • {{ comentariu }} inserează text; <script> apare literal, nu se execută;
  • [innerHTML]="html" trece valoarea prin sanitizer: păstrează formatarea sigură (<b>, <p>, linkuri obișnuite) și elimină scripturile, atributele on... și URL-urile javascript:; în modul de dezvoltare afișează un avertisment când a eliminat ceva;
  • [href] și [src] sunt verificate după context (URL, resursă);
  • template-urile sunt compilate la build, deci nu se construiesc template-uri din șiruri la rulare.
TypeScript
export class Articol {
  private sanitizer = inject(DomSanitizer);
  continutSigur = '<p>Text <b>bold</b></p><img src=x onerror="alert(1)">';
  // [innerHTML]="continutSigur" afișează textul și imaginea fără onerror

  // PERICULOS dacă html vine de la utilizator:
  html = this.sanitizer.bypassSecurityTrustHtml(this.comentariu);
}

bypassSecurityTrustHtml spune: „am verificat eu, nu mai sanitiza”. E acceptabil doar pentru conținut complet controlat de voi (de exemplu un SVG generat de cod), niciodată pentru text de la utilizatori sau dintr-un CMS fără validare.

Alte surse de risc care ocolesc Angular:

  • ElementRef.nativeElement.innerHTML = ... sau biblioteci care scriu direct în DOM;
  • randarea Markdown-ului cu o bibliotecă fără sanitizare;
  • injectarea pe server în index.html a datelor nesanitizate.

Apărare în adâncime: o politică Content Security Policy strictă (Angular suportă CSP cu nonce, inclusiv pentru stilurile proprii) și, unde e posibil, Trusted Types. Datele se validează și pe server, pentru că protecția din frontend apără doar afișarea, nu și alte sisteme care folosesc aceleași date.

Ce urmărește intervievatorul: Verifică conștientizarea securității în Angular. Greșeala tipică este folosirea lui bypassSecurityTrustHtml ca să „dispară avertismentul”.

98 Mid

După un deploy, unii utilizatori raportează pagină albă la deschiderea aplicației. Cum procedezi?

Răspuns scurt: Evaluez impactul și, dacă e larg, revin la versiunea anterioară. Apoi colectez erorile, cu source maps, și verific cauzele clasice: chunk-uri vechi lipsă din cauza cache-ului, configurarea serverului, o eroare la pornire. Repar, adaug o verificare și documentez.

Un model de răspuns structurat:

1. Stabilizez. Câți utilizatori sunt afectați și unde. Dacă problema e largă, rollback la versiunea anterioară e prioritar; investigația continuă fără presiune.

2. Colectez date. Erorile capturate de monitorizare (un ErrorHandler propriu care trimite erorile spre serviciul de logare, provideBrowserGlobalErrorListeners() pentru erorile globale), cu source maps încărcate în acel serviciu, nu publice. Dacă nu există monitorizare, reproduc în browser cu consola deschisă și tabul Network.

3. Verific cauzele clasice ale unei pagini albe după deploy:

  • chunk-uri lipsă: utilizatorul are în cache vechiul index.html (sau un tab deschis cu versiunea veche) care cere fișiere leneșe cu hash-uri vechi, deja șterse de pe server; rezultatul e o eroare de încărcare a modulului la navigare. Soluții: index.html servit fără cache, păstrarea fișierelor vechi o perioadă, reîncărcare la eroarea de încărcare a unui chunk;
  • configurarea serverului: rutele SPA nu cad pe index.html, base href greșit la publicarea într-un subdirector, tipuri MIME greșite pentru .js;
  • eroare la pornire: un provider de inițializare (provideAppInitializer) care eșuează, de exemplu configurarea de la rulare nu se încarcă, iar aplicația nu mai pornește deloc;
  • un service worker care servește versiunea veche amestecată cu cea nouă.

4. Repar și previn. Corectez cauza, adaug un test de fum după deploy (pagina principală se încarcă fără erori în consolă), o pagină de eroare prietenoasă în loc de ecran alb și un mesaj „există o versiune nouă” când se detectează schimbarea.

5. Comunic. Informez echipa și suportul, apoi scriu un scurt post-mortem fără vinovați.

Ce urmărește intervievatorul: Verifică felul în care gestionezi un incident în producție. Candidații sar direct la cod fără să stabilizeze situația sau să colecteze date.

99 Senior

Cum ai structura o aplicație Angular mare și cum alegi soluția de management al stării (servicii cu signals, NgRx Store, NgRx SignalStore)?

Răspuns scurt: Organizez pe funcționalități cu granițe clare, cu componente de prezentare separate de cele care gestionează datele. Pentru stare încep cu servicii cu signals și trec la o bibliotecă doar când complexitatea sau numărul de echipe o justifică.

Structura pe funcționalități, nu pe tipuri de fișiere:

src/app/
  core/            autentificare, interceptori, layout, handler de erori
  shared/ui/       componente de prezentare reutilizabile (butoane, tabele)
  features/
    catalog/       rute, pagini, componente, servicii, store, teste
    cos/
    comenzi/

Reguli de dependență: un feature nu importă din interiorul altui feature, doar din shared sau prin API-uri publice explicite. Regulile se pot verifica automat, de exemplu cu reguli de lint pentru importuri sau cu instrumentele de monorepo (Nx are constrângeri de module).

Componente:

  • de pagină/container: injectează servicii, citesc starea, coordonează;
  • de prezentare: doar input() și output(), OnPush, fără servicii; ușor de testat și refolosit.

Starea, în trepte: 1. stare locală în componentă (signal), dacă nu iese de acolo; 2. serviciu cu signals per feature: signal privat, computed, metode; acoperă majoritatea aplicațiilor; 3. NgRx SignalStore: aceeași idee, cu structură standard, extensii pentru entități, efecte și integrare cu RxJS; util când mai multe echipe trebuie să scrie stare la fel; 4. NgRx Store (Redux): acțiuni, reduceri, efecte, unelte de depanare cu istoric; costul în cod e mare și se justifică la fluxuri complexe, multe surse de evenimente sau cerințe de audit al schimbărilor.

Criteriile: câți oameni lucrează pe cod, cât de des se schimbă aceeași stare din locuri diferite și cât de familiară e echipa cu biblioteca. Decizia se scrie, cu motivele, într-un document scurt de arhitectură.

Greșeala frecventă: o bibliotecă de stare globală adoptată din prima zi pentru tot, inclusiv pentru starea unui formular, cu mult cod repetitiv și fără beneficiu real.

Ce urmărește intervievatorul: Verifică judecata arhitecturală și capacitatea de a argumenta compromisuri. Răspunsurile dogmatice („mereu NgRx” sau „niciodată NgRx”) sunt semnale slabe.

100 Senior

Aplicația voastră e pe Angular 15 și trebuie adusă la ultima versiune. Cum planifici și execuți actualizarea?

Răspuns scurt: Actualizez câte o versiune majoră o dată, cu ng update și ghidul de pe update.angular.dev, verificând la fiecare pas build-ul, testele și bibliotecile terțe. Modernizarea codului (standalone, control flow, signals) o fac separat, după actualizare.

Un model de răspuns structurat:

1. Inventar. Versiunea actuală, bibliotecile terțe și versiunile lor compatibile cu fiecare major Angular, versiunea de Node și TypeScript cerută, acoperirea testelor. Bibliotecile abandonate sunt cel mai mare risc; uneori trebuie înlocuite înainte.

2. Plasă de siguranță. Teste end-to-end pe fluxurile principale, build și teste în CI. Fără ele, fiecare pas e un salt în gol.

3. Pas cu pas, câte un major.

BASH
ng update @angular/core@16 @angular/cli@16
# rezolvi, rulezi build și teste, faci commit
ng update @angular/core@17 @angular/cli@17
# ...

ng update nu sare peste versiuni majore, iar migrările automate sunt scrise pentru trecerea de la versiunea anterioară. Ghidul interactiv de pe update.angular.dev listează schimbările manuale pentru fiecare pas. La fiecare major actualizezi și bibliotecile asociate (Angular Material, CDK, NgRx).

4. Ce urmăresc pe drum:

  • API-uri depreciate și eliminate (avertismentele de compilare din versiunea anterioară sunt lista de lucru);
  • trecerea la builder-ul application bazat pe esbuild, care poate cere ajustări de configurare;
  • schimbări de comportament la teste și la detectarea schimbărilor; în versiunile noi, multe proiecte schimbă și runner-ul de teste.

5. Modernizarea, separat. După actualizare, migrările opționale (standalone, control flow, inject, signal inputs) se fac în PR-uri separate, ca un bug să poată fi legat de o schimbare clară.

6. Livrare. Fiecare pas ajunge în producție cât mai repede, nu un branch care trăiește luni de zile.

Ca regulă de echipă, propun actualizarea la fiecare versiune majoră (Angular lansează una cam la fiecare șase luni), ca pașii să rămână mici.

Ce urmărește intervievatorul: Verifică experiența cu întreținerea pe termen lung a unui proiect. Candidații propun des un salt direct de mai multe versiuni sau o rescriere.

Întrebări de interviu pe meserie

Alte tehnologii

← Toate întrebările de interviu

Tudor Andrei Dumitrescu
Cine coordonează pregătirea de interviu

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Întrebările de aici urmăresc ce se cere la interviurile de Angular, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață Angular scriind cod, nu doar citind

Curs Angular: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.