TypeScript-Leistungsoptimierung

Die Performance-Optimierung von TypeScript-Projekten umfasst mehrere Aspekte wie Kompilierungsgeschwindigkeit, Laufzeitleistung und Codegröße.

Dieses Tutorial stellt gängige Techniken zur Performance-Optimierung vor, um effizientere TypeScript-Anwendungen zu erstellen.


SVG-Diagramm: Dimensionen der Performance-Optimierung Background Title TypeScript Performance Optimization Dimensions Compilation Speed Compilation Speed Incremental Build | skipLibCheck Runtime Performance Runtime Performance Type Inference | Avoid any Bundle Size Bundle Size Tree Shaking | Lazy Loading Bottom Section: Optimization Strategies Key Optimization Strategies Strategy 1 skipLibCheck Skip Library Type Checking Strategy 2 incremental Incremental Compilation Strategy 3 Project References Project References

Warum Performance-Optimierung notwendig ist

Obwohl TypeScript ein leistungsstarkes Typsystem bietet, kann unsachgemäße Verwendung die Kompilierungsgeschwindigkeit und Laufzeitleistung beeinträchtigen.

Das Kompilieren großer Projekte kann mehrere Minuten dauern und die Entwicklungserfahrung ernsthaft beeinträchtigen.

Die in diesem Tutorial vorgestellten Konfigurationen und Techniken können die Performance von TypeScript-Projekten deutlich verbessern.

Optimierungsziele:Schnellere Kompilierungsgeschwindigkeit, kleinere Bundle-Größe und höhere Laufzeitleistung.


Optimierung der Kompilierungskonfiguration

Verbessern Sie die Kompilierungsgeschwindigkeit durch Optimieren der tsconfig.json-Konfiguration.

Optimierungskonfiguration für tsconfig.json

{
    "compilerOptions": {
        // Inkrementelle Kompilierung aktivieren, letzte Kompilierungsinformationen speichern
        "incremental": true,

        // Typprüfung von node_modules überspringen
        // Kompilierungsgeschwindigkeit deutlich verbessern
        "skipLibCheck": true,

        // Generierung von Deklarationsdateien überspringen (nur während des finalen Builds generieren)
        "noEmit": true,

        // Schnelle inkrementelle Builds aktivieren
        "assumeChangesOnlyAffectDirectDependencies": true,

        // Parallel ausführen
        "parallel": true,

        // Caching aktivieren
        "tsBuildInfoFile": ".tsbuildinfo",

        // Dateien, die nicht geparst werden müssen
        "exclude": [
            "node_modules",
            "dist",
            "build",
            "**/*.test.ts"
        ]
    }
}

skipLibCheck:Dies ist die wichtigste Optimierungsoption, die die Kompilierungszeit um mehr als 50% reduzieren kann.


Optimierung der Projektreferenzen

Verwenden Sie Projektreferenzen, um große Projekte in kleinere Module aufzuteilen, um inkrementelle Kompilierung zu erreichen.

packages/utils/tsconfig.json

{
    // Basiskonfiguration erben
    "extends": "../../tsconfig.base.json",

    "compilerOptions": {
        "composite": true,
        "outDir": "./dist",
        "declaration": true,
        "declarationMap": true
    },

    "include": ["src/**/*"],
    "exclude": ["node_modules", "dist"]
}

composite:Wenn aktiviert, generiert TypeScript .tsbuildinfo-Dateien, um nachfolgende Kompilierungen zu beschleunigen.


Optimierung der Typinferenz

Nutzen Sie die Typinferenz von TypeScript voll aus und vermeiden Sie übermäßige Typannotation.

< h2 class="example">Beispiel
// Schlechte Praxis: übermäßiges Annotieren von Typen
const name: string = "Alice";
const age: number = 25;
const isActive: boolean = true;

// Gute Praxis: Typinferenz nutzen
const name = "Alice";
const age = 25;
const isActive = boolean;

// Rückgabetypen von Funktionen können weggelassen werden (TypeScript leitet sie automatisch ab)
function add(a: number, b: number) {
    return a + b;
}

// Typinferenz für komplexe Objekte verwenden
const user = {
    id: 1,
    name: "Bob",
    email: "bob@example.com"
};
// TypeScript leitet ab:
// { id: number; name: string; email: string }

// Nur explizit annotieren, wenn die Typinferenz ungenau ist
const elements: HTMLElement[] = [];

Annotationen reduzieren:TypeScripts Typinferenz ist bereits sehr intelligent, und in den meisten Fällen sind explizite Typannotationen nicht erforderlich.


Verwendung von any vermeiden

Die Verwendung von any verliert die Vorteile der Typprüfung und beeinträchtigt die Laufzeitleistung.

Beispiel

// Schlechte Praxis: Verwendung von any
function processData(data: any): any {
    return data.value;
}

// Gute Praxis: unknown oder spezifische Typen verwenden
function processData<T extends { value: string }>(data: T): string {
    return data.value;
}

// Wenn du den Typ wirklich nicht kennst, verwende unknown
function parseJSON(json: string): unknown {
    return JSON.parse(json);
}

// Typprüfung bei der Verwendung durchführen
const data = parseJSON('{"key": "value"}');
if (typeof data === "object" && data !== null) {
    const obj = data as { key: string };
    console.log(obj.key);
}

// Besserer Ansatz: Generics verwenden
function identity<T>(value: T): T {
    return value;
}

const result = identity("hello");
console.log("Ergebnis: " + result);

unknown vs. any:unknown ist ein typsicheres any, das vor der Verwendung eine Typüberprüfung erfordert.


Interface vs. Type Alias

Wählen Sie den passenden Ansatz zur Typdefinition je nach Szenario.

Beispiel

// Interface: geeignet zum Definieren von Objekttypen, unterstützt Declaration Merging
interface User {
    id: number;
    name: string;
}

// Ein Interface erweitern
interface User {
    email: string;
}

// Type Alias: geeignet für Union-Typen, Tupel und Funktionstypen
type ID = string | number;
type Status = "pending" | "success" | "error";
type Callback = (data: string) => void;

// Utility-Typen verwenden normalerweise type
type PartialUser = Partial<User>;
type ReadonlyUser = Readonly<User>;

// Leistungsüberlegung: Interfaces kompilieren im Allgemeinen schneller als Typ-Aliase
// Für einfache Objekttypen kann interface verwendet werden
interface Point {
    x: number;
    y: number;
}

// Für Union-Typen type verwenden
type Shape = Circle | Square | Triangle;

Auswahl-Empfehlungen:Verwenden Sie Interfaces für Objekttypen, type für Union-Typen und type für Funktionstypen.


Build-Tool-Optimierung

Konfigurieren Sie Build-Tools, um optimale Leistung zu erzielen.

vite.config.ts

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

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

    // Build-Optimierung
    build: {
        // Code-Splitting aktivieren
        rollupOptions: {
            output: {
                // Manuelles Chunk-Splitting
                manualChunks: {
                    'vendor': ['react', 'react-dom'],
                    'utils': ['lodash', 'axios']
                }
            }
        },

        // Code minifizieren
        minify: 'terser',

        // Sourcemap generieren
        sourcemap: false,

        // Chunk-Größenlimit
        chunkSizeWarningLimit: 500
    },

    // Optimierung des Dev-Servers
    server: {
        // Hot Module Replacement aktivieren
        hmr: {
            overlay: true
        }
    },

    // Abhängigkeitsauflösung optimieren
    optimizeDeps: {
        include: ['react', 'react-dom'],
        exclude: ['some-large-library']
    }
});

Code-Splitting:Verwende manualChunks, um große Bibliotheken zu trennen und die Größe des Haupt-Bundles zu reduzieren.


Tree Shaking

Konfiguriere Module, um Tree Shaking zu unterstützen und ungenutzten Code zu entfernen.

src/utils/index.ts

// ES-Modul-Exporte verwenden, um Tree Shaking zu unterstützen
export function add(a: number, b: number): number {
    return a + b;
}

export function subtract(a: number, b: number): number {
    return a - b;
}

export function multiply(a: number, b: number): number {
    return a * b;
}

export function divide(a: number, b: number): number {
    if (b === 0) {
        throw new Error("Division durch null nicht möglich");
    }
    return a / b;
}

// Benannte Exporte sind für Tree Shaking besser geeignet als Standard-Exporte
// Falsch: export default verhindert Tree Shaking
// export default { add, subtract, multiply, divide };

// Richtig: benannte Exporte verwenden
console.log("Hilfsmodul geladen");

Benannte Exporte:Die Verwendung benannter Exporte anstelle von Standard-Exporten ermöglicht es Build-Tools, Tree Shaking effektiver durchzuführen.


Hinweise

  • skipLibCheck:Muss in der Produktion aktiviert sein
  • Inkrementelle Kompilierung:Empfohlen, in der Entwicklungsumgebung zu aktivieren
  • any vermeiden:Stattdessen unknown verwenden
  • Tree Shaking:ES-Module und benannte Exporte verwenden

Best Practices:Optimierungskonfigurationen früh im Entwicklungsprozess einrichten, um spätere Refactorings zu vermeiden.


Zusammenfassung

Die Leistungsoptimierung von TypeScript umfasst mehrere Aspekte.

  • Kompilierungsoptimierung:skipLibCheck、incremental、project references
  • Typoptimierung:Inferenz nutzen, any vermeiden, geeignete Typdefinitionen wählen
  • Build-Optimierung:Code-Splitting, Tree Shaking, Abhängigkeitsoptimierung
  • Laufzeitoptimierung:Typsicherheit, generische Constraints

Empfehlungen:Kompilierungszeit und Bundle-Größe regelmäßig prüfen und die Projektleistung kontinuierlich optimieren.

Andere Erweiterungen