TypeScript-Pfadzuordnung paths

paths ist eine Konfigurationsoption in tsconfig.json, die verwendet wird, um Modul-Pfad-Aliase zu konfigurieren.

Es macht Importpfade prägnanter, während die Code-Struktur organisiert und klar bleibt.


SVG-Diagramm: Wie Pfadzuordnung funktioniert Background Title How Path Mapping paths Works Original Import Original Import Path import Button from "../../components/Button" Arrow After Path Mapping Import Using Alias import Button from "@/components/Button" Arrow tsconfig paths Configuration Bottom Section: Configuration Options paths Configuration Option Configuration 1 baseUrl Base Path Configuration 2 paths Path Aliases Configuration 3 rootDirs Root Directories Arrow Marker

Warum Pfadzuordnung benötigt wird

Mit zunehmender Projektgröße wird die Dateiverzeichnisstruktur tiefer.

Die Verwendung relativer Pfade zum Importieren von Dateien (z. B. ../../../components/Button) macht den Code schwer lesbar und wartbar.

Pfad-Mapping ermöglicht es uns, Aliase (z. B. @/components/Button) zu verwenden, um lange relative Pfade zu ersetzen.

Alias:Pfad-Aliase machen Importpfade prägnanter und erleichtern die Anpassung der Projektstruktur.


Basiskonfiguration

Konfiguriere paths und baseUrl in tsconfig.json.

tsconfig.json

{
    "compilerOptions": {
        // Basispfad: das Stammverzeichnis für alle Pfad-Aliase
        "baseUrl": ".",

        // Konfiguration der Pfadzuordnung
        "paths": {
            // Alias, der mit @/ beginnt und auf das Verzeichnis src verweist
            "@/*": ["src/*"],

            // Alias, der mit @components beginnt
            "@components/*": ["src/components/*"],

            // Alias, der mit @utils beginnt
            "@utils/*": ["src/utils/*"],

            // Alias, der mit @services beginnt
            "@services/*": ["src/services/*"],

            // Alias, der mit @assets beginnt
            "@assets/*": ["src/assets/*"],

            // Alias, der mit @types beginnt
            "@types/*": ["src/types/*"]
        }
    }
}

baseUrl:Nach dem Festlegen von baseUrl werden Pfade in der Option paths relativ zu diesem Verzeichnis aufgelöst.


Verwendung von Pfad-Aliasen

Nach Abschluss der Konfiguration können Sie Aliase verwenden, um Module in Ihrem Code zu importieren.

src/components/Button.tsx

// Import mit Pfad-Alias
import { Button } from '@/components/Button';
import { User } from '@types/user';
import { fetchUser } from '@services/userApi';
import { formatDate } from '@utils/date';

// Styles importieren
import styles from '@/components/Button.module.css';

// Bilder importieren
import logo from '@assets/logo.png';

// Das importierte Modul verwenden
const handleClick = () => {
    console.log('Button clicked');
};

const userButton = new Button({
    text: 'Benutzer',
    onClick: handleClick
});

console.log('Komponente erfolgreich geladen');

Syntax:Verwenden Sie * als Platzhalter in der paths-Konfiguration und gleichen Sie den tatsächlichen Pfad beim Import mit * ab.


Webpack-Alias-Konfiguration

Wenn Sie Webpack verwenden, müssen Sie außerdem resolve.alias konfigurieren, um die Laufzeit zu unterstützen.

webpack.config.js

// Webpack-Modul importieren
const path = require('path');

// Webpack-Konfiguration
module.exports = {
    // Weitere Konfiguration...
    resolve: {
        // Pfad-Alias-Konfiguration, muss mit tsconfig.json übereinstimmen
        alias: {
            // Alias, der mit @ beginnt
            '@': path.resolve(__dirname, 'src'),

            // Andere Aliase
            '@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')
        },

        // Dateiendungen
        extensions: ['.ts', '.tsx', '.js', '.jsx', '.json']
    }
};

Laufzeitkonsistenz:Webpacks Alias-Konfiguration muss mit TypeScripts paths-Konfiguration konsistent sein, andernfalls tritt zur Laufzeit ein Fehler „Modul nicht gefunden“ auf.


Vite-Konfiguration

Bei der Verwendung von Vite müssen sowohl tsconfig.json als auch vite.config.ts konfiguriert werden.

vite.config.ts

// Vite-Modul importieren
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
import path from 'path';

// Vite-Konfiguration
export default defineConfig({
    plugins: [react()],

    // Pfad-Alias-Konfiguration
    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 verwendet Rollup als Bundling-Engine, daher müssen Aliase in resolve.alias konfiguriert werden.


Multi-Projekt-Pfadkonfiguration

In Monorepo-Projekten können paketübergreifende Pfad-Aliase konfiguriert werden.

tsconfig.json (Monorepo)

{
    "compilerOptions": {
        // Basispfad
        "baseUrl": ".",

        // Pfadzuordnung, unterstützt paketübergreifende Referenzen
        "paths": {
            // Module aus dem aktuellen Paket referenzieren
            "@/*": ["src/*"],

            // Module aus anderen Paketen referenzieren
            "@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:In Monorepo-Projekten können Pfade auf Quellpfade anderer Pakete verweisen.


Hinweise

  • baseUrl ist erforderlich:paths müssen zusammen mit baseUrl verwendet werden
  • Wildcard-Übereinstimmung:Verwenden Sie *, um einen beliebigen Pfad abzugleichen
  • Konsistenz wahren:Webpack/Vite-Konfiguration muss mit tsconfig konsistent bleiben
  • Relative Pfade:Pfade in der paths-Option sind relativ zu baseUrl

Bewährte Methoden:Die Verwendung von Pfadaliasen kann Code prägnanter machen, aber verwenden Sie sie nicht übermäßig; es wird empfohlen, Namenskonventionen zu vereinheitlichen.


Zusammenfassung

Pfadzuordnung ist ein wichtiges Werkzeug zur Verwaltung von Importpfaden in TypeScript-Projekten.

  • paths:Pfadaliasen konfigurieren
  • baseUrl:Basispfad festlegen
  • Wildcard:Verwenden Sie *, um beliebige Zeichen abzugleichen
  • Build-Tools:Webpack/Vite benötigen eine synchronisierte Konfiguration

Empfehlung:Legen Sie Pfadaliasen für häufig verwendete Verzeichnisse fest, um die Lesbarkeit und Wartbarkeit des Codes zu verbessern.

Andere Erweiterungen