Optimización de rendimiento de TypeScript

La optimización del rendimiento de los proyectos TypeScript abarca varios aspectos, como la velocidad de compilación, el rendimiento en tiempo de ejecución y el tamaño del código.

Este tutorial presenta técnicas comunes de optimización del rendimiento para ayudar a crear aplicaciones TypeScript más eficientes.


Diagrama SVG: Dimensiones de la optimización del rendimiento Fondo Título Dimensiones de la optimización del rendimiento de TypeScript Velocidad de compilación Velocidad de compilación Compilación incremental | skipLibCheck Rendimiento en tiempo de ejecución Rendimiento en tiempo de ejecución Inferencia de tipos | Evitar any Tamaño del paquete Tamaño del paquete Tree Shaking | Carga diferida Parte inferior: Estrategias de optimización Estrategias clave de optimización Estrategia 1 skipLibCheck Omitir la verificación de tipos de las librerías Estrategia 2 incremental Compilación incremental Estrategia 3 Project References Referencias de proyecto

¿Por qué es necesario optimizar el rendimiento?

Aunque TypeScript ofrece un potente sistema de tipos, un uso inadecuado puede afectar la velocidad de compilación y el rendimiento en tiempo de ejecución.

La compilación de proyectos grandes puede tardar varios minutos, lo que afecta gravemente la experiencia de desarrollo.

La configuración y las técnicas presentadas en este tutorial pueden mejorar significativamente el rendimiento de los proyectos TypeScript.

Objetivos de optimización:Mayor velocidad de compilación, menor tamaño del paquete y mejor rendimiento en tiempo de ejecución.


Optimización de la configuración de compilación

Mejora la velocidad de compilación optimizando la configuración de tsconfig.json.

Configuración optimizada de tsconfig.json

{
    "compilerOptions": {
        // Habilitar la compilación incremental y guardar la información de la última compilación
        "incremental": true,

        // Omitir la verificación de tipos de node_modules
        // Mejora significativamente la velocidad de compilación
        "skipLibCheck": true,

        // Omitir la generación de archivos de declaración (generar solo en la compilación final)
        "noEmit": true,

        // Habilitar la compilación incremental rápida
        "assumeChangesOnlyAffectDirectDependencies": true,

        // Ejecución en paralelo
        "parallel": true,

        // Habilitar la caché
        "tsBuildInfoFile": ".tsbuildinfo",

        // Archivos que no necesitan análisis
        "exclude": [
            "node_modules",
            "dist",
            "build",
            "**/*.test.ts"
        ]
    }
}

skipLibCheck:Esta es la opción de optimización más importante; puede reducir el tiempo de compilación en más del 50 %.


Optimización de las referencias de proyecto

Utiliza referencias de proyecto para dividir un proyecto grande en módulos pequeños y lograr una compilación incremental.

packages/utils/tsconfig.json

{
    // Heredar la configuración base
    "extends": "../../tsconfig.base.json",

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

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

composite:Una vez habilitado, TypeScript generará un archivo .tsbuildinfo para acelerar las compilaciones posteriores.


Optimización de la inferencia de tipos

Aprovecha al máximo la inferencia de tipos de TypeScript y evita la anotación excesiva.

<h2 class="example">Ejemplo
// Mala práctica: anotación excesiva de tipos
const name: string = "Alice";
const age: number = 25;
const isActive: boolean = true;

// Buena práctica: usar la inferencia de tipos
const name = "Alice";
const age = 25;
const isActive = true;

// El tipo de retorno de la función se puede omitir (TypeScript lo infiere automáticamente)
function add(a: number, b: number) {
    return a + b;
}

// Usar inferencia de tipos para objetos complejos
const user = {
    id: 1,
    name: "Bob",
    email: "bob@example.com"
};
// TypeScript inferirá:
// { id: number; name: string; email: string }

// Solo se necesita anotación explícita cuando la inferencia de tipos no es precisa
const elements: HTMLElement[] = [];

Reducir las anotaciones:La inferencia de tipos de TypeScript ya es muy inteligente; en la mayoría de los casos no es necesario anotar los tipos explícitamente.


Evitar el uso de any

Usar any hace perder las ventajas de la verificación de tipos y afecta el rendimiento en tiempo de ejecución.

Ejemplo

// Mala práctica: usar any
function processData(data: any): any {
    return data.value;
}

// Buena práctica: usar unknown o un tipo específico
function processData<T extends { value: string }>(data: T): string {
    return data.value;
}

// Si realmente no se conoce el tipo, usar unknown
function parseJSON(json: string): unknown {
    return JSON.parse(json);
}

// Realizar verificación de tipos al usarlo
const data = parseJSON('{"key": "value"}');
if (typeof data === "object" && data !== null) {
    const obj = data as { key: string };
    console.log(obj.key);
}

// Mejor práctica: usar genéricos
function identity<T>(value: T): T {
    return value;
}

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

unknown vs any:unknown es un any con seguridad de tipos; es necesario realizar una verificación de tipos antes de usarlo.


Interfaz vs Alias de tipo

Elige la forma adecuada de definir tipos según el escenario.

Ejemplo

// Interfaz: adecuada para definir tipos de objeto; admite la fusión de declaraciones
interface User {
    id: number;
    name: string;
}

// Extender interfaz
interface User {
    email: string;
}

// Alias de tipo: adecuado para uniones, tuplas y tipos de función
type ID = string | number;
type Status = "pending" | "success" | "error";
type Callback = (data: string) => void;

// Los tipos utilitarios suelen usar type
type PartialUser = Partial<User>;
type ReadonlyUser = Readonly<User>;

// Consideración de rendimiento: las interfaces suelen compilar más rápido que los alias de tipo
// Para tipos de objeto simples, se puede usar interface
interface Point {
    x: number;
    y: number;
}

// Para uniones, usar type
type Shape = Circle | Square | Triangle;

Recomendaciones de selección:Usar interfaces para tipos de objeto, type para uniones y type para tipos de función.


Optimización de herramientas de construcción

Configura las herramientas de construcción para obtener el mejor rendimiento.

vite.config.ts

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

// Optimización de la configuración de Vite
export default defineConfig({
    plugins: [react()],

    // Optimización de la construcción
    build: {
        // Habilitar la división de código
        rollupOptions: {
            output: {
                // División manual de paquetes
                manualChunks: {
                    'vendor': ['react', 'react-dom'],
                    'utils': ['lodash', 'axios']
                }
            }
        },

        // Minificar el código
        minify: 'terser',

        // Generar sourcemap
        sourcemap: false,

        // Límite de tamaño de los chunks
        chunkSizeWarningLimit: 500
    },

    // Optimización del servidor de desarrollo
    server: {
        // Habilitar la actualización en caliente
        hmr: {
            overlay: true
        }
    },

    // Optimizar la resolución de dependencias
    optimizeDeps: {
        include: ['react', 'react-dom'],
        exclude: ['some-large-library']
    }
});

División de código:Usa manualChunks para separar las librerías grandes y reducir el tamaño del paquete principal.


Tree Shaking

Configura los módulos para admitir Tree Shaking y eliminar el código no utilizado.

src/utils/index.ts

// Usar exportaciones de módulos ES para admitir Tree Shaking
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("Cannot divide by zero");
    }
    return a / b;
}

// Las exportaciones nombradas favorecen más Tree Shaking que las exportaciones por defecto
// Incorrecto: export default impide Tree Shaking
// export default { add, subtract, multiply, divide };

// Correcto: usar exportaciones nombradas
console.log("Carga del módulo de herramientas");

Exportaciones nombradas:Usar exportaciones nombradas en lugar de exportaciones por defecto permite que las herramientas de construcción realicen mejor Tree Shaking.


Consideraciones

  • skipLibCheck:Debe habilitarse en el entorno de producción
  • Compilación incremental:Se recomienda habilitarla en el entorno de desarrollo
  • Evitar any:Usar unknown en su lugar
  • Tree Shaking:Usar módulos ES y exportaciones nombradas

Mejores prácticas:Configura las optimizaciones al inicio del desarrollo para evitar refactorizaciones posteriores.


Resumen

La optimización del rendimiento de TypeScript abarca varios aspectos.

  • Optimización de compilación:skipLibCheck、incremental、project references
  • Optimización de tipos:Usar la inferencia, evitar any y elegir definiciones de tipos adecuadas
  • Optimización de la construcción:División de código, Tree Shaking y optimización de dependencias
  • Optimización en tiempo de ejecución:Seguridad de tipos y restricciones de genéricos

Sugerencias:Revisa periódicamente el tiempo de compilación y el tamaño del paquete para optimizar continuamente el rendimiento del proyecto.

Otras extensiones