Fonctionnalités de TypeScript
Comparé à JavaScript, TypeScript ajoute de nombreuses fonctionnalités clés, notamment des améliorations autour du système de types et de la structure du code.
Quelques fonctionnalités clés de TypeScript :
Vérification statique des types: TypeScript vérifie si les types du code correspondent au moment de la compilation, ce qui permet d'attraper de nombreuses erreurs potentielles. Même des erreurs simples (telles que des fautes de frappe ou des incohérences de type) peuvent être détectées pendant l'écriture du code.
Inférence de types: TypeScript peut automatiquement inférer les types des variables. Par exemple, lorsque vous déclarez une variable et lui assignez une valeur, TypeScript infère le type de la variable en fonction de l'affectation, vous n'avez donc pas besoin de déclarer explicitement les types à chaque fois.
Interfaces et définitions de types: TypeScript fournit le
interfaceettypemot-clé, vous permettant de définir des structures de données complexes. Ceci est très important pour la collaboration sur le code et l'interaction des données entre différentes parties d'un projet.Prise en charge des classes et des modules: TypeScript prend en charge le concept de classe issu de la programmation orientée objet, en ajoutant des constructeurs, l’héritage, des modificateurs de contrôle d’accès (tels que
public、private、protected), et prend en charge la spécification des modules ES.Prise en charge des outils et des éditeurs: TypeScript bénéficie d’un excellent support d’éditeur, en particulier lorsqu’il est intégré à Visual Studio Code, offrant IntelliSense, l’autocomplétion, la refactorisation et d’autres outils, ce qui rend le développement plus efficace.
Compatible avec JavaScript: TypeScript est un sur-ensemble de JavaScript, ce qui signifie que tout code JavaScript valide est du code TypeScript valide. Cela permet aux projets JavaScript de migrer progressivement vers TypeScript sans réécriture complète.
Voici les principales fonctionnalités ajoutées par TypeScript :
1. Types statiques
La plus grande caractéristique de TypeScript est l’ajout d’un système de types statique. En TypeScript, les développeurs peuvent déclarer explicitement les types des variables, des paramètres et des valeurs de retour, ce qui permet de détecter de nombreuses erreurs de type potentielles à la compilation. Les types courants incluentnumber、string、boolean、array、tuple、enumetc., et les types personnalisés sont également pris en charge.
let name: string = "Alice"; let age: number = 25;
2. Inférence de type
TypeScript peut déduire automatiquement les types des variables. Même sans déclarer explicitement les types, TypeScript déduit les types en fonction de la valeur assignée, ce qui réduit la quantité d’annotations de type nécessaires dans la plupart des cas.
let name = "Alice"; // 推断为 string
3. Interfaces
TypeScript fournit des interfaces, ce qui permet de définir des structures d’objets complexes. Les interfaces peuvent définir des propriétés et des méthodes, et peuvent être implémentées à l’aide duimplementsmot-clé, ou étendues viaextendspour faciliter la définition de types de données complexes.
interface Person {
name: string;
age: number;
greet(): void;
}
class Student implements Person {
constructor(public name: string, public age: number) {}
greet() {
console.log(`Hello, my name is ${this.name}`);
}
}
4. Alias de type
Alias de type (type) peuvent définir des alias courts pour des types complexes, facilitant la réutilisation du code.
type StringOrNumber = string | number; let value: StringOrNumber = 42;
5. Énumérations
TypeScript introduit leenumtype, utilisé pour définir un ensemble de constantes nommées, améliorant la lisibilité du code. Les énumérations n'ont pas d'équivalent direct en JavaScript.
enum Direction {
Up,
Down,
Left,
Right,
}
let dir: Direction = Direction.Up;
6. Tuples
Les tuples permettent de définir des tableaux avec un nombre et des types d'éléments fixes. Ils conviennent aux scénarios nécessitant des structures de données fixes, telles que des coordonnées ou des valeurs de couleur RGB.
let point: [number, number] = [10, 20];
7. Modificateurs d'accès
TypeScript fournit lespublic、privateetprotectedmodificateurs dans les classes, permettant de contrôler la visibilité des propriétés ou des méthodes et favorisant une meilleure encapsulation.
class Person {
private name: string;
protected age: number;
public constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
8. Classes abstraites
TypeScript prend en charge les classes abstraites. Les classes abstraites ne peuvent pas être instanciées directement et doivent être implémentées par des sous-classes. Les classes abstraites conviennent pour définir des hiérarchies de classes avec un comportement commun et des méthodes abstraites.
abstract class Animal {
abstract makeSound(): void;
}
class Dog extends Animal {
makeSound() {
console.log("Woof!");
}
}
9. Génériques
TypeScript prend en charge les génériques, permettant des types paramétrés dans les classes, les interfaces et les fonctions, ce qui permet au code de s'adapter à différents besoins de types tout en conservant la sûreté du typage.
function identity<T>(value: T): T {
return value;
}
let num = identity<number>(42);
10. Modules et espaces de noms
TypeScript fournit un système de modules basé sur ES6, en utilisantimportetexportpour importer et exporter des modules. De plus, TypeScript prend en charge les espaces de noms pour organiser le code et éviter les conflits de noms.
// math.ts
export function add(a: number, b: number): number {
return a + b;
}
// main.ts
import { add } from "./math";
console.log(add(2, 3));
11. Gardes de type
TypeScript fournit des gardes de type, qui permettent de vérifier les types des variables dans le code et aident le compilateur à inférer des types plus spécifiques. Cela est particulièrement important pour les types union.
function printId(id: string | number) {
if (typeof id === "string") {
console.log(id.toUpperCase());
} else {
console.log(id.toFixed(2));
}
}
12. Opérateurs de chaînage optionnel et de coalescence des nuls
TypeScript ajoute le chaînage optionnel de JavaScript (?.) et l'opérateur de coalescence des nuls (??), ce qui simplifie la gestion desnullouundefinedvaleurs potentiellement indéfinies dans le code.
let user = { name: "Alice", address: { city: "Wonderland" } };
console.log(user?.address?.city); // 如果 address 存在则输出 city,否则返回 undefined
let value = null;
console.log(value ?? "default"); // 如果 value 为 null 或 undefined,则返回 "default"
13. Compatibilité des types et types utilitaires
TypeScript fournit certains types utilitaires, tels quePartial、Pick、Readonly、Recordetc. Ces types peuvent aider à générer de nouveaux types et à simplifier les définitions de types.
interface Todo {
title: string;
description: string;
}
let partialTodo: Partial<Todo> = { title: "Learn TypeScript" }; // 可选属性
14. Vérification des erreurs à la compilation
La vérification des erreurs à la compilation de TypeScript peut détecter des erreurs difficiles à repérer en JavaScript, telles que les fautes de frappe et les incompatibilités de types, ce qui aide à améliorer la qualité du code.
15. Prise en charge des nouvelles fonctionnalités ES
TypeScript prend en charge certaines fonctionnalités ES qui ne sont pas encore largement disponibles dans tous les environnements, telles que les décorateurs et les itérateurs asynchrones, et peut les compiler dans des versions JavaScript compatibles.
Grâce à ces fonctionnalités, TypeScript offre des capacités de codage plus sûres et plus structurées, particulièrement avantageuses dans les grands projets et la collaboration à plusieurs.
Autres extensions