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
¿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.
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
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
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
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
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
Otras extensionesSugerencias:Revisa periódicamente el tiempo de compilación y el tamaño del paquete para optimizar continuamente el rendimiento del proyecto.