Introduction à TypeScript
TypeScript est un langage de programmation open source développé par Microsoft. C'est un sur-ensemble de JavaScript qui, tout en étant entièrement compatible avec la syntaxe JavaScript, ajoute un système de types statique optionnel et des capacités de programmation orientée objet basées sur les classes.
Le code TypeScript est finalement compilé en JavaScript pur et peut s'exécuter dans tout environnement qui prend en charge JavaScript, notamment les navigateurs, Node.js et les plateformes mobiles.

Pourquoi TypeScript ?
JavaScript est un langage à typage dynamique ; le type d'une variable ne peut être déterminé qu'à l'exécution.
Cette flexibilité fonctionne bien dans les petits projets, mais à mesure que la taille du projet augmente, les problèmes apparaissent progressivement :
| Scénario problématique | Le dilemme de JavaScript | La solution de TypeScript |
|---|---|---|
| Passer un type incorrect à un paramètre de fonction | Les erreurs n'apparaissent qu'à l'exécution et sont difficiles à détecter tôt | Les erreurs apparaissent à la compilation, avec des indications en temps réel dans l'IDE |
| Accéder à des propriétés inexistantes | Renvoieundefined, le comportement est imprévisible | Le compilateur signale directement une erreur et refuse de laisser passer |
| Refactoriser de grands projets | Modifier un endroit, sans savoir où cela va casser | Le système de types suit automatiquement toutes les références |
| Collaboration en équipe | Les paramètres qu'une fonction accepte et la valeur qu'elle renvoie reposent entièrement sur des commentaires ou de la documentation | Les signatures de type servent de documentation, avec l'autocomplétion de l'IDE |
| Lisibilité du code | Vous ne pouvez pas connaître directement la structure de données à partir d'une définition de fonction | Les interfaces et les alias de type rendent la structure de données claire au premier coup d'œil |
L'objectif essentiel de TypeScript n'est pas de remplacer JavaScript, mais de rendre les projets JavaScript à grande échelle gérables et maintenables. C'est le « filet de sécurité » de JavaScript, pas un concurrent.
Regardons l'exemple le plus intuitif :
Exemple
function greet(name) {
return "Hello, " + name.toUpperCase();
}
greet(123); // Erreur d'exécution : name.toUpperCase n'est pas une fonction
Exemple
function greet(name: string): string {
return "Hello, " + name.toUpperCase();
}
greet(123); // Erreur de compilation : L'argument de type 'number' n'est pas attribuable au paramètre de type 'string'
greet("example"); // Correct : Hello, EXAMPLE
Relation entre TypeScript et JavaScript
La relation entre TypeScript et JavaScript peut se résumer en une phrase :TypeScript est un sur-ensemble de JavaScript, ce qui signifie que tout code JavaScript valide est aussi du code TypeScript valide.
Illustration de la relation d'ensemble
JavaScript (tout le code JS)
⊂ TypeScript (JS + système de types + nouvelles fonctionnalités)
⊂ Sortie compilée (JavaScript standard, peut s'exécuter dans n'importe quel environnement)
Différences principales entre les deux :
| Élément de comparaison | JavaScript | TypeScript |
|---|---|---|
| Système de types | Typage dynamique, déterminé à l'exécution | Typage statique, vérifié à la compilation (facultatif) |
| Méthode d'exécution | S'exécute directement dans le navigateur / Node.js | Doit être compilé en JS avant d'être exécuté |
| Moment de la détection des erreurs | Exécution | Au moment de la compilation (détectées tôt) |
| Prise en charge par l'IDE | Complétion de base | Inférence de type forte, complétion précise, prise en charge du refactoring |
| Courbe d'apprentissage | Relativement douce | Nécessite un apprentissage supplémentaire du système de types |
| Compatibilité avec le JS existant | — | Entièrement compatible, migration progressive possible |
| Extension de fichier | .js | .tsou.tsx(y compris JSX) |
TypeScript prend en charge « l'adoption progressive » : vous n'avez pas à réécrire tout le projet d'un seul coup. Vous pouvez d'abord
.jsmodifier.ts, puis ajouter progressivement des types aux modules clés, et le code existant continue de fonctionner comme d'habitude.
Fonctionnalités principales
TypeScript introduit un système de types complet au-dessus de JavaScript. Les éléments suivants sont les fonctionnalités de base les plus couramment utilisées.
Annotations de type de base
Déclarez les types après les variables, les paramètres de fonction et les valeurs de retour à l'aide d'un deux-points ; c'est la syntaxe la plus élémentaire de TypeScript.
Exemple
let age: number = 25;
let username: string = "example";
let isActive: boolean = true;
// Types de tableau, deux façons équivalentes
let scores: number[] = [90, 85, 92];
let tags: Array<string> = ["typescript", "javascript"];
// Tuple : tableau avec une longueur et des types fixes
let point: [number, number] = [10, 20];
let entry: [string, number] = ["EXAMPLE", 100];
// Fonction : types des paramètres + type de retour
function add(a: number, b: number): number {
return a + b;
}
// void : la fonction n'a pas de valeur de retour
function log(msg: string): void {
console.log(msg);
}
// Paramètre optionnel : ajouter ? après le nom du paramètre
function greet(name: string, title?: string): string {
return title ? `${title} ${name}` : name;
}
console.log(greet("EXAMPLE")); // Sortie : EXAMPLE
console.log(greet("example", "Mr.")); // Sortie : Mr. example
Interface
Une interface est utilisée pour décrire la "forme" d'un objet, en définissant quelles propriétés et méthodes l'objet doit posséder.
Exemple
interface User {
id: number; // Requis
name: string; // Requis
email?: string; // Optionnel, indiqué par ?
readonly role: string; // Lecture seule, ne peut pas être modifié après affectation
}
// Le paramètre de fonction utilise le type d'interface
function printUser(user: User): void {
console.log(`ID: ${user.id}, Name: ${user.name}`);
if (user.email) {
console.log(`Email: ${user.email}`);
}
}
const admin: User = {
id: 1,
name: "EXAMPLE",
email: "example@example.com",
role: "admin",
};
printUser(admin);
// Sortie : ID : 1, Nom : EXAMPLE
// Sortie : E-mail : example@example.com
// admin.role = "user"; // Erreur : impossible d'affecter à 'role' car il s'agit d'une propriété en lecture seule.
// Héritage d'interface
interface AdminUser extends User {
permissions: string[];
}
Alias de type
Les alias de type utilisenttypecomme mot-clé pour créer, et peuvent définir des alias pour n'importe quel type, y compris des structures complexes telles que les types union et les types d'intersection.
Exemple
type ID = string | number;
let userId: ID = "abc-123"; // Valide
userId = 456; // Également valide
// Type littéral : restreint la variable à des valeurs spécifiques
type Direction = "up" | "down" | "left" | "right";
type Status = "pending" | "active" | "inactive";
function move(dir: Direction): void {
console.log(`Moving ${dir}`);
}
move("up"); // Correct
// move("diagonal"); // Erreur : n'est pas dans la plage littérale
// Type d'intersection : combine plusieurs types
type WithTimestamp = {
createdAt: Date;
updatedAt: Date;
};
type UserRecord = User & WithTimestamp; // Possède toutes les propriétés de User et de WithTimestamp
// Alias de type de fonction
type Transformer<T, U> = (input: T) => U;
const toNumber: Transformer<string, number> = (s) => parseInt(s, 10);
Génériques
Les génériques permettent d'écrire des composants réutilisables tout en maintenant la sûreté du typage. Vous pouvez considérer les génériques comme des « variables de type » — passez des types spécifiques lorsque vous les utilisez.
Exemple
function firstNumber(arr: number[]): number {
return arr[0];
}
// Avec les génériques : T est un paramètre de type, le type spécifique est déterminé au moment de l'appel
function first<T>(arr: T[]): T {
return arr[0];
}
const n = first<number>([1, 2, 3]); // n est de type number
const s = first<string>(["a", "b"]); // s est de type string
const inferred = first([true, false]); // TypeScript infère automatiquement T comme boolean
// Interface générique
interface ApiResponse<T> {
data: T;
status: number;
message: string;
}
// Utilisation d'une interface générique
const userResponse: ApiResponse<User> = {
data: { id: 1, name: "EXAMPLE", role: "admin" },
status: 200,
message: "success",
};
// Contrainte générique : T doit avoir une propriété id
function getById<T extends { id: number }>(items: T[], id: number): T | undefined {
return items.find(item => item.id === id);
}
Énumération
Les énumérations sont utilisées pour définir un ensemble de constantes nommées, rendant les « nombres magiques » ou les « chaînes magiques » dans le code significatifs.
Exemple
enum Direction {
Haut, // 0
Down, // 1
Left, // 2
Right, // 3
}
console.log(Direction.Up); // Sortie : 0
console.log(Direction[0]); // Sortie : "Up" (mappage inverse)
// Énumération de chaînes (recommandé, les valeurs sont plus lisibles lors du débogage)
enum Color {
Red = "RED",
Green = "GREEN",
Blue = "BLUE",
}
function paint(color: Color): void {
console.log(`Painting in ${color}`);
}
paint(Color.Red); // Sortie : Painting in RED
// paint("red"); // Erreur : la chaîne "red" n'est pas de type Color
// const enum : intégré après compilation, réduisant la surcharge à l'exécution
const enum HttpStatus {
OK = 200,
NotFound = 404,
InternalError = 500,
}
const status: HttpStatus = HttpStatus.OK; // 编译后直接替换为数字 200
Inférence de type
TypeScript 不要求为每个变量手动标注类型;编译器会根据赋给它的值自动推断类型。
Exemple
let count = 0; // 推断为 number
let name = "EXAMPLE"; // 推断为 string
float flag = true; // 推断为 boolean
// 推断数组元素类型
let numbers = [1, 2, 3]; // 推断为 number[]
// 在函数返回值中
function double(n: number) { // 返回类型自动推断为 number
return n * 2;
}
对象类型推断
const config = {
host: ", // string
port: 3000, // number
debug: false, // boolean
};
// config.port = "3000"; // Erreur : le type 'string' n'est pas assignable au type 'number'.
Une suggestion pratique : les paramètres de fonction nécessitent généralement des annotations de type explicites (car les appelants ne peuvent pas inférer les types à partir des valeurs des paramètres), tandis que les variables locales et les valeurs de retour à l'intérieur du corps de la fonction peuvent majoritairement s'appuyer sur l'inférence — pas besoin d'annoter tout manuellement.
Classes et modificateurs d'accès
TypeScript prend entièrement en charge la syntaxe des classes ES6 et ajoutepublic、private、protected、readonlyquatre modificateurs d'accès.
Exemple
readonly name: string; // Lecture seule, ne peut pas être modifié après initialisation
private age: number; // Privé, accessible uniquement à l'intérieur de la classe
protected species: string; // Protégé, accessible par les sous-classes
constructor(name: string, age: number, species: string) {
this.name = name;
this.age = age;
this.species = species;
}
// méthode publique (publique par défaut, peut être omise)
public introduce(): string {
return `I`Je suis ${this.name}, un ${this.species}.`;
}
// getter : invoquer une méthode comme on accède à une propriété
get info(): string {
return `${this.name} (${this.age} ans)`;
}
}
class Dog extends Animal {
private breed: string;
constructor(name: string, age: number, breed: string) {
super(name, age, "Canis lupus familiaris"); // Appeler le constructeur de la classe parente
this.breed = breed;
}
// La sous-classe peut accéder aux propriétés protégées
describe(): string {
return `${this.name} est un ${this.species}, race : ${this.breed}`;
}
}
const dog = new Dog("EXAMPLE", 3, "Labrador");
console.log(dog.introduce()); // Sortie : Jesuis EXAMPLE, un Canis lupus familiaris.
console.log(dog.info); // Sortie : EXAMPLE (3 ans)
// console.log(dog.age); // Erreur : impossible d'accéder à la propriété privée depuis l'extérieur
Décorateur
Les décorateurs sont une syntaxe de métaprogrammation utilisée pour attacher un comportement supplémentaire aux classes, méthodes et propriétés ; couramment rencontrée dans des frameworks comme Angular, NestJS, etc.
TypeScript 5.0 a implémenté les décorateurs comme une norme officielle (proposition Stage 3), ne nécessitant plus l'experimentalDecoratorsoption.
Exemple
function sealed(constructor: Function) {
Object.seal(constructor); // Empêche l'ajout de nouvelles propriétés
Object.seal(constructor.prototype);
}
// Décorateur de méthode : peut être utilisé pour la journalisation, les vérifications des permissions, etc.
function log(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const original = descriptor.value;
descriptor.value = function (...args: any[]) {
console.log(`Appel de ${propertyKey} avec arguments:`, args);
const result = original.apply(this, args);
console.log(`${propertyKey} a retourné:`, result);
return result;
};
}
@sealed
class Calculator {
@log
add(a: number, b: number): number {
return a + b;
}
}
const calc = new Calculator();
calc.add(1, 2);
// Sortie : Appel de add avec arguments : [ 1, 2 ]
// Sortie : add a retourné : 3
Domaines d’application
Grâce à sa compatibilité totale avec JavaScript, TypeScript peut être utilisé presque partout où JavaScript s'exécute, et apporte des avantages supplémentaires dans les grands projets.
Développement Web Front-end
C'est le scénario le plus couramment utilisé pour TypeScript. Les trois principaux frameworks front-end offrent une prise en charge de premier ordre pour TypeScript :
| Framework | Prise en charge de TypeScript | Scénario typique |
|---|---|---|
| Angular | Langage officiel, TypeScript par défaut, impossible à éviter. | SPA d'entreprise, systèmes d'administration |
| React | Fourni officiellement@types/react, Create React App et Vite incluent tous deux des modèles TypeScript | E-commerce, plateformes de contenu, applications d'administration/backend |
| Vue | Le code principal de Vue 3 est réécrit en TypeScript, et la Composition API améliore considérablement l'affinité avec TypeScript | Projets de petite à moyenne taille, migration progressive |
| Next / Nuxt | Prise en charge intégrée de TypeScript, activée par défaut pour les nouveaux projets | Applications full-stack SSR/SSG |
Développement back-end Node.js
TypeScript est tout aussi répandu dans le développement back-end Node.js.NestJSC'est actuellement le framework back-end TypeScript le plus populaire, adoptant une architecture modulaire similaire à Angular, avec prise en charge intégrée de l'injection de dépendances et des décorateurs.
De plus,DenoL'environnement d'exécution prend nativement en charge TypeScript depuis le premier jour, et peut s'exécuter directement sans aucune configuration.tsfichiers.BunDispose également d'une prise en charge intégrée de TypeScript.
Outils en ligne de commande et scripts
Avec l'aide dets-node、tsxet d'autres outils, le code TypeScript peut être exécuté directement sans précompilation, ce qui le rend idéal pour écrire des scripts de build et des outils CLI.
Mobile et multiplateforme
React Nativeprend entièrement en charge TypeScript, et de nombreuses applications mobiles d'entreprise (comme Microsoft Office mobile, Shopify, etc.) utilisent cette pile technologique.ExpoLe nouveau modèle de projet est également basé sur TypeScript par défaut.
Développement de jeux et graphismes
Babylon.js(le moteur 3D de Microsoft) est entièrement écrit en TypeScript et traite les définitions de types TypeScript comme des citoyens de première classe.Phaseret d'autres moteurs de jeux 2D fournissent également des définitions de types complètes.
Historique du développement
La naissance et la croissance de TypeScript sont étroitement liées à l'évolution de l'écosystème JavaScript, et chaque version majeure est motivée par des besoins d'ingénierie clairs.
Origines (2010 - 2012)
L'histoire de TypeScript a commencé par un défi d'ingénierie au sein de Microsoft : comment rendre les grands projets JavaScript maintenables.
ConcepteurAnders Hejlsbergest une légende de l'industrie—l'architecte en chef de C# et le créateur de Turbo Pascal et Delphi. Il a commencé à concevoir ce langage vers 2010, avec pour objectif principal d'introduire la vérification statique des types sans rompre la compatibilité avec JavaScript.
Un autre contexte du lancement de TypeScript par Microsoft était la sortie de Windows 8 — les applications pouvaient être développées avec HTML + JavaScript, et Microsoft espérait attirer les programmeurs .NET, c'est pourquoi de nombreuses fonctionnalités syntaxiques de TypeScript ont été volontairement gardées similaires à C# et .NET.
En octobre 2012, TypeScript 0.8 a été rendu public, après environ deux ans de développement interne chez Microsoft.
Premières versions (2013 - 2015)
| Temps | Version | Événements importants |
|---|---|---|
| 2013-06 | 0.9 | Version stable officielle, performances considérablement améliorées, meilleure intégration dans l'IDE |
| 2014-04 | 1.0 | Première version stable officielle, introduisant les classes, les interfaces, les modules et prenant en charge la compilation vers JavaScript standard |
| 2014-07 | — | Code source du compilateur TypeScript ouvert, hébergé sur GitHub, acceptant les contributions de la communauté |
| 2015-04 | — | Microsoft publie Visual Studio Code avec une prise en charge approfondie de TypeScript intégrée ; les deux se complètent |
| 2015-07 | 1.5 | Introduction de la prise en charge de la syntaxe des modules ES6, des décorateurs (expérimentaux) et des espaces de noms |
Croissance rapide (2016 - 2019)
Cette phase a été une période charnière pour que TypeScript passe d'un outil de niche à une technologie grand public, la principale force motrice venant des choix dans l'écosystème des frameworks.
| Temps | Version / Événement | Importance du jalon |
|---|---|---|
| 2016-09 | TypeScript 2.0 | Introduction des types non nullables (--strictNullChecks), l'une des fonctionnalités les plus importantes de la sûreté de typage de TypeScript ; introduction des types d'union discriminés |
| 2016 | Sortie d'Angular 2 | L'équipe Google Angular a annoncé l'adoption de TypeScript comme langage de développement officiel, ce qui a fait connaître TypeScript au grand public |
| 2017 | Série TypeScript 2.x | Les types conditionnels, les types mappés et le mot-clé infer ont été introduits successivement, améliorant grandement l'expressivité du système de types |
| 2018-07 | TypeScript 3.0 | Project References, prenant en charge les grands monorepos ; introduction du type unknown (un type supérieur plus sûr que any) |
| 2019 | DefinitelyTyped | Dépôt de définitions de types maintenu par la communauté DefinitelyTyped (@types/*) couvre plus de 7,000 paquets, couvrant essentiellement toutes les bibliothèques npm courantes |
Maturité et adoption (2020 - 2022)
| Temps | Version / Événement | Contenu important |
|---|---|---|
| 2020-08 | TypeScript 4.0 | Types de tuples variadiques, éléments de tuple étiquetés ; expérience de l'éditeur considérablement améliorée |
| 2021 | Série TypeScript 4.x | Template Literal Types, types utilitaires intégrés améliorés,noImplicitOverrideet d'autres améliorations du mode strict |
| 2022 | Enquête State of JS | Le taux d'utilisation de TypeScript a dépassé celui du JavaScript pur pour la première fois, devenant le langage sur-ensemble le plus populaire de l'écosystème JS |
| 2022 | Adoption de Vue 3 / Vite | Le cœur de Vue 3 réécrit en TypeScript, combiné à Vite pour porter l'expérience TypeScript dans l'ingénierie front-end à un nouveau niveau |
Ère moderne (2023 - aujourd'hui)
| Temps | Version | Caractéristiques clés |
|---|---|---|
| 2023-03 | TypeScript 5.0 | Décorateurs modernes (norme Stage 3), paramètres de type const, tous les enums convertis en enums union, avec des améliorations de performance significatives |
| 2023-08 | TypeScript 5.2 | Introduction de la gestion explicite des ressources (usingmot-clé), résolvant le problème du nettoyage déterministe de ressources telles que les connexions aux bases de données et les descripteurs de fichiers |
| 2024-03 | TypeScript 5.4 | Amélioration du rétrécissement de type dans les fermetures,NoInfertypes utilitaires |
| 2024-06 | TypeScript 5.5 | inférence de prédicat de type, vérification de la syntaxe des expressions régulières, permettant au système de types de comprendre plus précisément la logique du code |
| 2024-11 | TypeScript 5.7 | Prise en charge de--target es2024, détection plus fiable des variables non initialisées |
| 2025-03 | TypeScript 5.8 | Vérification améliorée des valeurs de retour pour les types conditionnels et d'accès indexé ; prend en charge sous--module nodenextviarequire()chargement des modules ESM (nécessite Node.js 22+) |
Perspectives d'avenir : réécriture du compilateur en Go
Début 2025, Microsoft a annoncé une décision majeure : réécrire le compilateur TypeScript en Go, avec le nom de code du projetCorsa。
La déclaration officielle indique que le compilateur réécrit devrait offrir une amélioration des performances de plus de 10x, réduisant les temps de compilation des grands projets de quelques minutes à quelques secondes.
Selon le plan, la version Go sera officiellement publiée dans TypeScript 7.x, tandis que les versions actuelles 5.x / 6.x de TypeScript continueront leur itération et leur maintenance normales. La réécriture devrait être achevée d'ici la fin 2025.
Cette réécriture ne changera pas la syntaxe ni le système de types du langage TypeScript lui-même ; il s'agit d'une mise à niveau transparente pour les développeurs — votre code n'a besoin d'aucune modification, seule la vitesse de compilation est grandement améliorée.
Comparaison entre TypeScript et d'autres langages à typage statique
Si vous avez un bagage dans d'autres langages fortement typés, la comparaison suivante peut vous aider à comprendre rapidement la philosophie de conception de TypeScript.
| Élément de comparaison | TypeScript | Java / C# | Go |
|---|---|---|---|
| Système de types | Typage structurel (duck typing) | Typage nominal (doit déclarer explicitement les relations d'héritage) | Typage structurel (interfaces implicites) |
| Sécurité null | ActivationstrictNullChecksle prend en charge par la suite | Java nécessite des annotations ou Optional, C# 8+ prend en charge | Via des valeurs d'erreur et des vérifications nil |
| Génériques | Pris en charge, syntaxe similaire à Java/C# | Pris en charge, Java a des limitations d'effacement de type | Go 1.18+ le prend en charge, avec une syntaxe plus simple |
| Sortie compilée | JavaScript (s'exécute dans des environnements JS) | Bytecode (s'exécute sur JVM / CLR) | Code machine natif |
| Vérification des types à l'exécution | Aucune (les informations de type sont effacées après compilation) | Oui (mécanisme de réflexion) | Aucune |
| Courbe d'apprentissage | Accessible aux développeurs JS, peut être adopté progressivement | Plus difficile pour les débutants | Relativement simple, courbe d'apprentissage modérée |
TypeScript utiliseun système de typage structurel(typage structurel) : tant que deux types ont la même « forme », ils sont considérés comme compatibles, sans nécessiter la déclaration explicite de relations d'héritage. Cela diffère fondamentalement du typage nominal de Java/C#, et c'est aussi la raison clé pour laquelle TypeScript peut interagir de manière transparente avec JavaScript.
Limites de TypeScript
TypeScript n'est pas une solution miracle ; comprendre ses limites est tout aussi important.
| Limite | Description | Comment y remédier |
|---|---|---|
| Pas de types à l'exécution | Les informations de type sont complètement effacées après compilation, et l'on ne peut pas se fier aux types pour effectuer des vérifications à l'exécution | Utiliser des bibliothèques telles quezod、io-tslorsqu'une validation à l'exécution est nécessaire |
| Étape de compilation | Ajoute une étape de compilation par rapport au JS pur, augmentant la complexité du projet | Les outils de build modernes (Vite, esbuild) gèrent déjà bien cela |
| échappatoire du type any | La surutilisation deanyrend la vérification des types inefficace | ActivernoImplicitAnyetstrictmode, combiné à des règles ESLint |
| La barrière de la gymnastique de types | Les types conditionnels complexes et les types mappés ne sont pas adaptés aux débutants | La plupart du code métier ne nécessite pas de types avancés ; avancez étape par étape |
| Prise en charge des bibliothèques tierces | Quelques bibliothèques plus anciennes manquent de définitions de types, ce qui vous oblige à écrire vous-même les fichiers .d.ts | Vérifiez d'abord@types/*; si elle est vraiment absente, écrivez manuellement le fichier de déclaration |