Entretien TypeScript Débutant — Types et Interfaces

Q: Qu'est-ce que TypeScript ?

Bonne réponse : Un sur-ensemble typé de JavaScript qui se compile en JavaScript pur. TypeScript est un sur-ensemble typé de JavaScript développé par Microsoft. Il ajoute des fonctionnalités comme le typage statique, les classes, les interfaces, et les génériques, et se compile en JavaScript standard.

Q: Comment installe-t-on TypeScript globalement via npm ?

Bonne réponse : npm install -g typescript. La commande npm install -g typescript installe TypeScript globalement sur votre système. Le flag -g signifie "global". Une fois installé, la commande tsc (TypeScript Compiler) est disponible.

Q: Quelle commande permet de compiler un fichier TypeScript en JavaScript ?

Bonne réponse : tsc monfichier.ts. La commande tsc monfichier.ts (TypeScript Compiler) compile le fichier TypeScript et génère un fichier JavaScript du même nom (monfichier.js).

Q: Quel est le rôle du fichier tsconfig.json ?

Bonne réponse : Configurer les options du compilateur TypeScript pour un projet. Le fichier tsconfig.json est le fichier de configuration principal de TypeScript. Il permet de définir les options du compilateur (target, module, strict, etc.), les fichiers à inclure/exclure, et les chemins de résolution.

Q: Comment déclare-t-on une variable de type string en TypeScript ?

Bonne réponse : let nom: string = "Jean";. En TypeScript, on utilise la syntaxe let nom: string = "Jean"; où : string est l'annotation de type. TypeScript peut aussi inférer le type automatiquement si on omet l'annotation.

Q: Quels sont les types primitifs de base en TypeScript ?

Bonne réponse : string, number, boolean, null, undefined, symbol, bigint. TypeScript supporte les mêmes types primitifs que JavaScript : string, number, boolean, null, undefined, symbol (ES6), et bigint (ES2020).

Q: Comment déclarer un tableau de nombres en TypeScript ?

Bonne réponse : Les deux syntaxes sont correctes. Les deux syntaxes sont valides : type[] (forme courte) et Array<type> (forme générique). Exemple : let nombres: number[] = [1, 2, 3]; ou let nombres: Array<number> = [1, 2, 3];.

Q: Qu'est-ce que le type any en TypeScript ?

Bonne réponse : Un type qui désactive la vérification de type pour une variable. Le type any est un type "échappatoire" qui désactive complètement la vérification de type. Une variable de type any peut recevoir n'importe quelle valeur et appeler n'importe quelle méthode sans erreur de compilation.

Q: Quelle est la différence entre let et const en TypeScript ?

Bonne réponse : let permet la réassignation, const ne le permet pas. let déclare une variable qui peut être réassignée. const déclare une constante : la variable ne peut pas être réassignée après sa déclaration. Cependant, pour les objets, les propriétés internes d'un const peuvent être modifiées.

Q: Comment définir une fonction avec des paramètres typés en TypeScript ?

Bonne réponse : Les deux réponses A et C sont correctes. On peut typer les paramètres (a: number) et optionnellement le retour (: number). Si le type de retour est omis, TypeScript l'infère automatiquement. Les deux syntaxes sont correctes, mais typer explicitement le retour est une bonne pratique.

Typescript Debutant Quiz-Typescript-Debutant Typescript-Types Typescript-Interfaces Union-Types Questions-Entretien-Typescript Qcm-Typescript Apprendre-Typescript Type-Inference Ts-Fondamentaux Front-End Back-End Javascript-Typage

Débutant 🔀 Mixte 20 questions ⏱ 15 min

📝

Entretien TypeScript Débutant — Types et Interfaces

20 questions sur les bases de TypeScript : types primitifs, interfaces, unions, types littéraux, fonctions typées et inférence de type. Idéal pour préparer un premier entretien TypeScript.

20 questions ⏱ ~15 min Niveau Débutant

Publié/Développé par Mezgani Said

Développeur web full‑stack et formateur spécialisé en Angular, TypeScript et Node.js, il partage sur AngularForAll des ressources complètes pour les développeurs : tutoriels pratiques, guides pas‑à‑pas, outils gratuits, exercices, QCM techniques et retours d’expérience issus de projets réels (SaaS, micro‑frontends, architectures modulaires, applications d’entreprise).
Le site couvre l’ensemble de l’écosystème web : front‑end, intégration HTML/CSS, Composants réutilisables, SEO, back‑end, cloud, IA, CLI, productivité, bien‑être, outils web et métiers du digital.
Un espace pensé pour générer, apprendre, progresser et développer des projets modernes avec des bonnes pratiques professionnelles.

Banque de révision : les 30 questions corrigées

Voici l'intégralité des 30 questions de « Entretien TypeScript Débutant — Types et Interfaces », chacune avec sa bonne réponse et son explication. Le quiz interactif ci-dessus en tire une sélection aléatoire à chaque tentative — utilisez cette liste complète pour réviser.

Un sur-ensemble typé de JavaScript qui se compile en JavaScript pur (bonne réponse)
Un nouveau langage complètement différent de JavaScript
Une bibliothèque JavaScript pour la manipulation du DOM
Un framework front-end comme Angular

Explication : TypeScript est un sur-ensemble typé de JavaScript développé par Microsoft. Il ajoute des fonctionnalités comme le typage statique, les classes, les interfaces, et les génériques, et se compile en JavaScript standard.

Tout code JavaScript valide est aussi du code TypeScript valide. TypeScript ajoute des fonctionnalités sans casser la compatibilité.

npm install -g typescript (bonne réponse)
npm install typescript
npm install -g ts
npm install --save typescript

Explication : La commande npm install -g typescript installe TypeScript globalement sur votre système. Le flag -g signifie "global". Une fois installé, la commande tsc (TypeScript Compiler) est disponible.

Pour vérifier l'installation : tsc --version. Pour un projet local, utilisez npm install --save-dev typescript.

tsc monfichier.ts (bonne réponse)
ts compile monfichier.ts
typescript monfichier.ts
node monfichier.ts

Explication : La commande tsc monfichier.ts (TypeScript Compiler) compile le fichier TypeScript et génère un fichier JavaScript du même nom (monfichier.js).

Utilisez tsc --watch monfichier.ts pour compiler automatiquement à chaque modification.

Configurer les options du compilateur TypeScript pour un projet (bonne réponse)
Définir les dépendances du projet
Configurer le serveur de développement
Stocker les variables d'environnement

Explication : Le fichier tsconfig.json est le fichier de configuration principal de TypeScript. Il permet de définir les options du compilateur (target, module, strict, etc.), les fichiers à inclure/exclure, et les chemins de résolution.

Générez un tsconfig.json par défaut avec tsc --init.

let nom: string = "Jean"; (bonne réponse)
let nom = "Jean";
string nom = "Jean";
let nom: String = "Jean";

Explication : En TypeScript, on utilise la syntaxe let nom: string = "Jean"; où : string est l'annotation de type. TypeScript peut aussi inférer le type automatiquement si on omet l'annotation.

TypeScript distingue string (type primitif) de String (objet wrapper). Utilisez toujours string en minuscule.

string, number, boolean, null, undefined, symbol, bigint (bonne réponse)
String, Number, Boolean, Object
str, int, bool, float
text, integer, boolean, void

Explication : TypeScript supporte les mêmes types primitifs que JavaScript : string, number, boolean, null, undefined, symbol (ES6), et bigint (ES2020).

En TypeScript, number couvre à la fois les entiers et les nombres à virgule flottante.

let nombres: number[] = [1, 2, 3];
let nombres: Array = [1, 2, 3];
Les deux syntaxes sont correctes (bonne réponse)
let nombres: [number] = [1, 2, 3];

Explication : Les deux syntaxes sont valides : type[] (forme courte) et Array<type> (forme générique). Exemple : let nombres: number[] = [1, 2, 3]; ou let nombres: Array<number> = [1, 2, 3];.

La syntaxe type[] est plus courante et plus lisible pour les débutants.

Un type qui désactive la vérification de type pour une variable (bonne réponse)
Un type qui représente n'importe quel nombre
Un type qui signifie "aucune valeur"
Un type réservé aux objets

Explication : Le type any est un type "échappatoire" qui désactive complètement la vérification de type. Une variable de type any peut recevoir n'importe quelle valeur et appeler n'importe quelle méthode sans erreur de compilation.

Évitez any autant que possible. Utilisez unknown si vous ne connaissez pas le type à l'avance.

let permet la réassignation, const ne le permet pas (bonne réponse)
const est pour les constantes numériques uniquement
let est plus rapide que const
Il n'y a pas de différence

Explication : let déclare une variable qui peut être réassignée. const déclare une constante : la variable ne peut pas être réassignée après sa déclaration. Cependant, pour les objets, les propriétés internes d'un const peuvent être modifiées.

Privilégiez const par défaut, et utilisez let uniquement quand vous avez besoin de réassigner la variable.

function addition(a: number, b: number): number { return a + b; }
function addition(a, b) { return a + b; }
function addition(a: number, b: number) { return a + b; }
Les deux réponses A et C sont correctes (bonne réponse)

Explication : On peut typer les paramètres (a: number) et optionnellement le retour (: number). Si le type de retour est omis, TypeScript l'infère automatiquement. Les deux syntaxes sont correctes, mais typer explicitement le retour est une bonne pratique.

Pour les fonctions qui ne retournent rien, utilisez le type void : function log(message: string): void { console.log(message); }.

La capacité de TypeScript à deviner automatiquement le type d'une variable (bonne réponse)
Une fonction qui déduit des valeurs
Un type spécial pour les calculs
Une erreur de compilation

Explication : L'inférence de type est la capacité de TypeScript à déterminer automatiquement le type d'une variable en fonction de sa valeur initiale. Par exemple, let nom = "Jean"; est automatiquement typé comme string sans annotation explicite.

L'inférence fonctionne bien pour les cas simples. Pour les fonctions complexes, les annotations explicites sont recommandées.

function saluer(nom?: string): void { } (bonne réponse)
function saluer(nom = null): void { }
function saluer(nom? string): void { }
function saluer(optional nom: string): void { }

Explication : Un paramètre optionnel se déclare avec un ? après le nom du paramètre : nom?: string. Les paramètres optionnels doivent toujours venir après les paramètres obligatoires.

Vous pouvez aussi fournir une valeur par défaut : function saluer(nom: string = "Monde").

L'absence de valeur de retour pour une fonction (bonne réponse)
Une variable vide
Un type équivalent à undefined
Une fonction qui retourne null

Explication : Le type void représente l'absence de type. Il est principalement utilisé pour les fonctions qui ne retournent pas de valeur. Une variable de type void ne peut recevoir que undefined ou null (si strictNullChecks est désactivé).

Une fonction void peut retourner undefined ou null (selon la configuration), mais pas une valeur concrète.

Un type sécurisé qui représente une valeur inconnue, nécessitant une vérification de type avant utilisation (bonne réponse)
Un synonyme de any
Un type pour les valeurs nulles
Un type réservé aux APIs externes

Explication : unknown est l'alternative sécurisée à any. Une variable de type unknown peut recevoir n'importe quelle valeur, mais avant de pouvoir l'utiliser, vous devez vérifier son type (via typeof, instanceof, ou une assertion de type).

Préférez unknown à any pour représenter des valeurs dont le type n'est pas connu à l'avance.

let id: string | number; (bonne réponse)
let id: string & number;
let id: string or number;
let id: Union;

Explication : Les types union se créent avec le symbole | (pipe). let id: string | number; signifie que id peut être soit une string, soit un number.

Les types union sont très utiles pour les fonctions qui acceptent différents types de paramètres.

Une structure qui définit la forme d'un objet (bonne réponse)
Une classe spéciale
Un type réservé aux fonctions
Un fichier de configuration

Explication : Une interface définit un contrat qu'un objet doit respecter. Elle spécifie les noms, types et optionnalité des propriétés et méthodes. Les interfaces n'existent qu'à la compilation et n'ont pas de représentation en JavaScript.

Exemple : interface Personne { nom: string; age: number; }

age?: number (bonne réponse)
age: number?
optional age: number
age: number | undefined

Explication : Une propriété optionnelle se déclare avec un ? avant les deux-points : age?: number. L'objet peut alors avoir ou ne pas avoir cette propriété.

La différence entre age?: number et age: number | undefined est subtile : le premier autorise l'absence de la propriété, le second exige sa présence (même si sa valeur est undefined).

Les interfaces peuvent être étendues et implémentées par des classes ; les type aliases sont plus flexibles (unions, tuples) (bonne réponse)
Il n'y a aucune différence
Les interfaces sont pour les objets, les types pour les primitifs
Les types sont plus rapides à la compilation

Explication : Les interfaces sont spécifiquement conçues pour décrire la forme des objets et peuvent être déclarées plusieurs fois (fusion). Les type aliases peuvent représenter n'importe quel type (unions, intersections, tuples, primitifs) mais ne supportent pas la fusion automatique.

Utilisez interface par défaut pour les objets, type pour les unions, tuples, ou types utilitaires.

class Personne implements InterfacePersonne { } (bonne réponse)
class Personne extends InterfacePersonne { }
class Personne : InterfacePersonne { }
class Personne uses InterfacePersonne { }

Explication : Une classe implémente une interface avec le mot-clé implements. La classe doit alors fournir toutes les propriétés et méthodes définies dans l'interface. Exemple : class Employe implements Personne { nom: string; age: number; }.

Une classe peut implémenter plusieurs interfaces : class A implements B, C { }.

Un type qui représente une valeur qui ne se produit jamais (fonction qui ne retourne jamais ou lève toujours une erreur) (bonne réponse)
Un synonyme de void
Un type pour les valeurs null
Un type pour les boucles infinies

Explication : Le type never représente des valeurs qui ne se produisent jamais. Par exemple, une fonction qui lève toujours une exception ou qui a une boucle infinie retourne never. never est aussi utilisé pour l'exhaustivité dans les unions discriminées.

Exemple : function erreur(message: string): never { throw new Error(message); }

let coordonnees: [number, number] = [10, 20]; (bonne réponse)
let coordonnees: number[] = [10, 20];
let coordonnees: Tuple = [10, 20];
let coordonnees: (number, number) = [10, 20];

Explication : Un tuple se déclare avec la syntaxe [type1, type2, ...]. Exemple : let personne: [string, number] = ["Jean", 30]; définit un tableau avec exactement deux éléments : une string et un nombre.

Les tuples sont utiles pour retourner plusieurs valeurs d'une fonction tout en gardant un typage précis.

Une façon de dire au compilateur qu'une valeur est d'un type spécifique, sans vérification à l'exécution (bonne réponse)
Une vérification de type à l'exécution
Une fonction qui convertit les types
Une erreur de compilation

Explication : Une assertion de type est une façon de dire au compilateur : "Fais-moi confiance, je sais que cette valeur est de ce type". Elle se fait avec as Type ou <Type>valeur. Elle n'a aucun impact à l'exécution.

Exemple : let maValeur: unknown = "hello"; let longueur = (maValeur as string).length;

enum Couleur { Rouge, Vert, Bleu } (bonne réponse)
enum Couleur = { Rouge, Vert, Bleu }
type Couleur = "Rouge" | "Vert" | "Bleu"
const Couleur = ["Rouge", "Vert", "Bleu"]

Explication : Les enums se déclarent avec le mot-clé enum. Par défaut, les membres sont numérotés à partir de 0. Exemple : enum Couleur { Rouge, Vert, Bleu } donne Rouge=0, Vert=1, Bleu=2.

Préférez les unions de strings littérales (type Couleur = "Rouge" | "Vert" | "Bleu") aux enums pour un code JavaScript plus simple.

Empêche la modification d'une propriété après son initialisation
Rend une propriété accessible uniquement en lecture
Permet de lire une propriété privée
Les deux réponses A et B sont correctes (bonne réponse)

Explication : Le modificateur readonly marque une propriété comme étant en lecture seule. Elle ne peut être modifiée qu'au moment de l'initialisation (dans la déclaration ou dans le constructeur pour les classes).

Exemple : interface Point { readonly x: number; readonly y: number; }

function somme(...nombres: number[]): number { }
function somme(...nombres: number): number { }
function somme(...nombres: Array): number { }
Les deux réponses A et C sont correctes (bonne réponse)

Explication : Le paramètre rest se déclare avec ... suivi d'un tableau typé. Les deux syntaxes sont valides : ...nombres: number[] ou ...nombres: Array<number>. Ce paramètre capture tous les arguments restants dans un tableau.

Le paramètre rest doit toujours être le dernier paramètre de la fonction.

Active toutes les vérifications strictes de type (noImplicitAny, strictNullChecks, etc.) (bonne réponse)
Rend TypeScript plus lent
Désactive les vérifications de type
Active le mode production

Explication : L'option "strict": true active un ensemble de vérifications de type strictes, incluant noImplicitAny, strictNullChecks, strictFunctionTypes, etc. C'est fortement recommandé pour un code de qualité.

Commencez avec "strict": true pour les nouveaux projets. Pour les projets existants, activez les options une par une.

Dit au compilateur qu'une expression ne vaut ni null ni undefined (bonne réponse)
Inverse une valeur booléenne
Déclare une variable nullable
Crée une négation logique

Explication : L'opérateur ! (postfixe) est une assertion non-null. Il indique au compilateur que la valeur ne sera pas null ou undefined, même si le typage dit le contraire. Exemple : maVariable!.length.

Utilisez cet opérateur avec parcimonie. Une vérification explicite (if (maVariable) { ... }) est souvent préférable.

function identite(valeur: T): T { return valeur; }
function identite(valeur: any): any { return valeur; }
function identite(valeur: Type): Type { return valeur; }
Les deux réponses A et C sont correctes (bonne réponse)

Explication : Les génériques permettent de créer des composants réutilisables qui fonctionnent avec plusieurs types. La syntaxe utilise <T> (ou n'importe quel nom) avant les paramètres. Les deux exemples sont corrects : T et Type sont des noms conventionnels.

Le nom T (pour Type) est une convention, mais vous pouvez utiliser des noms plus descriptifs comme Key, Value, etc.

Vous essayez d'accéder à une propriété qui n'existe pas dans le type déclaré (bonne réponse)
La propriété existe mais est privée
Le fichier est manquant
La propriété est mal orthographiée dans le HTML

Explication : Cette erreur se produit quand vous tentez d'accéder à une propriété que le type de la variable ne possède pas. Par exemple, let x: number; x.length; génère cette erreur car number n'a pas de propriété length.

Vérifiez le type de votre variable. Utilisez une assertion de type ou une interface appropriée si nécessaire.

Définir "target": "ES5" dans le fichier tsconfig.json
Utiliser la commande tsc --target ES5
Les deux méthodes sont valides (bonne réponse)
Impossible, TypeScript compile toujours vers ES6

Explication : Vous pouvez définir la cible de compilation (target) soit dans tsconfig.json avec "target": "ES5", soit via la ligne de commande tsc --target ES5. TypeScript peut compiler vers ES3, ES5, ES6/ES2015, ES2016, etc.

Pour les navigateurs anciens, utilisez ES5. Pour les environnements modernes, ES2020 ou ESNext donne un code plus optimisé.