Domande e risposte per colloqui su TypeScript (2026): tipi, generici e narrowing

I colloqui su TypeScript verificano se capisci il sistema di tipi, al di là della sintassi. Qui sotto trovi 20 domande con risposte, dalle basi a quelle che distinguono chi usa TypeScript da chi sa perché funziona. Il codice è stato compilato con il compilatore TypeScript in modalità strict prima della pubblicazione, e i messaggi di errore citati sono quelli reali.

Le basi

1. Cosa aggiunge TypeScript a JavaScript?

Un sistema di tipi statico che viene controllato in fase di compilazione e poi rimosso. L'output è JavaScript puro, quindi i tipi non hanno alcun costo né presenza a runtime. Quest'ultimo punto è importante: non puoi verificare un tipo con typeof a runtime, a meno che non scriva tu stesso il controllo.

2. Qual è la differenza tra type e interface?

Entrambi descrivono la forma di un oggetto e spesso sono intercambiabili. Le differenze pratiche:

Dichiarare interface A due volte fonde i campi. Dichiarare type B due volte produce error TS2300: Duplicate identifier 'B'. Una regola pratica comune: usa interface per le forme di oggetti pubblici che altri potrebbero estendere, e type per tutto il resto.

3. Qual è la differenza tra any, unknown e never?

• any disattiva i controlli. Tutto è permesso e gli errori si nascondono.
• unknown è la versione sicura. Puoi assegnargli qualsiasi cosa, ma devi restringerlo prima di usarlo. Chiamare x.toFixed() su un unknown fallisce con error TS18046: 'x' is of type 'unknown'.
• never è il tipo dei valori che non possono esistere, come una funzione che lancia sempre un'eccezione. È utile per i controlli di esaustività.

Preferisci unknown a any per i valori di cui non controlli il tipo, come il JSON analizzato.

4. Cosa fa la modalità strict?

Attiva un gruppo di controlli, tra cui i più importanti strictNullChecks (così null e undefined sono tipi separati) e noImplicitAny. Con essa attiva, usare un valore opzionale senza controllarlo dà error TS18048: 'x' is possibly 'undefined'. I nuovi progetti dovrebbero partire con strict attivo.

5. Qual è la differenza tra readonly e const?

const impedisce che una variabile venga riassegnata. readonly impedisce che una proprietà venga assegnata. Scrivere su una proprietà readonly dà error TS2540: Cannot assign to 'n' because it is a read-only property. Nessuno dei due rende l'oggetto sottostante profondamente immutabile.

I tipi nella pratica

6. Cosa sono i tipi unione e come si restringono?

Un'unione significa "uno di questi tipi". Il restringimento usa controlli che il compilatore comprende:

type Id = number | string;
function describe(id: Id): string {
  if (typeof id === "string") return id.toUpperCase();
  return id.toFixed(1);
}

Dentro l'if, id è una string. Dopo, il compilatore sa che è un number. Altri strumenti di restringimento sono instanceof, l'operatore in, i controlli di uguaglianza e le type guard personalizzate.

7. Cos'è un'unione discriminata?

Un'unione in cui ogni membro ha un campo letterale condiviso, il discriminante, che li distingue:

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "sq"; s: number };

function assertNever(x: never): never {
  throw new Error("unexpected " + x);
}

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "sq": return s.s ** 2;
    default: return assertNever(s);
  }
}

Se in seguito aggiungi una nuova forma e dimentichi un case, il ramo default smette di compilare, perché s non è più never. Questo è un controllo di esaustività.

8. Cosa sono i generici e perché usarli?

Permettono a una funzione o a un tipo di funzionare con molti tipi mantenendo la relazione tra loro:

function first<T>(xs: T[]): T | undefined { return xs[0]; }
function pick<T, K extends keyof T>(o: T, k: K): T[K] { return o[k]; }

first([1, 2]) restituisce number | undefined, non any. pick(user, "name") restituisce il tipo di name. Il vincolo extends keyof T ti impedisce di passare una chiave che non esiste.

9. Quali sono i tipi di utilità più comuni?

10. Cosa sono i tipi mapped?

Costruiscono un nuovo tipo iterando sulle chiavi di un altro. Partial stesso è scritto come { [K in keyof T]?: T[K] }. Saperlo dimostra che capisci i tipi di utilità invece di impararli a memoria.

11. Cos'è as const?

Dice al compilatore di inferire il tipo più stretto e di marcare tutto come readonly. const arr = [1, 2, 3] as const ha il tipo readonly [1, 2, 3], e arr.push(4) fallisce con error TS2339: Property 'push' does not exist on type 'readonly [1, 2, 3]'. È utile per gli elenchi di valori ammessi e per gli oggetti di configurazione.

12. Cos'è un'asserzione di tipo e quando è pericolosa?

value as Type dice al compilatore di fidarsi di te. Non esegue alcun controllo a runtime. Se sbagli, l'errore si manifesta più tardi come un crash. Preferisci restringere con un controllo, o una funzione di type guard, piuttosto che asserire.

Comportamento del linguaggio

13. Qual è la differenza tra null e undefined?

undefined indica che un valore non è mai stato assegnato, mentre null significa "nessun valore" impostato di proposito. Con strictNullChecks, sono tipi separati. Usa l'optional chaining (a?.b) e il nullish coalescing (a ?? b) per gestirli. A differenza di ||, ?? applica il fallback solo per null e undefined, quindi 0 e la stringa vuota vengono mantenuti.

14. Cos'è la non-null assertion !?

value! dice al compilatore che un valore non è null né undefined. Come as, non è verificata. Va bene in qualche caso in cui sai più tu del compilatore, ma di solito un controllo a runtime è più sicuro.

15. Cosa fa keyof, e cos'è typeof in posizione di tipo?

keyof T produce l'unione dei nomi delle proprietà di T. In posizione di tipo, typeof x prende il tipo di un valore, evitando di ripeterlo. Insieme, keyof typeof obj restituisce le chiavi di un oggetto che hai definito come valore.

16. Come si confrontano gli enum con i tipi union?

Gli enum creano un oggetto a runtime e dei valori. Un'unione di string literal, come "idle" | "loading", viene cancellata in fase di compilazione e non richiede codice extra. Molti team preferiscono le union di string literal per semplicità e usano gli enum quando serve l'oggetto a runtime.

Tooling e progetti reali

17. A cosa serve tsconfig.json, e quali opzioni contano?

Indica al compilatore quali file includere e come verificarli. Le opzioni su cui ti chiedono di più: strict, target (la versione di JavaScript da generare), module e moduleResolution, noEmit (solo controllo, comune quando a compilare è un altro strumento), esModuleInterop e skipLibCheck.

18. Come tipizzi qualcosa che arriva dall'esterno, come la risposta di un'API?

I tipi svaniscono a runtime, quindi il compilatore non può verificare cosa restituisce la rete. Tratta i dati come unknown, poi validali con una libreria di schema o una type guard scritta a mano prima di usarli. Asserire un tipo su un JSON parsato nasconde i bug.

19. Come migri un progetto JavaScript a TypeScript?

Falllo in modo graduale. Aggiungi un tsconfig.json con allowJs, rinomina i file uno alla volta, attiva le opzioni più severe nel tempo e aggiungi i tipi prima ai confini, come i client API e le utility condivise. Evita una riscrittura big-bang.

20. Cos'è il typing strutturale?

TypeScript confronta i tipi per forma, non per nome. Se un oggetto ha i campi richiesti da un tipo, viene accettato, anche se non è mai stato dichiarato come quel tipo. È diverso dai linguaggi che usano il typing nominale, dove conta il nome dichiarato.

Come prepararti

1. Apri un playground o un piccolo progetto in strict mode e prova ciascun esempio qui sopra, compresi quelli che dovrebbero fallire.
2. Sii pronto a scrivere a memoria una funzione generica e una discriminated union.
3. Sappi perché sceglieresti unknown invece di any.
4. Preparati un aneddoto su quando hai tipizzato qualcosa di scomodo in un progetto reale.

Per esercitarti su argomenti correlati, dai un'occhiata alle nostre guide sulle domande di colloquio su Node.js, sulle domande di colloquio su Angular e sulle domande di colloquio su Python.

Esercitati ad alta voce e con parole tue. Una trascrizione successiva ti mostra dove hai divagato o saltato il punto. Segui le regole del datore di lavoro sugli strumenti di IA in qualsiasi colloquio o valutazione dal vivo.