Optimisation des performances de TypeScript

L’optimisation des performances d’un projet TypeScript implique plusieurs aspects tels que la vitesse de compilation, les performances d’exécution et la taille du code.

Ce tutoriel présente des techniques courantes d’optimisation des performances pour aider à créer des applications TypeScript plus efficaces.


Diagramme SVG : dimensions de l’optimisation des performances 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

Pourquoi l’optimisation des performances est nécessaire

Bien que TypeScript fournisse un système de types puissant, une utilisation incorrecte peut affecter la vitesse de compilation et les performances d’exécution.

La compilation de grands projets peut prendre plusieurs minutes, ce qui affecte sérieusement l’expérience de développement.

Les configurations et techniques présentées dans ce tutoriel peuvent améliorer considérablement les performances des projets TypeScript.

Objectifs d’optimisation :Compilation plus rapide, taille de bundle plus petite et performances d’exécution plus élevées.


Optimisation de la configuration de compilation

Améliorer la vitesse de compilation en optimisant la configuration tsconfig.json.

Configuration d’optimisation de tsconfig.json

{
    "compilerOptions": {
        // Activer la compilation incrémentielle, enregistrer les dernières informations de compilation
        "incremental": true,

        // Ignorer la vérification des types de node_modules
        // Améliorer considérablement la vitesse de compilation
        "skipLibCheck": true,

        // Ignorer la génération des fichiers de déclaration (générer uniquement lors de la compilation finale)
        "noEmit": true,

        // Activer des compilations incrémentielles rapides
        "assumeChangesOnlyAffectDirectDependencies": true,

        // Exécuter en parallèle
        "parallel": true,

        // Activer la mise en cache
        "tsBuildInfoFile": ".tsbuildinfo",

        // Fichiers qui n'ont pas besoin d'être analysés
        "exclude": [
            "node_modules",
            "dist",
            "build",
            "**/*.test.ts"
        ]
    }
}

skipLibCheck:C'est l'option d'optimisation la plus importante, qui peut réduire le temps de compilation de plus de 50%.


Optimisation des références de projet

Utilisez les références de projet pour diviser les grands projets en modules plus petits afin d'obtenir une compilation incrémentielle.

packages/utils/tsconfig.json

{
    // Hériter de la configuration de base
    "extends": "../../tsconfig.base.json",

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

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

composite:Lorsqu'activé, TypeScript générera des fichiers .tsbuildinfo pour accélérer les compilations suivantes.


Optimisation de l'inférence de types

Tirez pleinement parti de l'inférence de types de TypeScript et évitez la sur-annotation.

< h2 class="example">Exemple
// Mauvaise pratique : sur-annotation des types
const name: string = "Alice";
const age: number = 25;
const isActive: boolean = true;

// Bonne pratique : tirer parti de l'inférence de type
const name = "Alice";
const age = 25;
const isActive = true;

// Les types de retour de fonction peuvent être omis (TypeScript les infère automatiquement)
function add(a: number, b: number) {
    return a + b;
}

// Utilisez l'inférence de type pour les objets complexes
const user = {
    id: 1,
    name: "Bob",
    email: "bob@example.com"
};
// TypeScript inférera :
// { id: number; name: string; email: string }

// N'annotez explicitement que lorsque l'inférence de type est inexacte
const elements: HTMLElement[] = [];

Réduisez les annotations :L'inférence de type de TypeScript est déjà très intelligente, et dans la plupart des cas, les annotations de type explicites ne sont pas nécessaires.


Évitez d'utiliser any

L'utilisation de any fait perdre les avantages de la vérification de type et affecte les performances d'exécution.

Exemple

// Mauvaise pratique : utiliser any
function processData(data: any): any {
    return data.value;
}

// Bonne pratique : utiliser unknown ou des types spécifiques
function processData<T extends { value: string }>(data: T): string {
    return data.value;
}

// Si vous ne connaissez vraiment pas le type, utilisez unknown
function parseJSON(json: string): unknown {
    return JSON.parse(json);
}

// Effectuer une vérification de type lors de son utilisation
const data = parseJSON('{"key": "value"}');
if (typeof data === "object" && data !== null) {
    const obj = data as { key: string };
    console.log(obj.key);
}

// Meilleure approche : utiliser des génériques
function identity<T>(value: T): T {
    return value;
}

const result = identity("hello");
console.log("Résultat : " + result);

unknown vs any:unknown est un any sûr au niveau des types qui nécessite une vérification de type avant utilisation.


Interface vs alias de type

Choisissez l’approche de définition de type appropriée en fonction du scénario.

Exemple

// Interface : adaptée pour définir des types d’objet, prend en charge la fusion de déclarations
interface User {
    id: number;
    name: string;
}

// Étendre une interface
interface User {
    email: string;
}

// Alias de type : adapté pour les types union, les tuples et les types de fonction
type ID = string | number;
type Status = "pending" | "success" | "error";
type Callback = (data: string) => void;

// Les types utilitaires utilisent généralement type
type PartialUser = Partial<User>;
type ReadonlyUser = Readonly<User>;

// Considération de performance : les interfaces se compilent généralement plus vite que les alias de type
// Pour les types d'objets simples, vous pouvez utiliser interface
interface Point {
    x: nombre;
    y: nombre;
}

// Pour les types union, utilisez type
type Shape = Circle | Square | Triangle;

Recommandations de sélection :Utilisez des interfaces pour les types d'objets, type pour les types union, et type pour les types de fonctions.


Optimisation des outils de build

Configurez les outils de build pour obtenir des performances optimales.

vite.config.ts

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

// Optimisation de la configuration de Vite
export default defineConfig({
    plugins: [react()],

    // Optimisation du build
    build: {
        // Activer le découpage de code
        rollupOptions: {
            output: {
                // Découpage manuel des chunks
                manualChunks: {
                    'vendor': ['react', 'react-dom'],
                    'utils': ['lodash', 'axios']
                }
            }
        },

        // Minifier le code
        minify: 'terser',

        // Générer une sourcemap
        sourcemap: false,

        // Limite de taille des chunks
        chunkSizeWarningLimit: 500
    },

    // Optimisation du serveur de développement
    server: {
        // Activer le remplacement de module à chaud
        hmr: {
            overlay: true
        }
    },

    // Optimiser la résolution des dépendances
    optimizeDeps: {
        include: ['react', 'react-dom'],
        exclude: ['some-large-library']
    }
});

Fractionnement du code :Utilisez manualChunks pour séparer les grandes bibliothèques et réduire la taille du bundle principal.


Tree Shaking

Configurez les modules pour prendre en charge Tree Shaking, en éliminant le code inutilisé.

src/utils/index.ts

// Utiliser les exports de modules ES pour prendre en charge le Tree Shaking
export function add(a: number, b: number): nombre {
    return a + b;
}

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

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

export function divide(a: number, b: number): nombre {
    if (b === 0) {
        throw new Error("Impossible de diviser par zéro");
    }
    return a / b;
}

// Les exports nommés sont plus propices au Tree Shaking que les exports par défaut
// Incorrect : export default empêche le Tree Shaking
// export default { add, subtract, multiply, divide };

// Correct : utiliser des exports nommés
console.log("Module utilitaire chargé");

Exports nommés :L'utilisation d'exports nommés au lieu d'exports par défaut permet aux outils de construction d'effectuer le Tree Shaking plus efficacement.


Notes

  • skipLibCheck:Doit être activé en production
  • Compilation incrémentielle :Recommandé de l'activer dans l'environnement de développement
  • Éviter any :Utiliser unknown à la place
  • Tree Shaking:Utiliser les modules ES et les exports nommés

Bonnes pratiques :Mettez en place des configurations d'optimisation dès les premières étapes du développement afin d'éviter un refactoring ultérieur.


Résumé

L'optimisation des performances de TypeScript implique plusieurs aspects.

  • Optimisation de la compilation :skipLibCheck、incremental、project references
  • Optimisation des types :Tirez parti de l'inférence, évitez any, choisissez des définitions de type appropriées
  • Optimisation du build :Code splitting, Tree Shaking, optimisation des dépendances
  • Optimisation de l'exécution :Sécurité des types, contraintes de génériques

Recommandations :Vérifiez régulièrement le temps de compilation et la taille du bundle, et optimisez continuellement les performances du projet.

Autres extensions