Formations — 1 037 leçons en français

Accueil › TypeScript › Objets, interfaces et alias

Objets, interfaces et alias — entretien TypeScript

12 questions posées en entretien sur 6 sujets, avec la bonne réponse et son explication.

Typage structurel

Sur quoi TypeScript décide-t-il que deux types sont compatibles ?

  1. Sur leur forme : les membres présents et leurs types ✓
  2. Sur leur nom de déclaration
  3. Sur leur appartenance au même fichier
  4. Sur une clause « implements » explicite

Pourquoi : TypeScript est structurel : il compare les membres, jamais l'identité de la déclaration. Une bonne réponse en entretien ajoute la conséquence — « implements » existe mais ne sert qu'à vérifier une classe là où elle est écrite, et le retirer ne change rien à sa compatibilité. C'est l'écart le plus marquant avec Java et C#, qui sont nominaux.

Niveau junior

Pourquoi le premier appel passe-t-il et le second échoue-t-il ?

interface Options { largeur: number }
function dessiner(o: Options) {}

const config = { largeur: 10, hauteur: 20 };
dessiner(config);
dessiner({ largeur: 10, hauteur: 20 });
  1. La vérification des propriétés excédentaires ne porte que sur les littéraux écrits sur place ✓
  2. « config » est un « const », donc exempté de vérification
  3. Le premier appel est en fait une erreur elle aussi
  4. L'ordre des propriétés diffère entre les deux appels

Pourquoi : Structurellement, un objet qui a plus que le nécessaire reste utilisable : le type de « config » satisfait « Options », l'appel est légitime. La vérification des propriétés excédentaires est une exception ajoutée pour attraper les fautes de frappe dans un littéral frais, dont personne d'autre ne détient la référence. Elle disparaît par variable, par « as », ou si le type cible a une signature d'index.

Niveau confirme

interface ou type

Quel besoin ne peut pas être satisfait par « interface » ?

  1. Nommer une union de chaînes littérales ✓
  2. Décrire un objet avec des méthodes
  3. Hériter de plusieurs formes
  4. Décrire la forme attendue d'une classe

Pourquoi : Une interface décrit la forme d'un objet ou d'une fonction, jamais une union, un tuple ou une primitive — il n'y a pas de syntaxe pour cela. Les trois autres besoins sont couverts par les deux outils. La convention courante est donc « interface pour les formes d'objets, type pour tout le reste », et non une préférence de style.

Niveau junior

Que se passe-t-il si deux « interface Client » sont déclarées dans la même portée ?

  1. Elles fusionnent en une seule interface réunissant leurs membres ✓
  2. La seconde déclaration écrase la première
  3. Le compilateur signale un identifiant dupliqué
  4. La seconde est ignorée

Pourquoi : La fusion de déclarations est propre aux interfaces, et c'est elle qui permet d'enrichir le type d'une bibliothèque sans le modifier. Dans son propre code, elle transforme un doublon accidentel en type silencieusement enrichi, là où deux « type Client » auraient produit une erreur de duplication. C'est l'argument le plus souvent avancé en faveur de « type » pour le code applicatif.

Niveau confirme

Propriétés optionnelles

Quel est le type de « email » dans « interface C { email?: string } » sous strict ?

  1. string | undefined ✓
  2. string, avec une vérification générée à l'exécution
  3. string | null
  4. unknown

Pourquoi : Le point d'interrogation rend la clé facultative et ajoute « undefined » au type. C'est pourquoi « c.email.trim() » échoue avec « 'c.email' is possibly 'undefined' » (TS18048). Une erreur classique est d'attendre « null » : une propriété optionnelle absente vaut « undefined », et les deux valeurs ne se testent pas de la même façon.

Niveau junior

Qu'apporte l'option « exactOptionalPropertyTypes » ?

  1. Elle distingue une clé absente d'une clé présente valant undefined ✓
  2. Elle rend toutes les propriétés optionnelles requises
  3. Elle interdit les propriétés optionnelles
  4. Elle vérifie les propriétés optionnelles à l'exécution

Pourquoi : Sans elle, « { surnom: undefined } » et « {} » satisfont tous deux « { surnom?: string } », alors qu'ils se comportent différemment avec « in », « Object.keys » et « JSON.stringify ». La distinction compte pour une API de mise à jour partielle, où une clé présente à « undefined » signifie souvent « effacer ce champ ». L'option n'est pas incluse dans « strict » : elle s'active séparément.

Niveau confirme

readonly

Que devient un modificateur « readonly » après compilation ?

  1. Il disparaît : aucune protection ne subsiste à l'exécution ✓
  2. Il devient un accesseur sans setter
  3. Il devient un appel à Object.freeze
  4. Il devient une propriété non énumérable

Pourquoi : « readonly » appartient au système de types, et le système de types est effacé. Le JavaScript produit contient une propriété ordinaire. La conséquence pratique à citer en entretien : un « as » ou un passage par un type plus large suffit à écrire dans la propriété, et seul « Object.freeze » — du vrai code — protège réellement l'objet.

Niveau junior

Qu'affiche ce code, compilé puis exécuté ?

interface Reglage { readonly cles: string[] }

const r: Reglage = { cles: ["a"] };
r.cles.push("b");
console.log(r.cles.length);
  1. 2 : « readonly » interdit la réaffectation, pas la mutation du tableau ✓
  2. Rien : le compilateur refuse le push
  3. 1 : le push est sans effet
  4. Une TypeError à l'exécution

Pourquoi : « readonly » protège la liaison entre la clé et la valeur, exactement comme « const » sur une variable. Pour interdire le push au niveau du type, il faut « readonly cles: readonly string[] », qui retire les méthodes mutantes de l'interface du tableau. La distinction entre les deux « readonly » de cette déclaration est une question d'entretien fréquente.

Niveau confirme

Record

À quoi équivaut « Record<string, number> » ?

  1. À une signature d'index « [cle: string]: number » ✓
  2. À un objet sans aucune propriété
  3. À une Map<string, number>
  4. À un tableau de nombres

Pourquoi : « Record<string, V> » est l'écriture courte d'une signature d'index : tout nom de clé est permis, et la valeur vaut V. La différence avec « Map » est réelle et souvent demandée — « Map » accepte des clés non chaînes, expose « size », ne heurte aucune clé héritée, et son « get » renvoie « V | undefined » sans option à activer.

Niveau junior

Que produit « Record<"fr" | "en", string> » ?

  1. { fr: string; en: string } — les deux clés sont requises ✓
  2. Un objet dont les deux clés sont optionnelles
  3. Un objet acceptant n'importe quelle clé chaîne
  4. Une union de deux objets à une clé

Pourquoi : Avec une union de clés littérales, « Record » produit des propriétés requises : la clé oubliée et la clé en trop sont toutes deux signalées. L'intérêt se révèle lors d'une évolution — ajouter « es » à l'union fait désigner par le compilateur tous les dictionnaires à compléter. Pour des clés fermées mais facultatives, c'est « Partial<Record<…>> ».

Niveau confirme

Signatures d'index

Qu'affiche ce code, compilé puis exécuté, sans option supplémentaire ?

const stock: Record<string, number> = { pommes: 3 };
const n = stock["poires"];
console.log(n + 1);
  1. NaN, et le compilateur ne signale rien ✓
  2. Rien : le compilateur refuse l'accès à une clé absente
  3. 1
  4. Rien : TypeError à l'exécution

Pourquoi : L'accès indexé est typé comme si la clé existait toujours : « n » est « number » pour le compilateur et « undefined » à l'exécution. Le « NaN » se propage ensuite dans un total, loin de son origine, sans jamais lever d'erreur. « noUncheckedIndexedAccess » type l'accès « number | undefined » et impose une garde ; elle s'applique aussi à « tab[0] », qui est tout aussi mensonger sur un tableau vide.

Niveau senior

Quel est le coût réel d'ajouter « [cle: string]: unknown » à une interface ?

  1. Toute faute de frappe sur cet objet devient une clé valide ✓
  2. Les propriétés déclarées deviennent optionnelles
  3. L'interface ne peut plus être étendue
  4. Les clés inconnues lèvent une erreur à l'exécution

Pourquoi : La signature d'index déclare que toute clé est permise : « o.coleur » ne produit plus « Property 'coleur' does not exist », et la vérification des propriétés excédentaires sur un littéral n'a plus rien à signaler. C'est pour cela qu'on ne l'ajoute pas pour faire taire une erreur. Autre contrainte liée : chaque propriété déclarée doit être assignable au type de la signature d'index du même objet.

Niveau senior

S'entraîner sur ces questions, chronométré →