...
Pregătire interviuri

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

Întrebările despre TypeScript 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 TypeScript: 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 TypeScript cu răspunsuri

La un interviu în care se verifică TypeScript (versiunile 5.x și 6.0), întrebările rareori se opresc la „ce este TypeScript”. Intervievatorul vrea să vadă dacă înțelegi cum gândește sistemul de tipuri: ce deduce compilatorul singur, cum îngustezi un union, când scrii un generic și când nu, ce dispare la compilare și ce rămâne la rulare. De obicei primești un amestec de întrebări de teorie, fragmente de cod de tipul „unde e eroarea de tip” sau „ce tip are variabila aici”, și uneori o mică temă: tipizează o funcție, un hook sau un răspuns de API fără any.

Pentru un post de junior se așteaptă să stăpânești tipurile de bază, inferența, interfețele, union-urile cu narrowing, genericele simple și utility types uzuale, plus setările principale din tsconfig.json. La nivel mid se adaugă mapped și conditional types, infer, template literal types, declarații .d.ts, augmentarea modulelor, tipizarea codului React și Node și discuții despre compromisuri: cât de strict, unde validezi la rulare, cum migrezi un proiect JavaScript. Întrebările marcate senior ating unsoundness, performanța verificării și designul tipurilor pentru librării.

Folosește pagina așa: citește întâi întrebarea și încearcă să răspunzi cu voce tare, apoi compară cu răspunsul scurt și abia după aceea cu explicația detaliată. Copiază exemplele într-un fișier .ts cu strict: true și modifică-le până înțelegi fiecare eroare. Întrebările despre bazele JavaScript (closures, event loop, prototipuri) sunt pe pagina dedicată JavaScript, iar aici ne ocupăm strict de stratul de tipuri.

Tipuri de bază și inferență

1 Junior

Ce rămâne din tipurile TypeScript în codul JavaScript generat? De ce nu compilează codul de mai jos?

TypeScript
interface User { id: number; name: string }
function check(x: unknown) {
  if (x instanceof User) {
    console.log(x.name);
  }
}

Răspuns scurt: Nu rămâne nimic: tipurile, interfețele și adnotările sunt șterse la compilare (type erasure). User există doar în spațiul tipurilor, deci nu poate fi folosit ca valoare în instanceof.

TypeScript are două „spații de nume” separate: spațiul valorilor (variabile, funcții, clase, enum-uri) și spațiul tipurilor (interfețe, alias-uri type, parametri generici). La compilare, tot ce ține doar de spațiul tipurilor este eliminat, iar ce rămâne este JavaScript obișnuit. De aceea instanceof User dă eroarea „'User' only refers to a type, but is being used as a value here”.

Consecințe practice:

  • nu poți verifica la rulare dacă un obiect „este” o interfață; trebuie să verifici proprietățile lui (un type guard) sau să folosești o clasă, care există și ca valoare;
  • nu poți citi tipul unui parametru generic la rulare (T nu există în JS);
  • adnotările nu schimbă comportamentul programului: un as number nu convertește nimic.

O clasă este specială pentru că apare în ambele spații: class User {} creează și un tip, și o funcție constructor, deci instanceof funcționează.

TypeScript
function isUser(x: unknown): x is User {
  return typeof x === 'object' && x !== null && 'id' in x && 'name' in x;
}

Excepțiile de la ștergere sunt construcțiile care generează cod: enum, namespace cu valori și parameter properties din constructori. Tocmai de aceea opțiunea erasableSyntaxOnly (TypeScript 5.8) le interzice, pentru medii care doar șterg tipurile, cum face Node.js.

Ce urmărește intervievatorul: Se verifică dacă știi granița dintre compilare și rulare. Mulți candidați cred că interfețele există și în JavaScript sau că as face conversii.

Eroarea, în practică:TS2693: only refers to a type, used as a value

2 Junior

Ce tip deduce TypeScript pentru fiecare variabilă de mai jos?

TypeScript
let a = 5;
const b = 5;
let c = [1, 'doi'];
const d = { x: 1, y: 'ok' };
let e = null;

Răspuns scurt: a: number, b: 5 (tip literal), c: (string | number)[], d: { x: number; y: string }, iar e este any care evoluează după atribuiri (cu strictNullChecks și noImplicitAny), altfel any.

Inferența urmează o regulă numită widening (lărgire): când valoarea poate fi schimbată, TypeScript alege tipul general, nu valoarea exactă.

  • let a = 5: variabila poate primi alt număr, deci tipul e number.
  • const b = 5: nu mai poate fi reatribuită, deci tipul rămâne literalul 5.
  • let c = [1, 'doi']: tabloul poate primi elemente noi, deci TS calculează un tip comun, (string | number)[], nu tuplul [number, string].
  • const d = {...}: const protejează doar legătura, nu proprietățile. d.x = 2 e permis, deci proprietățile se lărgesc la number și string.
  • let e = null: în modul strict, TS folosește un „evolving any”: tipul se calculează din atribuirile următoare. Fără strictNullChecks, e devine pur și simplu any.

Dacă vrei tipuri exacte, ai două unelte: adnotarea explicită (let c: [number, string] = [1, 'doi']) sau as const, care face totul readonly și literal:

TypeScript
const d2 = { x: 1, y: 'ok' } as const;
// { readonly x: 1; readonly y: "ok" }

Înțelegerea acestor reguli explică multe erori de tipul „Type 'string' is not assignable to type '"GET" | "POST"'”, când un obiect de configurare își pierde literalele.

Ce urmărește intervievatorul: Verifică dacă înțelegi inferența și widening-ul, nu doar sintaxa. Greșeala tipică este să crezi că const face și proprietățile obiectului imutabile.

Eroarea, în practică:TS2322: Type '"XXL"' is not assignable to type

3 Junior

Când pui adnotări de tip explicite și când lași inferența să lucreze?

Răspuns scurt: Adnotezi parametrii funcțiilor, tipurile returnate ale funcțiilor exportate și valorile inițiale „goale” ([], null, {}). În rest, lași inferența, ca să ai cod mai scurt și tipuri exacte.

Regula practică: adnotează la granițe și lasă inferența în interior.

Unde e nevoie de adnotare:

  • Parametrii funcțiilor: TS nu îi poate deduce (cu noImplicitAny primești eroare), cu excepția callback-urilor, unde tipul vine din context (arr.map(x => x * 2)).
  • Tipul returnat al funcțiilor publice: dacă cineva modifică implementarea, eroarea apare în funcție, nu în zece locuri unde e folosită. Ajută și la viteză, fiindcă TS nu mai recalculează tipul.
  • Valori inițiale care nu spun nimic: const ids = [] sau useState(null). Scrii const ids: number[] = [] și useState<User | null>(null).
  • Contracte: obiecte care trebuie să respecte o formă (const config: Config = {...} sau satisfies Config).

Unde nu e nevoie:

TypeScript
const total = items.reduce((s, i) => s + i.price, 0); // number
const names = users.map(u => u.name);              // string[]

Adnotarea inutilă poate chiar strica: const method: string = 'GET' aruncă literalul 'GET' și îl transformă în string, deci nu mai poți pasa variabila unei funcții care cere 'GET' | 'POST'.

Unele echipe activează regula ESLint explicit-module-boundary-types sau opțiunea isolatedDeclarations (TypeScript 5.5), care cere tipuri explicite pe tot ce se exportă, ca declarațiile să poată fi generate fără analiza întregului proiect.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă un criteriu, nu „pun tipuri peste tot”. Candidații slabi adnotează fiecare variabilă locală și ratează locurile unde adnotarea chiar contează.

Eroarea, în practică:TS7023: recursive function implicitly returns 'any'TS7022: referenced in its own initializer

4 Junior

Care e diferența dintre un tablou și un tuplu în TypeScript? Ce se întâmplă în codul de mai jos?

TypeScript
const point: [number, number] = [10, 20];
point.push(30);
console.log(point.length);

Răspuns scurt: Un tuplu are lungime și tip fix pe fiecare poziție. Codul compilează și afișează 3, pentru că push nu e interzis pe tupluri mutabile. Cu readonly [number, number] primești eroare la compilare.

Un tablou number[] are orice lungime și același tip pe toate pozițiile. Un tuplu [string, number] descrie exact câte elemente sunt și ce tip are fiecare poziție, util pentru valori returnate în pereche (ca useState) sau pentru rânduri CSV.

TypeScript
type Entry = [key: string, value: number];   // tuplu etichetat
type Opt = [string, number?];                 // element opțional
type AtLeastOne = [string, ...string[]];      // rest
const [k, v] = ['a', 1] as Entry;

Capcana din exemplu: la rulare, un tuplu e un tablou JavaScript obișnuit, iar tipul [number, number] moștenește metodele lui Array, inclusiv push. Compilatorul permite push(30) și afișarea va fi 3, deși tipul încă spune că lungimea e 2. Accesul point[2] dă însă eroare la compilare, pentru că indexul nu există în tuplu.

Soluția este tuplul readonly:

TypeScript
const p: readonly [number, number] = [10, 20];
p.push(30); // eroare: Property 'push' does not exist

Și as const produce tupluri readonly: const rgb = [255, 0, 0] as const are tipul readonly [255, 0, 0]. Folosește-le pentru coordonate, perechi cheie-valoare și orice date care nu trebuie să își schimbe forma.

Ce urmărește intervievatorul: Testează dacă știi că tipurile nu schimbă obiectele de la rulare. Mulți candidați presupun că un tuplu e „protejat” complet de compilator.

Eroarea, în practică:TS2556: spread argument must have a tuple typeTS2493: Tuple type has no element at index

5 Junior

Ce se schimbă când activezi strictNullChecks? Ce eroare primești aici?

TypeScript
function initials(name?: string) {
  return name.split(' ').map(p => p[0]).join('');
}

Răspuns scurt: Cu strictNullChecks, null și undefined nu mai sunt atribuibile oricărui tip. name are tipul string | undefined, deci name.split dă eroarea „'name' is possibly 'undefined'”.

Fără strictNullChecks, null și undefined sunt subtipuri ale tuturor tipurilor: un string poate fi oricând null, iar compilatorul nu te avertizează. Este exact sursa clasică de „Cannot read properties of undefined”.

Cu opțiunea activă (parte din strict), null și undefined devin tipuri separate. Un parametru opțional name?: string are tipul string | undefined, iar orice acces la metodele lui trebuie precedat de o verificare:

TypeScript
function initials(name?: string) {
  if (!name) return '';
  return name.split(' ').map(p => p[0]).join('');
}
// sau
const len = name?.length ?? 0;

Variante de rezolvare, în ordinea preferinței:

  • verificare explicită (if, ??, ?.), care tratează cazul real;
  • valoare implicită pentru parametru: name = '';
  • operatorul non-null name!, doar când știi sigur ceva ce compilatorul nu poate ști.

Atenție și la p[0]: în mod strict obișnuit are tipul string, deși pentru un șir gol ar fi undefined. Dacă activezi și noUncheckedIndexedAccess, accesul prin index devine string | undefined, iar TS te obligă să tratezi și cazul acesta.

Într-un proiect nou, strictNullChecks nu e negociabil: elimină o clasă întreagă de bug-uri din producție.

Ce urmărește intervievatorul: Se verifică dacă ai lucrat cu modul strict. Răspunsul slab este „pun ! și merge”, fără să trateze cazul undefined.

Eroarea, în practică:TS18048: 'x' is possibly 'undefined'TS2322: Type 'null' is not assignable to 'string'

6 Junior

Care e diferența dintre tipul returnat void și undefined? De ce compilează codul de mai jos?

TypeScript
type Callback = () => void;
const cb: Callback = () => 42;
const nums: number[] = [];
[1, 2].forEach(n => nums.push(n));

Răspuns scurt: void înseamnă „valoarea returnată nu trebuie folosită”, nu „returnează exact undefined”. Un tip de funcție care returnează void acceptă funcții care returnează orice, ca să poți pasa callback-uri ca n => nums.push(n).

undefined este un tip de valoare concret: funcția trebuie să returneze undefined. void este o promisiune față de apelant: „nu te baza pe ce returnez”.

Regula de compatibilitate: un tip de funcție cu return void acceptă orice funcție, indiferent ce returnează. Altfel, exemple banale ar fi enervante: push returnează noua lungime (number), iar forEach cere un callback (value) => void. Dacă TS ar cere exact undefined, ai fi obligat să scrii acolade în jurul fiecărui apel.

Diferența apare când declari direct o funcție:

TypeScript
function log(msg: string): void {
  return 42; // eroare: Type 'number' is not assignable to type 'void'
}
const r = cb(); // r are tipul void, nu number

Deci void e strict la declarație, dar permisiv la atribuirea unei funcții la un tip. Valoarea 42 chiar există la rulare, însă tipul void te oprește să o folosești în mod util.

Tot aici intră Promise<void> pentru funcții async care nu returnează nimic și never pentru funcții care nu se termină normal (aruncă excepție sau buclă infinită). Nu folosi void într-un union (string | void); pentru o valoare care poate lipsi, scrie string | undefined.

Ce urmărește intervievatorul: Întrebarea arată dacă înțelegi compatibilitatea tipurilor de funcții. Candidații confundă des void cu undefined și nu pot explica de ce forEach(n => arr.push(n)) e valid.

Eroarea, în practică:TS1345: 'void' cannot be tested for truthiness

7 Junior

Ce face as const și de ce rezolvă eroarea din codul de mai jos?

TypeScript
function request(url: string, method: 'GET' | 'POST') {}
const options = { url: '/api/users', method: 'GET' };
request(options.url, options.method);

Răspuns scurt: options.method este dedus ca string, care nu e atribuibil lui 'GET' | 'POST'. Cu as const, obiectul devine readonly, iar method păstrează tipul literal 'GET'.

Obiectul options e mutabil, deci TypeScript lărgește method la string: oricine ar putea scrie options.method = 'DELETE'. Funcția request cere însă un union de literale, iar string e mai larg, de unde eroarea „Argument of type 'string' is not assignable to parameter of type '"GET" | "POST"'”.

Soluții posibile:

TypeScript
const a = { url: '/api/users', method: 'GET' } as const;
const b = { url: '/api/users', method: 'GET' as const };
const c: { url: string; method: 'GET' | 'POST' } = { url: '/api/users', method: 'GET' };

as const (const assertion) face trei lucruri:

  • nu lărgește literalele ('GET' rămâne 'GET', 5 rămâne 5);
  • marchează toate proprietățile readonly, recursiv;
  • transformă tablourile în tupluri readonly.

Un tipar foarte des folosit este derivarea unui union dintr-o listă de valori, ca să ai o singură sursă de adevăr, folosită și la rulare:

TypeScript
const ROLES = ['admin', 'editor', 'viewer'] as const;
type Role = typeof ROLES[number]; // 'admin' | 'editor' | 'viewer'

Atenție: as const nu verifică forma obiectului față de un tip. Pentru asta combini cu satisfies, despre care e altă întrebare.

Ce urmărește intervievatorul: Verifică dacă înțelegi legătura dintre mutabilitate și inferență. E una dintre cele mai frecvente erori reale, iar candidații o „rezolvă” cu as any.

Eroarea, în practică:TS2322: Type '"XXL"' is not assignable to typeTS1355: 'const' assertion only on literals

8 Junior

De ce prima atribuire dă eroare, iar a doua nu?

TypeScript
interface Point { x: number; y: number }
const p1: Point = { x: 1, y: 2, z: 3 };
const tmp = { x: 1, y: 2, z: 3 };
const p2: Point = tmp;

Răspuns scurt: Prima e un obiect literal „proaspăt”, la care TypeScript face excess property checking și semnalează z ca probabilă greșeală. A doua e o variabilă existentă, verificată doar structural: are x și y, deci e compatibilă.

Compatibilitatea în TypeScript este structurală: un obiect e atribuibil unui tip dacă are cel puțin proprietățile cerute. Proprietățile în plus nu încalcă regula, deci tmp cu z este un Point valid.

Totuși, când scrii un obiect literal direct acolo unde se așteaptă un tip, o proprietate în plus este aproape mereu o greșeală de tastare (colour în loc de color) sau o opțiune pe care funcția nu o suportă. Pentru acest caz, TS aplică o verificare suplimentară, excess property checking: „Object literal may only specify known properties, and 'z' does not exist in type 'Point'”.

Verificarea se aplică doar obiectelor literale „proaspete”: atribuire directă, argument de funcție, valoare returnată dintr-o funcție cu tip declarat. Odată ce obiectul trece printr-o variabilă, devine „vechi” și se aplică doar regula structurală.

TypeScript
function draw(p: Point) {}
draw({ x: 1, y: 2, z: 3 }); // eroare
draw(tmp);                   // ok

De ce contează: nu te baza pe faptul că TypeScript elimină câmpurile în plus. Dacă trimiți p2 la un API sau îl salvezi în baza de date, z pleacă și el, pentru că obiectul de la rulare îl conține. Când ai nevoie strict de anumite câmpuri, le copiezi explicit (const { x, y } = tmp).

Ce urmărește intervievatorul: Testează înțelegerea tipizării structurale și a unei excepții de la ea. Candidații cred adesea că TypeScript nu permite niciodată proprietăți în plus sau că le elimină.

Eroarea, în practică:TS2353: may only specify known properties

9 Junior

Cum scrii tipul unei funcții primite ca parametru? Care e diferența dintre x?: number, x: number | undefined și x = 0?

Răspuns scurt: Tipul unei funcții se scrie (param: Tip) => TipReturnat. x?: number poate lipsi la apel, x: number | undefined trebuie pasat explicit (chiar și undefined), iar x = 0 poate lipsi și în corp are mereu tipul number.

Pentru callback-uri și funcții ca valori, folosești sintaxa săgeată în poziție de tip:

TypeScript
type Comparator<T> = (a: T, b: T) => number;
function sortBy<T>(items: T[], cmp: Comparator<T>): T[] {
  return [...items].sort(cmp);
}
type Handler = { (event: string): void; description: string }; // call signature cu proprietăți

Numele parametrilor din tip sunt doar documentație: (a: T, b: T) => number acceptă și o funcție cu parametrii numiți altfel.

Cele trei forme de parametri diferă:

TypeScript
function f1(x?: number) {}            // f1() ok, x: number | undefined în corp
function f2(x: number | undefined) {} // f2() eroare, f2(undefined) ok
function f3(x = 0) {}                 // f3() ok, x: number în corp
  • x? e potrivit când lipsa valorii are sens și o tratezi explicit.
  • x: number | undefined obligă apelantul să se gândească la valoare, util când vrei ca nimeni să nu uite argumentul.
  • valoarea implicită elimină undefined din corp, deci codul e mai simplu.

Parametrii opționali trebuie să vină după cei obligatorii. Pentru multe opțiuni, e mai clar un obiect de opțiuni destructurat, function connect({ host, port = 5432 }: ConnectOptions), decât cinci parametri poziționali opționali, unde apelantul ajunge la connect('db', undefined, undefined, true).

Ce urmărește intervievatorul: Verifică dacă poți tipiza funcții de ordin superior și dacă știi nuanțele parametrilor opționali. Mulți candidați cred că x?: number și x: number | undefined sunt identice.

Eroarea, în practică:TS2554: Expected 2 arguments, but got 1TS1016: required parameter after optional one

10 Mid

Ce sunt supraîncărcările de funcții (overloads) în TypeScript? Scrie o funcție parse care returnează number pentru 'number' și boolean pentru 'boolean'.

Răspuns scurt: Overload-urile sunt mai multe semnături declarate deasupra unei singure implementări. Apelantul vede doar semnăturile, nu implementarea, iar TS alege prima semnătură care se potrivește argumentelor.

În JavaScript există o singură funcție, deci overload-urile sunt doar declarații de tip: mai multe semnături, urmate de o implementare cu o semnătură suficient de largă încât să le acopere pe toate.

TypeScript
function parse(value: string, as: 'number'): number;
function parse(value: string, as: 'boolean'): boolean;
function parse(value: string, as: 'number' | 'boolean'): number | boolean {
  return as === 'number' ? Number(value) : value === 'true';
}
const n = parse('42', 'number');   // number
const b = parse('true', 'boolean'); // boolean

Reguli importante:

  • semnătura implementării nu este vizibilă din exterior; dacă vrei să permiți și un apel cu union, adaugi o semnătură explicită pentru el;
  • TS încearcă semnăturile de sus în jos și o alege pe prima potrivită, deci pui cazurile specifice înaintea celor generale;
  • compilatorul nu verifică dacă implementarea respectă fiecare overload în parte, ci doar compatibilitatea generală. Poți returna boolean pentru 'number' fără eroare, deci logica trebuie testată.

Când să nu le folosești: dacă tipul returnat se poate exprima direct din parametri, un generic sau un tip condițional e mai scurt. Dacă semnăturile diferă doar prin tipul unui parametru și returnează același lucru, un simplu union pe parametru e suficient. Overload-urile sunt utile mai ales pentru API-uri publice, ca document.createElement, care returnează HTMLDivElement pentru 'div'.

Ce urmărește intervievatorul: Se verifică dacă știi că overload-urile sunt doar un strat de tipuri peste o singură funcție. Greșeala tipică: cred că implementarea e verificată pe fiecare semnătură.

Eroarea, în practică:TS2769: No overload matches this callTS2393: Duplicate function implementation

11 Mid

Care e diferența dintre tipurile object, Object, {} și Record<string, unknown>? Ce acceptă fiecare?

Răspuns scurt: {} și Object acceptă orice valoare în afară de null și undefined, inclusiv 'text' și 5. object acceptă doar valori non-primitive. Record<string, unknown> cere un obiect cu chei string, practic un dicționar.

Aceste tipuri arată similar, dar înseamnă lucruri diferite:

TypeScript
let a: {} = 'text';               // ok: orice în afară de null/undefined
let b: Object = 42;               // ok, la fel ca {}
let c: object = 'text';           // eroare: primitivele nu sunt object
let d: object = [1, 2];           // ok
let e: Record<string, unknown> = { x: 1 }; // ok
  • {} înseamnă „un tip fără proprietăți cerute”. Deoarece tipizarea e structurală, orice valoare care nu e null/undefined îl satisface, chiar și un număr. De aceea {} ca „obiect oarecare” e aproape mereu o greșeală, iar regula ESLint no-empty-object-type o semnalează. {} are un rol util: T & {} elimină null și undefined, iar așa e definit NonNullable<T>.
  • Object (cu majusculă) e tipul interfeței globale Object; se comportă aproape ca {}. Nu îl folosi.
  • object exclude primitivele (string, number, boolean, symbol, bigint, null, undefined). Acceptă însă tablouri și funcții.
  • Record<string, unknown> descrie un obiect folosit ca dicționar. Poți citi e.x, dar valoarea e unknown, deci trebuie îngustată.

Pentru date necunoscute primite din exterior, folosește unknown și verificări. Pentru un obiect cu formă cunoscută, scrie interfața. Pentru dicționare, Record<K, V> sau Map.

Ce urmărește intervievatorul: Intervievatorul caută precizie. Răspunsul greșit tipic este că {} înseamnă „obiect gol” și că nu acceptă un string.

Eroarea, în practică:TS2339: Property does not exist on type '{}'

12 Mid

Ce face operatorul satisfies (TypeScript 4.9) și cum diferă de o adnotare : Tip și de as Tip?

TypeScript
type Color = 'red' | 'green';
const palette = {
  red: '#f00',
  green: [0, 255, 0],
} satisfies Record<Color, string | number[]>;
palette.red.toUpperCase();

Răspuns scurt: satisfies verifică dacă valoarea respectă tipul, dar păstrează tipul dedus, mai precis. Cu adnotare, palette.red ar deveni string | number[] și toUpperCase ar da eroare; cu as, verificarea ar fi doar o aserțiune slabă.

Cele trei construcții răspund la întrebări diferite:

  • adnotarea const p: T = ... spune „variabila are tipul T”. Valoarea e verificată, dar tipul dedus se pierde: palette.red ar fi string | number[], iar toUpperCase() nu mai compilează fără narrowing;
  • aserțiunea ... as T spune „crede-mă, e T”. Verifică doar că tipurile se suprapun măcar parțial, deci ascunde greșeli: o cheie lipsă sau o valoare greșită pot trece;
  • satisfies T spune „verifică faptul că valoarea respectă T, dar păstrează tipul ei exact”. Primești erori pentru chei lipsă, chei în plus sau valori incompatibile, iar palette.red rămâne string și palette.green rămâne number[].
TypeScript
const routes = {
  home: '/',
  user: '/users/:id',
} as const satisfies Record<string, `/${string}`>;
type RouteName = keyof typeof routes; // 'home' | 'user'

Combinația as const satisfies e foarte utilă pentru configurații: valorile rămân literale și readonly, iar forma e validată de un tip. Cu o adnotare Record<string, ...> ai pierde exact lista de chei, deci keyof typeof routes ar deveni string.

Regula: adnotare pentru contracte (parametri, valori returnate), satisfies pentru obiecte constante pe care vrei să le validezi fără să le „lărgești”, iar as doar când chiar știi mai mult decât compilatorul.

Ce urmărește intervievatorul: Se verifică dacă ești la curent cu TypeScript modern și dacă înțelegi compromisul dintre siguranță și precizie. Mulți candidați nu știu că as poate ascunde chei lipsă.

Eroarea, în practică:TS1360: Type does not satisfy the expected type

Union, narrowing și type guards

13 Junior

De ce dă eroare codul de mai jos, deși verifici typeof?

TypeScript
function count(items: string[] | null) {
  if (typeof items === 'object') {
    return items.length;
  }
  return 0;
}

Răspuns scurt: Pentru că typeof null === 'object' în JavaScript, iar TypeScript știe asta: după verificare, items rămâne string[] | null. Trebuie verificat explicit items !== null sau folosit Array.isArray(items).

Narrowing (îngustare) înseamnă că TypeScript urmărește fluxul codului și restrânge tipul unei variabile după verificări precum typeof, ===, instanceof, in sau Array.isArray. Analiza respectă însă semantica reală a JavaScript-ului: typeof null returnează 'object', deci ramura 'object' păstrează și null. Eroarea este „'items' is possibly 'null'”.

Variante corecte:

TypeScript
function count(items: string[] | null) {
  if (items !== null) return items.length;      // string[]
  return 0;
}
function count2(items: string[] | null) {
  return Array.isArray(items) ? items.length : 0;
}
const count3 = (items: string[] | null) => items?.length ?? 0;

Rezultatele typeof pe care TS le recunoaște pentru narrowing sunt 'string', 'number', 'bigint', 'boolean', 'symbol', 'undefined', 'object' și 'function'. Pentru clase folosești instanceof, pentru tablouri Array.isArray, iar pentru obiecte simple operatorul in sau un câmp discriminant.

Această întrebare arată de ce TypeScript e util chiar și pentru programatori experimentați: bug-ul cu typeof null e o capcană veche a limbajului, iar compilatorul o prinde înainte să ajungă în producție.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi că narrowing-ul urmează regulile JavaScript. Greșeala tipică este să scrii as string[] ca să scapi de eroare, în loc să tratezi null.

Eroarea, în practică:TS18047: 'x' is possibly 'null'TS2339: Property does not exist on 'string | number'

14 Junior

Când folosești in și când instanceof pentru a îngusta un tip? Dă câte un exemplu.

Răspuns scurt: instanceof funcționează pentru valori create cu o clasă (constructor existent la rulare). in verifică existența unei proprietăți și e potrivit pentru obiecte simple descrise de interfețe sau type alias-uri.

instanceof verifică lanțul de prototipuri, deci are nevoie de o funcție constructor reală. E potrivit pentru clase proprii, Date, Error, Map sau elemente DOM:

TypeScript
function format(v: Date | string) {
  return v instanceof Date ? v.toISOString() : v.trim();
}
function onClick(e: Event) {
  if (e.target instanceof HTMLButtonElement) e.target.disabled = true;
}

Pentru obiecte simple, cum sunt cele venite din JSON, instanceof nu are sens: un obiect parsat nu e instanța niciunei clase, iar interfețele nu există la rulare. Aici folosești in:

TypeScript
interface Card { cardNumber: string }
interface Transfer { iban: string }
function describe(p: Card | Transfer) {
  if ('cardNumber' in p) return `Card ${p.cardNumber.slice(-4)}`;
  return `Transfer ${p.iban}`; // aici p e Transfer
}

Detalii utile:

  • in îngustează după membrii union-ului care declară proprietatea; dacă proprietatea e opțională într-un membru, acel membru rămâne în ambele ramuri;
  • din TypeScript 4.9, 'x' in obj pe un obiect de tip object adaugă proprietatea la tip (object & Record<'x', unknown>), util la validarea datelor unknown;
  • instanceof poate da rezultate false când obiectul vine din alt realm (un iframe) sau când două copii ale aceleiași librării sunt încărcate în bundle.

Pentru union-uri pe care le controlezi, un câmp discriminant (kind: 'card') e și mai clar decât in.

Ce urmărește intervievatorul: Se verifică dacă știi ce există la rulare și ce nu. Răspunsul slab folosește instanceof pe o interfață sau pe date din JSON.

Eroarea, în practică:TS2339: Property does not exist on 'string | number'TS2358: left side of instanceof must be an object

15 Junior

Unde e bug-ul în funcția de mai jos?

TypeScript
function formatDiscount(percent: number | undefined): string {
  if (!percent) return 'fără reducere';
  return `-${percent}%`;
}

Răspuns scurt: Verificarea „truthy” exclude și 0, nu doar undefined. Codul compilează, dar pentru percent = 0 afișează „fără reducere”, deși poate fi o valoare validă. Corect: if (percent === undefined).

TypeScript face narrowing și prin truthiness: după if (!percent) return, în restul funcției percent are tipul number. Compilatorul e mulțumit, dar ramura !percent prinde toate valorile falsy: undefined, 0 și NaN. Pentru stringuri, la fel, '' este falsy.

Aici e o problemă de logică pe care tipurile nu o pot vedea. Dacă 0 înseamnă „reducere zero, afișează -0%” sau dacă e o eroare de date, trebuie decis explicit:

TypeScript
function formatDiscount(percent: number | undefined): string {
  if (percent === undefined) return 'fără reducere';
  return `-${percent}%`;
}
// sau, pentru null și undefined deodată:
if (percent == null) return 'fără reducere';

== null este singurul loc unde mulți folosesc egalitatea lejeră intenționat: prinde null și undefined, dar nu 0 sau ''. Similar, ?? (nullish coalescing) în loc de ||:

TypeScript
const qty = input.qty || 1;  // 0 devine 1, probabil greșit
const qty2 = input.qty ?? 1; // 0 rămâne 0

Linia de interpretat la interviu: narrowing-ul garantează că tipul e corect, nu că logica e corectă. Regula ESLint strict-boolean-expressions din typescript-eslint semnalează condițiile ambigue de acest fel.

Ce urmărește intervievatorul: Intervievatorul caută bug-uri pe care TypeScript nu le prinde. Mulți candidați nu observă cazul 0 pentru că „compilează”.

16 Junior

Scrie un type guard isProduct(x: unknown): x is Product și explică ce riști când scrii unul.

Răspuns scurt: Un type guard este o funcție care returnează boolean și are tipul de return x is T; când returnează true, TS îngustează argumentul la T. Riscul: compilatorul nu verifică logica din corp, deci un guard greșit minte despre tip.

TypeScript
interface Product { id: number; name: string; price: number }

function isProduct(x: unknown): x is Product {
  return (
    typeof x === 'object' && x !== null &&
    'id' in x && typeof x.id === 'number' &&
    'name' in x && typeof x.name === 'string' &&
    'price' in x && typeof x.price === 'number'
  );
}

const data: unknown = JSON.parse(raw);
if (isProduct(data)) {
  console.log(data.price.toFixed(2)); // data: Product
}

Tipul de return x is Product se numește type predicate. În ramura true, argumentul devine Product; în ramura false, TS scoate Product din union, dacă argumentul era un union.

Riscul este că TypeScript are încredere oarbă în predicat. Dacă uiți să verifici price sau scrii typeof x.price === 'string' din greșeală, compilatorul tot îngustează la Product, iar eroarea apare abia la rulare, departe de cauză. Practic, un type guard este o aserțiune as ascunsă într-o funcție.

Cum reduci riscul:

  • testezi guard-ul cu unit teste, inclusiv cu date invalide;
  • pentru obiecte mari, folosești o librărie de validare (Zod, Valibot, ArkType), care derivă tipul din schemă, astfel încât verificarea și tipul nu se pot desincroniza;
  • păstrezi guard-urile mici și aproape de tipul pe care îl verifică.

Ce urmărește intervievatorul: Se verifică dacă știi sintaxa x is T și, mai ales, limita ei. Candidații buni spun singuri că predicatul nu e verificat de compilator.

Eroarea, în practică:TS18046: 'e' is of type 'unknown'TS2677: type predicate must match parameter type

17 Junior

Ce tip are err în blocul catch și cum afișezi corect mesajul erorii?

TypeScript
try {
  await saveOrder(order);
} catch (err) {
  console.error(err.message);
}

Răspuns scurt: Cu strict (din TypeScript 4.4, prin useUnknownInCatchVariables), err are tipul unknown, deci err.message nu compilează. Îngustezi cu err instanceof Error înainte să citești message.

În JavaScript poți arunca orice: throw 'eroare', throw 404, throw { code: 1 }. Prin urmare, TypeScript nu poate garanta că în catch primești un Error. Istoric, err era any, deci err.message compila și putea crăpa la rulare. Din TypeScript 4.4, opțiunea useUnknownInCatchVariables, inclusă în strict, schimbă tipul în unknown.

TypeScript
try {
  await saveOrder(order);
} catch (err) {
  if (err instanceof Error) {
    console.error(err.message, err.cause);
  } else {
    console.error('Eroare necunoscută', err);
  }
}

Un helper reutilizabil evită repetarea:

TypeScript
function errorMessage(err: unknown): string {
  if (err instanceof Error) return err.message;
  if (typeof err === 'string') return err;
  return JSON.stringify(err);
}

Nu poți adnota catch (err: Error), pentru că TS permite doar any sau unknown acolo. Pentru erori proprii, folosești clase care extind Error și le deosebești cu instanceof:

TypeScript
if (err instanceof ValidationError) showFieldErrors(err.fields);
else throw err; // ce nu știi să tratezi, rearunci

La fel, .catch(e => ...) pe un Promise primește any, deci acolo regula use-unknown-in-catch-callback-variable din typescript-eslint te ajută să tratezi la fel de atent eroarea.

Ce urmărește intervievatorul: Intervievatorul verifică dacă ai lucrat cu TypeScript strict modern. Răspunsul slab este catch (err: any), care ascunde problema în loc să o rezolve.

Eroarea, în practică:TS18046: 'e' is of type 'unknown'TS1196: Catch clause type must be any or unknown

18 Junior

Ce fac as și operatorul non-null !? Ce problemă are codul următor?

TypeScript
const input = document.querySelector('#email') as HTMLInputElement;
const user = users.find(u => u.id === id)!;
console.log(input.value, user.name);

Răspuns scurt: Ambele sunt aserțiuni: îi spui compilatorului „știu mai bine” și el nu mai verifică. Dacă elementul nu există sau find nu găsește nimic, codul crapă la rulare, iar TypeScript nu te-a avertizat.

O aserțiune de tip nu convertește și nu verifică nimic la rulare. Doar schimbă tipul văzut de compilator:

  • x as T acceptă conversia dacă tipurile se suprapun măcar parțial (de la Element | null la HTMLInputElement);
  • x! elimină null și undefined din tipul lui x.

În exemplu, querySelector returnează Element | null. Aserțiunea ascunde două presupuneri: că elementul există și că e chiar un input. find returnează User | undefined, iar ! presupune că utilizatorul există mereu. Dacă oricare presupunere e falsă, primești Cannot read properties of null departe de cauza reală.

Variante mai sigure:

TypeScript
const el = document.querySelector('#email');
if (!(el instanceof HTMLInputElement)) throw new Error('Lipsește #email');
el.value; // HTMLInputElement, verificat

const user = users.find(u => u.id === id);
if (!user) throw new Error(`Utilizator inexistent: ${id}`);

Aruncarea unei erori cu mesaj clar e mult mai ușor de depanat decât un crash anonim.

Când as este acceptabil: teste, cod generat, as const, sau când un API returnează un tip prea larg și tu ai verificat deja în alt mod. Construcția x as unknown as T (dublă aserțiune) ocolește complet sistemul de tipuri și ar trebui să atragă atenția la code review.

Ce urmărește intervievatorul: Se verifică dacă știi că aserțiunile nu au efect la rulare. Mulți candidați le folosesc reflex ca să „scape de erori roșii”.

Eroarea, în practică:TS18048: 'x' is possibly 'undefined'TS2532: Object is possibly 'undefined'

19 Mid

Cum te asiguri, la compilare, că un switch tratează toate variantele unui union, chiar și pe cele adăugate mai târziu? Scrie funcția assertNever.

Răspuns scurt: Pui în ramura default o atribuire către never, de obicei prin assertNever(x). Dacă cineva adaugă o variantă nouă în union, valoarea nu mai e never în default, iar compilatorul dă eroare.

După ce toate cazurile unui union au fost tratate, narrowing-ul lasă variabila cu tipul never (mulțimea vidă). Asta poate fi folosit ca verificare de completitudine (exhaustiveness check):

TypeScript
type Status = 'pending' | 'paid' | 'shipped';

function assertNever(x: never): never {
  throw new Error(`Caz netratat: ${JSON.stringify(x)}`);
}

function label(s: Status): string {
  switch (s) {
    case 'pending': return 'În așteptare';
    case 'paid':    return 'Plătită';
    case 'shipped': return 'Expediată';
    default:        return assertNever(s);
  }
}

Dacă mâine adaugi 'cancelled' în Status, în default variabila s are tipul 'cancelled', care nu e atribuibil lui never, iar eroarea apare exact în funcția care trebuie actualizată. Fără acest truc, codul ar compila și ar returna undefined pentru noua stare.

De ce aruncă și eroare la rulare: datele pot veni din exterior (un API care trimite o stare nouă înainte ca frontendul să fie actualizat). Mesajul explicit ajută la depanare.

Alternative:

  • const _exhaustive: never = s; în default, fără funcție separată;
  • satisfies never în default (TypeScript 4.9+);
  • un obiect Record<Status, string> în loc de switch, care cere toate cheile;
  • regula ESLint switch-exhaustiveness-check.

Ce urmărește intervievatorul: Intervievatorul vrea să vadă că folosești tipurile ca să previi bug-uri viitoare, nu doar curente. Mulți candidați știu de never doar teoretic.

Eroarea, în practică:TS2322: Type is not assignable to type 'never'TS2678: Type is not comparable to type (case)

20 Mid

Ce sunt funcțiile de aserțiune (asserts) și cum diferă de un type guard? Scrie assertDefined.

Răspuns scurt: O funcție de aserțiune are tipul de return asserts x is T sau asserts condiție; dacă se întoarce normal, TS consideră condiția adevărată în restul blocului. Un type guard returnează boolean și trebuie folosit într-un if.

Ambele construcții îngustează tipuri, dar stilul diferă. Type guard-ul te obligă să ramifici codul; funcția de aserțiune aruncă o excepție dacă condiția e falsă și îți permite să continui liniar:

TypeScript
function assertDefined<T>(value: T, msg?: string): asserts value is NonNullable<T> {
  if (value === null || value === undefined) {
    throw new Error(msg ?? 'Valoare lipsă');
  }
}

function assert(cond: unknown, msg: string): asserts cond {
  if (!cond) throw new Error(msg);
}

const user = users.find(u => u.id === id);
assertDefined(user, `Nu există utilizatorul ${id}`);
user.name; // User, fără if

assert(typeof config.port === 'number', 'port invalid');
config.port.toFixed(); // number

Detalii care contează:

  • funcția trebuie să aibă tipul de return declarat explicit (asserts ...), altfel nu are efect;
  • dacă o scrii ca arrow function, variabila trebuie să aibă un tip declarat explicit, altfel TS dă eroarea „Assertions require every name in the call target to be declared with an explicit type annotation”;
  • ca la type guard-uri, compilatorul nu verifică logica din corp.

Când alegi una sau alta: aserțiunile sunt bune pentru precondiții care, dacă sunt încălcate, înseamnă un bug (configurație lipsă, invariant rupt). Type guard-urile sunt potrivite când ambele ramuri sunt cazuri normale de business (utilizator logat sau nu).

Ce urmărește intervievatorul: Se verifică dacă cunoști o unealtă mai rară, dar utilă în cod real. Candidații o confundă adesea cu as sau cu console.assert.

Eroarea, în practică:TS2345: 'string | undefined' to parameter 'string'TS2775: Assertions require explicit type annotation

21 Mid

De ce narrowing-ul pare să „dispară” în callback-ul de mai jos și ce s-a schimbat în TypeScript 5.4?

TypeScript
function render(title: string | undefined) {
  if (title === undefined) title = 'Fără titlu';
  return items.map(i => `${title.toUpperCase()}: ${i}`);
}

Răspuns scurt: Înainte de TypeScript 5.4, narrowing-ul pentru let și parametri reatribuiți se pierdea în funcțiile create ulterior, pentru că callback-ul ar putea rula după o nouă atribuire. Din 5.4, TS îl păstrează dacă nu mai există atribuiri după crearea closure-ului.

Narrowing-ul este calculat pe fluxul de control al funcției curente. Un callback însă poate fi apelat oricând: imediat, peste o secundă sau după ce variabila a fost modificată din nou. Pentru variabile const, TS știe că valoarea nu se mai schimbă, deci păstrează narrowing-ul în orice closure. Pentru let și pentru parametrii care sunt reatribuiți undeva în funcție, versiunile mai vechi resetau tipul la cel declarat în interiorul funcțiilor create ulterior. În exemplu, în TypeScript 5.3 title ar fi fost din nou string | undefined în map, cu eroarea „'title' is possibly 'undefined'”.

TypeScript 5.4 a îmbunătățit analiza: dacă closure-ul este creat după ultima atribuire a variabilei, narrowing-ul se păstrează. Exemplul compilează acum. Dacă însă adaugi o atribuire după map, eroarea revine, pe bună dreptate.

Soluția portabilă, care funcționează în orice versiune și e și mai clară:

TypeScript
function render(rawTitle: string | undefined) {
  const title = rawTitle ?? 'Fără titlu'; // string
  return items.map(i => `${title.toUpperCase()}: ${i}`);
}

Regula practică: copiază valoarea îngustată într-o constantă înainte de callback-uri, setTimeout, handler-e de evenimente sau Promise. Același tipar te ajută cu proprietăți ale obiectelor (const { user } = state), unde narrowing-ul e mai fragil.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi de ce compilatorul se comportă așa, nu doar soluția. Un candidat bun explică legătura dintre momentul apelului și siguranța tipului.

22 Mid

Un formular are stările „nemodificat”, „se salvează”, „salvat” și „eroare”, modelate cu trei câmpuri boolean și un error?: string. Ce problemă vezi și cum ai remodela tipul?

Răspuns scurt: Trei boolean-uri permit 8 combinații, majoritatea imposibile (salvat și eroare simultan). Un union discriminat cu câmpul status face stările invalide imposibil de reprezentat, iar error există doar în varianta 'error'.

Modelul cu flag-uri arată așa:

TypeScript
interface FormState {
  isDirty: boolean;
  isSaving: boolean;
  isSaved: boolean;
  error?: string;
}

Tipul acceptă { isSaving: true, isSaved: true, error: 'x' }, o stare fără sens. Fiecare componentă trebuie să ghicească prioritățile („dacă e și salvat și eroare, ce arăt?”), iar bug-urile apar când cineva uită să reseteze un flag.

Alternativa este să descrii fiecare stare reală ca variantă separată, cu un câmp comun literal, numit discriminant:

TypeScript
type SaveState =
  | { status: 'idle' }
  | { status: 'saving'; startedAt: number }
  | { status: 'saved'; savedAt: Date }
  | { status: 'error'; message: string; retry: () => void };

function Banner({ state }: { state: SaveState }) {
  switch (state.status) {
    case 'error': return `Eroare: ${state.message}`;
    case 'saved': return `Salvat la ${state.savedAt.toLocaleTimeString()}`;
    default: return null;
  }
}

Câștiguri concrete:

  • datele specifice unei stări (message, savedAt) există doar acolo unde au sens, iar TS te împiedică să citești message în starea saved;
  • trecerea între stări se face prin înlocuirea obiectului, nu prin modificarea a patru câmpuri;
  • adăugarea unei stări noi produce erori de compilare în switch-urile cu verificare never.

Principiul se numește „make illegal states unrepresentable” și se aplică la fel pe backend, de exemplu pentru starea unei plăți.

Ce urmărește intervievatorul: Se verifică dacă poți folosi tipurile pentru design, nu doar pentru adnotări. Răspunsul slab adaugă încă un boolean.

23 Mid

Ce tip are ids în versiunile TypeScript de dinainte de 5.5 și în 5.5+? Cum rezolvai problema înainte?

TypeScript
const raw = [1, undefined, 3];
const ids = raw.filter(x => x !== undefined);

Răspuns scurt: Înainte de 5.5, ids avea tipul (number | undefined)[], pentru că filter nu știa ce face callback-ul. Din 5.5, TS deduce automat predicatul x is number (inferred type predicates), deci ids devine number[].

Array.prototype.filter are în tipurile standard două semnături: una care primește un callback ce returnează boolean și păstrează tipul elementelor, și una care primește un type predicate (x) => x is S și returnează S[]. Până la TypeScript 5.5, o săgeată ca x => x !== undefined era considerată doar o funcție care returnează boolean, deci rezultatul rămânea (number | undefined)[].

Soluția clasică era un predicat explicit:

TypeScript
const ids = raw.filter((x): x is number => x !== undefined);
// sau un helper reutilizabil
const isDefined = <T>(x: T | undefined): x is T => x !== undefined;
const ids2 = raw.filter(isDefined);

TypeScript 5.5 a introdus inferred type predicates: dacă o funcție returnează o expresie booleană care îngustează parametrul și nu are tip de return explicit, TS deduce singur predicatul. Acum raw.filter(x => x !== undefined) dă number[].

Limite de reținut:

  • predicatul se deduce doar dacă e „exact”: și ramura false trebuie să însemne că valoarea nu e de acel tip. x => !!x pe number | undefined nu produce predicat, pentru că 0 e și el exclus;
  • dacă scrii tipul de return boolean, inferența nu mai are loc;
  • verificările pe proprietăți ale obiectelor (u => u.email !== undefined) nu îngustează obiectul în această formă.

La interviu e bine să spui versiunea, fiindcă multe proiecte rulează încă versiuni mai vechi.

Ce urmărește intervievatorul: Intervievatorul verifică experiența practică cu o problemă foarte frecventă și dacă știi că depinde de versiune. Mulți candidați folosesc as number[] în loc de un predicat.

24 Senior

Primești un obiect unknown dintr-un mesaj postMessage. Fără librării, cum îl îngustezi pas cu pas până la { type: 'resize'; width: number }? Ce face TypeScript cu operatorul in pe object?

Răspuns scurt: Verifici în ordine: typeof x === 'object' && x !== null, apoi 'type' in x, apoi valorile. Din TypeScript 4.9, 'type' in x adaugă proprietatea type: unknown la tip, deci poți continua cu x.type === 'resize' fără aserțiuni.

unknown te obligă să demonstrezi forma datelor înainte să le folosești. Lanțul de verificări construiește treptat tipul:

TypeScript
type ResizeMsg = { type: 'resize'; width: number };

function isResizeMsg(x: unknown): x is ResizeMsg {
  if (typeof x !== 'object' || x === null) return false;
  // x: object
  if (!('type' in x) || x.type !== 'resize') return false;
  // x: object & Record<'type', unknown>, cu type comparat
  return 'width' in x && typeof x.width === 'number' && Number.isFinite(x.width);
}

window.addEventListener('message', (e: MessageEvent<unknown>) => {
  if (e.origin !== 'https://app.exemplu.ro') return;
  if (isResizeMsg(e.data)) resize(e.data.width);
});

Înainte de TypeScript 4.9, 'type' in x pe un object nu adăuga nimic la tip, deci x.type dădea eroare și erai nevoit să scrii (x as any).type sau (x as Record<string, unknown>).type. Acum, in pe un tip care nu declară proprietatea o adaugă ca unknown, ceea ce face verificările manuale curate și fără any.

Observații pentru interviu:

  • typeof x === 'object' singur lasă null posibil, de aceea verificarea x !== null;
  • typeof NaN === 'number', de aceea Number.isFinite;
  • verificarea origin e o măsură de securitate, nu de tipuri: tipurile nu protejează împotriva datelor trimise de alt site.

Pentru mesaje cu multe variante, merită o schemă de validare declarativă, dar înțelegerea acestor pași rămâne necesară ca să citești codul generat de librării.

Ce urmărește intervievatorul: Se verifică stăpânirea lui unknown în practică și cunoașterea unei îmbunătățiri recente. Candidații slabi sar direct la as ResizeMsg.

Eroarea, în practică:TS18046: 'e' is of type 'unknown'

Obiecte, interfețe și compatibilitate

Exersează capitolul cu exerciții reale: Curs TypeScript pentru începători →
25 Junior

Ce înseamnă că TypeScript are tipizare structurală? Compilează codul de mai jos?

TypeScript
class Euro { constructor(public amount: number) {} }
class Leu { constructor(public amount: number) {} }
function payInLei(x: Leu) { return x.amount; }
payInLei(new Euro(100));

Răspuns scurt: Da, compilează: TypeScript compară forma tipurilor, nu numele lor. Euro și Leu au aceeași structură (amount: number), deci sunt interschimbabile. În Java sau C#, unde tipizarea e nominală, codul ar da eroare.

În sistemele nominale (Java, C#), un tip e compatibil cu altul doar dacă e declarat explicit așa (class A extends B, implements I). TypeScript folosește tipizare structurală: dacă un obiect are toate proprietățile cerute, cu tipurile potrivite, este acceptat, indiferent cum s-a numit tipul sau cine l-a creat. Alegerea reflectă felul în care se scrie JavaScript: obiecte literale, date din JSON, „duck typing”.

Avantaje:

  • poți pasa obiecte literale și mock-uri în teste fără să implementezi interfețe formal;
  • interfețele se pot defini „după fapt”, pentru cod care nu le cunoaște.

Dezavantajul se vede în exemplu: două concepte diferite cu aceeași formă se pot amesteca accidental (euro și lei, userId și orderId, ambele string). Soluții:

  • câmpuri care diferențiază formele: currency: 'EUR' vs currency: 'RON';
  • branded types, care adaugă o etichetă existentă doar la nivel de tip (detaliat la altă întrebare);
  • membri private sau #private în clase: din momentul în care o clasă are un membru private, doar instanțele ei (și ale subclaselor) îi sunt compatibile, ceea ce introduce o formă de nominalitate.
TypeScript
class Leu2 { private readonly _brand = 'RON'; constructor(public amount: number) {} }
// acum new Euro(100) nu mai e acceptat ca Leu2

Tipizarea structurală explică și excess property checking și compatibilitatea funcțiilor, care sunt alte întrebări frecvente.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi modelul fundamental al compatibilității. Candidații veniți din Java presupun adesea că numele claselor contează.

26 Junior

Ce garantează readonly într-o interfață și ce nu? Ce se întâmplă aici?

TypeScript
interface Cart { readonly items: string[] }
const cart: Cart = { items: ['carte'] };
cart.items.push('pix');
cart.items = [];

Răspuns scurt: readonly interzice doar reatribuirea proprietății (cart.items = [] dă eroare), nu și modificarea obiectului din ea, deci push compilează. Pentru tablou imutabil la nivel de tip folosești readonly string[]; nimic din acestea nu există la rulare.

readonly este un modificator superficial (shallow) și exclusiv de compilare:

  • protejează legătura: nu poți scrie cart.items = [];
  • nu protejează conținutul: tabloul referit e încă string[], cu push, splice și sort.

Pentru tablouri ai tipul readonly string[] (echivalent cu ReadonlyArray<string>), care elimină metodele care modifică tabloul:

TypeScript
interface Cart { readonly items: readonly string[] }
const cart: Cart = { items: ['carte'] };
cart.items.push('pix');           // eroare: push nu există
const next = [...cart.items, 'pix']; // corect: tablou nou

Pentru obiecte imbricate, Readonly<T> e tot superficial, de aceea echipele scriu un DeepReadonly<T> recursiv.

Ce nu face readonly:

  • nu îngheață obiectul la rulare; altă parte de cod, fără tipul Cart (de exemplu JavaScript sau as any), îl poate modifica. Pentru asta există Object.freeze, iar Object.freeze(obj) returnează tipul Readonly<T>;
  • nu blochează atribuirea: un readonly string[] nu poate fi atribuit unui string[], dar invers e permis, deci o funcție care primește readonly string[] poate primi orice tablou.

Practic, marchează parametrii de tip tablou ca readonly în funcțiile care nu îi modifică. Comunici intenția, iar apelanții pot pasa și tablouri as const. E una dintre cele mai ieftine îmbunătățiri ale unui API intern.

Ce urmărește intervievatorul: Verifică dacă știi diferența dintre imutabilitatea legăturii și cea a datelor. Mulți candidați cred că readonly îngheață obiectul ca Object.freeze.

Eroarea, în practică:TS2540: Cannot assign to read-only propertyTS2542: Index signature only permits reading

27 Junior

Ce este un index signature și ce problemă de siguranță are codul de mai jos? Cum o rezolvă noUncheckedIndexedAccess?

TypeScript
const stock: { [sku: string]: number } = { A1: 5 };
const qty = stock['B7'];
console.log(qty.toFixed(0));

Răspuns scurt: Index signature-ul { [sku: string]: number } spune că orice cheie string are o valoare number, deci stock['B7'] e number, deși la rulare e undefined. Cu noUncheckedIndexedAccess, accesul prin index devine number | undefined și te obligă să verifici.

Un index signature descrie obiecte folosite ca dicționar, cu chei cunoscute doar la rulare: { [key: string]: T } sau, echivalent, Record<string, T>. Problema: tipul afirmă că *orice* cheie există. Codul din exemplu compilează fără eroare și crapă la rulare cu „Cannot read properties of undefined (reading 'toFixed')”. La fel se întâmplă cu tablourile: arr[10] are tipul elementului chiar dacă tabloul are 3 elemente.

Opțiunea noUncheckedIndexedAccess (nu e inclusă în strict) adaugă | undefined la fiecare acces prin index:

TypeScript
const qty = stock['B7'];   // number | undefined
if (qty !== undefined) console.log(qty.toFixed(0));
const first = arr[0];      // T | undefined
for (const x of arr) {}    // x: T, for...of nu e afectat

Avantaje: prinde bug-uri reale de tip „cheie lipsă” sau „index în afara tabloului”. Cost: mai multe verificări în cod, uneori redundante (după if (arr.length > 0) TS tot nu știe că arr[0] există). Mulți preferă să o activeze în proiectele noi și să folosească for...of, .at(), destructurare cu valori implicite sau Map, al cărui get returnează oricum V | undefined.

Alte detalii despre index signatures: cheia poate fi string, number, symbol sau template literal (` [key: data-${string}]: string `), iar proprietățile declarate explicit în același tip trebuie să fie compatibile cu tipul valorii din index signature.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi unde TypeScript implicit nu e sigur. Puțini candidați cunosc noUncheckedIndexedAccess, deși e des activat în proiecte noi.

Eroarea, în practică:TS18048: 'x' is possibly 'undefined'TS2532: Object is possibly 'undefined'

28 Junior

Ce se întâmplă când extinzi două tipuri care au aceeași proprietate cu tipuri diferite, o dată cu interface extends și o dată cu &?

TypeScript
interface A { id: string }
interface B extends A { id: number }
type C = { id: string } & { id: number };

Răspuns scurt: interface B extends A dă eroare imediat la declarație: „Interface 'B' incorrectly extends interface 'A'”. Intersecția C compilează, dar id devine string & number, adică never, iar eroarea apare abia când încerci să creezi o valoare.

extends la interfețe verifică compatibilitatea: proprietatea redeclarată trebuie să fie un subtip al celei moștenite. Poți îngusta (id: string devine id: 'admin'), dar nu poți schimba tipul în ceva incompatibil. Greșeala e semnalată la definiția tipului, unde e cauza.

Intersecția & nu verifică nimic la definiție. Combină pur și simplu cerințele: un obiect de tip C trebuie să aibă id care e simultan string și number. Nu există o asemenea valoare, deci C['id'] este never, iar erorile apar mai târziu și sunt mai greu de înțeles:

TypeScript
const c: C = { id: '1' }; // eroare: Type 'string' is not assignable to type 'never'

Dacă proprietățile conflictuale sunt literale folosite ca discriminant ({ kind: 'a' } & { kind: 'b' }), TS reduce întreaga intersecție la never.

Ce înseamnă pentru alegerea dintre ele:

  • pentru ierarhii de obiecte (entități, props extinse), interface extends dă erori mai bune și e verificat mai rapid de compilator, pentru că relațiile dintre interfețe sunt memorate;
  • & e necesar pentru combinații pe care interfețele nu le pot exprima: intersecții cu union-uri, cu tipuri mapate sau cu parametri generici (T & { id: string }).

Când vrei să înlocuiești o proprietate, nu să o combini, folosești Omit: type B2 = Omit<A, 'id'> & { id: number }.

Ce urmărește intervievatorul: Se verifică dacă știi o diferență concretă și practică dintre extends și &, nu doar „sunt la fel”. Candidații descoperă de obicei never abia la depanare.

Eroarea, în practică:TS2430: Interface incorrectly extends interface

29 Junior

De ce Object.keys(user) returnează string[] și nu (keyof User)[]? Cum parcurgi corect cheile unui obiect tipizat?

Răspuns scurt: Pentru că, datorită tipizării structurale, un obiect de tip User poate avea la rulare și alte chei decât cele declarate. Dacă Object.keys ar returna keyof User, tipul ar minți. Pentru obiecte cu chei fixe, iterezi peste o listă de chei cunoscută.

Exemplul care justifică decizia:

TypeScript
interface User { name: string; age: number }
const admin = { name: 'Ana', age: 30, role: 'admin' };
const u: User = admin; // valid structural
Object.keys(u); // ['name', 'age', 'role']

Dacă tipul returnat ar fi ('name' | 'age')[], codul care face switch pe chei ar crede că a tratat toate cazurile, iar 'role' ar trece neobservat. Echipa TypeScript a ales varianta sigură: string[].

Variante practice:

TypeScript
// 1. Lista de chei e sursa de adevăr
const FIELDS = ['name', 'age'] as const satisfies readonly (keyof User)[];
for (const k of FIELDS) console.log(k, u[k]);

// 2. Object.entries, când nu ai nevoie de tipul exact al cheii
for (const [k, v] of Object.entries(u)) console.log(k, v);

// 3. Aserțiune, asumată conștient
const keys = Object.keys(u) as Array<keyof User>;

Varianta a treia e acceptabilă când obiectul e creat de tine (de exemplu un Record<Status, string> construit local) și știi că nu are chei în plus. E o aserțiune, deci merită izolată într-un helper cu nume clar, de exemplu typedKeys, ca să fie evidentă la code review.

Pentru dicționare cu chei dinamice, alege un Map<K, V>: map.keys() are tipul exact al cheilor, iar iterarea păstrează ordinea inserării.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi consecințele tipizării structurale în cod de zi cu zi. Răspunsul slab este „e un bug al TypeScript-ului”.

Eroarea, în practică:TS7053: 'string' can't be used to index typeTS2405: for...in variable must be string or any

30 Mid

De ce compilează codul de mai jos, deși callback-ul primește mai puțini parametri decât cere tipul? Ce reguli de compatibilitate se aplică funcțiilor?

TypeScript
type Handler = (value: string, index: number, all: string[]) => void;
const h: Handler = (value) => console.log(value);
const getName: () => string = () => 'Ana' as const;

Răspuns scurt: O funcție cu mai puțini parametri e compatibilă cu un tip care cere mai mulți, pentru că poate ignora argumentele în plus. Tipul returnat poate fi mai specific (covariant), iar tipurile parametrilor se compară invers (contravariant, cu strictFunctionTypes).

Regulile de compatibilitate pentru funcții urmează ce e sigur la rulare:

  • Numărul de parametri: în JavaScript, argumentele în plus sunt ignorate. O funcție care folosește doar value funcționează perfect când e apelată cu (value, index, all). De aceea scrii arr.map(x => x * 2), deși map trimite trei argumente. Invers nu merge: o funcție care cere doi parametri obligatorii nu poate fi folosită unde apelantul trimite unul.
  • Tipul returnat: poate fi mai specific. Un () => 'Ana' e un () => string, pentru că oricine așteaptă un string primește unul.
  • Tipurile parametrilor: trebuie să fie la fel de largi sau mai largi. O funcție care acceptă string | number poate înlocui una care primește string, dar nu invers:
TypeScript
type OnText = (s: string) => void;
const ok: OnText = (x: string | number) => {};
const bad: OnText = (x: 'a' | 'b') => {}; // eroare cu strictFunctionTypes

A doua atribuire ar fi periculoasă: apelantul poate trimite 'z', pe care funcția nu îl așteaptă.

Excepție importantă: metodele declarate cu sintaxa de metodă (onChange(s: string): void) sunt verificate bivariant chiar și cu strictFunctionTypes, din motive de compatibilitate cu DOM-ul și cu cod vechi. Proprietățile de tip funcție (onChange: (s: string) => void) sunt verificate strict. De aceea unele ghiduri de stil recomandă forma de proprietate în interfețele publice.

Ce urmărește intervievatorul: Se verifică înțelegerea variance la funcții, nu doar memorarea regulilor. Candidații buni explică de ce fiecare regulă e sigură la rulare.

31 Mid

Codul de mai jos compilează. Ce problemă ascunde și ce spune asta despre variance în TypeScript?

TypeScript
interface Animal { name: string }
interface Dog extends Animal { bark(): void }
const dogs: Dog[] = [{ name: 'Rex', bark() {} }];
const animals: Animal[] = dogs;
animals.push({ name: 'Tom' });
dogs[1].bark();

Răspuns scurt: Tablourile sunt tratate covariant: Dog[] e acceptat ca Animal[]. Prin alias-ul animals adaugi un animal fără bark în același tablou, iar dogs[1].bark() crapă la rulare. E o alegere deliberată de unsoundness, în favoarea ergonomiei.

Variance descrie cum se transmite relația de subtip prin tipuri compuse. Dacă Dog e subtip al lui Animal:

  • covariant: Box<Dog> e subtip al lui Box<Animal> (sigur pentru citire);
  • contravariant: relația se inversează (sigur pentru scriere, ca la parametrii funcțiilor);
  • invariant: nicio relație (sigur pentru citire și scriere).

Un tablou mutabil ar trebui să fie invariant, pentru că permite și citire, și scriere. TypeScript îl tratează covariant, pentru că altfel foarte mult cod real (funcții care primesc Animal[] și doar citesc) ar necesita copii sau generice. Prețul se vede în exemplu: aliasing-ul permite introducerea unui element greșit, iar bug-ul apare la bark().

Cum te protejezi:

TypeScript
function printAll(list: readonly Animal[]) {
  list.forEach(a => console.log(a.name)); // doar citire, sigur
}
  • parametrii care doar citesc să fie readonly T[]; covarianța e atunci corectă, pentru că lipsesc metodele de scriere;
  • evită să modifici tablouri primite din afară; returnează tablouri noi.

Din TypeScript 4.7 poți adnota explicit variance pe parametrii generici, cu in și out (interface Producer<out T>). Adnotările sunt folosite mai ales în librării, pentru erori mai clare și verificare mai rapidă, nu pentru a schimba regulile.

Exemplul e bun pentru interviu fiindcă arată că TypeScript nu e complet „sound” și că echipa a ales conștient unde face compromisuri.

Ce urmărește intervievatorul: Intervievatorul caută o înțelegere profundă a sistemului de tipuri. Răspunsul slab: „TypeScript ar fi trebuit să dea eroare, deci e un bug”.

32 Mid

Cum tipizezi o structură recursivă, cum ar fi o valoare JSON oarecare sau un meniu cu submeniuri pe oricâte niveluri?

Răspuns scurt: Folosești un type alias sau o interfață care se referă la ea însăși: type Json = string | number | boolean | null | Json[] | { [k: string]: Json }, respectiv interface MenuItem { label: string; children?: MenuItem[] }.

TypeScript permite tipuri recursive atât timp cât referința la sine e „amânată”, adică apare în interiorul unui obiect, tablou sau al unei funcții:

TypeScript
type Json =
  | string | number | boolean | null
  | Json[]
  | { [key: string]: Json };

interface MenuItem {
  label: string;
  href?: string;
  children?: MenuItem[];
}

function countItems(items: MenuItem[]): number {
  return items.reduce((n, i) => n + 1 + countItems(i.children ?? []), 0);
}

Tipul Json e util când scrii o funcție care trebuie să accepte doar date serializabile, de exemplu pentru localStorage sau postMessage. Dacă cineva încearcă să pună un Date, o funcție sau undefined într-un obiect Json, primește eroare la compilare. La citire, nu e un înlocuitor pentru validare: JSON.parse returnează any, iar un as Json nu verifică nimic.

Pentru arbori generici, poți parametriza:

TypeScript
interface TreeNode<T> { value: T; children: TreeNode<T>[] }

Limite de reținut:

  • tipurile recursive condiționale (cum ar fi DeepPartial) au o adâncime maximă de instanțiere; la structuri foarte adânci primești „Type instantiation is excessively deep and possibly infinite”;
  • interfețele recursive sunt de obicei mai rapide decât intersecțiile recursive, pentru că TS memorează relațiile dintre ele.

Pentru date venite din API, combină tipul cu o schemă de validare recursivă (de exemplu z.lazy în Zod).

Ce urmărește intervievatorul: Se verifică dacă știi să modelezi date reale cu adâncime variabilă. Candidații slabi folosesc any pentru children.

Eroarea, în practică:TS2456: Type alias circularly references itself

33 Mid

Ce schimbă opțiunea exactOptionalPropertyTypes și de ce contează în codul de mai jos?

TypeScript
interface Options { timeout?: number }
const defaults = { timeout: 5000 };
const user: Options = { timeout: undefined };
const final = { ...defaults, ...user };
console.log(final.timeout);

Răspuns scurt: Fără opțiune, timeout?: number acceptă și valoarea explicită undefined, iar spread-ul suprascrie valoarea implicită, deci se afișează undefined. Cu exactOptionalPropertyTypes, proprietatea poate lipsi, dar nu poate fi setată explicit la undefined, deci atribuirea dă eroare.

În JavaScript, „proprietatea lipsește” și „proprietatea există cu valoarea undefined” sunt situații diferite:

TypeScript
'timeout' in {}                     // false
'timeout' in { timeout: undefined } // true
{ ...{ timeout: 5000 }, ...{ timeout: undefined } } // { timeout: undefined }

Spread-ul, Object.assign, Object.keys și JSON.stringify tratează diferit cele două cazuri. Implicit, TypeScript le confundă: timeout?: number înseamnă number | undefined și acceptă ambele forme. Rezultatul din exemplu e un bug clasic: utilizatorul trimite un câmp gol, iar timeout-ul implicit dispare.

Cu exactOptionalPropertyTypes: true (nu e inclus în strict):

TypeScript
const user: Options = { timeout: undefined };
// eroare: Type 'undefined' is not assignable to type 'number'
interface Options2 { timeout?: number | undefined } // dacă vrei explicit ambele

Acum tipul exprimă exact intenția: timeout?: number înseamnă „lipsește sau e număr”. Dacă vrei să permiți și undefined, o scrii explicit.

Opțiunea e utilă pentru obiecte de configurare, PATCH-uri parțiale și orice cod care face merge de obiecte. Costul: la activare apar erori în cod existent și uneori în declarațiile unor librării care nu au fost scrise cu ea în minte. Mulți o activează doar în proiecte noi.

Ca alternativă la nivel de cod, filtrezi valorile undefined înainte de merge sau folosești ?? pe fiecare câmp.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi o subtilitate JavaScript reflectată în tipuri. Candidații de nivel mid au de obicei experiența bug-ului, dar nu știu că există o opțiune pentru el.

34 Senior

TypeScript nu este „sound”. Dă exemple concrete de cod care compilează, dar are tipul greșit la rulare, și spune cum te protejezi în fiecare caz.

Răspuns scurt: Exemple: acces prin index (arr[99]), covarianța tablourilor, parametrii de metode bivarianți, any, aserțiunile as, type guard-uri greșite și aliasing prin {}. Te protejezi prin opțiuni stricte, reguli ESLint, validare la granițe și evitarea aserțiunilor.

Un sistem de tipuri sound garantează că, dacă programul compilează, valorile au la rulare tipul declarat. TypeScript renunță conștient la această garanție în câteva locuri, pentru a putea tipiza JavaScript real:

  • acces prin index: arr[99] și dict['x'] au tipul elementului, deși pot fi undefined. Protecție: noUncheckedIndexedAccess.
  • covarianța tablourilor: un Dog[] atribuit unui Animal[] poate primi un Cat. Protecție: readonly T[] în parametri.
  • metode bivariante: parametrii metodelor nu sunt verificați strict. Protecție: proprietăți de tip funcție în interfețe.
  • any: se propagă tăcut. Protecție: noImplicitAny, regulile no-unsafe-* din typescript-eslint, unknown în loc de any.
  • aserțiuni și type guard-uri: as, ! și x is T nu sunt verificate. Protecție: validare reală.
  • aliasing prin tipuri largi:
TypeScript
const raw = { timeout: 'mult' };
const anything: {} = raw;
const opts: { timeout?: number } = anything; // compilează
opts.timeout?.toFixed(); // crapă: toFixed nu e funcție pe string
  • date externe: JSON.parse, res.json(), variabile de mediu, localStorage intră ca any sau sunt aserționate.

Strategia unei echipe mature: tipuri stricte în interior, validare cu schemă la granițe (HTTP, cozi, fișiere), unknown pentru tot ce vine din exterior, iar as și any permise doar cu comentariu și verificate la code review. Și testele rămân necesare: tipurile reduc numărul de bug-uri, nu le elimină.

Ce urmărește intervievatorul: Se verifică dacă ai o imagine realistă despre ce garantează TypeScript. Un candidat senior știe exemple concrete și o strategie de echipă, nu doar „folosesc strict”.

Generice și constrângeri

35 Junior

Scrie funcția generică last care returnează ultimul element al unui tablou. Ce tip deduce TypeScript pentru last([1, 'a']) și de ce tipul returnat include undefined?

Răspuns scurt: function last<T>(arr: readonly T[]): T | undefined. Pentru [1, 'a'], TS deduce T = string | number. Returnează T | undefined pentru că tabloul poate fi gol, iar tipul trebuie să spună asta.

TypeScript
function last<T>(arr: readonly T[]): T | undefined {
  return arr[arr.length - 1];
}

const a = last([1, 2, 3]);      // number | undefined
const b = last([1, 'a']);       // string | number | undefined
const c = last<string>([]);     // string | undefined, argument de tip explicit
const d = last(['x', 'y'] as const); // 'x' | 'y' | undefined

Ce se întâmplă la apel: TypeScript face inferența argumentelor de tip: compară tipul argumentului cu tipul parametrului readonly T[] și caută un T potrivit. Pentru [1, 'a'], tabloul literal are tipul (string | number)[], deci T devine union-ul. Când inferența nu are de unde lua informații (tablou gol), T devine never în exemplul cu [] neadnotat, motiv pentru care uneori pasezi argumentul de tip explicit.

De ce readonly T[]: funcția nu modifică tabloul, iar parametrul readonly acceptă și tablouri obișnuite, și tablouri as const.

De ce T | undefined: fără noUncheckedIndexedAccess, arr[arr.length - 1] are tipul T, iar codul ar compila cu tipul de return T. Ar fi o minciună pentru tablouri goale. Declarând explicit T | undefined, obligi apelantul să trateze cazul gol.

Alternativa modernă din JavaScript este arr.at(-1), care în tipurile standard returnează deja T | undefined.

Ce urmărește intervievatorul: Intervievatorul verifică dacă scrii generice simple corect și dacă te gândești la cazurile limită. Greșeala tipică e tipul de return T sau any.

36 Junior

Ce face extends într-un parametru generic? De ce nu compilează prima variantă și cum o repari?

TypeScript
function longest<T>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

Răspuns scurt: Fără constrângere, T poate fi orice, inclusiv number, care nu are length. Constrângerea T extends { length: number } limitează tipurile acceptate la cele cu length, iar în corp poți folosi proprietatea.

Un parametru generic neconstrâns e tratat ca unknown în interiorul funcției: nu poți accesa nicio proprietate, pentru că apelantul ar putea trimite orice. Eroarea este „Property 'length' does not exist on type 'T'”.

Constrângerea extends spune „T poate fi orice tip, cu condiția să fie compatibil cu X”:

TypeScript
function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

longest('abc', 'de');        // string
longest([1, 2], [3]);        // number[]
longest(10, 20);             // eroare: number nu are length

De ce nu scrii direct (a: { length: number }, b: { length: number })? Pentru că ai pierde tipul exact: rezultatul ar fi { length: number }, nu string sau number[]. Genericul cu constrângere păstrează tipul concret al argumentului și îi garantează în același timp forma minimă.

Câteva constrângeri uzuale:

  • T extends string sau T extends string | number pentru chei și identificatori;
  • T extends object ca să excluzi primitivele;
  • T extends (...args: any[]) => any pentru funcții;
  • K extends keyof T ca o cheie să aparțină unui obiect.

Atenție la un efect al constrângerii: dacă apelezi longest('abc', [1]), TS încearcă să găsească un T comun și dă eroare, pentru că inferă T din primul argument. E un comportament corect: funcția promite să returneze același tip pe care l-a primit.

Ce urmărește intervievatorul: Se verifică înțelegerea rolului constrângerilor și diferența față de un parametru cu tip fix. Mulți candidați rezolvă cu any.

Eroarea, în practică:TS2344: Type does not satisfy the constraintTS2339: Property does not exist on type 'T'

37 Junior

Definește un tip generic pentru răspunsurile unui API, care conține fie datele, fie o eroare, cu un parametru implicit. Cum îl folosești?

Răspuns scurt: Un type alias generic cu valoare implicită: type ApiResult<T = unknown, E = ApiError> = { ok: true; data: T } | { ok: false; error: E }. Apelantul scrie ApiResult<User[]>, iar după if (r.ok) TS știe că data există.

Interfețele și alias-urile pot avea parametri de tip, la fel ca funcțiile. Parametrii impliciți (T = unknown) funcționează ca valorile implicite ale argumentelor: pot fi omiși la utilizare.

TypeScript
interface ApiError { code: string; message: string }

type ApiResult<T = unknown, E = ApiError> =
  | { ok: true; data: T }
  | { ok: false; error: E };

interface Page<T> { items: T[]; total: number; next: string | null }

async function getUsers(): Promise<ApiResult<Page<User>>> {
  const res = await fetch('/api/users');
  if (!res.ok) return { ok: false, error: await res.json() };
  return { ok: true, data: await res.json() };
}

const r = await getUsers();
if (r.ok) r.data.items.forEach(u => console.log(u.name));
else console.error(r.error.message);

Reguli pentru parametri impliciți:

  • trebuie să vină după parametrii fără valoare implicită;
  • valoarea implicită trebuie să respecte constrângerea: <T extends object = {}>;
  • un default unknown e mai sigur decât any: cine uită să specifice tipul e obligat să îngusteze datele.

Observă că res.json() returnează Promise<any>, deci data primește tipul declarat fără nicio verificare. Tipul generic descrie un contract, nu îl garantează: la granița cu rețeaua, fie generezi tipurile din specificația API-ului (OpenAPI), fie validezi răspunsul cu o schemă.

Tiparul ok: true | false este un union discriminat: forțează tratarea erorii înainte de a accesa datele, ceea ce un data?: T; error?: E nu face.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să compui generice cu union-uri și să le folosești în cod realist. Candidații slabi pun ambele câmpuri opționale.

38 Junior

Ce tipuri generice din biblioteca standard folosești zilnic? Când trebuie să pasezi explicit argumentul de tip, ca în new Map<string, number>()?

Răspuns scurt: Array<T>, Promise<T>, Map<K, V>, Set<T>, Record<K, V>, ReadonlyArray<T>. Pasezi argumentul explicit când inferența nu are informații: colecții create goale, useState(null), JSON.parse sau un generic folosit doar în tipul returnat.

Multe API-uri pe care le folosești sunt generice, chiar dacă nu scrii niciodată <...>, pentru că inferența completează argumentele de tip:

TypeScript
const tags = new Set(['ts', 'js']);       // Set<string>
const p = Promise.resolve(42);            // Promise<number>
const m = new Map([['a', 1], ['b', 2]]);  // Map<string, number>

Problema apare când valoarea inițială nu spune nimic:

TypeScript
const cache = new Map();                  // Map<any, any>
const cache2 = new Map<string, User>();   // corect
const queue: Promise<void>[] = [];
const ids = new Set<number>();

new Map() fără argumente devine Map<any, any>, deci orice get returnează any și siguranța dispare tăcut, fără eroare chiar și cu noImplicitAny. E un caz pe care merită să îl cauți la code review.

Situații tipice în care specifici explicit:

  • colecții create goale (Map, Set, tablouri);
  • useState<User | null>(null) sau useRef<HTMLInputElement>(null) în React;
  • funcții al căror generic apare doar în return, ca document.querySelector<HTMLInputElement>('#q'). Acestea sunt de fapt aserțiuni deghizate: TS nu verifică selectorul;
  • când vrei un tip mai larg decât cel dedus: new Set<string>(['a']) ca să poți adăuga orice string.

Regula practică: lasă inferența când există o valoare din care să deducă tipul și specifică explicit când nu există sau când tipul dedus ar fi prea îngust.

Ce urmărește intervievatorul: Se verifică experiența practică cu tipurile generice ale platformei. Capcana new Map() devenit Map<any, any> e frecventă și puțini o observă.

Eroarea, în practică:TS2345: Argument ... to parameter of type 'never'TS2314: Generic type requires type argument(s)

39 Mid

Ce problemă are funcția generică de mai jos? Care e regula după care decizi dacă un parametru de tip își are rostul?

TypeScript
function parseJson<T>(text: string): T {
  return JSON.parse(text);
}
const user = parseJson<User>(raw);

Răspuns scurt: T apare o singură dată, doar în tipul returnat, deci funcția e o aserțiune deghizată: apelantul alege orice tip și nimic nu îl verifică. Regula: un parametru de tip ar trebui să apară de cel puțin două ori, ca să lege intrarea de ieșire.

Genericele există ca să exprime o relație între tipuri: „returnez același tip pe care l-am primit”, „cheia aparține obiectului”, „callback-ul primește elementele tabloului”. Dacă T apare într-un singur loc, nu leagă nimic.

În parseJson<T>, apelantul scrie parseJson<User>(raw), iar rezultatul e User fără nicio verificare, exact ca JSON.parse(raw) as User, dar ascuns. E mai periculos decât aserțiunea explicită, pentru că arată ca un API sigur.

Variante mai oneste:

TypeScript
function parseJson(text: string): unknown {
  return JSON.parse(text);
}
// sau, cu un validator, T apare de două ori
function parseWith<T>(text: string, guard: (x: unknown) => x is T): T {
  const data: unknown = JSON.parse(text);
  if (!guard(data)) throw new Error('JSON invalid');
  return data;
}

Alt exemplu de generic inutil:

TypeScript
function len<T extends string>(s: T): number { return s.length; }
// identic cu: function len(s: string): number

Aici T apare o dată în parametri, iar rezultatul nu depinde de el; un tip simplu e mai clar și mai ușor de citit.

Excepții acceptate: unele API-uri cunoscute (querySelector<E>, useState<T>) folosesc genericul doar în return din motive de ergonomie. Când le scrii pe ale tale, documentează că e o aserțiune. Regula „cel puțin două apariții” vine din ghidurile echipei TypeScript pentru declarații.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi scopul genericelor, nu doar sintaxa. Mulți candidați cred că orice funcție devine „mai tipată” dacă primește un <T>.

40 Mid

Scrie o funcție pluck(items, key) care returnează valorile unei proprietăți din toate obiectele unui tablou, cu tipul corect al rezultatului. De ce ai nevoie de doi parametri de tip?

Răspuns scurt: function pluck<T, K extends keyof T>(items: T[], key: K): T[K][]. T e tipul obiectelor, iar K e cheia exactă aleasă; fără K separat, rezultatul ar fi union-ul tuturor valorilor din T, nu tipul proprietății cerute.

TypeScript
function pluck<T, K extends keyof T>(items: readonly T[], key: K): T[K][] {
  return items.map(item => item[key]);
}

interface Product { id: number; name: string; tags: string[] }
const products: Product[] = [];

const names = pluck(products, 'name'); // string[]
const ids = pluck(products, 'id');     // number[]
pluck(products, 'price');              // eroare: 'price' nu e keyof Product

Cum funcționează:

  • keyof T produce union-ul cheilor: 'id' | 'name' | 'tags';
  • K extends keyof T permite doar chei existente și, important, reține cheia exactă transmisă ('name'), nu tot union-ul;
  • T[K] este un tip de acces indexat: tipul proprietății K din T.

Varianta cu un singur parametru de tip pierde informația:

TypeScript
function pluckBad<T>(items: T[], key: keyof T): T[keyof T][] { ... }
pluckBad(products, 'name'); // (string | number | string[])[]

Parametrul key acceptă oricare cheie, dar tipul returnat nu mai știe care a fost aleasă, deci primești union-ul tuturor valorilor.

Același tipar stă la baza multor API-uri: getProperty(obj, key), sortBy(items, key), groupBy, form.setValue('email', ...) din librăriile de formulare sau addEventListener<K extends keyof WindowEventMap>(type: K, listener: (ev: WindowEventMap[K]) => any) din tipurile DOM. Recunoașterea lui în cod existent e la fel de importantă ca scrierea lui.

Ce urmărește intervievatorul: Se verifică înțelegerea combinației keyof și acces indexat în generice, unul dintre cele mai folosite tipare. Candidații slabi folosesc string pentru cheie.

Eroarea, în practică:TS2536: Type 'K' cannot be used to index type 'T'

41 Mid

Ce sunt parametrii generici const din TypeScript 5.0? Ce tip are r în fiecare caz?

TypeScript
function routes<T extends readonly string[]>(paths: T) { return paths; }
function routes2<const T extends readonly string[]>(paths: T) { return paths; }
const r = routes(['/', '/despre']);
const r2 = routes2(['/', '/despre']);

Răspuns scurt: r are tipul string[], pentru că literalele se lărgesc. r2 are tipul readonly ['/', '/despre']: modificatorul const face inferența să se comporte ca și cum apelantul ar fi scris as const.

Înainte de TypeScript 5.0, dacă voiai ca o funcție să păstreze literalele exacte primite, apelantul trebuia să scrie routes(['/', '/despre'] as const). Ușor de uitat, iar fără el tipurile literal se pierdeau.

Modificatorul const pe un parametru de tip mută responsabilitatea în declarația funcției:

TypeScript
function defineEvents<const T extends readonly string[]>(names: T) {
  return names;
}
const events = defineEvents(['login', 'logout']);
type EventName = typeof events[number]; // 'login' | 'logout'

function config<const T extends Record<string, unknown>>(c: T) { return c; }
const c = config({ mode: 'dark', size: 2 });
// { readonly mode: 'dark'; readonly size: 2 }

Detalii importante:

  • funcționează doar pe expresii literale scrise direct în apel. Dacă pasezi o variabilă declarată anterior, tipul ei e deja lărgit, iar const nu îl mai recuperează;
  • pentru tablouri, constrângerea trebuie să fie readonly string[]. Cu T extends string[], un tuplu readonly nu ar respecta constrângerea, iar TS revine la inferența obișnuită, string[];
  • modificatorul nu face nimic la rulare: valorile nu sunt înghețate.

Unde e util: funcții de tip „define” din librării (rute, evenimente, chei de traducere, schema unui formular), unde vrei ca restul aplicației să cunoască exact valorile declarate, cu autocompletare și erori la greșeli de scriere.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi funcționalități moderne și limita lor. Un răspuns bun menționează constrângerea readonly.

42 Mid

Scrie o clasă generică InMemoryRepository pentru entități care au un id. Ce restricții are un parametru de tip la nivel de clasă?

Răspuns scurt: class InMemoryRepository<T extends { id: string }> cu un Map<string, T> intern și metode save, findById, findAll. Parametrul de tip e disponibil pe membrii de instanță, dar nu și pe cei statici, pentru că există o singură clasă la rulare.

TypeScript
interface Entity { id: string }

class InMemoryRepository<T extends Entity> {
  private readonly items = new Map<string, T>();

  save(item: T): T {
    this.items.set(item.id, item);
    return item;
  }
  findById(id: T['id']): T | undefined {
    return this.items.get(id);
  }
  findAll(filter?: (item: T) => boolean): T[] {
    const all = [...this.items.values()];
    return filter ? all.filter(filter) : all;
  }
  delete(id: T['id']): boolean {
    return this.items.delete(id);
  }
}

interface Customer extends Entity { email: string }
const customers = new InMemoryRepository<Customer>();
customers.save({ id: 'c1', email: 'ana@exemplu.ro' });
customers.findAll(c => c.email.endsWith('.ro'));

De reținut:

  • constrângerea T extends Entity garantează că poți citi item.id în interior;
  • membrii statici nu pot folosi T: „Static members cannot reference class type parameters”. O singură funcție constructor există la rulare, partajată de toate „instanțele de tip”, deci un static cache: T[] nu ar avea sens;
  • tipul se poate deduce din constructor dacă acesta primește date: new Stack([1, 2]) devine Stack<number>. Fără argumente, specifici explicit;
  • T['id'] în loc de string permite entități cu identificatori branded (CustomerId) fără să schimbi clasa.

Un repository generic e o temă frecventă la interviuri de nivel mid: arată că știi să separi logica de stocare de tipul concret și să o testezi fără bază de date, injectând implementarea în memorie în locul celei reale.

Ce urmărește intervievatorul: Se verifică aplicarea genericelor într-o structură reală și cunoașterea limitei cu membrii statici. Candidații slabi scriu câte o clasă pentru fiecare entitate.

43 Mid

De ce dă eroare funcția de mai jos? Explică mesajul „'T' could be instantiated with a different subtype of constraint”.

TypeScript
function withDefault<T extends string>(value: T | undefined): T {
  return value ?? 'implicit';
}

Răspuns scurt: Pentru că T poate fi un subtip mai îngust al lui string, de exemplu 'ro' | 'en'. Valoarea 'implicit' e un string, dar nu e garantat un T. Tipul returnat corect este T | 'implicit', sau funcția nu trebuie să fie generică.

Mesajul complet este: „Type 'string' is not assignable to type 'T'. 'string' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint 'string'”. Tradus: constrângerea spune doar că T e *un fel de* string, nu că e string.

Gândește-te la un apel concret:

TypeScript
type Lang = 'ro' | 'en';
const lang = withDefault<Lang>(undefined);
// tipul promis: Lang, valoarea reală: 'implicit'

Dacă TS ar accepta funcția, ar promite 'ro' | 'en' și ar returna altceva. În interiorul unei funcții generice, compilatorul trebuie să verifice codul pentru *orice* T posibil, nu doar pentru cel mai larg.

Reparații, în funcție de intenție:

TypeScript
function withDefault<T extends string>(value: T | undefined): T | 'implicit' {
  return value ?? 'implicit';
}
function withDefault2<T extends string>(value: T | undefined, fallback: T): T {
  return value ?? fallback; // valoarea implicită vine tot din T
}
function withDefault3(value: string | undefined): string {
  return value ?? 'implicit'; // nu era nevoie de generic
}

Aceeași eroare apare când construiești un obiect nou și încerci să-l returnezi ca T: function create<T extends Base>(): T { return { id: 1 }; }. T ar putea avea câmpuri în plus pe care obiectul tău nu le are. În loc să adaugi as T, întreabă-te dacă tipul returnat descrie onest ce se întâmplă.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi cum „gândește” compilatorul despre parametrii generici. Răspunsul slab este „adaug as T”.

Eroarea, în practică:TS2322: not assignable to type 'T' (arbitrary type)

44 Mid

Ce face NoInfer<T> (TypeScript 5.4)? De ce acceptă prima variantă un argument greșit?

TypeScript
function createMachine<S extends string>(states: S[], initial: S) {}
createMachine(['idle', 'loading', 'done'], 'idel');

Răspuns scurt: Fără NoInfer, TS deduce S din ambii parametri, deci 'idel' intră și el în union, iar apelul compilează. Cu initial: NoInfer<S>, al doilea parametru nu mai participă la inferență, iar 'idel' e semnalat ca eroare.

Când un parametru de tip apare în mai multe locuri, TypeScript adună candidații din toate și calculează un tip comun. În exemplu, din states rezultă 'idle' | 'loading' | 'done', iar din initial rezultă 'idel'. Toți sunt literale string care respectă constrângerea, deci S devine union-ul celor patru. Greșeala de scriere trece.

Intenția era alta: states definește valorile permise, iar initial trebuie doar verificat față de ele. NoInfer<T> (tip utilitar intrinsec, introdus în TypeScript 5.4) spune exact asta: „nu deduce din acest loc”.

TypeScript
function createMachine<S extends string>(states: S[], initial: NoInfer<S>) {}
createMachine(['idle', 'loading', 'done'], 'idel');
// eroare: Argument of type '"idel"' is not assignable to parameter of type '"idle" | "loading" | "done"'

Înainte de 5.4, soluția era un al doilea parametru de tip:

TypeScript
function createMachine2<S extends string, I extends S>(states: S[], initial: I) {}

Funcționa, dar complica semnătura și mesajele de eroare.

Unde mai e util:

  • valori implicite care trebuie să aparțină unei liste (select(options, defaultValue));
  • callback-uri care nu ar trebui să lărgească tipul dedus din date;
  • funcții de tip assertEqual(actual, expected), unde expected nu trebuie să schimbe tipul dedus din actual.

NoInfer nu are niciun efect asupra tipului rezultat după inferență: NoInfer<S> e evaluat tot ca S. Schimbă doar sursa inferenței.

Ce urmărește intervievatorul: Se verifică înțelegerea mecanismului de inferență din mai multe surse. Puțini candidați cunosc NoInfer, dar mulți au întâlnit problema.

45 Senior

Proiectezi API-ul public al unei librării: o funcție format(value) care primește Date, number sau string și returnează mereu string, iar parse(text, kind) returnează tipuri diferite după kind. Când alegi union, overload-uri sau generice?

Răspuns scurt: Pentru format, un simplu union pe parametru: tipul returnat nu depinde de intrare. Pentru parse, unde returnul depinde de kind, alegi overload-uri pentru puține cazuri fixe sau un generic cu o hartă de tipuri pentru cazuri extensibile.

Regula de bază: folosește cel mai simplu instrument care exprimă relația dintre intrare și ieșire.

Union, când rezultatul nu depinde de tipul intrării:

TypeScript
export function format(value: Date | number | string): string { ... }

Overload-urile aici ar fi zgomot: trei semnături identice ca rezultat și erori mai greu de citit.

Overload-uri, când ai câteva combinații fixe și vrei mesaje clare în editor (fiecare semnătură apare separat la autocompletare):

TypeScript
export function parse(text: string, kind: 'date'): Date;
export function parse(text: string, kind: 'number'): number;

Dezavantaj: un apelant cu kind: 'date' | 'number' nu se potrivește niciunei semnături, deci adaugi și una pentru union. Implementarea nu e verificată pe fiecare caz.

Generic cu hartă de tipuri, când lista de cazuri e mare sau extensibilă:

TypeScript
interface ParseMap { date: Date; number: number; boolean: boolean }
export function parse<K extends keyof ParseMap>(text: string, kind: K): ParseMap[K] { ... }

Cu declare module, utilizatorii librăriei pot extinde ParseMap prin declaration merging. Implementarea are nevoie de obicei de o aserțiune internă, pentru că TS nu poate corela kind cu ParseMap[K] în corp.

Criterii pentru decizie, în ordine: claritatea mesajelor de eroare pentru utilizator, comportamentul cu argumente de tip union, extensibilitatea și costul de întreținere. Pentru o librărie publică, scrii și teste de tipuri (expectTypeOf din Vitest sau tsd), pentru că semnăturile sunt parte din API.

Ce urmărește intervievatorul: Se verifică judecata de design la nivel de API, nu doar sintaxa. Un candidat senior discută compromisurile și testarea tipurilor.

46 Senior

Tipizează o funcție debounce astfel încât funcția returnată să accepte exact aceiași parametri ca funcția originală.

Răspuns scurt: Folosești un parametru de tip pentru lista de argumente: function debounce<A extends unknown[]>(fn: (...args: A) => void, ms: number): (...args: A) => void. TS deduce A ca tuplu din semnătura lui fn și îl reutilizează pentru funcția returnată.

TypeScript
function debounce<A extends unknown[]>(
  fn: (...args: A) => void,
  ms: number,
): (...args: A) => void {
  let timer: ReturnType<typeof setTimeout> | undefined;
  return (...args: A) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), ms);
  };
}

const save = debounce((id: string, draft: { text: string }) => {
  console.log(id, draft.text);
}, 300);

save('p1', { text: 'salut' }); // ok
save('p1');                    // eroare: lipsește draft

Elemente de explicat:

  • A extends unknown[] este un parametru de tip pentru o listă de argumente. TypeScript deduce din fn un tuplu ([id: string, draft: { text: string }]), păstrând chiar și numele parametrilor pentru editor;
  • ...args: A reutilizează tuplul, deci funcția returnată are exact aceeași semnătură;
  • ReturnType<typeof setTimeout> evită diferența dintre Node (Timeout) și browser (number), fără any.

Varianta alternativă F extends (...args: any[]) => void cu (...args: Parameters<F>) => void funcționează, dar folosește any în constrângere și dă mesaje de eroare mai greu de citit. Varianta cu tuplu e de preferat.

Dacă funcția originală returnează o valoare, debounce-ul nu o poate returna sincron. O variantă corectă returnează Promise<R> sau nimic. Tot aici se pot discuta this (dacă funcția e o metodă, adaugi un parametru this) și anularea (cancel() pe funcția returnată), ca proprietate declarată în tipul de return.

Ce urmărește intervievatorul: Intervievatorul verifică stăpânirea tipurilor pentru funcții de ordin superior și a tuplurilor variadice. Candidații slabi returnează (...args: any[]) => void.

keyof, mapped, conditional și template literal types

47 Junior

Care e diferența dintre typeof folosit în cod și typeof folosit într-un tip? Ce produce fiecare linie?

TypeScript
const settings = { theme: 'dark', fontSize: 14 };
const t = typeof settings;
type T = typeof settings;

Răspuns scurt: typeof din cod e operatorul JavaScript și returnează la rulare stringul 'object'. typeof în poziție de tip e operator TypeScript și produce tipul dedus al variabilei: { theme: string; fontSize: number }.

Același cuvânt are două roluri, în funcție de context:

  • în expresii (spațiul valorilor), typeof x e operatorul JavaScript, evaluat la rulare. Returnează unul dintre stringurile 'string', 'number', 'object', 'function' etc. și e folosit pentru narrowing;
  • în poziție de tip (după :, în type X = ..., în argumente generice), typeof x e un operator TypeScript evaluat la compilare. Returnează tipul static al variabilei sau al proprietății.
TypeScript
const t = typeof settings;   // valoare: 'object', tip: union-ul de stringuri al lui typeof
type T = typeof settings;    // { theme: string; fontSize: number }
type Theme = typeof settings.theme; // string

function makeStore() { return { items: [] as string[], count: 0 }; }
type Store = ReturnType<typeof makeStore>;

De ce e util typeof de tip: îți permite să faci valoarea sursa de adevăr și să derivezi tipul din ea, în loc să le scrii pe amândouă și să riști să se desincronizeze. Cazuri tipice: configurații, obiecte de traduceri, valori implicite ale unui formular, rezultatul unei funcții factory.

Limitări:

  • funcționează doar pe identificatori și pe accesul la proprietăți, nu pe expresii arbitrare (typeof getX() nu e permis; folosești ReturnType<typeof getX>);
  • preia tipul așa cum a fost dedus, inclusiv lărgirea literalelor. Pentru valori exacte, declari obiectul cu as const.

Combinația keyof typeof obj apare des și e explicată la o întrebare separată.

Ce urmărește intervievatorul: Se verifică dacă știi să deosebești spațiul tipurilor de cel al valorilor. Candidații confundă des cele două sensuri ale lui typeof.

Eroarea, în practică:TS2693: only refers to a type, used as a valueTS2749: refers to a value, used as a type

48 Junior

Ai un obiect cu mesaje de traducere. Cum obții un tip care acceptă doar cheile existente, fără să le scrii de mână?

TypeScript
const messages = {
  welcome: 'Bun venit',
  logout: 'Ieșire',
  cartEmpty: 'Coșul este gol',
};

Răspuns scurt: Folosești keyof typeof messages, care produce 'welcome' | 'logout' | 'cartEmpty'. Funcția t(key: keyof typeof messages) acceptă apoi doar chei existente, iar orice cheie nouă din obiect apare automat în tip.

typeof messages dă tipul obiectului, iar keyof aplicat unui tip obiect dă union-ul literal al cheilor lui. Combinate, obții tipul cheilor direct din valoare:

TypeScript
type MessageKey = keyof typeof messages; // 'welcome' | 'logout' | 'cartEmpty'

function t(key: MessageKey): string {
  return messages[key];
}

t('welcome');  // ok, cu autocompletare în editor
t('welcom');   // eroare la compilare

Avantaje:

  • o singură sursă de adevăr: adaugi o cheie în obiect, iar tipul se actualizează automat;
  • greșelile de scriere sunt prinse la compilare, nu în producție, ca un text lipsă pe ecran;
  • redenumirea unei chei în editor arată imediat toate locurile afectate.

Pentru a verifica și că alte limbi au aceleași chei:

TypeScript
const en: Record<MessageKey, string> = {
  welcome: 'Welcome',
  logout: 'Log out',
  cartEmpty: 'Your cart is empty',
}; // o cheie lipsă sau în plus dă eroare

Câteva detalii despre keyof:

  • pe un tip cu index signature { [k: string]: T }, keyof dă string | number, pentru că cheile numerice sunt convertite la string în JavaScript;
  • pe o clasă, keyof include doar membrii publici;
  • pe un union (keyof (A | B)) dă doar cheile comune, iar pe o intersecție dă toate cheile.

Tiparul se folosește la fel pentru rute, permisiuni, nume de evenimente sau feature flags.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să derivezi tipuri din date, un tipar foarte comun. Răspunsul slab scrie manual union-ul și îl lasă să se desincronizeze.

49 Junior

Ce sunt tipurile de acces indexat? Cum extragi din tipul de mai jos tipul unui element din items și tipul câmpului address.city?

TypeScript
interface Order {
  id: string;
  items: { sku: string; qty: number }[];
  address: { city: string; zip: string };
}

Răspuns scurt: Un tip de acces indexat citește tipul unei proprietăți: Order['address']['city'] e string. Pentru elementul unui tablou folosești [number]: Order['items'][number] e { sku: string; qty: number }.

Sintaxa T['cheie'] funcționează în spațiul tipurilor ca accesul la proprietăți din cod, dar cu tipuri în loc de valori:

TypeScript
type OrderItem = Order['items'][number];   // { sku: string; qty: number }
type City = Order['address']['city'];       // string
type IdOrItems = Order['id' | 'items'];     // string | { sku: string; qty: number }[]

function addItem(order: Order, item: OrderItem) {
  order.items.push(item);
}

Elemente de reținut:

  • cheia trebuie să fie un tip, nu o variabilă: Order[key] nu funcționează dacă key e o valoare; scrii Order[typeof key];
  • [number] înseamnă „tipul obținut indexând cu orice număr”, adică tipul elementelor unui tablou. Pe un tuplu, dă union-ul tuturor pozițiilor, iar T[0] dă tipul primei poziții;
  • poți indexa cu un union de chei și primești union-ul valorilor;
  • T[keyof T] dă union-ul tuturor tipurilor de valori din T.

De ce e util: tipul Order vine adesea dintr-o sursă generată (OpenAPI, Prisma, GraphQL), unde tipurile imbricate nu au nume proprii. Indexarea îți permite să le refolosești fără să le duplici. Dacă schema se schimbă, toate tipurile derivate se actualizează automat.

Tiparul se combină cu as const:

TypeScript
const PLANS = [{ id: 'free', price: 0 }, { id: 'pro', price: 49 }] as const;
type PlanId = typeof PLANS[number]['id']; // 'free' | 'pro'

Ce urmărește intervievatorul: Se verifică dacă poți naviga tipuri complexe fără să le rescrii. Candidații slabi copiază definițiile imbricate în interfețe noi.

Eroarea, în practică:TS2713: is a type, but not a namespaceTS2702: type used as a namespace

50 Junior

Ce sunt template literal types? Ce tip rezultă mai jos și ce erori prinde?

TypeScript
type Size = 'sm' | 'md' | 'lg';
type Variant = 'primary' | 'ghost';
type ButtonClass = `btn-${Variant}-${Size}`;
type Handler<E extends string> = `on${Capitalize<E>}`;

Răspuns scurt: Template literal types construiesc tipuri string din alte tipuri, cu aceeași sintaxă ca template literals din JS. ButtonClass devine union-ul celor 6 combinații ('btn-primary-sm' etc.), iar Handler<'click'> devine 'onClick'.

Introduse în TypeScript 4.1, template literal types aplică sintaxa ` ...${}... ` în spațiul tipurilor. Când pui un union în interpolare, TS produce toate combinațiile (produs cartezian):

TypeScript
type ButtonClass = `btn-${Variant}-${Size}`;
// 'btn-primary-sm' | 'btn-primary-md' | 'btn-primary-lg'
// | 'btn-ghost-sm' | 'btn-ghost-md' | 'btn-ghost-lg'

const cls: ButtonClass = 'btn-primary-xl'; // eroare
type Click = Handler<'click'>;             // 'onClick'

TypeScript are patru tipuri intrinseci pentru manipularea literalelor: Uppercase, Lowercase, Capitalize și Uncapitalize.

Interpolarea acceptă și tipuri primitive, nu doar literale, ceea ce produce tipare:

TypeScript
type Px = `${number}px`;
const w: Px = '12px';   // ok
const h: Px = '12 px';  // eroare
type ApiPath = `/api/${string}`;
type DataAttr = `data-${string}`;

Unde se folosesc:

  • nume de evenimente derivate din chei ('change' devine 'onChange');
  • clase CSS sau design tokens cu variante (` space-${1 | 2 | 4} `);
  • chei de traducere cu namespace ('cart.empty');
  • rute și URL-uri cu prefix obligatoriu.

Atenție la explozia combinatorică: trei union-uri a câte 20 de membri produc 8000 de tipuri, iar TS are o limită de 100.000 de membri într-un union. Pentru cazuri mari, preferă tiparele cu ${string} sau validarea la rulare. Combinate cu infer, aceste tipuri pot și „parsa” stringuri, subiect pentru o întrebare de nivel avansat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi o unealtă modernă și unde e utilă practic. Candidații slabi nu știu de tipurile Capitalize sau de tiparele cu ${number}.

51 Junior

Ce tip produce keyof pentru un union și pentru o intersecție? Ce afișează editorul pentru K1 și K2?

TypeScript
type Cat = { name: string; meow(): void };
type Dog = { name: string; bark(): void };
type K1 = keyof (Cat | Dog);
type K2 = keyof (Cat & Dog);

Răspuns scurt: K1 este 'name': dintr-un union poți accesa sigur doar cheile comune tuturor membrilor. K2 este 'name' | 'meow' | 'bark': o intersecție are toate proprietățile ambelor tipuri.

Pare contraintuitiv că union-ul (|) dă mai puține chei, iar intersecția (&) mai multe. Explicația vine din ce reprezintă fiecare tip ca mulțime de valori:

  • Cat | Dog înseamnă „fie pisică, fie câine”. Când ai o astfel de valoare, singura proprietate garantat prezentă este cea comună, name. De aceea keyof (Cat | Dog) este 'name', iar animal.meow() nu compilează fără narrowing;
  • Cat & Dog înseamnă „o valoare care e simultan și pisică, și câine”, deci are toate proprietățile. Cheile se adună: 'name' | 'meow' | 'bark'.

Formal, keyof (A | B) este egal cu keyof A & keyof B, iar keyof (A & B) este keyof A | keyof B. Mulțimile de valori și mulțimile de chei se comportă invers.

Consecințe practice:

TypeScript
function getName(a: Cat | Dog) {
  return a.name;          // ok
}
function speak(a: Cat | Dog) {
  if ('meow' in a) a.meow();
  else a.bark();
}

Acest comportament explică și de ce utility types precum Omit sau Pick aplicate pe un union pot pierde proprietăți: ele folosesc intern keyof T, care pe union înseamnă doar cheile comune. Problema și soluția ei, DistributiveOmit, sunt discutate la utility types.

Reține regula și pentru mesaje de eroare: „Property 'meow' does not exist on type 'Cat | Dog'” nu înseamnă că lipsește din Cat, ci că nu e în toți membrii union-ului.

Ce urmărește intervievatorul: Se verifică înțelegerea tipurilor ca mulțimi. Mulți candidați inversează rezultatele, pentru că asociază | cu „mai mult”.

52 Mid

Scrie un mapped type Nullable<T>, care permite null pe fiecare proprietate, și un Mutable<T>, care elimină readonly. Cum sunt implementate Partial și Required în biblioteca standard?

Răspuns scurt: type Nullable<T> = { [K in keyof T]: T[K] | null } și type Mutable<T> = { -readonly [K in keyof T]: T[K] }. Partial adaugă ? cu [K in keyof T]?, iar Required îl elimină cu modificatorul -?.

Un mapped type parcurge un set de chei și construiește un tip obiect nou. Forma generală este { [K in Chei]: TipValoare }, unde Chei e de obicei keyof T.

TypeScript
type Nullable<T> = { [K in keyof T]: T[K] | null };
type Mutable<T>  = { -readonly [K in keyof T]: T[K] };

// definițiile din lib.es5.d.ts
type Partial<T>  = { [P in keyof T]?: T[P] };
type Required<T> = { [P in keyof T]-?: T[P] };
type Readonly<T> = { readonly [P in keyof T]: T[P] };

interface Draft { readonly id: string; title?: string }
type EditableDraft = Mutable<Required<Draft>>;
// { id: string; title: string }

Modificatorii:

  • readonly și ? adaugă proprietatea respectivă (forma lungă: +readonly, +?);
  • -readonly și -? le elimină. -? scoate și undefined adăugat implicit de ?.

Când mapped type-ul are forma [K in keyof T], se numește homomorphic și păstrează modificatorii originali: dacă title era opțional, Nullable<Draft> îl lasă opțional. Dacă T e un tablou sau un tuplu, rezultatul e tot tablou sau tuplu, nu un obiect cu chei '0', '1', 'length'.

Cheile pot veni și din alt union, nu doar din keyof:

TypeScript
type Flags = { [K in 'darkMode' | 'beta']: boolean };

Cazul acesta e echivalent cu Record<'darkMode' | 'beta', boolean>, care e definit exact așa în biblioteca standard.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi cum sunt construite utility types, nu doar cum le folosești. Puțini candidați cunosc modificatorul -?.

Eroarea, în practică:TS4104: readonly cannot be assigned to mutable type

53 Mid

Folosind key remapping (as în mapped types), scrie Getters<T>, care transformă { name: string; age: number } în { getName(): string; getAge(): number }. Cum elimini cheile care nu sunt funcții?

Răspuns scurt: type Getters<T> = { [K in keyof T as get${Capitalize<string & K>}]: () => T[K] }. Pentru filtrare, clauza as returnează never pentru cheile nedorite: [K in keyof T as T[K] extends Function ? K : never].

Din TypeScript 4.1, mapped types acceptă o clauză as care transformă fiecare cheie. Dacă transformarea produce never, cheia dispare din rezultat.

TypeScript
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

interface Person { name: string; age: number }
type PersonGetters = Getters<Person>;
// { getName: () => string; getAge: () => number }

type MethodsOnly<T> = {
  [K in keyof T as T[K] extends (...args: any[]) => any ? K : never]: T[K];
};

type WithoutPrivate<T> = {
  [K in keyof T as K extends `_${string}` ? never : K]: T[K];
};

Detalii de explicat:

  • string & K e necesar pentru că keyof T poate conține și number sau symbol, iar Capitalize acceptă doar stringuri. Intersecția păstrează doar cheile string;
  • condiția din as se evaluează pentru fiecare cheie în parte;
  • filtrarea după tipul valorii (T[K] extends ...) e baza unor utilitare ca PickByValue<T, V>.

Un exemplu practic: generarea tipurilor de evenimente dintr-un model.

TypeScript
type ChangeEvents<T> = {
  [K in keyof T as `${string & K}Changed`]: (value: T[K]) => void;
};
// pentru Person: { nameChanged: (v: string) => void; ageChanged: (v: number) => void }

Atenție: un mapped type cu as nu mai e homomorphic în toate situațiile; de exemplu, aplicat pe un tablou, nu mai produce un tablou. Pentru tipuri complicate, scrie teste de tipuri ca să verifici rezultatul.

Ce urmărește intervievatorul: Se verifică stăpânirea mapped types moderne, utile în librării și în cod de formulare sau evenimente. Candidații slabi uită de string & K.

54 Mid

Ce tipuri rezultă mai jos? Ce înseamnă că un conditional type este distributiv și cum oprești distribuirea?

TypeScript
type ToArray<T> = T extends unknown ? T[] : never;
type A = ToArray<string | number>;
type ToArray2<T> = [T] extends [unknown] ? T[] : never;
type B = ToArray2<string | number>;
type C = ToArray<never>;

Răspuns scurt: A este string[] | number[]: condiția se aplică separat fiecărui membru al union-ului. B este (string | number)[], pentru că [T] nu mai e un parametru „gol”. C este never, fiindcă distribuirea peste un union vid dă tot vid.

Un conditional type are forma T extends U ? X : Y: dacă T e atribuibil lui U, rezultatul e X, altfel Y. Când T este un parametru de tip „gol” (naked, nu înfășurat în altceva) și primește un union, condiția se evaluează pentru fiecare membru, iar rezultatele se reunesc. Asta e distribuirea.

TypeScript
ToArray<string | number>
// = ToArray<string> | ToArray<number>
// = string[] | number[]

Distribuirea e foarte utilă: Exclude și Extract sunt implementate pe ea:

TypeScript
type Exclude<T, U> = T extends U ? never : T;
type E = Exclude<'a' | 'b' | 'c', 'a'>; // 'b' | 'c'

Uneori vrei să tratezi union-ul ca întreg. Soluția standard e să înfășori ambele părți într-un tuplu, [T] extends [U], astfel încât T nu mai e gol.

Cazul never e o capcană frecventă. never e union-ul vid, deci distribuirea nu are pe ce rula și rezultatul e never, indiferent de ramuri:

TypeScript
type IsNever<T> = T extends never ? true : false;
type X = IsNever<never>; // never, nu true
type IsNever2<T> = [T] extends [never] ? true : false;
type Y = IsNever2<never>; // true

Regula de reținut: distribuirea are loc doar pe parametri de tip goi și doar în momentul instanțierii. Scrierea string | number extends unknown ? ... direct, fără parametru generic, nu distribuie.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi comportamentul care stă la baza multor utility types. Cazul never deosebește candidații care au scris efectiv astfel de tipuri.

55 Mid

Ce face cuvântul cheie infer? Scrie ElementType<T> pentru tablouri și UnwrapPromise<T>. De ce există totuși Awaited<T> în biblioteca standard?

Răspuns scurt: infer U declară, în interiorul unei condiții, o variabilă de tip pe care TS o deduce din potrivire. ElementType<T> = T extends readonly (infer U)[] ? U : never. Awaited desface recursiv promisiuni imbricate și obiecte thenable, nu doar un nivel de Promise.

infer funcționează ca un „pattern matching” pe tipuri: descrii forma așteptată și marchezi cu infer partea pe care vrei să o extragi. Poate fi folosit doar în clauza extends a unui conditional type.

TypeScript
type ElementType<T> = T extends readonly (infer U)[] ? U : never;
type E1 = ElementType<string[]>;            // string
type E2 = ElementType<readonly [1, 'a']>;   // 1 | 'a'

type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
type P1 = UnwrapPromise<Promise<number>>;   // number
type P2 = UnwrapPromise<Promise<Promise<number>>>; // Promise<number>

type FirstArg<F> = F extends (first: infer A, ...rest: any[]) => any ? A : never;

UnwrapPromise desface un singur nivel. Awaited<T> (TypeScript 4.5) modelează exact ce face await la rulare:

  • desface recursiv: Awaited<Promise<Promise<number>>> e number;
  • tratează orice obiect cu metoda then (thenable), nu doar Promise;
  • e folosit de tipurile lui Promise.all și ale funcțiilor async.
TypeScript
async function load() { return { id: 1 }; }
type Data = Awaited<ReturnType<typeof load>>; // { id: number }

Din TypeScript 4.7 poți constrânge variabila dedusă: T extends [infer H extends string, ...unknown[]] ? H : never extrage primul element doar dacă e string, fără un al doilea conditional.

Când există mai multe poziții infer cu același nume, TS calculează un tip comun: union pentru poziții covariante (valori returnate), intersecție pentru poziții contravariante (parametri). E un detaliu care explică rezultate surprinzătoare la tipuri complexe.

Ce urmărește intervievatorul: Se verifică dacă poți scrie tipuri care extrag informații din alte tipuri. Candidații buni știu de ce Awaited e mai mult decât un infer simplu.

Eroarea, în practică:TS1338: infer only in the extends clause

56 Mid

Un prop size trebuie să ofere autocompletare pentru 'sm' | 'md' | 'lg', dar să accepte și orice alt string. De ce 'sm' | 'md' | 'lg' | string nu funcționează și ce face trucul string & {}?

Răspuns scurt: Union-ul cu string se reduce imediat la string, pentru că literalele sunt subtipuri ale lui, deci editorul nu mai sugerează nimic. string & {} e tot orice string la verificare, dar TS nu îl mai combină cu literalele, așa că sugestiile rămân.

TypeScript simplifică union-urile prin subtype reduction: dacă un membru e subtip al altuia, e absorbit. 'sm' | string devine string, iar informația despre valorile recomandate se pierde. Editorul nu mai are ce sugera.

Trucul:

TypeScript
type Size = 'sm' | 'md' | 'lg' | (string & {});

function Button(props: { size?: Size }) {}
Button({ size: 'md' });     // autocompletare pentru sm, md, lg
Button({ size: '13px' });   // acceptat

string & {} înseamnă „un string care este și non-null”, ceea ce pentru orice string e adevărat. Practic, acceptă exact aceleași valori ca string. Diferența e că TS nu îl mai recunoaște ca fiind identic cu string atunci când reduce union-ul, deci literalele rămân vizibile ca membri separați.

Același tipar funcționează pentru alte primitive: 200 | 404 | (number & {}) pentru coduri de status.

Când îl folosești:

  • design systems și librării de componente, unde vrei să ghidezi utilizatorul fără să-l blochezi;
  • nume de evenimente sau chei de configurare extensibile.

Când nu îl folosești: dacă doar valorile din listă sunt corecte, nu le slăbi cu string, pentru că pierzi verificarea. Și nu folosi string & {} în tipuri pe care faci narrowing exhaustiv: verificarea cu never nu mai poate funcționa, pentru că union-ul conține o mulțime infinită de valori. Pentru compatibilitate cu viitorul, documentează că valoarea liberă e o „trapă” intenționată.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi cum se comportă union-urile în editor și în compilator. E un detaliu care apare des în codul librăriilor de UI.

57 Senior

Scrie un tip RouteParams<'/users/:id/posts/:postId'> care produce { id: string; postId: string }, astfel încât o funcție buildUrl să ceară exact parametrii din rută.

Răspuns scurt: Combini template literal types cu infer și recursivitate: potrivești ${string}:${infer P}/${infer Rest}, extragi numele parametrului, apoi continui pe restul rutei. Rezultatul se transformă într-un obiect cu un mapped type.

Ideea: extragi întâi un union cu numele parametrilor, apoi construiești obiectul din el.

TypeScript
type ParamNames<S extends string> =
  S extends `${string}:${infer P}/${infer Rest}`
    ? P | ParamNames<Rest>
    : S extends `${string}:${infer P}`
      ? P
      : never;

type RouteParams<S extends string> = { [K in ParamNames<S>]: string };

type T1 = RouteParams<'/users/:id/posts/:postId'>;
// { id: string; postId: string }
type T2 = RouteParams<'/despre'>; // {}

function buildUrl<const S extends string>(route: S, params: RouteParams<S>): string {
  return route.replace(/:(\w+)/g, (_, k: string) =>
    encodeURIComponent((params as Record<string, string>)[k]));
}

buildUrl('/users/:id/posts/:postId', { id: '7', postId: '42' }); // ok
buildUrl('/users/:id', {});  // eroare: lipsește id

Cum se potrivește primul caz pe '/users/:id/posts/:postId':

  • ${string} consumă '/users/' până la primul :;
  • infer P se oprește la primul /, deci P = 'id';
  • Rest = 'posts/:postId', iar recursivitatea găsește 'postId' prin al doilea caz.

Observații pentru interviu:

  • const S sau un literal scris direct în apel e necesar; dacă ruta e o variabilă de tip string, tipul devine { [x: string]: string } și verificarea dispare;
  • în implementare e nevoie de o aserțiune, pentru că TS nu poate lega regex-ul de tipul calculat; o izolezi într-un singur loc;
  • tipare asemănătoare există în routere reale (de exemplu în tipurile pentru Express 5 sau în librării de rutare tipizată).

Discută și costul: tipurile recursive mari încetinesc editorul și produc mesaje de eroare greu de citit. Sunt justificate în cod de infrastructură folosit în multe locuri, nu în logica de business.

Ce urmărește intervievatorul: Se verifică stăpânirea completă a tipurilor la nivel de compilare: template literals, infer, recursivitate și mapped types. Contează și discuția despre cost.

58 Senior

Scrie DeepReadonly<T> și explică ce cazuri trebuie tratate separat ca rezultatul să fie corect pentru funcții, tablouri, Map și Date.

Răspuns scurt: Un mapped type recursiv care aplică readonly pe fiecare nivel, dar lasă neatinse funcțiile și primitivele. Tablourile și tuplurile sunt tratate automat de mapped types homomorfice, iar Map, Set și Date au nevoie de ramuri speciale.

Versiunea naivă:

TypeScript
type DeepReadonlyNaive<T> = { readonly [K in keyof T]: DeepReadonlyNaive<T[K]> };

Probleme: aplicată pe o funcție, o transformă într-un obiect fără semnătură de apel; pe Date sau Map, mapează metodele și strică tipul, iar Map rămâne oricum modificabil prin set.

O variantă mai corectă:

TypeScript
type Primitive = string | number | boolean | bigint | symbol | null | undefined;

type DeepReadonly<T> =
  T extends Primitive | ((...args: any[]) => unknown) | Date ? T :
  T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> :
  T extends Set<infer U> ? ReadonlySet<DeepReadonly<U>> :
  { readonly [P in keyof T]: DeepReadonly<T[P]> };

interface State {
  user: { name: string; tags: string[] };
  cache: Map<string, number>;
  onSave: () => void;
}
type RO = DeepReadonly<State>;
// RO['user']['tags'] este readonly string[]
// RO['cache'] este ReadonlyMap<string, number>

De ce funcționează tablourile: când un mapped type homomorfic ([P in keyof T]) primește ca T un tablou sau un tuplu, TS produce tot un tablou, iar modificatorul readonly îl face readonly string[].

Date rămâne mutabil (are setFullYear); îl lași ca atare sau îl înlocuiești cu un tip imutabil, în funcție de proiect.

Limite: tipurile recursive se evaluează leneș, dar pe structuri foarte mari sau cu referințe ciclice pot încetini editorul. Iar DeepReadonly nu oferă nicio protecție la rulare. Pentru stare cu adevărat imutabilă, combini cu Object.freeze recursiv în development sau cu o librărie ca Immer, care are propriile tipuri pentru asta.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți scrie tipuri recursive robuste și dacă te gândești la cazurile limită. Răspunsul naiv strică funcțiile din obiect.

59 Senior

Editorul devine lent, iar compilatorul afișează „Type instantiation is excessively deep and possibly infinite”. Cum investighezi și ce schimbi în tipuri?

Răspuns scurt: Măsori întâi cu tsc --extendedDiagnostics și --generateTrace, ca să găsești fișierele și tipurile costisitoare. Apoi simplifici: limitezi recursivitatea, înlocuiești intersecțiile mari cu interfețe, adaugi tipuri de return explicite și rupi union-urile uriașe.

Eroarea apare când TS depășește limita internă de instanțieri imbricate, de obicei din cauza unui tip recursiv fără caz de oprire clar sau a unei combinații de generice care se expandează exponențial.

Pași de investigare:

  • tsc --noEmit --extendedDiagnostics arată timpul de verificare, numărul de tipuri și instanțieri. Te ajută să compari înainte și după o schimbare;
  • tsc --generateTrace ./trace produce un trace pe care îl deschizi în chrome://tracing sau îl analizezi cu @typescript/analyze-trace, care indică fișierele și pozițiile cele mai costisitoare;
  • în editor, „TypeScript: Open TS Server log” arată ce cereri sunt lente.

Cauze și remedii tipice:

  • tipuri recursive adânci (căi de chei imbricate, parsere de stringuri): adaugi un contor de adâncime și te oprești, de exemplu la 5 niveluri;
  • intersecții mari (A & B & C & ...): le înlocuiești cu interface X extends A, B, C. Relațiile dintre interfețe sunt memorate în cache, iar intersecțiile sunt recalculate;
  • union-uri foarte mari generate din template literals: le reduci sau treci la tipare cu ${string};
  • inferența tipurilor de return pe funcții complexe exportate: adaugi tipuri explicite, ca TS să nu le recalculeze în fiecare fișier care le importă;
  • librării cu tipuri grele: actualizezi versiunea sau izolezi utilizarea lor.

Pe termen lung, ajută project references și urmărirea timpului de type-check în CI. Portul nativ al compilatorului, scris în Go (TypeScript 7), aduce accelerări mari, dar nu repară tipurile proiectate prost.

Un principiu bun: tipurile foarte „inteligente” sunt justificate doar dacă economisesc mai mult timp decât costă în compilare și înțelegere.

Ce urmărește intervievatorul: Se verifică experiența cu proiecte mari și abordarea bazată pe măsurare. Candidații slabi adaugă any până dispare eroarea.

Eroarea, în practică:TS2589: Type instantiation is excessively deep

Utility types și modelarea datelor

Exersează capitolul cu exerciții reale: Curs TypeScript pentru începători →
60 Junior

Ce fac utility types Required, Readonly și NonNullable? Ce tip are R mai jos?

TypeScript
interface Settings { theme?: 'light' | 'dark'; lang?: string | null }
type R = Required<Settings>;
type L = NonNullable<Settings['lang']>;

Răspuns scurt: Required<T> face toate proprietățile obligatorii: R este { theme: 'light' | 'dark'; lang: string | null }. Readonly<T> le face readonly, superficial. NonNullable<T> scoate null și undefined, deci L este string.

Sunt utilitare mici, dar apar des:

  • Required<T> elimină ? de pe fiecare proprietate. Atenție: scoate doar „opționalitatea”, nu și null declarat explicit. În exemplu, lang devine obligatoriu, dar rămâne string | null;
  • Readonly<T> marchează proprietățile readonly, doar la primul nivel. Obiectele imbricate rămân modificabile;
  • NonNullable<T> este definit ca T & {} din TypeScript 4.8 și elimină null și undefined dintr-un union.

Un caz practic: setări cu valori implicite.

TypeScript
const DEFAULTS: Required<Settings> = { theme: 'light', lang: 'ro' };

function resolve(user: Settings): Required<Settings> {
  return {
    theme: user.theme ?? DEFAULTS.theme,
    lang: user.lang ?? DEFAULTS.lang,
  };
}

Tipul Required<Settings> pentru DEFAULTS garantează că nicio setare nouă nu rămâne fără valoare implicită: dacă adaugi fontSize? în interfață, compilatorul cere imediat o valoare în DEFAULTS.

De ce ?? și nu spread: { ...DEFAULTS, ...user } ar suprascrie valorile implicite cu undefined explicit, dacă utilizatorul a trimis { theme: undefined }.

NonNullable e util după filtrare sau în tipuri derivate:

TypeScript
type Lang = NonNullable<Settings['lang']>; // string

Ca idee generală: utility types transformă tipuri existente, astfel încât variantele (intrare de la utilizator, configurație rezolvată, versiune readonly pentru UI) rămân sincronizate cu sursa.

Ce urmărește intervievatorul: Se verifică dacă știi exact ce face fiecare utilitar, inclusiv limitele. Greșeala tipică: cred că Required elimină și null.

61 Junior

Care e diferența dintre Exclude, Extract și Omit? Cum extragi dintr-un union de evenimente doar evenimentele de tip 'click'?

Răspuns scurt: Exclude și Extract lucrează pe membrii unui union (îi scot, respectiv îi păstrează pe cei atribuibili). Omit lucrează pe cheile unui tip obiect. Pentru evenimente: Extract<AppEvent, { type: 'click' }>.

Confuzia e frecventă pentru că toate trei „scot ceva”, dar la niveluri diferite:

TypeScript
type Status = 'draft' | 'published' | 'archived';
type Visible = Exclude<Status, 'archived'>;      // 'draft' | 'published'
type OnlyDraft = Extract<Status, 'draft' | 'x'>; // 'draft'

interface User { id: string; email: string; password: string }
type PublicUser = Omit<User, 'password'>;          // { id; email }
  • Exclude<T, U>: din union-ul T, elimină membrii atribuibili lui U;
  • Extract<T, U>: din union-ul T, păstrează doar membrii atribuibili lui U;
  • Omit<T, K>: dintr-un tip obiect, elimină proprietățile cu cheile K.

Extract e foarte util pe union-uri discriminate, pentru că U poate fi o formă parțială:

TypeScript
type AppEvent =
  | { type: 'click'; x: number; y: number }
  | { type: 'key'; key: string }
  | { type: 'scroll'; offset: number };

type ClickEvent = Extract<AppEvent, { type: 'click' }>;
// { type: 'click'; x: number; y: number }

function on<T extends AppEvent['type']>(
  type: T,
  cb: (e: Extract<AppEvent, { type: T }>) => void,
) {}
on('key', e => console.log(e.key)); // e este evenimentul key

O capcană la Omit: cheile nu sunt constrânse la keyof T (semnătura e Omit<T, K extends keyof any>), deci Omit<User, 'pasword'> compilează fără să scoată nimic. Pick în schimb verifică cheile. Dacă vrei siguranță, definește un StrictOmit<T, K extends keyof T> = Omit<T, K>.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi la ce nivel lucrează fiecare utilitar. Detaliul despre cheile neverificate din Omit deosebește candidații atenți.

62 Junior

Ce fac Parameters, ConstructorParameters, InstanceType și Awaited? Dă un exemplu în care le folosești ca să nu duplici tipuri dintr-o librărie.

Răspuns scurt: Parameters<F> dă tuplul parametrilor unei funcții, ConstructorParameters<C> pe cei ai constructorului, InstanceType<C> tipul instanței, iar Awaited<T> tipul rezultat după await. Le folosești când librăria nu exportă tipurile de care ai nevoie.

Toate patru extrag informații din tipuri existente, folosind intern infer:

TypeScript
function createClient(url: string, opts: { retries: number; timeoutMs?: number }) {
  return { get: async (path: string) => ({ status: 200, body: '' }) };
}

type ClientOptions = Parameters<typeof createClient>[1];
// { retries: number; timeoutMs?: number }
type Client = ReturnType<typeof createClient>;
type GetResult = Awaited<ReturnType<Client['get']>>;
// { status: number; body: string }

class Logger { constructor(public prefix: string, public level: 'info' | 'debug') {} }
type LoggerArgs = ConstructorParameters<typeof Logger>; // [prefix: string, level: 'info' | 'debug']
type LoggerInstance = InstanceType<typeof Logger>;      // Logger

Scenariul tipic: o librărie exportă funcția, dar nu și tipul opțiunilor. În loc să copiezi definiția (care se va desincroniza la următoarea versiune), o derivezi din funcție. La fel pentru wrapper-e:

TypeScript
function withLogging<F extends (...args: any[]) => any>(fn: F) {
  return (...args: Parameters<F>): ReturnType<F> => {
    console.log('apel', args);
    return fn(...args);
  };
}

Detalii:

  • toate primesc tipuri, deci pentru o valoare scrii typeof: Parameters<typeof fn>, nu Parameters<fn>;
  • InstanceType<typeof Logger> e de obicei identic cu Logger, dar devine util când lucrezi cu constructori primiți ca parametri (ctor: new (...a: any[]) => T);
  • pentru o funcție cu overload-uri, Parameters și ReturnType iau în considerare doar ultima semnătură, care e de obicei cea mai generală. E o sursă de surprize.

Ce urmărește intervievatorul: Se verifică dacă știi să derivezi tipuri în loc să le copiezi. Detaliul despre overload-uri arată experiență reală.

63 Junior

Când alegi Record<'ro' | 'en', T>, un index signature { [k: string]: T } sau un Map<string, T>?

Răspuns scurt: Record cu un union de chei, când cheile sunt cunoscute și vrei să fie toate prezente. Index signature sau Record<string, T> pentru obiecte-dicționar serializabile cu chei arbitrare. Map pentru chei dinamice, adăugări și ștergeri frecvente sau chei care nu sunt stringuri.

Record<K, V> cu chei finite verifică exhaustivitatea:

TypeScript
type Locale = 'ro' | 'en';
const labels: Record<Locale, string> = { ro: 'Coș', en: 'Cart' };
// dacă adaugi 'de' în Locale, compilatorul cere și eticheta în germană

E alegerea potrivită pentru tabele de corespondență între un union și valori (stări și culori, roluri și permisiuni), adesea mai bună decât un switch.

Index signature sau Record<string, V> descrie un obiect cu chei arbitrare. E util pentru JSON (răspunsuri API, configurații), pentru că se serializează direct. Dezavantaje: accesul la o cheie inexistentă are tipul V (fără noUncheckedIndexedAccess), iar cheile se pot ciocni cu proprietăți moștenite, ca constructor sau __proto__, dacă vin de la utilizator.

Map<K, V> e o structură de date reală:

  • get returnează V | undefined, deci TS te obligă să tratezi lipsa;
  • cheile pot fi de orice tip (obiecte, numere) fără conversie la string;
  • size, iterare în ordinea inserării, ștergere eficientă;
  • nu se serializează direct cu JSON.stringify; ai nevoie de Object.fromEntries(map) sau [...map].
TypeScript
const sessions = new Map<string, Session>();
const s = sessions.get(token); // Session | undefined

Regula practică: chei cunoscute la compilare înseamnă Record cu union; date care vin sau pleacă prin JSON înseamnă obiect cu index signature; colecții manipulate intens la rulare (cache, grupări, contoare) înseamnă Map.

Ce urmărește intervievatorul: Intervievatorul verifică dacă alegi structura după caz, nu din obișnuință. Mulți candidați nu știu că Record cu union verifică toate cheile.

Eroarea, în practică:TS7052: Map has no index signature, call getTS1337: index signature cannot use a literal type

64 Junior

Ai tipul User cu id, email, name, createdAt. Tipizează corpul unui request PATCH /users/:id, care poate modifica email și name, dar nu id sau createdAt, și cere cel puțin un câmp.

Răspuns scurt: Pornești de la Partial<Pick<User, 'email' | 'name'>>, care permite doar câmpurile editabile, opționale. Pentru „cel puțin un câmp”, construiești un union în care fiecare variantă face obligatoriu un câmp diferit sau validezi această regulă la rulare.

Pasul de bază: alegi explicit câmpurile editabile, nu le excluzi pe cele interzise.

TypeScript
interface User { id: string; email: string; name: string; createdAt: Date }

type EditableUser = Pick<User, 'email' | 'name'>;
type UserPatch = Partial<EditableUser>;
// { email?: string; name?: string }

De ce Pick și nu Omit<User, 'id' | 'createdAt'>: dacă mâine adaugi passwordHash sau role în User, Omit le-ar face automat editabile prin PATCH. Pick e o listă albă (allowlist), mai sigură pentru date care vin de la client.

„Cel puțin un câmp” se poate exprima la nivel de tip:

TypeScript
type AtLeastOne<T> = { [K in keyof T]: Pick<T, K> & Partial<T> }[keyof T];
type UserPatchStrict = AtLeastOne<EditableUser>;

const ok: UserPatchStrict = { name: 'Ana' };
const bad: UserPatchStrict = {};  // eroare

Mapped type-ul creează câte o variantă pentru fiecare cheie (în care acea cheie e obligatorie), iar [keyof T] le reunește într-un union.

Două observații pentru interviu:

  • tipul protejează doar codul tău care construiește patch-uri. Corpul unui request real e unknown până îl validezi, deci aceleași reguli trebuie exprimate într-o schemă (Zod, Valibot) din care derivezi tipul;
  • cu exactOptionalPropertyTypes, diferențiezi „câmp lipsă” de „câmp setat la undefined”, important când null înseamnă „șterge valoarea”. Decizia trebuie documentată în contractul API-ului.

Ce urmărește intervievatorul: Se verifică aplicarea utility types la o problemă reală și gândirea de securitate (allowlist). Răspunsul slab folosește Partial<User> și permite modificarea lui id.

65 Mid

Implementează de mână MyPick, MyRecord și MyReturnType, fără să folosești utility types din biblioteca standard.

Răspuns scurt: MyPick<T, K extends keyof T> = { [P in K]: T[P] }, MyRecord<K extends keyof any, V> = { [P in K]: V }, MyReturnType<F extends (...args: any) => any> = F extends (...args: any) => infer R ? R : never.

Aceste implementări arată că utility types sunt doar mapped și conditional types cu nume:

TypeScript
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };

type MyRecord<K extends keyof any, V> = { [P in K]: V };

type MyReturnType<F extends (...args: any) => any> =
  F extends (...args: any) => infer R ? R : never;

type MyParameters<F extends (...args: any) => any> =
  F extends (...args: infer P) => any ? P : never;

type MyOmit<T, K extends keyof any> = MyPick<T, Exclude<keyof T, K>>;

Puncte de explicat:

  • la MyPick, constrângerea K extends keyof T împiedică selectarea unor chei inexistente, iar [P in K] iterează doar peste cheile alese. Pentru că nu e de forma [P in keyof T], nu e homomorfic în sens strict, dar TS păstrează totuși modificatorii ? și readonly când K e constrâns la keyof T;
  • keyof any este string | number | symbol, adică orice tip valid de cheie. Biblioteca standard folosește același truc, iar TypeScript are și alias-ul PropertyKey;
  • la MyReturnType, constrângerea pe F produce o eroare clară dacă cineva pasează un tip care nu e funcție; infer R extrage tipul returnat;
  • MyOmit se construiește din Pick și Exclude, exact ca în lib.es5.d.ts.

Testează implementările cu un tip de egalitate:

TypeScript
type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
type Test = Equal<MyReturnType<() => string>, string>; // true

Exercițiul verifică dintr-o dată keyof, mapped types, constrângeri și infer.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi utility types la nivel de implementare. Candidații slabi le pot doar enumera.

66 Mid

De ce Omit aplicat pe un union discriminat strică tipul? Cum scrii un DistributiveOmit?

TypeScript
type Shape =
  | { kind: 'circle'; radius: number; id: string }
  | { kind: 'rect'; width: number; height: number; id: string };
type NewShape = Omit<Shape, 'id'>;

Răspuns scurt: Omit folosește intern keyof Shape, care pe un union dă doar cheile comune, deci rezultatul e { kind: 'circle' | 'rect' }, iar radius și width dispar. DistributiveOmit<T, K> = T extends unknown ? Omit<T, K> : never aplică Omit pe fiecare membru.

Omit<T, K> e definit ca Pick<T, Exclude<keyof T, K>>. Pe un union, keyof T returnează doar cheile prezente în toți membrii, deci:

TypeScript
keyof Shape;               // 'kind' | 'id'
Omit<Shape, 'id'>;         // { kind: 'circle' | 'rect' }

Ai pierdut atât proprietățile specifice, cât și legătura dintre kind și ele. Un formular de creare care folosește NewShape nu mai poate trimite radius.

Soluția este să forțezi distribuirea printr-un conditional type cu parametru gol:

TypeScript
type DistributiveOmit<T, K extends PropertyKey> =
  T extends unknown ? Omit<T, K> : never;

type NewShape = DistributiveOmit<Shape, 'id'>;
// | { kind: 'circle'; radius: number }
// | { kind: 'rect'; width: number; height: number }

function create(s: NewShape) {
  if (s.kind === 'circle') s.radius; // narrowing funcționează din nou
}

T extends unknown e mereu adevărat, dar pentru că T e un parametru gol, condiția se evaluează separat pentru fiecare membru al union-ului, iar Omit se aplică individual.

Aceeași problemă o au Pick, Partial combinat cu Omit și orice tip care folosește keyof T pe un union. Partial<Shape> în sine e în regulă, pentru că mapped types homomorfice distribuie automat peste union-uri.

În React, problema apare des la componente wrapper: Omit<ButtonProps, 'onClick'> când ButtonProps e un union (de exemplu link sau buton). Un DistributiveOmit păstrează variantele separate.

Ce urmărește intervievatorul: Se verifică o capcană reală din cod de producție și legătura cu distribuirea. Candidații care au lucrat cu union-uri discriminate au întâlnit-o aproape sigur.

67 Mid

Funcția refund(orderId: string, userId: string) a fost apelată cu argumentele inversate și a trecut de compilare. Cum folosești branded types ca să previi asta?

Răspuns scurt: Creezi tipuri distincte pentru același primitiv: type OrderId = string & { readonly __brand: 'OrderId' }. Valorile se obțin doar prin funcții care validează, iar un UserId nu mai poate fi pasat unde se cere OrderId, deși la rulare ambele sunt stringuri.

Din cauza tipizării structurale, toate stringurile sunt interschimbabile. Un branded type (sau „nominal type”) adaugă o etichetă care există doar în spațiul tipurilor:

TypeScript
declare const brand: unique symbol;
type Brand<T, B extends string> = T & { readonly [brand]: B };

type OrderId = Brand<string, 'OrderId'>;
type UserId = Brand<string, 'UserId'>;

function toOrderId(raw: string): OrderId {
  if (!/^ord_[a-z0-9]+$/.test(raw)) throw new Error('OrderId invalid');
  return raw as OrderId; // singurul loc cu aserțiune
}

function refund(orderId: OrderId, userId: UserId) {}

const o = toOrderId('ord_123');
const u = 'usr_9' as UserId;
refund(u, o);   // eroare la compilare
refund(o, u);   // ok
o.toUpperCase(); // rămâne string pentru toate operațiile

Cum funcționează: OrderId e un string care are, teoretic, și o proprietate specială. Niciun string obișnuit nu o are, deci nu poate fi atribuit fără aserțiune. Proprietatea nu există la rulare, așa că costul e zero. Folosirea unui unique symbol în loc de __brand evită coliziunile și ascunde eticheta din autocompletare.

Unde se folosesc:

  • identificatori de entități diferite;
  • valori validate: Email, NonEmptyString, PositiveInt, unde existența tipului dovedește că validarea a avut loc;
  • unități de măsură: Cents vs Lei, Milliseconds vs Seconds.

Regula de disciplină: aserțiunea as OrderId apare doar în funcțiile constructoare. Librării de validare ca Zod au suport direct (.brand<'OrderId'>()).

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi să compensezi limitele tipizării structurale. Răspunsul bun include și funcția care validează.

68 Senior

O componentă acceptă fie href (și devine link), fie onClick (și devine buton), dar niciodată pe amândouă. De ce { href: string } | { onClick: () => void } nu e suficient și cum scrii un tip XOR?

Răspuns scurt: Union-ul acceptă și obiectul care le are pe amândouă, pentru că acesta respectă structural ambii membri. Un XOR adaugă în fiecare variantă proprietățile celeilalte ca ?: never, ceea ce interzice prezența lor simultană.

Tipizarea structurală face union-urile „deschise”: { href: '/x', onClick } e un { href: string } valid (proprietatea în plus nu contează când obiectul nu e literal proaspăt), iar excess property checking pe union-uri e permisiv, deci multe combinații greșite trec. Componenta nu știe atunci ce să randeze.

Soluția explicită:

TypeScript
type LinkProps = { href: string; onClick?: never };
type ActionProps = { onClick: () => void; href?: never };
type Props = { label: string } & (LinkProps | ActionProps);

const a: Props = { label: 'Acasă', href: '/' };
const b: Props = { label: 'Salvează', onClick: save };
const c: Props = { label: 'X', href: '/', onClick: save }; // eroare

onClick?: never înseamnă „poate lipsi, dar dacă există, trebuie să fie de tip never”, ceea ce nicio valoare nu poate fi (în afară de undefined).

Varianta generică:

TypeScript
type Without<T, U> = { [K in Exclude<keyof T, keyof U>]?: never };
type XOR<T, U> = (T & Without<U, T>) | (U & Without<T, U>);
type Props2 = { label: string } & XOR<{ href: string }, { onClick: () => void }>;

Narrowing-ul funcționează apoi natural: if (props.href !== undefined) lasă varianta link.

Alternativa, adesea mai clară, este un discriminant explicit (as: 'link' | 'button'). XOR-ul are avantajul că API-ul componentei rămâne natural pentru utilizatori. Pentru mai mult de două variante, tipul devine greu de citit, iar un discriminant e de preferat.

Tiparul se aplică și pe backend: căutare după email sau după phone, nu după amândouă.

Ce urmărește intervievatorul: Se verifică înțelegerea profundă a union-urilor deschise și capacitatea de a modela constrângeri reale. E un tipar frecvent în librăriile de componente.

69 Senior

Echipa discută dacă funcțiile din stratul de servicii ar trebui să returneze un tip Result<T, E> în loc să arunce excepții. Cum îl tipizezi și ce argumente pro și contra aduci?

Răspuns scurt: type Result<T, E> = { ok: true; value: T } | { ok: false; error: E } face erorile vizibile în semnătura funcției și obligă apelantul să le trateze. Contra: cod mai verbos, propagare manuală și coexistență cu excepțiile din librării.

Problema excepțiilor în TypeScript: tipul unei funcții nu spune ce poate arunca, iar în catch primești unknown. Apelantul nu e obligat să trateze nimic, iar erorile de business (stoc insuficient, card refuzat) se amestecă cu bug-urile.

TypeScript
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };

const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });

type OrderError =
  | { code: 'OUT_OF_STOCK'; sku: string }
  | { code: 'PAYMENT_DECLINED' };

async function placeOrder(cart: Cart): Promise<Result<Order, OrderError>> {
  if (!inStock(cart)) return err({ code: 'OUT_OF_STOCK', sku: cart.items[0].sku });
  return ok(await save(cart));
}

const r = await placeOrder(cart);
if (!r.ok) {
  switch (r.error.code) {
    case 'OUT_OF_STOCK': return showStock(r.error.sku);
    case 'PAYMENT_DECLINED': return askNewCard();
  }
}

Argumente pro:

  • erorile așteptate devin parte din contract și sunt tratate exhaustiv;
  • refactorizările care adaugă un tip nou de eroare produc erori de compilare la apelanți.

Argumente contra:

  • propagarea e manuală (if (!r.ok) return r la fiecare nivel), fără o sintaxă dedicată;
  • librăriile, fetch și baza de date aruncă oricum excepții, deci ai două mecanisme;
  • echipa trebuie să aplice consecvent regula, altfel ai combinații confuze.

O poziție echilibrată: Result pentru erori de domeniu așteptate, excepții pentru bug-uri și erori de infrastructură, tratate central (middleware, error boundary). Librării precum neverthrow sau Effect oferă abstracții mai complete, dar și o curbă de învățare.

Ce urmărește intervievatorul: Intervievatorul caută o discuție de design cu compromisuri, nu o preferință dogmatică. Un candidat senior propune o regulă clară pentru echipă.

Clase, enum și erori

70 Junior

Care e diferența dintre private din TypeScript și câmpurile #private din JavaScript? Ce se întâmplă la rulare în codul de mai jos?

TypeScript
class Account {
  private pin = '1234';
  #balance = 100;
}
const acc = new Account();
console.log((acc as any).pin, Object.keys(acc));

Răspuns scurt: private e verificat doar la compilare și dispare din JavaScript, deci (acc as any).pin afișează '1234', iar Object.keys include 'pin'. #balance e privat la rulare: nu apare în chei și nu poate fi citit din afara clasei.

private (TypeScript) e un modificator de acces la nivel de tipuri. Compilatorul interzice acc.pin din afara clasei, dar în JavaScript-ul generat pin e o proprietate obișnuită. Poate fi citită cu as any, din JavaScript, în debugger, cu JSON.stringify sau chiar cu acc['pin'], pe care TS îl permite intenționat ca „trapă de ieșire”.

#balance (JavaScript, ES2022) e un câmp privat real, impus de motorul JavaScript:

  • nu apare în Object.keys, JSON.stringify sau în spread;
  • accesul din afara clasei e eroare de sintaxă, nu doar de tip;
  • poți verifica existența lui cu #balance in obj în interiorul clasei, util pentru type guards sigure;
  • subclasele nu îl pot accesa.

Rezultatul afișării: '1234' și ['pin'].

Când alegi fiecare:

  • #private pentru încapsulare reală: librării publice, date sensibile, invarianți care nu trebuie ocoliți;
  • private când vrei acces din teste sau compatibilitate cu framework-uri care inspectează proprietățile (unele ORM-uri sau sisteme de serializare);
  • protected există doar în varianta TypeScript, pentru acces din subclase.

Notă de compilare: pentru un target mai vechi de ES2022, TypeScript emulează câmpurile # cu WeakMap, ceea ce costă puțin la performanță și face codul generat mai greu de citit. Pentru targeturi moderne, rămân native.

Niciuna dintre variante nu e un mecanism de securitate: un pin nu se ține în codul de client, oricât de privat ar fi câmpul.

Ce urmărește intervievatorul: Se verifică diferența dintre verificările de compilare și garanțiile de rulare, aplicată la clase. Mulți candidați cred că private ascunde proprietatea.

Eroarea, în practică:TS2341: Property is privateTS18013: #private not accessible outside class

71 Junior

Ce sunt parameter properties și de ce unele echipe au început să le evite odată cu opțiunea erasableSyntaxOnly din TypeScript 5.8?

TypeScript
class OrderService {
  constructor(private readonly repo: OrderRepo, private logger: Logger) {}
}

Răspuns scurt: Parameter properties declară și inițializează câmpuri direct din parametrii constructorului. Generează cod JavaScript (this.repo = repo), deci nu sunt simplă sintaxă de tip. Medii care doar șterg tipurile, ca Node.js cu type stripping, nu le suportă, iar erasableSyntaxOnly le interzice.

Forma scurtă din exemplu e echivalentă cu:

TypeScript
class OrderService {
  private readonly repo: OrderRepo;
  private logger: Logger;
  constructor(repo: OrderRepo, logger: Logger) {
    this.repo = repo;
    this.logger = logger;
  }
}

Un modificator (private, public, protected, readonly) pus pe un parametru al constructorului îl transformă în proprietate. E popular în codul cu dependency injection (Angular, NestJS), pentru că elimină mult cod repetitiv.

De ce contează acum: majoritatea sintaxei TypeScript poate fi pur și simplu ștearsă ca să obții JavaScript valid. Câteva construcții însă generează cod la rulare: parameter properties, enum, namespace cu valori și import x = require(). Node.js a introdus type stripping (experimental din 22.6, activat implicit în versiunile ulterioare), care rulează direct fișiere .ts înlocuind tipurile cu spații. Nu transformă nimic, deci construcțiile de mai sus dau eroare.

TypeScript 5.8 a adăugat erasableSyntaxOnly, care semnalează exact aceste construcții, ca să știi la compilare că fișierul poate rula prin type stripping.

Ce înseamnă pentru un proiect:

  • dacă folosești tsc, un bundler sau un framework care compilează complet, parameter properties funcționează în continuare;
  • dacă vrei ca codul să ruleze și prin type stripping sau să fie compatibil cu propunerea de „tipuri ca adnotări” din JavaScript, scrii câmpurile explicit și înlocuiești enum cu obiecte as const.

E o decizie de echipă, nu o regulă absolută.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce sintaxă TypeScript generează cod și dacă urmărești evoluția ecosistemului. Puțini candidați fac legătura cu type stripping din Node.js.

72 Junior

Când folosești o interfață și când o clasă abstractă? Ce primește o clasă din implements și ce primește din extends?

Răspuns scurt: implements doar verifică forma clasei față de interfață și nu adaugă niciun cod. extends moștenește implementarea și constructorul. Alegi interfața pentru contracte, iar clasa abstractă când vrei să partajezi cod comun și să impui pașii unui algoritm.

O interfață există doar la compilare și descrie un contract. implements cere ca clasa să aibă membrii declarați, dar nu le furnizează. O greșeală frecventă: candidații cred că implements tipizează automat parametrii metodelor; de fapt, parametrii trebuie adnotați în clasă, altfel sunt any.

TypeScript
interface PaymentGateway {
  charge(amountCents: number): Promise<string>;
}
class StripeGateway implements PaymentGateway {
  async charge(amountCents: number) { return 'tx_1'; }
}

O clasă abstractă există și la rulare. Poate conține câmpuri, implementări, constructor și metode abstract, pe care subclasele trebuie să le implementeze. Nu poate fi instanțiată direct.

TypeScript
abstract class Exporter<T> {
  export(rows: T[]): string {
    return [this.header(), ...rows.map(r => this.row(r))].join('\n');
  }
  protected abstract header(): string;
  protected abstract row(item: T): string;
}
class CsvExporter extends Exporter<Product> {
  protected header() { return 'sku,name'; }
  protected row(p: Product) { return `${p.sku},${p.name}`; }
}

Exemplul e tiparul Template Method: clasa de bază fixează algoritmul, subclasele completează pașii.

Criterii:

  • o clasă poate implementa oricâte interfețe, dar extinde o singură clasă;
  • interfețele permit mock-uri simple în teste (un obiect literal e suficient);
  • clasele abstracte sunt potrivite când ai cod comun real; dacă au doar metode abstracte, o interfață e mai simplă;
  • pentru dependency injection, depinde de interfețe, nu de clase concrete.

Ce urmărește intervievatorul: Se verifică înțelegerea diferenței dintre contract și implementare. Greșeala tipică: crede că implements moștenește cod sau tipizează parametrii.

Eroarea, în practică:TS2511: Cannot create instance of abstract classTS2420: Class incorrectly implements interface

73 Junior

Ce afișează codul de mai jos? Ce se schimbă la un enum cu valori string?

TypeScript
enum Level { Low, Medium, High }
console.log(Level.Medium, Level[2], Object.keys(Level));

Răspuns scurt: Afișează 1, 'High' și ['0', '1', '2', 'Low', 'Medium', 'High']. Un enum numeric generează un obiect cu mapare în ambele sensuri (reverse mapping). Un enum string nu are mapare inversă, deci Object.keys returnează doar numele.

Spre deosebire de interfețe, un enum generează cod JavaScript. Pentru enum-ul numeric, compilatorul produce aproximativ:

TypeScript
var Level;
(function (Level) {
  Level[Level['Low'] = 0] = 'Low';
  Level[Level['Medium'] = 1] = 'Medium';
  Level[Level['High'] = 2] = 'High';
})(Level || (Level = {}));

Obiectul rezultat are și chei de la nume la număr, și de la număr la nume. De aici:

  • Level.Medium este 1;
  • Level[2] este 'High' (reverse mapping);
  • Object.keys(Level) conține atât cheile numerice, cât și numele, o capcană când construiești un dropdown din enum.

Enum-ul string nu are mapare inversă:

TypeScript
enum Status { Active = 'ACTIVE', Banned = 'BANNED' }
Object.values(Status); // ['ACTIVE', 'BANNED']

Valorile string sunt și mai ușor de citit în loguri și în baza de date decât 0 sau 2.

Alte detalii:

  • enum-urile numerice primesc implicit valori de la 0, iar ordinea contează: dacă inserezi un membru la mijloc, valorile se decalează și datele salvate anterior își schimbă sensul. De aceea e bine să atribui valori explicite;
  • din TypeScript 5.0, atribuirea unui literal numeric care nu e membru (const l: Level = 7) dă eroare. Un number oarecare (de exemplu dintr-o variabilă) e însă încă acceptat, deci nu te baza pe enum pentru validare;
  • enum-urile string sunt nominale: un string literal 'ACTIVE' nu poate fi atribuit direct lui Status, ci doar Status.Active.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi ce cod generează un enum și capcanele care decurg de aici. Puțini candidați pot explica de ce Object.keys are 6 elemente.

Eroarea, în practică:TS1061: Enum member must have initializer

74 Junior

Pentru stările unei comenzi poți folosi un enum, un union de string literals sau un obiect as const. Ce alegi într-un proiect nou și de ce?

Răspuns scurt: Pentru majoritatea proiectelor noi: un union de literale, eventual derivat dintr-un obiect sau tablou as const când ai nevoie și de valori la rulare. Enum-urile generează cod, sunt nominale și nu funcționează cu type stripping, deși unele echipe le preferă pentru lizibilitate.

Cele trei variante:

TypeScript
// 1. enum
enum OrderStatus { Pending = 'pending', Paid = 'paid', Shipped = 'shipped' }

// 2. union de literale
type OrderStatus2 = 'pending' | 'paid' | 'shipped';

// 3. obiect as const + tip derivat
const ORDER_STATUS = { Pending: 'pending', Paid: 'paid', Shipped: 'shipped' } as const;
type OrderStatus3 = typeof ORDER_STATUS[keyof typeof ORDER_STATUS];

Union-ul de literale:

  • nu generează cod, se șterge complet;
  • e compatibil cu stringurile venite din JSON sau din baza de date, după validare;
  • funcționează direct cu narrowing, switch exhaustiv și template literal types.

Obiectul as const adaugă valori disponibile la rulare (pentru dropdown-uri, validare, iterare) și un namespace cu nume (ORDER_STATUS.Paid), fără dezavantajele enum-ului. Pentru iterare, Object.values(ORDER_STATUS) dă exact valorile.

Enum-ul:

  • generează un obiect la rulare și e nominal: 'paid' venit din API nu e atribuibil lui OrderStatus fără conversie, ceea ce unii consideră un avantaj de siguranță, alții o povară;
  • nu e acceptat de erasableSyntaxOnly și de type stripping în Node.js;
  • are capcanele enum-urilor numerice (reverse mapping, decalarea valorilor).

Recomandarea mea pentru un proiect nou: union de literale când valorile apar doar în tipuri, obiect as const când ai nevoie de ele și la rulare. Într-un proiect existent cu enum-uri consecvente, nu le înlocuiești doar din principiu; consecvența contează mai mult. La interviu, ce contează e să poți argumenta alegerea.

Ce urmărește intervievatorul: Se verifică dacă poți compara variante echivalente și argumenta o alegere. Răspunsul slab: „enum, pentru că așa e în Java”.

75 Mid

Ce este un const enum și de ce poate crea probleme când proiectul e compilat cu esbuild, swc sau Babel, sau cu opțiunea isolatedModules?

Răspuns scurt: Un const enum nu generează obiect: tsc înlocuiește fiecare utilizare cu valoarea literală. Transpilatoarele care lucrează fișier cu fișier nu văd declarația din alt fișier, deci nu pot face înlocuirea, iar cu isolatedModules TS semnalează utilizarea const enum-urilor ambientale.

TypeScript
// colors.ts
export const enum Color { Red = 'red', Blue = 'blue' }
// app.ts
import { Color } from './colors';
const c = Color.Red;
// după tsc: const c = "red"; și nu mai există niciun obiect Color

Avantajul inițial: zero cod la rulare și acces mai rapid. Problema: înlocuirea are nevoie de informații de tip din alt fișier. tsc vede tot proiectul și o poate face. Unelte precum esbuild, swc, Babel sau Vite (care folosește esbuild pentru transpilare în development) compilează fiecare fișier izolat și nu știu ce valoare are Color.Red din colors.ts. Rezultatul poate fi un import către un obiect care nu există, deci o eroare la rulare.

Opțiunea isolatedModules: true îi cere lui TypeScript să semnaleze codul care nu poate fi transpilat corect fișier cu fișier. Pentru const enum-uri, dă eroare când folosești unul declarat ambiental (de exemplu într-un .d.ts dintr-o librărie). Opțiunea e recomandată în orice proiect care folosește un bundler modern.

Alte probleme:

  • o librărie care publică const enum în declarații îi obligă pe utilizatori să compileze cu tsc;
  • dacă valoarea se schimbă în librărie, codul compilat anterior păstrează vechea valoare inlinată.

Alternative: enum obișnuit (generează obiect, dar funcționează peste tot) sau, mai simplu, obiect as const cu union derivat, care are același beneficiu de lizibilitate și nicio capcană de compilare. Opțiunea preserveConstEnums păstrează obiectul generat, dar anulează avantajul principal.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi diferența dintre tsc și transpilatoarele moderne. Problema apare des în proiecte migrate pe Vite.

Eroarea, în practică:TS2475: const enum used as an object

76 Junior

Ce face cuvântul cheie override și de ce ai activa noImplicitOverride? Ce bug prinde în exemplul de mai jos?

TypeScript
class Notifier {
  protected format(msg: string) { return msg; }
  send(msg: string) { console.log(this.format(msg)); }
}
class SmsNotifier extends Notifier {
  protected fromat(msg: string) { return msg.slice(0, 160); }
}

Răspuns scurt: override (TypeScript 4.3) marchează explicit o metodă care suprascrie una din clasa de bază; dacă metoda nu există în bază, primești eroare. Aici fromat e o greșeală de scriere: fără override, subclasa adaugă o metodă nouă, iar mesajul nu e trunchiat.

Fără override, o metodă dintr-o subclasă care are un nume greșit sau rămâne în urmă după o redenumire în clasa de bază devine pur și simplu o metodă nouă. Codul compilează, dar comportamentul e greșit: SmsNotifier.send folosește în continuare format din clasa de bază, deci SMS-urile nu sunt trunchiate.

Cu override:

TypeScript
class SmsNotifier extends Notifier {
  protected override fromat(msg: string) { return msg.slice(0, 160); }
  // eroare: This member cannot have an 'override' modifier because it is not declared in the base class 'Notifier'
}

Opțiunea noImplicitOverride face cuvântul obligatoriu: orice metodă care suprascrie una din bază fără override dă eroare. Astfel, ambele direcții sunt acoperite:

  • suprascrieri accidentale (o metodă nouă care, din întâmplare, are același nume cu una din bază);
  • suprascrieri ratate (nume greșit sau metodă redenumită în bază).

Despre protected din exemplu: un membru protected e accesibil în clasa care îl declară și în subclase, dar nu din exterior. E potrivit pentru „puncte de extensie” ca format, pe care subclasele le pot schimba fără ca restul aplicației să le apeleze direct. Ca și private, e doar o verificare de compilare.

override funcționează și pentru proprietăți și pentru metodele care implementează membri abstract. Pentru proiecte cu ierarhii de clase (servicii NestJS, componente Angular, modele de domeniu), noImplicitOverride e o opțiune ieftină cu beneficiu clar.

Ce urmărește intervievatorul: Se verifică dacă știi unelte care previn bug-uri de moștenire. Mulți candidați veniți din Java recunosc @Override și pot face legătura.

Eroarea, în practică:TS4113: 'override' but not declared in base class

77 Mid

De ce crapă codul de mai jos la rulare și cum ar fi putut TypeScript să te avertizeze? Dă trei moduri de a-l repara.

TypeScript
class Counter {
  count = 0;
  increment() { this.count++; }
}
const c = new Counter();
button.addEventListener('click', c.increment);

Răspuns scurt: Metoda pierde legătura cu instanța când e pasată ca referință: la click, this e butonul, nu Counter. Reparații: arrow function ca proprietate de clasă, c.increment.bind(c) sau () => c.increment(). Parametrul this tipat permite TS să semnaleze problema.

În JavaScript, this se stabilește la apel, nu la definire. c.increment extrage funcția fără obiect, iar addEventListener o apelează cu this setat la elementul pe care s-a produs evenimentul. this.count++ incrementează o proprietate inexistentă pe buton, deci contorul nu se schimbă. Într-un alt context (de exemplu un setTimeout), this ar fi undefined în corpul unei clase și ai primi o excepție.

Implicit, TypeScript nu prinde problema, pentru că tipul metodei nu spune nimic despre this. Poți declara explicit un parametru this, care e șters la compilare:

TypeScript
class Counter {
  count = 0;
  increment(this: Counter) { this.count++; }
}
const fn = c.increment;
fn(); // eroare: The 'this' context of type 'void' is not assignable to method's 'this' of type 'Counter'

Regula unbound-method din typescript-eslint semnalează automat astfel de referințe.

Reparații:

TypeScript
// 1. proprietate arrow, legată de instanță la creare
class Counter2 { count = 0; increment = () => { this.count++; }; }
// 2. bind
button.addEventListener('click', c.increment.bind(c));
// 3. closure
button.addEventListener('click', () => c.increment());

Compromisuri: varianta 1 creează câte o funcție pentru fiecare instanță și nu pune metoda pe prototip, deci subclasele nu o pot suprascrie cu super.increment(). Varianta 3 e cea mai explicită. Opțiunea noImplicitThis (inclusă în strict) dă eroare când this ar avea implicit tipul any, de exemplu în funcții obișnuite din obiecte literale.

Ce urmărește intervievatorul: Se verifică înțelegerea lui this și a uneltelor TypeScript care îl verifică. Mulți candidați știu soluția cu arrow, dar nu și de ce funcționează.

Eroarea, în practică:TS2683: 'this' implicitly has type 'any'TS2684: The 'this' context of type 'void'

78 Mid

Scrie o clasă de eroare proprie NotFoundError care poate fi deosebită cu instanceof și păstrează cauza originală. Ce problemă apare dacă target este ES5?

Răspuns scurt: Extinzi Error, setezi name și transmiți { cause } către super. Cu target ES5, extinderea claselor built-in strică lanțul de prototipuri, iar instanceof NotFoundError returnează false, dacă nu apelezi Object.setPrototypeOf(this, new.target.prototype).

TypeScript
class AppError extends Error {
  constructor(message: string, options?: ErrorOptions) {
    super(message, options);
    this.name = new.target.name;
  }
}

class NotFoundError extends AppError {
  constructor(public readonly resource: string, public readonly id: string, options?: ErrorOptions) {
    super(`${resource} ${id} nu există`, options);
  }
}

try {
  await repo.get('ord_1');
} catch (e) {
  if (e instanceof NotFoundError) return res.status(404).json({ resource: e.resource });
  throw new AppError('Eroare la încărcarea comenzii', { cause: e });
}

Puncte de explicat:

  • ErrorOptions și proprietatea cause vin din lib ES2022. Păstrarea cauzei originale e esențială pentru loguri: vezi atât contextul tău, cât și eroarea din driver;
  • name setat corect face mesajele din loguri ușor de citit (NotFoundError: ...);
  • câmpurile proprii (resource, id) permit tratarea erorii fără să parsezi mesajul.

Problema cu ES5: în ES5 nu există clase native, iar Error, apelat ca funcție de constructorul compilat, returnează un obiect nou care nu are prototipul subclasei. Rezultatul: instanceof NotFoundError dă false, iar metodele adăugate în subclasă lipsesc. Soluția clasică:

TypeScript
Object.setPrototypeOf(this, new.target.prototype);

apelat în constructor după super. Cu target ES2015 sau mai nou, clasele native extind corect Error și nu mai e nevoie de acest truc. În TypeScript 6.0, target: ES5 este marcat ca depreciat și va dispărea în versiunea 7, dar îl vei întâlni încă în proiecte mai vechi.

Atenție: instanceof poate eșua și când eroarea vine din altă copie a librăriei din bundle; în acel caz, un câmp code e o verificare mai robustă.

Ce urmărește intervievatorul: Intervievatorul verifică experiența cu tratarea erorilor în proiecte reale. Problema cu ES5 apare încă în proiecte vechi și puțini candidați o pot explica.

79 Mid

Cum tipizezi un parametru care trebuie să fie o clasă (constructor), nu o instanță? Scrie o funcție createAll care primește o listă de clase și returnează instanțele lor, plus un mixin Timestamped.

Răspuns scurt: Folosești o semnătură de construct: new (...args: any[]) => T. Pentru clase abstracte, abstract new (...args: any[]) => T. Un mixin e o funcție generică ce primește un constructor și returnează o clasă care îl extinde.

Un tip ca User descrie instanța. Clasa însăși, ca valoare, are tipul typeof User, care conține semnătura new și membrii statici. Pentru a accepta orice clasă cu o anumită formă, folosești un tip constructor:

TypeScript
type Ctor<T = object> = new (...args: any[]) => T;

function create<T>(C: new () => T): T {
  return new C();
}

interface Plugin { name: string; init(): void }
function createAll(classes: Array<new () => Plugin>): Plugin[] {
  return classes.map(C => new C());
}

class Analytics implements Plugin { name = 'analytics'; init() {} }
createAll([Analytics]); // ok

Pentru clase abstracte, new () => T nu se potrivește, pentru că nu pot fi instanțiate. Din TypeScript 4.2 există abstract new () => T, util pentru registre de tipuri sau pentru containere de dependency injection care primesc „tokenuri” de clasă.

Mixin-ul, un mod de a compune comportament fără moștenire multiplă:

TypeScript
function Timestamped<TBase extends Ctor>(Base: TBase) {
  return class extends Base {
    createdAt = new Date();
    touch() { this.createdAt = new Date(); }
  };
}

class Note { constructor(public text: string) {} }
const TimestampedNote = Timestamped(Note);
const n = new TimestampedNote('salut');
n.text; n.touch(); // ambele disponibile

Constrângerea trebuie să aibă exact forma new (...args: any[]) => ..., altfel TS nu acceptă class extends Base. Tipurile utilitare InstanceType<C> și ConstructorParameters<C> lucrează tot pe astfel de tipuri constructor. Mixin-urile sunt puternice, dar fac ierarhiile greu de urmărit; compoziția simplă cu obiecte e adesea mai clară.

Ce urmărește intervievatorul: Se verifică diferența dintre tipul instanței și tipul clasei, o confuzie frecventă. Răspunsul slab scrie C: User sau C: Function.

Eroarea, în practică:TS2351: This expression is not constructable

80 Mid

Construiești un query builder cu metode înlănțuite. De ce metodele ar trebui să returneze tipul this, nu numele clasei? Ce se strică în subclasă în varianta greșită?

Răspuns scurt: Tipul this înseamnă „tipul instanței pe care s-a apelat metoda”, inclusiv în subclase. Dacă metodele din bază returnează QueryBuilder, după primul apel în lanț pierzi metodele adăugate de subclasă și nu le mai poți folosi.

TypeScript
class QueryBuilder {
  protected parts: string[] = [];
  where(cond: string): this {
    this.parts.push(`WHERE ${cond}`);
    return this;
  }
  limit(n: number): this {
    this.parts.push(`LIMIT ${n}`);
    return this;
  }
  build(): string { return this.parts.join(' '); }
}

class UserQuery extends QueryBuilder {
  active(): this { return this.where('active = true'); }
}

new UserQuery().where('age > 18').active().limit(10).build(); // ok

Dacă where ar fi declarat : QueryBuilder, expresia new UserQuery().where('age > 18') ar avea tipul QueryBuilder, iar .active() ar da eroare, deși obiectul de la rulare este un UserQuery. Tipul polimorfic this rezolvă problema: e un fel de parametru generic implicit, legat de tipul real al instanței.

Alte utilizări ale tipului this:

  • type guards pe metode: isLoaded(): this is LoadedModel, care îngustează instanța după apel;
  • metode clone(): this în ierarhii.

Pentru un API fluent imutabil (fiecare apel returnează un obiect nou), this e mai greu de folosit, pentru că new QueryBuilder() nu are tipul this. Variantele uzuale sunt fie un builder mutabil ca mai sus, fie un builder generic care își schimbă tipul la fiecare pas, așa cum fac librăriile de query tipizate (Kysely, Drizzle), unde tipul rezultatului se construiește pe măsură ce adaugi select sau join. Acolo merită discutat costul de compilare al tipurilor foarte complexe.

Ce urmărește intervievatorul: Intervievatorul verifică dacă știi tipul polimorfic this, folosit în API-uri reale. Mulți candidați nu știu că this poate fi tip de return.

tsconfig, module și fișiere .d.ts

81 Junior

Ce activează opțiunea strict din tsconfig.json? De ce un upgrade de TypeScript poate produce erori noi chiar dacă nu ai schimbat configurația?

Răspuns scurt: strict activează o familie de opțiuni: noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, noImplicitThis, alwaysStrict, useUnknownInCatchVariables și altele noi. Versiunile noi pot adăuga opțiuni în familie, deci apar erori noi.

strict: true e un comutator pentru mai multe verificări, fiecare putând fi dezactivată individual:

  • noImplicitAny: eroare când TS nu poate deduce un tip și ar folosi any;
  • strictNullChecks: null și undefined devin tipuri separate;
  • strictFunctionTypes: parametrii tipurilor de funcții sunt verificați contravariant;
  • strictBindCallApply: argumentele pentru bind, call și apply sunt verificate;
  • strictPropertyInitialization: proprietățile de clasă trebuie inițializate în declarație sau în constructor (sau marcate cu !);
  • noImplicitThis: eroare când this ar fi implicit any;
  • alwaysStrict: emite "use strict" și parsează în mod strict;
  • useUnknownInCatchVariables (4.4): variabila din catch e unknown;
  • strictBuiltinIteratorReturn (5.6): tipuri mai precise pentru valorile returnate de iteratorii built-in.

Pentru că familia crește, un upgrade de TypeScript poate aduce erori noi. Mai mult, TypeScript nu respectă strict versionarea semantică: și versiunile minore (5.4, 5.5) pot avea „breaking changes” în verificare sau în tipurile din lib. De aceea se fixează versiunea în package.json și se citesc notele de lansare la upgrade.

JSON
{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true,
    "noImplicitOverride": true
  }
}

Opțiunile din a doua parte a exemplului nu sunt incluse în strict, dar sunt des adăugate în proiecte noi. Din TypeScript 6.0, strict este activat implicit chiar și fără tsconfig, iar tsc --init generează o configurație care include și noUncheckedIndexedAccess și exactOptionalPropertyTypes. Într-un proiect nou, pornești cu modul strict de la prima zi: costul de a-l activa mai târziu crește cu fiecare fișier scris.

Ce urmărește intervievatorul: Se verifică dacă știi ce verificări folosești de fapt, nu doar că „e strict”. Detaliul despre upgrade arată experiență cu proiecte întreținute în timp.

Eroarea, în practică:TS7006: Parameter implicitly has an 'any' typeTS7008: Member implicitly has an 'any' type

82 Junior

Ce face noImplicitAny? Ce erori dă codul de mai jos și cum le repari corect, fără să scrii any?

TypeScript
function total(items) {
  return items.reduce((sum, i) => sum + i.price, 0);
}
const handlers = {};
handlers['save'] = () => {};

Răspuns scurt: noImplicitAny dă eroare oriunde TS ar deduce tacit any: aici la parametrul items. Repari adnotând parametrul cu un tip real (items: { price: number }[]) și dând obiectului handlers un tip explicit, de exemplu Record<string, () => void>.

Fără noImplicitAny, un parametru neadnotat devine any, iar any se propagă: items.reduce returnează any, total(...) returnează any, iar orice cod care folosește rezultatul pierde verificarea. Erorile nu apar nicăieri, deci ai iluzia unui proiect tipizat.

Cu opțiunea activă:

  • items dă eroarea „Parameter 'items' implicitly has an 'any' type”;
  • sum și i nu mai sunt problema după ce items are tip, pentru că le deduce TS din context;
  • handlers['save'] dă o eroare de tip index pe {}: „Element implicitly has an 'any' type because expression of type '"save"' can't be used to index type '{}'”.

Reparații corecte:

TypeScript
interface LineItem { price: number; qty: number }

function total(items: readonly LineItem[]): number {
  return items.reduce((sum, i) => sum + i.price * i.qty, 0);
}

const handlers: Record<string, () => void> = {};
handlers['save'] = () => {};
// sau, dacă știi cheile:
const handlers2: { save?: () => void; cancel?: () => void } = {};

Ce să nu faci: să scrii items: any. Eroarea dispare, dar problema rămâne, doar că acum e explicită. Dacă tipul chiar nu e cunoscut, unknown e varianta sigură, care te obligă să verifici înainte de folosire.

Reține că noImplicitAny nu prinde tot any-ul: valorile returnate de JSON.parse, res.json() sau din librării fără tipuri sunt any explicit și trec. Pentru ele există regulile no-unsafe-assignment, no-unsafe-member-access și no-explicit-any din typescript-eslint.

Ce urmărește intervievatorul: Intervievatorul verifică dacă repari cauza, nu simptomul. Candidații slabi transformă implicit-any în explicit-any.

Eroarea, în practică:TS7006: Parameter implicitly has an 'any' typeTS2339: Property does not exist on type '{}'

83 Junior

Care e diferența dintre opțiunile target, lib și module din tsconfig.json? Dacă pui target: "ES2015", poți folosi Array.prototype.includes în cod?

Răspuns scurt: target decide ce sintaxă JavaScript se emite (și lib-ul implicit), lib decide ce API-uri cunoaște verificatorul de tipuri, iar module decide formatul modulelor generate. Cu ES2015, includes (ES2016) dă eroare de tip, iar TS nu adaugă polyfill.

Cele trei opțiuni sunt des confundate:

  • target: versiunea de JavaScript pentru codul emis. Cu ES2015, TS transformă sintaxa mai nouă (?., ??, câmpuri de clasă, async pe targeturi foarte vechi) în echivalente mai vechi. Determină și valoarea implicită pentru lib;
  • lib: fișierele de declarații încărcate, adică ce obiecte și metode globale „există” pentru verificator: ES2022, DOM, DOM.Iterable, WebWorker. Nu adaugă cod;
  • module: formatul import/export în output: CommonJS, ESNext, NodeNext, Preserve (TS 5.4, pentru bundlere).

Despre includes: e un API din ES2016. Cu target: "ES2015" și fără lib explicit, declarația lui lipsește și primești „Property 'includes' does not exist on type 'string[]'... Try changing the 'lib' compiler option”. Dacă adaugi "lib": ["ES2016", "DOM"], eroarea dispare, dar TypeScript nu face polyfill: dacă browserul țintă chiar nu are includes, codul crapă la rulare. Transformă sintaxa, nu adaugă API-uri. Pentru polyfill-uri folosești core-js sau setările bundler-ului.

Configurații tipice:

JSON
{ "compilerOptions": { "target": "ES2022", "lib": ["ES2022", "DOM", "DOM.Iterable"], "module": "ESNext", "moduleResolution": "bundler" } }

pentru o aplicație web cu Vite, și "module": "NodeNext" pentru un serviciu Node.js. Pentru Node, alege target și lib după versiunea de Node folosită în producție. Dacă nu folosești DOM pe backend, scoate DOM din lib, ca să nu poți folosi accidental window sau document.

Ce urmărește intervievatorul: Se verifică înțelegerea configurației de bază și a faptului că TS nu face polyfill. Mulți candidați cred că target adaugă metodele lipsă.

Eroarea, în practică:TS2584: Cannot find name 'document'TS2550: change your target library

84 Junior

Ce este import type și ce schimbă opțiunea verbatimModuleSyntax (TypeScript 5.0)? Ce problemă poate apărea fără ele?

TypeScript
import { User, saveUser } from './users';
import './polyfills';

Răspuns scurt: import type declară că importul e folosit doar ca tip și va fi șters complet. Cu verbatimModuleSyntax, TS păstrează exact importurile fără type și le șterge pe cele cu type, deci comportamentul nu mai depinde de analiza utilizării, iar transpilatoarele fișier cu fișier funcționează corect.

Istoric, TypeScript elimina automat importurile folosite doar ca tipuri (import elision). Dacă User era o interfață, tsc știa să o elimine, pentru că vedea tot proiectul. Un transpilator ca esbuild sau swc, care procesează un fișier izolat, nu știe dacă User din ./users e tip sau valoare. Poate păstra importul unui export inexistent, ceea ce dă eroare în modulele ES native.

import type face intenția explicită:

TypeScript
import type { User } from './users';
import { saveUser, type UserRole } from './users'; // forma inline

verbatimModuleSyntax înlocuiește opțiunile mai vechi importsNotUsedAsValues și preserveValueImports cu o regulă simplă: ce are type se șterge, ce nu are type rămâne exact cum e scris. Consecințe:

  • trebuie să marchezi explicit importurile de tipuri, altfel primești eroare când importi un tip fără type;
  • importurile pentru efecte secundare (import './polyfills') sunt păstrate garantat;
  • codul se comportă la fel indiferent de unealta de transpilare.

Cu module: CommonJS, opțiunea interzice sintaxa ESM și cere import x = require(), de aceea se folosește mai ales în proiecte ESM.

Beneficii secundare: importurile de tip nu creează dependențe la rulare, deci evită cicluri de import care ar produce undefined la încărcare și ajută bundler-ul să elimine cod nefolosit. Regula consistent-type-imports din typescript-eslint poate adăuga automat type acolo unde lipsește.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi interacțiunea dintre TypeScript și uneltele de build moderne. Candidații slabi nu știu că un import poate rămâne în bundle din greșeală.

85 Mid

Într-un proiect Node.js cu "type": "module", compilatorul cere import { x } from './utils.js', deși fișierul se numește utils.ts. De ce? Care e diferența dintre moduleResolution nodenext și bundler?

Răspuns scurt: Cu nodenext, TS aplică regulile reale ale Node.js pentru ESM, unde importurile relative trebuie să aibă extensie, iar extensia e cea a fișierului emis, .js. bundler modelează Vite sau webpack, care acceptă importuri fără extensie, dar respectă câmpul exports din package.json.

TypeScript nu rescrie implicit căile de import: ce scrii în .ts ajunge identic în .js. Node.js în modul ESM nu ghicește extensii, deci import './utils' eșuează la rulare. Prin urmare, în sursă scrii calea fișierului care va exista după compilare, ./utils.js, iar TS știe să o asocieze cu utils.ts la verificare.

Modurile principale de rezolvare:

  • node16 / nodenext: imită exact Node.js. Ține cont de "type" din package.json, de extensiile .mts/.cts, de câmpurile exports și imports și cere extensii în importurile relative ESM. Se folosește împreună cu module: "nodenext";
  • bundler (TypeScript 5.0): pentru cod procesat de un bundler. Respectă exports, dar nu cere extensii. Se folosește cu module: "esnext" sau "preserve";
  • node10 (fostul node): modelul vechi CommonJS, care ignoră exports. Poate rezolva importuri pe care Node.js modern le-ar refuza, deci nu e recomandat pentru cod nou; în TypeScript 6.0 este marcat ca depreciat.

Alegerea greșită produce erori la rulare pe care verificarea nu le arată, de exemplu cod compilat cu bundler și rulat direct de Node.

Alternative recente: cu allowImportingTsExtensions poți scrie ./utils.ts când nu emiți cod (bundler sau type stripping). Din TypeScript 5.7, rewriteRelativeImportExtensions rescrie .ts în .js la emitere, util pentru cod care rulează și direct prin type stripping, și compilat.

Pentru librării publicate, verifică pachetul cu unelte precum „Are the Types Wrong?”, care testează rezolvarea în toate modurile.

Ce urmărește intervievatorul: Se verifică experiența cu proiecte Node.js ESM reale, o sursă frecventă de confuzie. Răspunsul slab: „e un bug, pun .js și nu știu de ce”.

86 Mid

Ce conține un fișier .d.ts? Folosești o librărie JavaScript fără tipuri și un import de imagini SVG. Cum le declari ca să compileze proiectul?

Răspuns scurt: Un .d.ts conține doar declarații de tip, fără implementare. Pentru librăria fără tipuri scrii declare module 'nume' { ... } cu semnăturile folosite, iar pentru SVG-uri un wildcard: declare module '*.svg' { const src: string; export default src; }.

Fișierele de declarații descriu forma unui cod JavaScript existent: funcții, clase, variabile, module. Sunt generate automat (declaration: true) pentru librăriile scrise în TypeScript, vin din pachetele @types/* (proiectul DefinitelyTyped) sau le scrii tu.

Librărie fără tipuri:

TypeScript
// src/types/legacy-slugify.d.ts
declare module 'legacy-slugify' {
  export interface SlugOptions { lower?: boolean; separator?: string }
  export default function slugify(input: string, opts?: SlugOptions): string;
}

Dacă nu ai timp acum, forma scurtă declare module 'legacy-slugify'; face ca toate exporturile să fie any. Compilează, dar e o datorie tehnică; mai bine declari doar funcțiile pe care le folosești.

Fișiere non-cod importate prin bundler:

TypeScript
declare module '*.svg' {
  const src: string;
  export default src;
}
declare module '*.module.css' {
  const classes: Readonly<Record<string, string>>;
  export default classes;
}

Variabile globale injectate (de exemplu de un script extern):

TypeScript
declare const __APP_VERSION__: string;

Reguli practice:

  • fișierul trebuie inclus de tsconfig (include sau typeRoots);
  • un .d.ts fără import/export la nivel de top e „script global”; dacă adaugi un import, devine modul și declarațiile globale trebuie mutate în declare global;
  • skipLibCheck sare peste verificarea .d.ts-urilor, inclusiv a celor scrise de tine, deci greșelile din ele pot trece neobservate;
  • declarațiile nu sunt verificate față de implementarea JavaScript, deci un tip greșit minte la fel ca un as. Contribuirea lor înapoi la DefinitelyTyped sau la librărie ajută și alți utilizatori.

Ce urmărește intervievatorul: Intervievatorul verifică dacă poți lucra cu ecosistemul JavaScript imperfect. Candidații slabi nu știu ce e @types sau scriu // @ts-ignore la fiecare import.

Eroarea, în practică:TS2307: Cannot find moduleTS2503: Cannot find namespace 'NodeJS'

87 Senior

Middleware-ul de autentificare adaugă req.user, iar aplicația citește process.env.DATABASE_URL și window.dataLayer. Cum extinzi tipurile existente pentru toate trei, ce riscuri au aceste augmentări și cum le reduci?

Răspuns scurt: Folosești declaration merging în declare global: interfața Express.Request, NodeJS.ProcessEnv și Window. Riscul: tipul afirmă că valorile există peste tot, deși sunt setate doar uneori. Le faci opționale sau validezi la pornire și expui obiecte deja verificate.

Interfețele cu același nume se combină (declaration merging), iar librăriile își declară tipurile ca interfețe tocmai ca să poată fi extinse:

TypeScript
// src/types/global.d.ts
import type { AuthUser } from '../auth';

declare global {
  namespace Express {
    interface Request { user?: AuthUser }
  }
  namespace NodeJS {
    interface ProcessEnv { DATABASE_URL?: string; NODE_ENV: 'development' | 'production' | 'test' }
  }
  interface Window { dataLayer: unknown[] }
}
export {};

Detalii tehnice: fișierul trebuie să fie modul (are import sau export {}) ca să poți folosi declare global, și trebuie inclus în compilare. Pentru librării, poți augmenta direct modulul, de exemplu declare module 'express-serve-static-core' { interface Request { ... } }.

Riscurile sunt reale:

  • req.user: AuthUser (neopțional) promite utilizatorul în toate rutele, inclusiv în cele publice, unde e undefined;
  • ProcessEnv declarat cu valori obligatorii nu verifică nimic: dacă variabila lipsește în producție, aplicația pornește și crapă la prima cerere;
  • augmentările globale se aplică în tot proiectul, iar conflictele între pachete sunt greu de depanat.

Cum le reduci:

  • câmpuri opționale plus un helper requireUser(req) care aruncă eroare sau un tip de request separat pentru rutele protejate;
  • variabilele de mediu validate o singură dată la pornire, cu o schemă, iar aplicația folosește obiectul config rezultat, nu process.env;
  • un singur fișier global.d.ts, revizuit atent la code review.

Ce urmărește intervievatorul: Se verifică stăpânirea declaration merging în scenarii practice și gândirea critică despre ce garantează tipurile. Un candidat senior propune validare, nu doar declarații.

Eroarea, în practică:TS2717: Subsequent property declarations same typeTS7017: 'typeof globalThis' has no index signature

88 Junior

Proiectul folosește Vite (sau Next.js) și se compilează chiar și când are erori de tip. De ce? Ce rol au noEmit, isolatedModules și skipLibCheck într-un astfel de proiect?

Răspuns scurt: Vite transpilează TypeScript cu esbuild, care doar șterge tipurile, fără verificare. Verificarea se rulează separat cu tsc --noEmit, în editor și în CI. isolatedModules garantează că fiecare fișier poate fi transpilat izolat, iar skipLibCheck sare peste verificarea .d.ts-urilor din dependențe.

În multe proiecte moderne, două unelte diferite fac două lucruri diferite:

  • transpilarea (TypeScript în JavaScript): esbuild, swc sau Babel, foarte rapide, pentru că lucrează pe fiecare fișier separat și ignoră tipurile;
  • verificarea tipurilor: doar tsc (sau vue-tsc pentru Vue), care analizează tot proiectul.

De aceea serverul de dezvoltare Vite pornește și când ai erori de tip: le vezi în editor, dar build-ul nu se oprește. Next.js rulează în schimb verificarea la next build, dar nu și în development.

Opțiuni relevante:

  • noEmit: true: tsc doar verifică și nu scrie fișiere, pentru că emiterea o face bundler-ul;
  • isolatedModules: true: TS semnalează construcțiile care nu pot fi transpilate corect fișier cu fișier, cum ar fi re-exportarea unui tip fără export type sau folosirea const enum-urilor ambientale;
  • skipLibCheck: true: nu verifică fișierele .d.ts, ceea ce scurtează mult timpul și evită erori din conflicte între versiuni de @types. Costul: greșelile din declarațiile proprii trec nevăzute.

Configurarea corectă a pipeline-ului:

JSON
{ "scripts": { "typecheck": "tsc --noEmit", "build": "npm run typecheck && vite build" } }

plus pasul typecheck în CI, pe fiecare pull request. Fără el, erorile de tip ajung în main și se acumulează. Pentru monorepo-uri, tsc -b cu project references face verificarea incrementală. În editor, eroarea apare imediat, dar nu e o garanție: cineva poate face commit fără să deschidă fișierul afectat.

Ce urmărește intervievatorul: Intervievatorul verifică dacă înțelegi lanțul de build modern. Mulți juniori cred că dacă aplicația pornește, nu are erori de tip.

89 Senior

Într-un monorepo cu pachetele shared, api și web, verificarea tipurilor durează tot mai mult, iar web importă din greșeală cod de server. Cum folosești project references ca să rezolvi ambele probleme?

Răspuns scurt: Fiecare pachet primește propriul tsconfig.json cu composite: true, iar dependențele se declară prin references. tsc -b construiește incremental doar ce s-a schimbat, iar un pachet poate importa doar din pachetele declarate ca referință.

Fără project references, un singur tsconfig mare verifică tot codul de fiecare dată, iar orice fișier poate importa orice alt fișier. Granițele dintre pachete sunt doar o convenție.

Structura cu referințe:

JSON
// packages/shared/tsconfig.json
{ "compilerOptions": { "composite": true, "declaration": true, "outDir": "dist", "rootDir": "src" } }

// packages/web/tsconfig.json
{
  "compilerOptions": { "composite": true, "outDir": "dist", "lib": ["ES2022", "DOM"] },
  "references": [{ "path": "../shared" }]
}

// tsconfig.json la rădăcină
{ "files": [], "references": [{ "path": "packages/shared" }, { "path": "packages/api" }, { "path": "packages/web" }] }

Ce obții:

  • build incremental: tsc -b folosește fișierele .tsbuildinfo și declarațiile .d.ts generate. Dacă modifici doar web, shared nu mai e reverificat. Pachetele dependente văd shared prin declarațiile lui, ceea ce e mult mai rapid decât reanalizarea surselor;
  • granițe impuse: web nu are referință către api, deci importurile din api dau eroare. Configurații diferite per pachet (DOM doar în web, tipuri Node doar în api) previn și ele amestecul;
  • editorul încarcă proiectele separat, deci rămâne responsiv.

Cerințe și capcane: composite impune declaration: true și ca toate fișierele să fie incluse explicit; ciclurile de referințe nu sunt permise, ceea ce te forțează să extragi codul comun. Unele bundlere rezolvă importurile direct din surse, nu din dist; trebuie aliniate căile (prin exports în package.json sau aliasuri). Uneltele de monorepo (Nx, Turborepo) pot adăuga cache peste tsc -b în CI.

Ce urmărește intervievatorul: Se verifică experiența cu proiecte mari și arhitectura de build. Un candidat senior leagă performanța de granițele arhitecturale.

90 Senior

Ți se cere să migrezi treptat la TypeScript o aplicație JavaScript de mărime medie, fără să oprești dezvoltarea de funcționalități. Cum planifici migrarea?

Răspuns scurt: Pornești cu allowJs și un tsconfig permisiv, convertești fișierele de la „frunze” spre centru, adaugi tipuri la granițe (API, modele) și înăsprești opțiunile strict pe rând. Măsori progresul și impui regula: fișierele noi se scriu direct în TypeScript, strict.

Un model de răspuns structurat:

1. Pregătire, fără să schimbi comportamentul. Adaugi TypeScript și un tsconfig cu allowJs: true, checkJs: false, strict: false, noEmit dacă un bundler face transpilarea. Build-ul trebuie să producă exact aceeași aplicație. Adaugi pasul tsc --noEmit în CI de la început.

2. Reguli pentru codul nou. Orice fișier nou se scrie în .ts. Fără această regulă, migrarea nu se termină niciodată.

3. Conversie de la frunze spre centru. Începi cu utilitare și modele de date fără dependențe interne, apoi serviciile care le folosesc, apoi componentele. Fiecare fișier convertit oferă tipuri celor care îl importă. Pentru fișierele care rămân JavaScript, poți activa verificarea parțială cu // @ts-check și adnotări JSDoc.

4. Tipuri la granițe, devreme. Modelele de domeniu și răspunsurile API aduc cel mai mare câștig: un tip Order corect propagă informații în tot codul.

5. Strict pe etape. Activezi pe rând noImplicitAny, strictNullChecks (de obicei cel mai costisitor), apoi restul. Pentru fișierele care nu trec încă, folosești o listă de excepții sau un plugin care aplică regulile stricte doar fișierelor migrate.

6. Măsurare. Numeri fișierele .js rămase și utilizările de any și @ts-expect-error, vizibile într-un raport la fiecare sprint.

Ce eviți: o conversie „big bang” într-un branch de lungă durată, care intră în conflict cu tot restul echipei, și any folosit ca soluție permanentă. Contează și oamenii: o scurtă sesiune internă despre tiparele folosite (union-uri, generice, validare) evită ca fiecare coleg să inventeze propriul stil.

Ce urmărește intervievatorul: Intervievatorul evaluează planificarea și pragmatismul, nu doar cunoștințele de configurare. Răspunsul slab propune rescrierea completă.

TypeScript în React, Node și situații reale

Exersează capitolul cu exerciții reale: Curs TypeScript pentru începători →
91 Junior

Tipizează o componentă React TextField care primește label, value, onChange(value: string) și orice atribut nativ de input, cu excepția celor redefinite. Cum tipizezi evenimentul?

Răspuns scurt: Extinzi React.ComponentProps<'input'> cu Omit pentru value și onChange, apoi adaugi props-urile proprii. Evenimentul nativ are tipul React.ChangeEvent<HTMLInputElement>, iar valoarea se citește din e.target.value.

TypeScript
import type { ComponentProps, ChangeEvent } from 'react';

type TextFieldProps = Omit<ComponentProps<'input'>, 'value' | 'onChange'> & {
  label: string;
  value: string;
  onChange: (value: string) => void;
};

export function TextField({ label, value, onChange, id, ...rest }: TextFieldProps) {
  const handle = (e: ChangeEvent<HTMLInputElement>) => onChange(e.target.value);
  return (
    <label htmlFor={id}>
      {label}
      <input id={id} value={value} onChange={handle} {...rest} />
    </label>
  );
}

<TextField label="Email" value={email} onChange={setEmail} type="email" required />;

De explicat:

  • ComponentProps<'input'> aduce toate atributele native (type, placeholder, disabled, aria-*), deci componenta e utilizabilă fără să le declari manual;
  • Omit e necesar pentru că onChange al tău are altă semnătură decât cel nativ; fără el, intersecția ar cere ambele semnături simultan;
  • tipurile de evenimente React sunt generice pe element: ChangeEvent<HTMLInputElement>, FormEvent<HTMLFormElement>, MouseEvent<HTMLButtonElement>, KeyboardEvent<HTMLInputElement>. Când scrii handler-ul inline, tipul se deduce din context.

Despre children și React.FC: din tipurile React 18, FC nu mai adaugă implicit children. Mulți preferă funcții obișnuite cu props tipizate, ca mai sus, și declară children: React.ReactNode doar când componenta chiar îl acceptă. ReactNode acceptă text, elemente, null și tablouri; ReactElement acceptă doar elemente JSX.

Pentru a primi ref pe input, în React 19 ref vine ca prop obișnuit, iar ComponentProps<'input'> îl include; în versiunile anterioare foloseai forwardRef.

Ce urmărește intervievatorul: Se verifică tipizarea practică a componentelor, nu doar teoria. Răspunsul slab declară manual cinci atribute și uită restul.

92 Junior

Ce tip returnează await res.json() și de ce funcția de mai jos oferă o siguranță falsă? Cum ai scrie-o mai onest?

TypeScript
async function getJson<T>(url: string): Promise<T> {
  const res = await fetch(url);
  return res.json();
}
const products = await getJson<Product[]>('/api/products');

Răspuns scurt: res.json() returnează Promise<any>, deci orice T e acceptat fără verificare. Funcția nu verifică nici res.ok. Variantă mai onestă: returnezi unknown sau primești o funcție de validare care transformă unknown în T și aruncă eroare la date greșite.

Problemele funcției:

  • T apare doar în return: e o aserțiune ascunsă. getJson<Product[]> și getJson<string> compilează la fel, oricare ar fi răspunsul real;
  • res.ok nu e verificat: un 404 sau un 500 cu un corp JSON de eroare devine „lista de produse”, iar bug-ul apare mai târziu, în altă componentă;
  • any se propagă: res.json() returnează Promise<any>, care e atribuibil lui Promise<T> fără eroare.

Variantă mai onestă:

TypeScript
class HttpError extends Error {
  constructor(public status: number, public body: unknown) { super(`HTTP ${status}`); }
}

async function getJson<T>(url: string, parse: (data: unknown) => T, init?: RequestInit): Promise<T> {
  const res = await fetch(url, init);
  const body: unknown = await res.json().catch(() => null);
  if (!res.ok) throw new HttpError(res.status, body);
  return parse(body);
}

const products = await getJson('/api/products', data => ProductList.parse(data));

Aici T e dedus din funcția parse, deci tipul rezultatului e legat de o verificare reală. ProductList poate fi o schemă Zod (z.array(Product)) sau un type guard scris de mână.

Dacă proiectul nu poate valida tot, un compromis acceptabil: tipuri generate din specificația OpenAPI a backendului, astfel încât contractul să nu fie scris de mână, plus validare în locurile critice (plăți, autentificare). La interviu, important e să spui explicit unde e granița de încredere și cine o garantează.

Ce urmărește intervievatorul: Intervievatorul verifică dacă recunoști aserțiunile deghizate în cod foarte comun. Mulți candidați cred că getJson<T> „tipizează” răspunsul.

93 Mid

Scrie o componentă React generică Select<T> care primește o listă de opțiuni de orice tip, o funcție pentru etichetă și un onChange(value: T). Ce particularitate are sintaxa genericelor în fișierele .tsx?

Răspuns scurt: Declari componenta ca funcție generică: function Select<T>({ options, getLabel, onChange }: SelectProps<T>). TS deduce T din options la utilizare. Într-un .tsx, o arrow function generică se scrie <T,>(...) sau <T extends unknown>, ca parserul să nu creadă că <T> e un tag JSX.

TypeScript
type SelectProps<T> = {
  options: readonly T[];
  value: T | null;
  getLabel: (option: T) => string;
  getKey: (option: T) => string | number;
  onChange: (value: T) => void;
};

export function Select<T>({ options, value, getLabel, getKey, onChange }: SelectProps<T>) {
  return (
    <select
      value={value === null ? '' : String(getKey(value))}
      onChange={e => {
        const found = options.find(o => String(getKey(o)) === e.target.value);
        if (found !== undefined) onChange(found);
      }}
    >
      <option value="" disabled>Alege</option>
      {options.map(o => (
        <option key={getKey(o)} value={String(getKey(o))}>{getLabel(o)}</option>
      ))}
    </select>
  );
}

<Select
  options={cities}
  value={city}
  getLabel={c => c.name}
  getKey={c => c.id}
  onChange={c => setCity(c)}  // c are tipul City
/>;

Avantajul: componenta funcționează cu orice tip de opțiune, iar callback-urile primesc tipul exact, fără as și fără conversii manuale din string. TS deduce T din prop-ul options, apoi verifică celelalte props-uri față de el.

Particularitatea .tsx: const Select = <T>(props: SelectProps<T>) => ... e ambiguu pentru parser, care vede <T> ca început de element JSX. Variantele acceptate sunt <T,>(props) => ... sau <T extends unknown>(props) => .... Declarația cu function nu are această problemă.

Limite: React.memo și forwardRef (înainte de React 19) pierd parametrul generic. Soluția uzuală este o aserțiune pe rezultat: export const MemoSelect = memo(Select) as typeof Select.

Ce urmărește intervievatorul: Se verifică dacă poți aplica genericele în componente reutilizabile, frecvent cerute în echipe cu design system. Sintaxa <T,> e un detaliu pe care îl știu cei care au scris astfel de componente.

94 Senior

Implementează un event emitter tipizat în care emit('orderPaid', payload) acceptă doar payload-ul corect pentru fiecare eveniment, iar on primește callback-ul cu tipul potrivit.

Răspuns scurt: Definești o hartă de evenimente ({ orderPaid: { orderId: string; amount: number }; ... }) și folosești K extends keyof Events în on și emit, cu payload-ul Events[K]. Handler-ele le stochezi într-un mapped type indexat după cheie.

TypeScript
type Listener<P> = (payload: P) => void;

class TypedEmitter<Events extends Record<string, unknown>> {
  private listeners: { [K in keyof Events]?: Set<Listener<Events[K]>> } = {};

  on<K extends keyof Events>(event: K, cb: Listener<Events[K]>): () => void {
    const set = (this.listeners[event] ??= new Set<Listener<Events[K]>>());
    set.add(cb);
    return () => set.delete(cb); // funcție de dezabonare
  }

  emit<K extends keyof Events>(event: K, payload: Events[K]): void {
    this.listeners[event]?.forEach(cb => cb(payload));
  }
}

type ShopEvents = {
  orderPaid: { orderId: string; amount: number };
  cartCleared: undefined;
};

const bus = new TypedEmitter<ShopEvents>();
const off = bus.on('orderPaid', e => console.log(e.amount.toFixed(2)));
bus.emit('orderPaid', { orderId: 'o1', amount: 99 });
bus.emit('orderPaid', { orderId: 'o1' }); // eroare: lipsește amount
bus.emit('cartCleard', undefined);       // eroare: eveniment inexistent
off();

Puncte de discutat:

  • ShopEvents e declarat cu type, nu cu interface: o interfață nu are index signature implicit, deci nu satisface constrângerea Record<string, unknown>. Alternativa e constrângerea Events extends object sau { [K in keyof Events]: unknown };
  • returnarea funcției de dezabonare previne scurgerile de memorie, mai ales în componente React (useEffect cleanup);
  • pentru evenimente fără payload, poți face al doilea parametru opțional printr-un tuplu condițional: emit<K>(event: K, ...args: Events[K] extends undefined ? [] : [Events[K]]).

Același tipar stă la baza tipurilor addEventListener din DOM (WindowEventMap) și a librăriilor ca mitt. La nivel de arhitectură, e util de discutat când un bus de evenimente decuplează util module și când ascunde dependențele, făcând fluxul greu de urmărit.

Ce urmărește intervievatorul: Intervievatorul verifică combinarea genericelor, keyof și mapped types într-un tipar real. Capcana cu interface față de Record<string, unknown> arată experiență practică.

95 Junior

Cum tipizezi un handler Express pentru PUT /users/:id, astfel încât req.params, req.body și răspunsul să aibă tipuri corecte? Ce nu garantează aceste tipuri?

Răspuns scurt: Folosești parametrii generici ai lui Request sau RequestHandler: <Params, ResBody, ReqBody, Query>. req.params.id devine string, req.body primește tipul declarat, iar res.json acceptă doar forma răspunsului. Tipurile nu verifică însă la rulare ce trimite clientul.

Tipurile din @types/express au parametri generici pentru fiecare parte a cererii:

TypeScript
import type { RequestHandler } from 'express';

type Params = { id: string };
type UpdateUserBody = { name?: string; email?: string };
type UserDto = { id: string; name: string; email: string };
type ErrorDto = { error: string };

export const updateUser: RequestHandler<Params, UserDto | ErrorDto, UpdateUserBody> =
  async (req, res) => {
    const { id } = req.params;          // string
    const { name, email } = req.body;   // tipurile declarate
    const user = await users.update(id, { name, email });
    if (!user) {
      res.status(404).json({ error: 'Utilizator inexistent' });
      return;
    }
    res.json(user);                     // trebuie să fie UserDto
  };

app.put('/users/:id', updateUser);

Ordinea parametrilor generici: Params, ResBody, ReqBody, ReqQuery, Locals. Tipizarea lui ResBody verifică forma răspunsului, dar nu te protejează de câmpuri în plus: dacă trimiți entitatea din baza de date cu passwordHash, ea este structural tot un UserDto, iar compilatorul tace. De aceea maparea explicită spre DTO rămâne necesară.

Ce nu garantează: req.body e, la rulare, ce a trimis clientul. Tipul UpdateUserBody e doar o promisiune. Un email: 123 trece de compilare și ajunge în baza de date. Validarea se face la intrare, cu un middleware bazat pe schemă, din care derivezi și tipul, ca să nu le scrii de două ori. Și req.params.id e mereu string; dacă îl vrei număr, îl convertești și îl validezi.

Note de versiune: Express 5 tratează nativ promisiunile respinse din handler-e async; în Express 4 aveai nevoie de un wrapper care trimite eroarea la next.

Ce urmărește intervievatorul: Se verifică tipizarea practică a unui backend Node și înțelegerea granițelor de încredere. Răspunsul slab folosește req: any.

96 Junior

Într-un code review vezi că un coleg a rezolvat zece erori de compilare cu any și // @ts-ignore, ca să treacă build-ul înainte de demo. Cum reacționezi?

Răspuns scurt: Recunosc presiunea termenului și nu blochez demo-ul fără motiv, dar cer înlocuirea lui @ts-ignore cu @ts-expect-error plus comentariu și un tichet de remediere. Apoi analizăm împreună cauza erorilor, care e adesea un tip greșit într-un singur loc.

Un model de răspuns structurat:

Situația și obiectivul. Demo-ul e important, dar suprimarea erorilor ascunde bug-uri posibile și creează precedentul că erorile de tip sunt opționale.

Ce fac imediat.

  • citesc erorile suprimate: adesea zece erori au o singură cauză, de exemplu un tip de răspuns API greșit. Dacă e așa, propun o reparație de cinci minute;
  • pentru ce nu se poate repara acum, cer // @ts-expect-error în loc de // @ts-ignore. Diferența: @ts-expect-error dă el însuși eroare când nu mai există nicio eroare dedesubt, deci comentariul nu rămâne uitat după reparație. Fiecare are o explicație și un link spre tichet;
  • any înlocuit cu unknown acolo unde se poate, ca să nu se propage tăcut.

Cum comunic. În comentariile din PR, la obiect: „eroarea asta indică faptul că price poate fi null din API; dacă e adevărat, pagina de checkout crapă”. Explic riscul concret, nu regula abstractă. Evit tonul de reproș; colegul a ales sub presiune.

Ce schimb în proces.

  • regulile typescript-eslint ban-ts-comment (care permite doar @ts-expect-error cu descriere) și no-explicit-any ca avertisment;
  • un contor de suprimări vizibil în CI, ca tendința să nu crească;
  • discuție la retrospectivă: dacă erorile de tip apar mereu la final, poate verificarea nu rulează în editor sau CI suficient de devreme.

Rezultatul urmărit. Demo-ul are loc, datoria e documentată și programată, iar echipa are reguli care previn repetarea.

Ce urmărește intervievatorul: Se verifică echilibrul dintre pragmatism și calitate, plus comunicarea în echipă. Răspunsurile extreme („resping PR-ul” sau „e ok, e demo”) sunt slabe.

Eroarea, în practică:TS2578: Unused '@ts-expect-error' directive

97 Junior

Primești o eroare de tip de 25 de rânduri, cu tipuri imbricate, într-o componentă care folosește o librărie de formulare. Cum o descifrezi pas cu pas?

Răspuns scurt: Citesc ultimele rânduri, cele mai indentate, care conțin incompatibilitatea concretă (o proprietate, un tip). Apoi reduc problema: extrag valorile în variabile tipizate, verific tipurile prin hover și caut exact punctul unde forma diferă.

Model de abordare:

1. Înțeleg structura mesajului. Primul rând spune ce nu se potrivește la nivel înalt („Type X is not assignable to type Y”). Rândurile următoare, indentate progresiv, coboară prin structură: proprietate, apoi subproprietate, apoi parametrul unei funcții. Ultimul rând e de obicei cauza concretă, de exemplu „Type 'string | undefined' is not assignable to type 'string'” pentru proprietatea defaultValues.email.

2. Reduc zgomotul.

  • extrag argumentele complexe în variabile cu tip explicit sau cu satisfies: const defaults = {...} satisfies FormValues. Eroarea se mută într-un loc mai mic și mai clar;
  • verific prin hover tipul dedus al fiecărei variabile implicate. Adesea problema e o inferență neașteptată (un literal lărgit, un undefined venit dintr-un câmp opțional);
  • dacă e un generic, pasez argumentul de tip explicit, ca TS să compare cu ce cred eu, nu cu ce a dedus el.

3. Izolez. Dacă tot nu e clar, reproduc problema într-un fișier mic sau în TypeScript Playground, cu tipurile minime. Exercițiul arată de multe ori singur greșeala, iar dacă nu, am un exemplu bun pentru o întrebare în echipă sau la librărie.

4. Folosesc unelte. Extensia „Pretty TypeScript Errors” formatează mesajele în VS Code; „Go to Type Definition” arată semnătura reală a funcției din librărie.

5. Repar cauza, nu simptomul. Evit as any. Dacă tipurile librăriei sunt greșite, documentez și, eventual, deschid un issue.

La interviu, contează să arăți un proces calm și repetabil, nu ghicire.

Ce urmărește intervievatorul: Intervievatorul evaluează metoda de depanare, o abilitate zilnică în TypeScript. Candidații slabi spun că pun any când mesajul e prea lung.

98 Senior

Ai actualizat TypeScript la o versiune minoră nouă (de exemplu de la 5.4 la 5.6) și au apărut peste o sută de erori noi. Cum procedezi?

Răspuns scurt: Tratez upgrade-ul ca pe o schimbare separată: citesc secțiunea „Breaking changes” din notele de lansare, grupez erorile după cauză, repar categoriile mari cu schimbări mecanice și las excepții documentate doar pentru restul. Fixez versiunea exactă.

Model de răspuns:

Context. TypeScript nu urmează strict versionarea semantică: versiunile minore pot înăspri verificarea, modifica tipurile din lib (DOM, ES) sau inferența. Erorile noi sunt adesea bug-uri reale descoperite acum, nu regresii.

Pași:

  • izolare: upgrade-ul într-un branch dedicat, fără alte schimbări, ca să poată fi revizuit și, la nevoie, anulat;
  • documentare: citesc notele de lansare pentru fiecare versiune sărită (5.5, 5.6), în special secțiunile de breaking changes și opțiunile noi adăugate în strict;
  • grupare: rulez tsc --noEmit și grupez erorile după cod (TS2322, TS2345 etc.) și după fișier. De obicei, două-trei cauze produc majoritatea erorilor, de exemplu o schimbare în tipurile DOM sau o inferență mai precisă la filter;
  • reparații: încep cu categoriile mari și mecanice. Unele sunt chiar simplificări (cod defensiv care nu mai e necesar). Pentru dependențe, verific dacă există versiuni ale librăriilor compatibile cu noul TypeScript;
  • restul: dacă câteva erori nu pot fi reparate rapid, folosesc @ts-expect-error cu tichet, nu dezactivez opțiuni la nivel de proiect;
  • validare: rulez testele și verific build-ul, pentru că unele schimbări (de exemplu în emitere sau rezolvarea modulelor) au efect la rulare.

Prevenție. Fixez versiunea exactă sau cu ~ în package.json, actualizez regulat (versiuni mici, des, în loc de salturi mari) și, pentru proiecte critice, pot rula periodic verificarea și pe versiunea următoare, aflată în beta.

Comunicare. Anunț echipa înainte de merge, pentru că branch-urile deschise vor avea și ele erori noi după rebase.

Ce urmărește intervievatorul: Se verifică maturitatea în întreținerea proiectelor și cunoașterea politicii de versiuni a TypeScript. Răspunsul slab: „revin la versiunea veche”.

99 Senior

La code review găsești const user = data as unknown as User; într-un serviciu care procesează mesaje dintr-o coadă. Autorul spune că „altfel nu compila”. Ce faci?

Răspuns scurt: Explic că dubla aserțiune dezactivează complet verificarea și e un semnal că tipurile nu se potrivesc cu realitatea. Propun validarea mesajului la intrare, cu o schemă sau un type guard, și tratarea explicită a mesajelor invalide (log, coadă de erori).

Model de răspuns structurat:

De ce e o problemă. as User simplu ar fi fost refuzat, pentru că tipurile nu se suprapun deloc. as unknown as User trece pentru că orice tip poate deveni unknown și unknown poate deveni orice. E echivalentul lui „oprește verificarea aici”. Într-un consumator de coadă, datele vin de la alt serviciu, poate altă versiune, poate un mesaj vechi reîncercat. Dacă forma diferă, eroarea apare departe, de exemplu la scrierea în baza de date, cu date corupte.

Cum discut cu autorul. Întreb întâi ce eroare primea; uneori e o problemă reală de tip, cum ar fi un câmp numit diferit, care trebuie corectată, nu ascunsă. Explic riscul în termenii sistemului nostru, nu ca regulă de stil.

Ce propun:

TypeScript
const OrderMessage = z.object({ orderId: z.string(), total: z.number().nonnegative() });
type OrderMessage = z.infer<typeof OrderMessage>;

function handle(raw: unknown) {
  const parsed = OrderMessage.safeParse(raw);
  if (!parsed.success) {
    logger.warn({ issues: parsed.error.issues }, 'mesaj invalid');
    return deadLetter(raw);
  }
  process(parsed.data); // tip garantat
}
  • tipul e derivat din schemă, deci nu se pot desincroniza;
  • mesajele invalide sunt vizibile și nu blochează coada;
  • contractul dintre servicii poate fi partajat într-un pachet comun.

Regula de echipă. Dubla aserțiune doar în teste sau în adaptoare documentate, cu comentariu care explică de ce e sigură. Pot propune o regulă de lint pentru a o semnala automat.

Rezultatul: o problemă de review transformată într-o îmbunătățire a robusteții, explicată, nu impusă.

Ce urmărește intervievatorul: Intervievatorul evaluează judecata tehnică și felul în care dai feedback. Contează să propui o alternativă concretă, nu doar să interzici.

Eroarea, în practică:TS2352: Conversion of type may be a mistake

100 Mid

Un coleg nou, cu experiență bună în JavaScript, spune că TypeScript îl încetinește și că „se luptă cu compilatorul” toată ziua. Cum îl ajuți?

Răspuns scurt: Îl ascult ca să aflu unde apare frecarea concretă, apoi îi arăt tiparele care elimină majoritatea problemelor (inferență, union-uri cu narrowing, tipuri la granițe), lucrăm împreună pe codul lui și ajustăm convențiile echipei dacă sunt inutil de complicate.

Model de răspuns structurat:

1. Înțeleg problema concretă. „Mă lupt cu compilatorul” poate însemna lucruri diferite: adnotează prea mult, nu înțelege mesajele de eroare, folosește tipuri prea largi și apoi face aserțiuni, sau lucrează pe o parte de cod cu tipuri excesiv de „inteligente”. Îi cer două-trei exemple din ultima săptămână.

2. Arăt tiparele cu impact mare:

  • lasă inferența să lucreze și adnotează doar la granițe (parametri, valori returnate publice);
  • modelează datele cu union-uri discriminate și folosește narrowing, în loc de as;
  • unknown la intrare plus validare, ca restul codului să fie simplu;
  • citirea mesajelor de eroare de la ultimul rând în sus, plus hover pe variabile.

3. Pair programming pe codul lui. O oră pe un task real e mai utilă decât documentația. Îi arăt cum eroarea de tip semnalează un caz netratat, de exemplu un undefined care ar fi ajuns în producție. Câștigul devine concret.

4. Verific și partea echipei. Dacă tipurile din proiect sunt greu de folosit (generice pe cinci niveluri, utilitare nedocumentate), problema nu e doar a lui. Propun simplificări sau documentarea tiparelor comune.

5. Urmăresc progresul. Revin peste o săptămână-două; de obicei, frecarea scade mult după ce tiparele de bază devin reflex.

Mesajul de fond pentru coleg: TypeScript mută o parte din depanare de la rulare la editare. Costul e la început, câștigul apare la refactorizări și la codul scris de alții.

Ce urmărește intervievatorul: Se verifică empatia, mentoratul și capacitatea de a explica valoarea tipurilor fără dogmatism. Răspunsul slab: „trebuie să se obișnuiască”.

Î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 TypeScript, de la junior la mid, iar pe JoburiIT.ro îți poți certifica apoi cunoștințele.

Învață TypeScript scriind cod, nu doar citind

Curs TypeScript: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.