Clean Code en TypeScript: principios y ejemplos para principiantes

Clean Code en TypeScript: principios y ejemplos para principiantes

El código limpio (Clean Code) no es solo un término de moda, sino una filosofía de desarrollo que ayuda a escribir programas comprensibles para otros desarrolladores (y para usted mismo seis meses después). Para los programadores principiantes en TypeScript, dominar los principios del código limpio es un paso clave hacia el crecimiento profesional. En este artículo, analizaremos las reglas principales, daremos ejemplos claros y mostraremos cómo hacer que su código en TypeScript sea elegante y mantenible.

¿Por qué es importante el código limpio?

Imagine que lee un libro sin párrafos, signos de puntuación y con todas las palabras escritas juntas. Así es más o menos como se ve el código sucio para otro desarrollador. El código limpio ahorra tiempo en la depuración, simplifica la adición de nuevas funciones y reduce la cantidad de errores. TypeScript, con su tipado estricto, ya ayuda a escribir código más confiable, pero sin seguir los principios de limpieza, incluso el código tipificado puede volverse ilegible.

// Mal: ilegiblefunction d(a:any,b:any){if(a>b){return a}else{return b}}

// Bien: limpio y clarofunction findMaxValue(firstNumber: number, secondNumber: number): number {    if (firstNumber > secondNumber) {        return firstNumber;    }    return secondNumber;}

Principios fundamentales de Clean Code en TypeScript

1. Nombres significativos para variables y funciones

El nombre debe responder a las preguntas "¿qué?" y "¿por qué?". Evite abreviaturas de una sola letra (excepto índices de bucles) y nombres abstractos. Use camelCase para variables y PascalCase para clases.

// Malconst d = new Date();const arr = [1, 2, 3];function p(x: number) { return x * 2; }

// Bienconst currentDate = new Date();const numbersList: number[] = [1, 2, 3];function doubleValue(value: number): number {    return value * 2;}

2. Las funciones deben hacer solo una cosa

Cada función debe resolver una sola tarea. Si una función hace más de una acción, divídala en varias pequeñas. Esto mejora la legibilidad y la capacidad de prueba.

// Mal: la función lo hace todo a la vezfunction processUserData(userData: string): void {    const parsed = JSON.parse(userData);    const isValid = parsed.name && parsed.email;    if (isValid) {        console.log(`User ${parsed.name} registered`);        saveToDatabase(parsed);    }}

// Bien: cada función se encarga de lo suyofunction parseUserData(rawData: string): User {    return JSON.parse(rawData);}

function validateUserData(user: User): boolean {    return !!user.name && !!user.email;}

function registerUser(userData: string): void {    const user = parseUserData(userData);    if (validateUserData(user)) {        console.log(`User ${user.name} registered`);        saveToDatabase(user);    }}

3. Evite números y cadenas mágicas

Los números mágicos son literales cuyo valor no se entiende sin contexto. Sáquelos a constantes con nombres claros.

// Malif (user.age > 18) {    // ...}const discount = price * 0.1;

// Bienconst ADULT_AGE = 18;const STANDARD_DISCOUNT_RATE = 0.1;

if (user.age > ADULT_AGE) {    // ...}const discount = price * STANDARD_DISCOUNT_RATE;

4. Use tipos e interfaces correctamente

TypeScript proporciona herramientas potentes para describir datos. No abuse de any, prefiera tipos concretos. Cree interfaces para objetos complejos.

// Malfunction createUser(name: any, age: any) {    return { name, age, createdAt: new Date() };}

// Bieninterface User {    name: string;    age: number;    createdAt: Date;}

function createUser(name: string, age: number): User {    return {        name,        age,        createdAt: new Date()    };}