Código limpio en TypeScript: reglas, ejemplos y trucos

Entrenador de Python en Línea para Principiantes

Aprende Python fácilmente sin sobrecargarte de teoría. Resuelve tareas prácticas con verificación automática, recibe pistas y escribe código directamente en el navegador, sin instalar nada.

Start Course

Por qué el código limpio en TypeScript no es un lujo, sino una necesidad

Cada desarrollador se ha encontrado al menos una vez con esta situación: abres un proyecto escrito hace un par de meses y no entiendes lo que está pasando. Las variables se llaman a, b, data, las funciones ocupan 200 líneas cada una, y los tipos están puestos a medias. ¿Te suena?

TypeScript nos da una herramienta poderosa: el tipado estático. Pero por sí mismo no hace que el código sea limpio. Se puede escribir código horrible tanto en TypeScript como en cualquier otro lenguaje. El código limpio es disciplina, estilo y respeto hacia uno mismo y hacia los colegas.

En este artículo analizaremos cómo escribir código limpio en TypeScript que sea fácil de leer, mantener y escalar. Aprenderás sobre los principios SOLID, el tipado estricto, la nomenclatura, el trabajo con interfaces y mucho más. ¡Allá vamos!

1. La nomenclatura es la cara de tu código

Nombrar correctamente variables, funciones y clases es el 50% del éxito. Un buen nombre debe responder a las preguntas: "¿Qué es esto?" o "¿Qué hace esta función?".

Variables y constantes

Usa sustantivos y camelCase. Evita nombres de una sola letra (excepto en bucles).

// Malconst d = new Date();const u = users.find(u => u.id === 5);

// Bienconst currentDate = new Date();const activeUser = users.find(user => user.id === 5);

Funciones

Los nombres de las funciones deben comenzar con un verbo. Esto deja claro de inmediato qué acción se realiza.

// Malfunction data(id: number) { ... }

// Bienfunction fetchUserData(id: number): Promise<UserData> { ... }

Clases e interfaces

Las clases son sustantivos en PascalCase. Las interfaces también, aunque a menudo con el prefijo I (aunque en la comunidad hay debate). Es mejor simplemente dar un nombre claro sin prefijo.

// Malinterface IUser {  name: string;}

// Bieninterface User {  name: string;  email: string;}

2. El tipado estricto es tu mejor amigo

TypeScript fue creado para que los tipos trabajen a tu favor. No uses any a menos que sea estrictamente necesario. Cada vez que escribes any, desactivas la protección del compilador.

Evita any

// Malfunction process(data: any) {  return data.name;}

// Bieninterface Item {  name: string;  price: number;}

function process(data: Item): string {  return data.name;}

Usa tipos Union e Intersection

Cuando una variable puede aceptar varios tipos, usa Union (|). Para combinaciones, usa Intersection (&).

type Status = 'active' | 'inactive' | 'pending';type AdminUser = User & { role: 'admin' };

Genéricos: funciones universales

Los genéricos permiten escribir código flexible sin perder el tipado.

function firstElement<T>(arr: T[]): T | undefined {  return arr[0];}

const num = firstElement([1, 2, 3]); // numberconst str = firstElement(['a', 'b']); // string

3. SOLID: principios para adultos

Los principios SOLID ayudan a construir una arquitectura flexible y mantenible. Veamos cada uno con ejemplos en TypeScript.

Responsabilidad Única (SRP)

Una clase o función debe tener solo una razón para cambiar.

// Mal: la clase lo hace todoclass UserService {  createUser() { ... }  sendEmail() { ... }  generateReport() { ... }}

// Bien: separamos responsabilidadesclass UserCreator { ... }class EmailService { ... }class ReportGenerator { ... }