Comment réussir un entretien TypeScript : les meilleures questions de A à Z

Introduction : pourquoi TypeScript est un must-have pour le développeur moderne

TypeScript s'est solidement imposé comme le standard de facto dans le développement enterprise. Selon les enquêtes Stack Overflow, plus de 70% des développeurs frontend utilisent ou prévoient d'utiliser TypeScript. Lors des entretiens, les questions sur cette technologie sont incontournables — même si le poste est officiellement intitulé "JavaScript Developer".

Dans cet article, nous aborderons les sujets clés qu'on vous posera obligatoirement lors d'un entretien technique : des types de base aux generics complexes et aux types conditionnels. Le contenu est structuré du plus simple au plus complexe, pour vous permettre de vous préparer de manière systématique.

1. Les bases : types, interfaces et leurs différences

1.1. Types primitifs et spéciaux

Commençons par les fondamentaux. L'intervieweur vous posera presque certainement des questions sur any, unknown, never et void.

\n
• any — désactive la vérification des types. À utiliser uniquement en dernier recours lors d'une migration.
\n
• unknown — alternative sûre à any. Nécessite une vérification de type avant utilisation.
\n
• never — type qui ne se produit jamais (fonctions lançant des exceptions ou boucles infinies).
\n
• void — absence de valeur de retour pour une fonction.
\n

function throwError(msg: string): never {\n    throw new Error(msg);\n}\n\nfunction log(msg: string): void {\n    console.log(msg);\n}\n\nlet data: unknown = JSON.parse('{"name":"John"}');\n// data.name // Erreur ! Une vérification est nécessaire\nif (typeof data === 'object' && data !== null) {\n    console.log((data as Record<string, unknown>).name);\n}

1.2. Interface vs Type : que choisir ?

C'est une question classique. Les deux approches permettent de décrire la structure d'un objet, mais il y a des nuances :

\n
• Interface — extensible (extends), peut être fusionnée (declaration merging).
\n
• Type — peut décrire des types union, intersection, des primitifs. Ne permet pas le declaration merging.
\n

// Interface - extension\ninterface User {\n    name: string;\n}\ninterface User {\n    age: number; // declaration merging\n}\nconst user: User = { name: 'Alice', age: 30 };\n\n// Type - union\ntype Status = 'active' | 'inactive';\ntype UserOrStatus = User | Status;

Conseil : Pour les objets et les classes, utilisez interface ; pour les compositions complexes, utilisez type.

2. Generics et types utilitaires

2.1. Generics : programmation générique

Aucun entretien sérieux ne se passe sans generics. Savoir écrire un type qui s'adapte à l'argument passé est un signe de maturité chez un développeur.

// Generic simple\nfunction identity<T>(arg: T): T {\n    return arg;\n}\n\n// Contrainte de generic\nfunction getLength<T extends { length: number }>(arg: T): number {\n    return arg.length;\n}\n\n// Generic pour tableau\nfunction last<T>(arr: T[]): T | undefined {\n    return arr[arr.length - 1];\n}

On demande souvent infer — le mot-clé pour déduire les types dans les constructions conditionnelles :

// Extraction du type d'élément d'une Promise\ntype Unwrap<T> = T extends Promise<infer U> ? U : T;\ntype Result = Unwrap<Promise<number>>; // number

2.2. Types utilitaires (Utility Types)

La connaissance des utilitaires intégrés est un minimum obligatoire. L'intervieweur peut vous demander d'implémenter un équivalent manuellement.

\n
• Partial<T> — tous les champs deviennent optionnels.
\n
• Required<T> — tous les champs deviennent obligatoires.
\n
• Pick<T, K> — sélectionne uniquement les clés spécifiées.
\n
• Omit<T, K> — exclut les clés spécifiées.
\n