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
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
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 { 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 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 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
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() 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
Autres extensionsRecommandation :Organiser raisonnablement la structure des modules, utiliser des alias de chemins pour simplifier les imports, et établir des conventions claires d'export/import.