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
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.
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
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 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
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
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
Andere ErweiterungenEmpfehlungen:Kompilierungszeit und Bundle-Größe regelmäßig prüfen und die Projektleistung kontinuierlich optimieren.