Clean Code vs Mejores Prácticas: ¿Cuál es la Diferencia?

En el desarrollo de software, "Clean Code" y "Mejores Prácticas" son dos conceptos importantes. A veces podrías escuchar comentarios como "Buen trabajo, tu código se ve limpio" o "Aplica mejores prácticas para evitar la deuda técnica la próxima vez". Aunque se superponen, cada uno juega un papel único en la creación de software de alta calidad y mantenible. Vamos a desglosar lo que significa cada término, explorar algunos ejemplos ilustrativos y ver cómo difieren.

¿Qué es "Clean Code"? 📚

"Clean Code" es un libro de Robert C. Martin (Uncle Bob) que proporciona directrices para escribir código que sea fácil de leer, entender y mantener. Aquí hay ocho principios clave que debes conocer:

1. Nombres Significativos: Los nombres deben describir claramente lo que hace una variable, función o clase.

• Ejemplo: En lugar de x, usa userAge si representa la edad de un usuario, y en lugar de calculate, escribe lo que calcula la función.

 // Malo function calculate(x: number): number { return x * 12; } // Bueno function calculateUserAgeInMonths(userAge: number): number { return userAge * 12; } 

2. Regla del Boy Scout: Deja el código mejor de lo que lo encontraste. Refactoriza y mejora a medida que avanzas.

• Ejemplo: Si corriges un error y ves código desordenado, límpialo antes de hacer el commit.

 // Antes function fetchUserData(userId: string): any { const data = getDataFromDatabase(userId); return data; } // Después function fetchUserData(userId: string): User { return getDataFromDatabase(userId).user; } 

3. Reducir el Acoplamiento: Minimiza las dependencias entre clases para hacer tu base de código más modular.

• Ejemplo: Usa inyección de dependencias en lugar de codificar las dependencias directamente.

 // Malo class UserService { private database: Database; constructor() { this.database = new Database(); } } // Bueno class UserService { private database: Database; constructor(database: Database) { this.database = database; } } 

4. Sé el Autor: Escribe código como si contaras una historia. Las funciones deben ser pequeñas y enfocadas.

• Ejemplo: Piensa en ello como hacer un batido. En lugar de una función gigante que elige frutas, mezcla y sirve, divídela en funciones más pequeñas y enfocadas.

 // Antes function makeSmoothie(fruit: string, liquid: string): void { console.log(`Choosing ${fruit}`); console.log(`Blending ${fruit} with ${liquid}`); console.log(`Pouring the smoothie into a glass`); } // Después function chooseFruit(fruit: string): void { console.log(`Choosing ${fruit}`); } function blend(fruit: string, liquid: string): void { console.log(`Blending ${fruit} with ${liquid}`); } function pourIntoGlass(): void { console.log(`Pouring the smoothie into a glass`); } function makeSmoothie(fruit: string, liquid: string): void { chooseFruit(fruit); blend(fruit, liquid); pourIntoGlass(); } 

5. DRY (No te Repitas): Evita duplicar código creando componentes reutilizables.

• Ejemplo: Crea una función auxiliar en lugar de copiar y pegar bloques de código.

 // Antes function makeDogSound(): string { return "The dog says: Woof!"; } function makeCatSound(): string { return "The cat says: Meow!"; } // Después function makeAnimalSound(animal: string, sound: string): string { return `The ${animal} says: ${sound}!`; } function makeDogSound(): string { return makeAnimalSound("dog", "Woof"); } function makeCatSound(): string { return makeAnimalSound("cat", "Meow"); } 

6. Comentarios: Comenta solo cuando sea necesario y evita explicaciones obvias.

• Ejemplo: En lugar de // Increase salary by 10%, nombra tu función increaseSalaryByPercentage(10).

 // Antes function increaseSalary(employee: Employee): void { // Increase salary by 10% employee.salary *= 1.10; } // Después function increaseSalaryByPercentage(employee: Employee, percentage: number): void { employee.salary *= (1 + percentage / 100); } 

7. Manejo de Errores: Maneja los errores de manera clara e inmediata, con mensajes específicos.

• Ejemplo: Si un archivo no se puede abrir, lanza una excepción con un mensaje sobre la ruta del archivo y el error.

 // Antes function readFile(filePath: string): string { const file = fs.readFileSync(filePath, 'utf8'); return file; } // Después function readFile(filePath: string): string { try { return fs.readFileSync(filePath, 'utf8'); } catch (e) { throw new Error(`Failed to open file ${filePath}: ${e.message}`); } } 

8. Pruebas Limpias: Asegúrate de que tus pruebas sean rápidas, independientes, repetibles, auto-validables y oportunas.

• Ejemplo: Escribe pruebas unitarias que se concentren en un aspecto de la funcionalidad a la vez.

 // Ejemplo de prueba para una función describe('calculateCircleArea', () => { it('should correctly calculate the area of a circle', () => { expect(calculateCircleArea(5)).toBeCloseTo(78.54); }); }); describe('calculateCylinderArea', () => { it('should correctly calculate the area of a cylinder', () => { expect(calculateCylinderArea(5, 10)).toBeCloseTo(471.23); }); }); 

¿Qué son las "Mejores Prácticas"? 🛠️

Las "Mejores Prácticas" son métodos y técnicas probados para mejorar diversos aspectos del desarrollo de software. Aquí hay seis ejemplos clave que también deberías conocer:

1. Pruebas de Código: Prueba tu código regularmente para detectar errores temprano.

• Ejemplo: Usa herramientas como Jest para JavaScript o JUnit para Java para automatizar tus pruebas.

2. Legibilidad: Escribe código que sea fácil de leer y entender.

• Ejemplo: Usa convenciones de nombres consistentes y una clara indentación.

3. Arquitectura: Diseña tu software con una estructura clara.

• Ejemplo: Aplica patrones como MVC (Modelo-Vista-Controlador) para separar preocupaciones.

4. Patrones de Diseño: Usa patrones establecidos para resolver problemas comunes.

• Ejemplo: El patrón Singleton asegura que una clase tenga solo una instancia, lo que lo hace ideal para mantener una conexión de base de datos única y eficiente en toda la aplicación. Te dejo un ejemplo en caso de que tengas curiosidad sobre este patrón.

 import { Client } from 'pg'; // Ejemplo con PostgreSQL class DatabaseConnection { private static instance: DatabaseConnection; private client: Client; // Constructor privado para evitar instanciación directa private constructor() { this.client = new Client({ connectionString: process.env.DATABASE_URL, }); this.client.connect(); } // Método estático para obtener la única instancia de la clase public static getInstance(): DatabaseConnection { if (!DatabaseConnection.instance) { // Crear la instancia si no existe DatabaseConnection.instance = new DatabaseConnection(); } return DatabaseConnection.instance; } public async query(text: string, params?: any[]): Promise<any> { return this.client.query(text, params); } } // Ejemplo de uso de la conexión a base de datos singleton const db = DatabaseConnection.getInstance(); // Obtener la única instancia de la conexión a base de datos db.query('SELECT * FROM users WHERE id = $1', [1]) .then(res => console.log(res.rows)) .catch(err => console.error('Database query error:', err)); 

5. Sistemas de Control de Versiones (VCS): Gestiona los cambios de código con herramientas como Git.

• Ejemplo: Sigue los principios ACID para commits: Atomicidad, Consistencia, Aislamiento y Durabilidad.

6. DRY y KISS: Aplica Don’t Repeat Yourself (DRY) y Keep It Simple and Stupid (KISS).

• Ejemplo: Simplifica funciones complejas y evita el código redundante.

Diferencias Clave 🔍

• Alcance: "Clean Code" se enfoca en escribir código limpio y mantenible. En contraste, las "Mej

ores Prácticas" abarcan una gama más amplia de técnicas y estrategias para diversos aspectos del desarrollo de software.

• Aplicación: "Clean Code" proporciona directrices específicas para mejorar la calidad del código, mientras que las "Mejores Prácticas" ofrecen un enfoque más integral para mejorar la efectividad general del proyecto.

Conclusión 🎯

"Clean Code" es una parte crucial de las Mejores Prácticas, enfocándose en crear código legible y mantenible. Las Mejores Prácticas, por otro lado, abarcan una amplia gama de técnicas para mejorar diferentes aspectos del desarrollo de software. Usar ambos puede mejorar significativamente la calidad y eficiencia de tus proyectos.

¿Cuáles son tus mejores prácticas favoritas para escribir código limpio y gestionar proyectos? Comparte tus consejos y experiencias a continuación—¡ayudémonos mutuamente a evitar esos "dolores de cabeza" y "WTFs" en nuestros viajes de desarrollo! 💬