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ématiqueLe dilemme de JavaScriptLa solution de TypeScript
Passer un type incorrect à un paramètre de fonctionLes erreurs n'apparaissent qu'à l'exécution et sont difficiles à détecter tôtLes erreurs apparaissent à la compilation, avec des indications en temps réel dans l'IDE
Accéder à des propriétés inexistantesRenvoieundefined, le comportement est imprévisibleLe compilateur signale directement une erreur et refuse de laisser passer
Refactoriser de grands projetsModifier un endroit, sans savoir où cela va casserLe système de types suit automatiquement toutes les références
Collaboration en équipeLes paramètres qu'une fonction accepte et la valeur qu'elle renvoie reposent entièrement sur des commentaires ou de la documentationLes signatures de type servent de documentation, avec l'autocomplétion de l'IDE
Lisibilité du codeVous ne pouvez pas connaître directement la structure de données à partir d'une définition de fonctionLes 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

// JavaScript : l'erreur ne se produit qu'à l'exécution
function greet(name) {
    return "Hello, " + name.toUpperCase();
}

greet(123); // Erreur d'exécution : name.toUpperCase n'est pas une fonction

Exemple

// TypeScript : les erreurs peuvent être détectées à la compilation
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 comparaisonJavaScriptTypeScript
Système de typesTypage dynamique, déterminé à l'exécutionTypage statique, vérifié à la compilation (facultatif)
Méthode d'exécutionS'exécute directement dans le navigateur / Node.jsDoit être compilé en JS avant d'être exécuté
Moment de la détection des erreursExécutionAu moment de la compilation (détectées tôt)
Prise en charge par l'IDEComplétion de baseInférence de type forte, complétion précise, prise en charge du refactoring
Courbe d'apprentissageRelativement douceNé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

// Types de base : number, string, boolean, null, undefined, symbol, bigint
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

// Définir l'interface : décrire la structure d'un objet utilisateur
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 union : une variable peut être l'un de plusieurs types
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

// Sans génériques : ne peut gérer que le type number
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

// Énumération numérique (incrémentation par défaut à partir de 0)
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

TypeScript 会自动推断变量类型,无需显式标注
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

class Animal {
    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 : Je
suis 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

// Décorateur de classe : exécuté lorsque la classe est définie
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 :

FrameworkPrise en charge de TypeScriptScénario typique
AngularLangage officiel, TypeScript par défaut, impossible à éviter.SPA d'entreprise, systèmes d'administration
ReactFourni officiellement@types/react, Create React App et Vite incluent tous deux des modèles TypeScriptE-commerce, plateformes de contenu, applications d'administration/backend
VueLe code principal de Vue 3 est réécrit en TypeScript, et la Composition API améliore considérablement l'affinité avec TypeScriptProjets de petite à moyenne taille, migration progressive
Next / NuxtPrise en charge intégrée de TypeScript, activée par défaut pour les nouveaux projetsApplications 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)

TempsVersionÉvénements importants
2013-060.9Version stable officielle, performances considérablement améliorées, meilleure intégration dans l'IDE
2014-041.0Premiè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-071.5Introduction 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.

TempsVersion / ÉvénementImportance du jalon
2016-09TypeScript 2.0Introduction 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
2016Sortie d'Angular 2L'é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
2017Série TypeScript 2.xLes 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-07TypeScript 3.0Project References, prenant en charge les grands monorepos ; introduction du type unknown (un type supérieur plus sûr que any)
2019DefinitelyTypedDé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)

TempsVersion / ÉvénementContenu important
2020-08TypeScript 4.0Types de tuples variadiques, éléments de tuple étiquetés ; expérience de l'éditeur considérablement améliorée
2021Série TypeScript 4.xTemplate Literal Types, types utilitaires intégrés améliorés,noImplicitOverrideet d'autres améliorations du mode strict
2022Enquête State of JSLe 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
2022Adoption de Vue 3 / ViteLe 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)

TempsVersionCaractéristiques clés
2023-03TypeScript 5.0Dé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-08TypeScript 5.2Introduction 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-03TypeScript 5.4Amélioration du rétrécissement de type dans les fermetures,NoInfertypes utilitaires
2024-06TypeScript 5.5infé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-11TypeScript 5.7Prise en charge de--target es2024, détection plus fiable des variables non initialisées
2025-03TypeScript 5.8Vé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 comparaisonTypeScriptJava / C#Go
Système de typesTypage structurel (duck typing)Typage nominal (doit déclarer explicitement les relations d'héritage)Typage structurel (interfaces implicites)
Sécurité nullActivationstrictNullChecksle prend en charge par la suiteJava nécessite des annotations ou Optional, C# 8+ prend en chargeVia des valeurs d'erreur et des vérifications nil
GénériquesPris en charge, syntaxe similaire à Java/C#Pris en charge, Java a des limitations d'effacement de typeGo 1.18+ le prend en charge, avec une syntaxe plus simple
Sortie compiléeJavaScript (s'exécute dans des environnements JS)Bytecode (s'exécute sur JVM / CLR)Code machine natif
Vérification des types à l'exécutionAucune (les informations de type sont effacées après compilation)Oui (mécanisme de réflexion)Aucune
Courbe d'apprentissageAccessible aux développeurs JS, peut être adopté progressivementPlus difficile pour les débutantsRelativement 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.

LimiteDescriptionComment y remédier
Pas de types à l'exécutionLes 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écutionUtiliser des bibliothèques telles quezod、io-tslorsqu'une validation à l'exécution est nécessaire
Étape de compilationAjoute une étape de compilation par rapport au JS pur, augmentant la complexité du projetLes outils de build modernes (Vite, esbuild) gèrent déjà bien cela
échappatoire du type anyLa surutilisation deanyrend la vérification des types inefficaceActivernoImplicitAnyetstrictmode, combiné à des règles ESLint
La barrière de la gymnastique de typesLes types conditionnels complexes et les types mappés ne sont pas adaptés aux débutantsLa plupart du code métier ne nécessite pas de types avancés ; avancez étape par étape
Prise en charge des bibliothèques tiercesQuelques bibliothèques plus anciennes manquent de définitions de types, ce qui vous oblige à écrire vous-même les fichiers .d.tsVérifiez d'abord@types/*; si elle est vraiment absente, écrivez manuellement le fichier de déclaration
Autres extensions