Système de modules TypeScript

Le système de modules est la base du développement TypeScript moderne.

TypeScript prend entièrement en charge la syntaxe des modules ES et fournit de riches stratégies de résolution de modules.

Grâce au système de modules, le code peut être divisé en unités réutilisables, ce qui permet l'organisation et la réutilisation du code.


Diagramme SVG : Export/Import de modules Background Title Module Export/Import Flow user.ts Module user.ts export const name = "Alice" export class User { ... } export interface Config { ... Arrow import main.ts Module main.ts import { name, User } from "./user"; import User from "./user" Arrow use Runtime Output JavaScript Execute Code Lower Section: Export Types Export/Import Methods Method 1 Named Export/Import Method 2 Default Export/Import Method 3 Re-export Method 4 Dynamic Import Arrow Marker

Pourquoi avons-nous besoin d'un système de modules

À mesure que l'échelle du projet augmente, la quantité de code augmente.

Répartir le code sur plusieurs fichiers et l'organiser via des modules améliore la maintenabilité et la réutilisabilité du code.

Le système de modules donne à chaque fichier sa propre portée, empêchant la pollution des variables globales.

Explication du concept :Un module est un fichier TypeScript qui contient des instructions export et import. Le contenu est exporté via export et importé via import.


Export de module

Utilisez le mot-clé export pour exporter des variables, des fonctions, des classes, des interfaces, etc. afin qu'elles soient utilisées par d'autres modules.

Module user.ts

// Exporter une variable
export var name = "Alice";
export const age = 25;

// Exporter une fonction
export function greet(message: string): string {
    return "Bonjour, " + message;
}

// Exporter la classe
export class User {
    // Propriétés des paramètres du constructeur
    constructor(public name: string) {}

    // Méthode d'auto-présentation
    introduce(): string {
        return "Je suis " + this.name;
    }
}

// Exporter l'interface (les interfaces disparaissent après compilation ; elles ne sont utilisées que pour la vérification de type)
export interface Config {
    // Configurer l'hôte
    host: string;
    // Configurer le port
    port: number;
}

// Export par lots : renommer les exports
export { name as userName, age as userAge };

Remarque :Les interfaces et les types ne génèrent pas de code réel dans le JavaScript compilé ; ils ne sont utilisés que pour la vérification de type TypeScript.


Import de module

Utilisez le mot-clé import pour importer le contenu exporté depuis d'autres modules.

main.ts Importation de module

// Import nommé : importer un contenu spécifique depuis un module
import { name, age, greet } from "./user";

// Import par défaut : importer l'export par défaut d'un module
import User from "./user";

// Tout importer : placer toutes les exportations du module dans un objet
import * as UserModule from "./user";

// Renommer l'import : éviter les conflits de noms
import { greet as sayHello } from "./user";

// Utiliser le contenu importé
console.log(greet("World"));
console.log(sayHello("TypeScript"));

Sortie :

Hello, World
Hello, TypeScript

Explication du chemin :Les chemins d'import peuvent être des chemins relatifs (par ex.,./user) ou des chemins absolus (par ex.,@/utils)。


Export par défaut

Chaque module peut avoir un export par défaut.

Les exports par défaut ne nécessitent pas d'accolades lors de l'importation et peuvent recevoir n'importe quel nom.

Module math.ts

// Export par défaut : un module ne peut avoir qu'un seul export par défaut
export default function add(a: number, b: number): nombre {
    return a + b;
}

// Peut être combiné avec d'autres exports
export function multiply(a: number, b: number): nombre {
    return a * b;
}

Import de main.ts

// Import de l'export par défaut : peut utiliser n'importe quel nom
import add from "./math";

// Import d'un export nommé : nécessite des accolades
import { multiply } from "./math";

console.log("Addition: " + add(2, 3));
console.log("Multiplication: " + multiply(4, 5));

Sortie :

加法: 5
乘法: 20

Recommandation :Utilisez les exports par défaut pour le contenu d'export principal tel que les fonctions utilitaires et les classes ; utilisez les exports nommés pour les fonctions auxiliaires, les interfaces, etc.


Réexport

Le réexport est utilisé pour agréger le contenu de plusieurs modules ou exposer les exports d'un module à un autre module.

index.ts Module d'agrégation

// Réexporter du contenu spécifique depuis d'autres modules
export { name, age } from "./user";

// Réexporter l'export par défaut (nécessite un renommage)
export { default as User } from "./user";

// Réexporter tout le contenu
export * from "./math";

Cas d'utilisation :Utiliser index.ts comme fichier d'entrée pour exporter de manière centralisée le contenu des modules enfants afin d'unifier les imports.


Stratégies de résolution de modules

TypeScript fournit plusieurs stratégies de résolution de modules pour localiser les modules importés.

Cela peut être configuré dans tsconfig.json.

Configuration de tsconfig.json

{
    "compilerOptions": {
        // Stratégie de résolution Node
        // Suit les règles de résolution de modules de Node.js
        "moduleResolution": "node",

        // Stratégie de résolution classique
        // Stratégie utilisée par les premières versions de TypeScript
        "moduleResolution": "classic",

        // URL de base : définit le chemin de base
        // Tous les imports dont le chemin n'est pas relatif sont résolus en fonction de ce chemin
        "baseUrl": "./src",

        // Mappage de chemins : définit des alias pour les chemins d'import
        "paths": {
            // Les imports commençant par @ correspondent au répertoire src
            "@/*": ["./*"],
            // Les imports commençant par @components correspondent au répertoire components
            "@components/*": ["./components/*"]
        }
    }
}

Recommandation de configuration :Pour les nouveaux projets, la stratégie de résolution Node est recommandée car c'est actuellement l'approche la plus couramment utilisée.


Import dynamique

L'import dynamique utilise la syntaxe import() pour charger des modules à la demande au moment de l'exécution.

C'est très utile pour le découpage de code et le chargement différé.

Exemple

// Import dynamique - chargement différé
// import() renvoie une Promise
async function loadMath() {
    // Importer dynamiquement le module ; il n'est chargé que lorsque l'exécution atteint ce point
    var math = await import("./math");

    // math.default est la fonction exportée par défaut
    console.log("Addition dynamique : " + math.default(1, 2));
}

// Appeler la fonction à chargement différé
loadMath();

// Import conditionnel : charger dynamiquement différents modules selon les conditions
async function loadFeature(enable: boolean) {
    if (enable) {
        // Ne charger le module que lorsque la condition est remplie
        var feature = await import("./feature");
        feature.run();
    }
}

// Charger en fonction de la condition
loadFeature(true);

Sortie :

动态加法: 3

Optimisation des performances :Les imports dynamiques permettent le découpage du code, en chargeant du code supplémentaire uniquement lorsque cela est nécessaire, ce qui réduit le temps de chargement initial.


Notes

  • Chemins relatifs :Utilisez des chemins relatifs pour importer des modules locaux (./, ../)
  • Extensions de module :TypeScript gère automatiquement les extensions lors de la compilation
  • Par défaut vs nommé :Un export par défaut par module, plusieurs exports nommés
  • esModuleInterop:L'activation de cette option facilite l'importation des modules CommonJS

Bonnes pratiques :Gardez des chemins d'importation cohérents, utilisez des alias de chemin pour simplifier les chemins longs, et établissez une structure claire d'organisation des modules.


Résumé

Le système de modules est au cœur de l'organisation des projets TypeScript.

  • export:Exporter des variables, des fonctions, des classes, des interfaces
  • import:Importer le contenu exporté
  • Export par défaut :Un par module, flexible à utiliser
  • Réexport :Agréger des modules, créer des fichiers d'entrée
  • Import dynamique :Chargement différé, optimisation des performances
  • Résolution de modules :Configurer les alias de chemins et les stratégies de résolution

Recommandation :Organiser raisonnablement la structure des modules, utiliser des alias de chemins pour simplifier les imports, et établir des conventions claires d'export/import.

Autres extensions