Chemins de mappage de TypeScript
paths est une option de configuration dans tsconfig.json, utilisée pour configurer des alias de chemins de modules.
Il rend les chemins d'importation plus concis tout en gardant la structure du code organisée et claire.
Diagramme SVG : Comment fonctionne le mappage de chemins
Pourquoi le mappage de chemins est nécessaire
À mesure que la taille du projet augmente, la structure des répertoires de fichiers devient plus profonde.
L'utilisation de chemins relatifs pour importer des fichiers (par ex., ../../../components/Button) rend le code difficile à lire et à maintenir.
Le mappage de chemins permet d'utiliser des alias (par ex., @/components/Button) pour remplacer les longs chemins relatifs.
Alias :Les alias de chemins rendent les chemins d'importation plus concis et facilitent l'ajustement de la structure du projet.
Configuration de base
Configurez paths et baseUrl dans tsconfig.json.
tsconfig.json
"compilerOptions": {
// Chemin de base : le répertoire racine pour tous les alias de chemins
"baseUrl": ".",
// Configuration du mappage de chemins
"paths": {
// Alias commençant par @/, pointant vers le répertoire src
"@/*": ["src/*"],
// Alias commençant par @components
"@components/*": ["src/components/*"],
// Alias commençant par @utils
"@utils/*": ["src/utils/*"],
// Alias commençant par @services
"@services/*": ["src/services/*"],
// Alias commençant par @assets
"@assets/*": ["src/assets/*"],
// Alias commençant par @types
"@types/*": ["src/types/*"]
}
}
}
baseUrl:Après avoir défini baseUrl, les chemins dans l'option paths seront résolus relativement à ce répertoire.
Utilisation des alias de chemin
Une fois la configuration terminée, vous pouvez utiliser des alias pour importer des modules dans votre code.
src/components/Button.tsx
import { Button } from '@/components/Button';
import { User } from '@types/user';
import { fetchUser } from '@services/userApi';
import { formatDate } from '@utils/date';
// Importer les styles
import styles from '@/components/Button.module.css';
// Importer les images
import logo from '@assets/logo.png';
// Utiliser le module importé
const handleClick = () => {
console.log('Button clicked');
};
const userButton = new Button({
text: 'Utilisateur',
onClick: handleClick
});
console.log('Composant chargé avec succès');
Syntaxe :Utilisez * comme caractère générique dans la configuration paths, et faites correspondre le chemin réel avec * lors de l'importation.
Configuration des alias Webpack
Si vous utilisez Webpack, vous devez également configurer resolve.alias pour prendre en charge l'exécution.
webpack.config.js
const path = require('path');
// Configuration Webpack
module.exports = {
// Autre configuration...
resolve: {
// Configuration des alias de chemin, doit rester cohérente avec tsconfig.json
alias: {
// Alias commençant par @
'@': path.resolve(__dirname, 'src'),
// Autres alias
'@components': path.resolve(__dirname, 'src/components'),
'@utils': path.resolve(__dirname, 'src/utils'),
'@services': path.resolve(__dirname, 'src/services'),
'@types': path.resolve(__dirname, 'src/types'),
'@assets': path.resolve(__dirname, 'src/assets')
},
// Extensions de fichier
extensions: ['.ts', '.tsx', '.js', '.jsx', '.json']
}
};
Cohérence à l'exécution :La configuration d'alias de Webpack doit être cohérente avec la configuration paths de TypeScript, sinon une erreur de module introuvable se produira à l'exécution.
Configuration de Vite
Lorsque vous utilisez Vite, vous devez configurer à la fois tsconfig.json et vite.config.ts.
vite.config.ts
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import path from 'path';
// Configuration Vite
export default defineConfig({
plugins: [react()],
// Configuration des alias de chemin
resolve: {
alias: {
'@': path.resolve(__dirname, './src'),
'@components': path.resolve(__dirname, './src/components'),
'@utils': path.resolve(__dirname, './src/utils'),
'@services': path.resolve(__dirname, './src/services'),
'@types': path.resolve(__dirname, './src/types'),
'@assets': path.resolve(__dirname, './src/assets')
}
}
});
Vite:Vite utilise Rollup comme moteur d’empaquetage, vous devez donc configurer les alias dans resolve.alias.
Configuration des chemins multi-projets
Dans les projets Monorepo, vous pouvez configurer des alias de chemins entre packages.
tsconfig.json (Monorepo)
"compilerOptions": {
// Chemin de base
"baseUrl": ".",
// Mappage de chemins, prend en charge les références inter-packages
"paths": {
// Référencer les modules du package actuel
"@/*": ["src/*"],
// Référencer les modules d'autres packages
"@my-ui/button": ["packages/ui-button/src/index.ts"],
"@my-ui/modal": ["packages/ui-modal/src/index.ts"],
"@my-utils/date": ["packages/utils-date/src/index.ts"],
"@my-hooks/useFetch": ["packages/hooks-use-fetch/src/index.ts"]
}
}
}
Monorepo:Dans les projets Monorepo, les chemins peuvent référencer les chemins sources d'autres packages.
Notes
- baseUrl est requis :paths doivent être utilisés conjointement avec baseUrl
- Correspondance avec caractères génériques :Utilisez * pour correspondre à n'importe quel chemin
- Restez cohérent :La configuration Webpack/Vite doit rester cohérente avec tsconfig
- Chemins relatifs :Les chemins dans l'option paths sont relatifs à baseUrl
Bonnes pratiques :L'utilisation d'alias de chemins peut rendre le code plus concis, mais n'en abusez pas ; il est recommandé d'unifier les conventions de nommage.
Résumé
Le mappage de chemins est un outil important pour gérer les chemins d'import dans les projets TypeScript.
- paths:Configurer les alias de chemins
- baseUrl:Définir le chemin de base
- Caractère générique :Utilisez * pour correspondre à n'importe quels caractères
- Outils de build :Webpack/Vite nécessitent une configuration synchronisée
Autres extensionsRecommandation :Définissez des alias de chemins pour les répertoires couramment utilisés afin d'améliorer la lisibilité et la maintenabilité du code.