Documentation TypeScript
Référence TypeScript concise et illustrée par des exemples. Lisez le concept, voyez le code, puis pratiquez-le dans un parcours Coddy.
Commencer un parcours guidé en TypeScriptPour commencer
- Qu'est-ce que TypeScriptTypeScript, c'est quoi ? C'est JavaScript avec des types statiques. Vous annotez les valeurs avec des types, le compilateur les vérifie avant l'exécution, et le résultat est du JavaScript ordinaire qui tourne dans n'importe quel navigateur ou dans Node.js, Deno et Bun.
- TypeScript vs JavaScriptTypeScript, c'est JavaScript plus un système de types statique vérifié avant l'exécution. Comparez les deux côte à côte : syntaxe, erreurs détectées par le vérificateur de types, étape de build, vitesse d'exécution, courbe d'apprentissage et migration d'un projet JavaScript.
- Installer TypeScriptInstallez TypeScript avec npm comme dépendance de développement du projet, vérifiez la version avec npx tsc --version, créez un tsconfig.json avec tsc --init et compilez votre premier fichier. Installation globale, pnpm, Yarn, Bun et erreurs fréquentes.
- Exécuter TypeScriptCinq façons d'exécuter un fichier .ts : compiler avec tsc puis lancer le JavaScript, le lancer directement avec node file.ts (type stripping), utiliser tsx ou ts-node, ou passer par Deno et Bun. Lesquelles vérifient les types, quelle syntaxe chacune accepte, et laquelle choisir.
- tsconfig.jsontsconfig.json marque un dossier comme projet TypeScript et définit les options du compilateur. Les options qui comptent (target, module, moduleResolution, strict, rootDir, outDir, include, lib, types, noEmit, skipLibCheck), une configuration de départ recommandée, extends et ce qu'a changé TypeScript 7.
- TypeScript 7TypeScript 7, c'est le compilateur TypeScript réécrit en Go sous forme de programme natif : environ dix fois plus rapide, avec la même commande tsc et le même langage. Ce qui change pour vous (nouvelles valeurs par défaut, options supprimées, API JavaScript absente), les outils qui ont encore besoin de TypeScript 6, et comment migrer.
- CommentairesTypeScript utilise les commentaires // et /* */ de JavaScript, plus les commentaires JSDoc /** */ que les éditeurs affichent au survol. Il lit aussi quelques commentaires spéciaux : @ts-expect-error, @ts-ignore, @ts-nocheck, @ts-check et les directives /// <reference>.
- TypeScript vs PythonTypeScript et Python sont deux langages de haut niveau avec ramasse-miettes, mais TypeScript vérifie ses types avant l'exécution alors que les type hints de Python sont facultatifs et ignorés à l'exécution. Une comparaison côte à côte du typage, de l'exécution, de la vitesse, des écosystèmes et des usages, avec le même programme dans les deux langages.
Types de base
- Types de baseLes types intégrés de TypeScript : string, number, boolean, bigint, symbol, null et undefined, plus un aperçu des tableaux et des objets. Comment écrire une annotation de type, pourquoi il n'existe pas de type entier, et pourquoi on écrit string plutôt que String.
- Inférence de typeTypeScript déduit la plupart des types à partir des valeurs que vous écrivez. Découvrez ce qu'il infère pour les variables, let contre const, les objets, les tableaux et les valeurs de retour, comment les callbacks reçoivent leurs types du contexte, et où une annotation reste nécessaire.
- Chaînes de caractèresManipuler les chaînes en TypeScript : interpolation avec les template literals, chaînes multilignes, vérifier si une chaîne contient une sous-chaîne, les méthodes courantes et les types qu'elles renvoient, et les types littéraux de chaîne.
- Chaîne en nombreConvertir une chaîne en nombre en TypeScript avec Number(), parseInt(), parseFloat() ou le + unaire, voir comment chacun traite des entrées comme "42px", "" et "1e3", vérifier NaN sans risque, et reconvertir les nombres en chaînes.
- TableauxTyper les tableaux en TypeScript : T[] ou Array<T>, tableaux d'objets, tableaux contenant plusieurs types, tableaux readonly, et ce que renvoient map, filter, reduce et find. Plus le piège de includes avec les tableaux de littéraux.
- TuplesUn tuple TypeScript est un tableau au nombre d'éléments fixe dont les types sont connus position par position, comme [string, number]. Découvrez la syntaxe, les éléments nommés, optionnels et rest, les tuples readonly et as const, le retour d'un tuple depuis une fonction, et la différence avec les tableaux.
- Types objetTyper les objets en TypeScript : types objet en ligne, propriétés optionnelles avec ?, propriétés readonly, objets imbriqués, méthodes, vérification des propriétés en trop, et la différence entre object, {} et Object.
- EnumsUn enum TypeScript est un ensemble nommé de constantes, comme enum Direction { Up, Down }. Découvrez les enums numériques et string, le JavaScript produit par un enum, le reverse mapping, l'itération sur un enum, les const enum, et quand une union de littéraux de chaîne ou un objet as const est un meilleur choix.
Types spéciaux
- Types littérauxUn type littéral est un type qui n'a qu'une seule valeur, comme "GET" ou 404. Découvrez les types littéraux string, number et boolean, les unions de littéraux, pourquoi let élargit et const non, ce que fait as const, et les paramètres de type const.
- any vs unknownany et unknown acceptent toutes les valeurs. any désactive la vérification des types pour cette valeur, alors que unknown vous oblige à la vérifier avant de l'utiliser. Découvrez les différences, comment affiner unknown, noImplicitAny, et par où any se glisse dans du code typé.
- Type nevernever est le type sans aucune valeur. C'est le type de retour des fonctions qui ne se terminent jamais, le type qui reste quand le narrowing a écarté tous les cas, et l'outil derrière les vérifications exhaustives de switch. Découvrez d'où il vient et en quoi il diffère de void.
- null et undefinedAvec strictNullChecks, null et undefined sont des types distincts que TypeScript vous oblige à traiter. Découvrez comment les vérifier, le chaînage optionnel (?.), le double point d'interrogation (??) et ??=, et la différence entre une propriété optionnelle et | undefined.
- Assertion non nulle (!)Un point d'exclamation après une valeur, comme user!, est l'opérateur d'assertion non nulle : il retire null et undefined du type sans aucune vérification à l'exécution. Découvrez ce que fait x!, les formes d'assignation définie let x!: T et prop!: T, pourquoi elles sont risquées, et des alternatives plus sûres.
Interfaces et alias de type
- InterfacesUne interface nomme la forme d'un objet : ses propriétés et les types qu'elles contiennent. Apprenez à en déclarer une, les propriétés optionnelles et readonly, les méthodes, les signatures d'index, l'extension, l'implémentation dans une classe, la fusion de déclarations, les interfaces génériques et comment donner des valeurs par défaut à une interface.
- Alias de typeUn alias de type donne un nom à n'importe quel type grâce au mot-clé type : formes d'objets, unions, tuples, fonctions, génériques et types récursifs. Découvrez la syntaxe, à quoi ressemble chaque forme, et pourquoi un alias n'est qu'un nom et pas un nouveau type distinct.
- Interface vs typeinterface et type peuvent tous deux décrire des formes d'objets, et la plupart du temps l'un ou l'autre fonctionne. Découvrez les vraies différences : fusion de déclarations, unions et types mappés, extends contre intersections, signatures d'index implicites, messages d'erreur et performances du compilateur, plus une règle claire pour choisir.
- Mot-clé extendsLe mot-clé extends construit un type à partir d'un autre. Apprenez à étendre une interface (une seule ou plusieurs), à étendre un alias de type avec &, à redéfinir le type d'une propriété, à remplacer des propriétés avec Omit, et ce que signifie extends dans les classes, les contraintes génériques et les types conditionnels.
- Types unionUn type union comme string | number signifie qu'une valeur peut être l'un de plusieurs types. Découvrez ce que vous pouvez faire avec une union (uniquement ce que tous les membres permettent), comment l'affiner, les unions de littéraux et de types objet, et la différence entre (A | B)[] et A[] | B[].
- Types intersectionUn type intersection A & B décrit une valeur qui est à la fois A et B, et qui possède donc tous les membres des deux. Apprenez à combiner des types objet avec &, pourquoi les propriétés contradictoires deviennent never, pourquoi l'intersection d'unions ne garde que les membres communs, et quand utiliser plutôt extends.
- Unions discriminéesUne union discriminée est une union de types objet qui partagent une propriété étiquette littérale, comme kind ou status. Vérifier l'étiquette affine tout l'objet. Découvrez le motif, le narrowing avec switch, les vérifications exhaustives avec never, et comment modéliser des résultats d'API, l'état d'une requête et des machines à états.
Fonctions
- FonctionsTyper les fonctions en TypeScript : annoter chaque paramètre, annoter ou inférer le type de retour, utiliser void pour les fonctions qui ne renvoient rien, et typer les fonctions fléchées, les expressions de fonction, les fonctions async et le paramètre this.
- Types de fonctionsÉcrire le type d'une fonction en TypeScript : la syntaxe fléchée (a: number) => string, les alias de type pour les fonctions, le typage des fonctions fléchées et des callbacks, les signatures d'appel et de construction, et pourquoi le type Function est trop permissif.
- Paramètres optionnelsRendez un paramètre TypeScript optionnel avec ?, donnez-lui une valeur par défaut, ou rassemblez un nombre quelconque d'arguments avec un paramètre rest. Règles d'ordre, argument omis ou undefined, objets d'options et paramètres optionnels dans les types de fonctions.
- Surcharge de fonctionsLes overloads de fonctions TypeScript permettent à une fonction d'avoir plusieurs signatures d'appel, chacune avec son propre type de retour. Découvrez le motif signatures de surcharge plus implémentation, les règles que vérifie le compilateur, quand un paramètre union est préférable, et les surcharges dans les classes.
Affinage et vérification des types
- Narrowing de typesLe narrowing, c'est la façon dont TypeScript transforme un type large comme string | number en un type précis dans un if, un switch ou après un return anticipé. Toutes les formes de narrowing au même endroit : typeof, véracité, égalité, in, instanceof, assignations, prédicats de type et unions discriminées.
- Opérateur typeoftypeof a deux rôles en TypeScript. Dans le code, c'est l'opérateur JavaScript qui renvoie "string", "number", "object" et ainsi de suite à l'exécution, et TypeScript affine les types à partir de lui. Dans un type, c'est la requête de type qui copie le type d'une variable, comme dans keyof typeof obj et ReturnType<typeof fn>.
- Opérateur instanceofinstanceof vérifie à l'exécution si un objet a été créé par une classe, et TypeScript affine la variable vers cette classe. Comment il fonctionne avec vos propres classes et les sous-classes d'Error, pourquoi il ne peut pas vérifier les interfaces ni les alias de type, et où il donne des réponses surprenantes.
- Type guardsUn type guard est une vérification à l'exécution que TypeScript comprend. Découvrez les guards intégrés, comment écrire les vôtres avec un prédicat value is Type, comment vérifier qu'un objet est d'un type donné, les fonctions d'assertion avec asserts, et comment valider des données unknown.
- Assertions de typeLe mot-clé as demande à TypeScript de traiter une valeur comme un autre type. Ce n'est pas un cast : rien n'est converti ni vérifié à l'exécution. Découvrez la syntaxe as et celle à chevrons, ce qu'autorise le compilateur, les doubles assertions via unknown, et quand un type guard est le meilleur outil.
- Opérateur satisfiesL'opérateur satisfies vérifie qu'une valeur correspond à un type sans changer le type inféré de la valeur. Découvrez ce qu'il fait, comment il se compare à une annotation de type et à as (le même objet écrit de trois façons), comment il se combine avec as const, et pourquoi il convient aux objets de configuration.
Classes
- ClassesLes classes TypeScript sont des classes JavaScript avec des champs, des méthodes et des constructeurs typés. Découvrez le fonctionnement des déclarations de champs et de strictPropertyInitialization, comment typer this, les getters et setters, les membres statiques, implements, et comment une classe sert aussi de type.
- ConstructeursTyper le constructeur d'une classe en TypeScript : paramètres typés et optionnels, propriétés de paramètres comme constructor(private name: string), ordre d'initialisation des champs, surcharges de constructeur, appels à super dans les sous-classes, constructeurs privés et types de constructeurs avec new.
- Modificateurs d'accèsTypeScript a trois modificateurs d'accès, public, private et protected, plus readonly. Découvrez ce que chacun autorise, pourquoi le private de TypeScript est une vérification à la compilation alors que les champs #private de JavaScript sont imposés à l'exécution, et lequel choisir.
- HéritageL'héritage de classes en TypeScript : extends et super, redéfinition de méthodes avec des types compatibles, le mot-clé override et noImplicitOverride, les membres protected, la redéclaration de champs avec declare, et quand implements est le meilleur outil.
- Classes abstraitesUne classe abstraite en TypeScript est une classe de base qui ne peut pas être instanciée et peut laisser des méthodes à implémenter par les sous-classes. Découvrez les méthodes et propriétés abstraites, le motif template method, les types de constructeurs abstraits, et quand une interface est un meilleur choix.
- DécorateursLes décorateurs sont des fonctions qui enveloppent ou remplacent des membres de classe avec la syntaxe @. Découvrez les décorateurs standard que TypeScript prend en charge sans aucune option (classe, méthode, getter, champ et accessor), les fabriques de décorateurs, addInitializer, et en quoi ils diffèrent des anciens experimentalDecorators utilisés par Angular et NestJS.
Génériques
- GénériquesLes génériques permettent à une fonction, une interface, un type ou une classe de fonctionner avec de nombreux types tout en les gardant liés : ce qui entre décide de ce qui sort. Découvrez les fonctions génériques, l'inférence des arguments de type, les paramètres de type multiples, les interfaces et classes génériques, les valeurs par défaut, et quand ne pas utiliser les génériques.
- Contraintes génériquesUne contrainte générique, T extends Something, limite les types qu'accepte un paramètre de type et permet à la fonction d'utiliser ce que la contrainte garantit. extends avec des formes d'objets et des interfaces, K extends keyof T pour un accès sûr aux propriétés, contraintes sur les primitives, et les erreurs que vous rencontrerez.
Opérateurs de type
- Opérateur keyofkeyof prend un type objet et vous donne l'union de ses noms de propriétés. Découvrez keyof avec les interfaces, keyof typeof pour les objets simples, l'accès typé aux propriétés avec les génériques, les signatures d'index (string | number), et pourquoi Object.keys renvoie string[].
- Types d'accès indexéUn type d'accès indexé lit le type d'une propriété dans un autre type : Person["age"] vaut number. Découvrez T["key"], les unions de clés, T[keyof T], T[number] pour les éléments de tableau, les indices de tuple, et (typeof arr)[number] pour transformer un tableau const en union.
- Types mappésUn type mappé construit un nouveau type objet en parcourant des clés : { [K in keyof T]: ... }. Découvrez la syntaxe, les modificateurs readonly et ? avec + et -, le remappage des clés avec as, le filtrage des clés, et comment sont écrits Partial, Readonly, Required, Pick et Record.
- Types conditionnelsUn type conditionnel choisit l'un de deux types selon un test : T extends U ? X : Y. Découvrez la syntaxe, comment les types conditionnels se distribuent sur les unions (et comment l'empêcher), l'extraction de types avec infer, et comment écrire ReturnType vous-même.
- Template literal typesLes template literal types construisent des types littéraux de chaîne avec la même syntaxe à backticks que les template strings JavaScript : `on${Capitalize<E>}`. Découvrez la syntaxe, la multiplication des unions, Uppercase et Capitalize, les motifs comme `${number}px`, les getters générés par mapped types et l'analyse de chaînes avec infer.
- Branded typesUn branded type est un type primitif portant une étiquette invisible, comme string & { readonly __brand: "UserId" }, pour qu'un UserId ne puisse pas être passé là où un OrderId est attendu. Découvrez le fonctionnement des brands, les fonctions constructrices qui valident, un helper générique Brand, les brands par unique symbol et les nombres brandés.
Types utilitaires
- Utility typesTous les utility types intégrés à TypeScript au même endroit : Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, NonNullable, Parameters, ReturnType, Awaited, les types de chaîne et d'autres, chacun avec une description en une ligne et un exemple exécutable.
- RecordRecord<K, V> est le type objet dont les clés sont K et dont toutes les valeurs sont V. Découvrez Record avec des clés string et avec des clés union (toutes obligatoires), Partial<Record>, le parcours d'un Record avec des clés typées, le piège de la clé absente, et quand préférer une signature d'index ou une Map.
- Partial et RequiredPartial<T> rend optionnelles toutes les propriétés de T, ce qui correspond exactement au type d'un objet de mise à jour ou de patch. Découvrez Partial dans les fonctions de mise à jour, pourquoi il est superficiel, comment écrire un DeepPartial, le piège du undefined explicite, et son inverse Required<T>.
- OmitOmit<T, K> crée un type avec toutes les propriétés de T sauf les clés K. Découvrez Omit avec une ou plusieurs clés, la redéfinition du type d'une propriété, la suppression de la propriété à l'exécution, Omit vs Exclude et Pick, pourquoi Omit accepte des clés inexistantes, un Omit strict, et Omit sur les types union.
- PickPick<T, K> crée un type ne contenant que les propriétés de T dont les clés sont dans K. Découvrez Pick avec une ou plusieurs clés, la vérification des clés, Pick vs Omit, la sélection dans des types imbriqués, une fonction pick() typée, et la sélection de propriétés selon le type de leur valeur.
- readonly et ReadonlyLe modificateur readonly et le utility type Readonly<T> empêchent le code de réaffecter des propriétés. Découvrez les propriétés et champs de classe readonly, Readonly<T>, les tableaux readonly (readonly T[] et ReadonlyArray), ReadonlyMap et ReadonlySet, pourquoi readonly est superficiel et limité à la compilation, et comment il se compare à Object.freeze et as const.
- Exclude et ExtractExclude, Extract et NonNullable filtrent les membres d'un type union. Découvrez ce que chacun garde et retire, comment sélectionner des membres d'une union par leur forme, comment ils sont construits à partir de types conditionnels, et en quoi ils diffèrent de Omit et Pick.
- ReturnType et ParametersReturnType, Parameters, ConstructorParameters, InstanceType et Awaited extraient des types de fonctions, de classes et de promesses. Découvrez comment les utiliser avec typeof, comment obtenir le type du résultat d'une fonction async, ce qui se passe avec les surcharges et les génériques, et comment ReturnType est construit avec infer.
Boucles et collections
- BouclesToutes les façons de faire une boucle en TypeScript et les types que chacune vous donne : la boucle for classique, for...of sur les tableaux, les Maps et les chaînes, for...in et ses clés string, forEach (ni break ni await), les boucles typées sur les clés d'un objet, et while.
- Instruction switchL'instruction switch en TypeScript : syntaxe, comment chaque case affine un type union, les switch exhaustifs qui refusent de compiler quand un case manque, le motif switch (true), le fallthrough et la portée des blocs.
- MapComment utiliser Map en TypeScript : créer une Map<K, V> typée, pourquoi get renvoie V | undefined, set, has et delete, le parcours dans l'ordre d'insertion, les clés objets, la conversion vers et depuis des objets et du JSON, Map vs objet vs Record, et le typage de array.map().
- DictionnaireTypeScript n'a pas de classe dictionnaire ou hashmap : on type une table clé valeur avec une index signature, Record<K, V> ou Map<K, V>. Découvrez chacune de ces solutions, comment vérifier qu'une clé existe, ajouter, supprimer et parcourir, et pourquoi noUncheckedIndexedAccess compte pour les dictionnaires.
Asynchrone et erreurs
- PromisesComment les promesses sont typées en TypeScript : le type Promise<T>, typer new Promise et resolve, comment then change le type, pourquoi catch vous donne any, Promise.all avec des résultats en tuple, les types de résultat de Promise.allSettled, et encapsuler une API à callbacks dans une promesse typée.
- Async/AwaitComment async et await sont typés en TypeScript : une fonction async renvoie Promise<T>, await la déballe, les erreurs se capturent avec try/catch, le await de premier niveau exige un module ES, et la différence entre attendre un par un, attendre en parallèle, et le piège de forEach.
- Gestion des erreursLa gestion des erreurs en TypeScript : pourquoi la variable du catch est unknown, comment la restreindre avec instanceof Error, lever des erreurs, écrire des classes d'erreur personnalisées avec name et cause, et le pattern Result pour les erreurs prévues.
- SleepTypeScript n'a pas de sleep intégré, mais une ligne suffit pour en avoir un : une fonction qui renvoie une Promise<void> résolue par setTimeout. Découvrez comment l'attendre avec await, faire une pause dans une boucle, réessayer après un délai, annuler un sleep, et pourquoi JavaScript n'a pas de sleep bloquant.
Modules et outils
- ModulesTout fichier TypeScript qui contient un import ou un export de premier niveau est un module. Découvrez les exports nommés et par défaut, import type et export type, comment l'option module choisit entre une sortie module ES et CommonJS, et pourquoi node16 et nodenext veulent des extensions .js dans les imports.
- NamespacesUn namespace TypeScript regroupe des valeurs et des types sous un même nom et se compile en un simple objet. Découvrez la syntaxe, comment les namespaces fusionnent entre eux et avec les fonctions et les classes, pourquoi les modules ES les ont remplacés, et où vous les rencontrez encore : fichiers de déclaration et augmentation globale.
- Fichiers de déclarationUn fichier .d.ts décrit les types d'un code JavaScript sans en contenir une ligne, et le mot clé declare fait la même chose dans un fichier .ts. Découvrez comment les fichiers de déclaration sont générés, le rôle des paquets @types, comment typer un module sans types, et comment declare global et l'augmentation de module étendent des types existants.
- Mode strictstrict: true dans tsconfig.json active une famille de vérifications de types : noImplicitAny, strictNullChecks, strictPropertyInitialization et cinq autres. Voyez ce que chacune détecte, comment activer le mode strict dans un projet existant, et les options utiles que strict n'inclut pas.
- JSONJSON.parse renvoie any, donc TypeScript fait confiance au type que vous donnez au résultat. Découvrez comment typer du JSON analysé, le valider avec un type guard, transformer un exemple JSON en interface, importer des fichiers .json, et ce que JSON.stringify fait des Date, des Set et de undefined.
Aller plus loin
- Bonnes pratiquesHuit habitudes TypeScript qui évitent de vrais bugs : garder strict activé, utiliser unknown plutôt que any, laisser l'inférence travailler, préférer les unions aux enums, vérifier la configuration avec satisfies, modéliser l'état avec des unions discriminées, éviter ! et as, et rendre les données readonly. Chacune avec un avant et un après exécutables.
- Questions d'entretien25 questions d'entretien TypeScript avec des réponses courtes, justes et accompagnées de code, classées du niveau débutant au niveau avancé : any ou unknown, interface ou type, génériques, narrowing, types utilitaires, mapped types et types conditionnels, typage structurel, tsconfig et TypeScript 7.
