DEV Community

The Eagle 🦅
The Eagle 🦅

Posted on

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;
   }
Enter fullscreen mode Exit fullscreen mode

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;
   }
Enter fullscreen mode Exit fullscreen mode

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;
       }
   }
Enter fullscreen mode Exit fullscreen mode

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();
   }
Enter fullscreen mode Exit fullscreen mode

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");
    }
Enter fullscreen mode Exit fullscreen mode

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);
   }
Enter fullscreen mode Exit fullscreen mode

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}`);
       }
   }
Enter fullscreen mode Exit fullscreen mode

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);
       });
   });
Enter fullscreen mode Exit fullscreen mode

¿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));
Enter fullscreen mode Exit fullscreen mode

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! 💬

Top comments (0)

Image of Docusign

🛠️ Bring your solution into Docusign. Reach over 1.6M customers.

Docusign is now extensible. Overcome challenges with disconnected products and inaccessible data by bringing your solutions into Docusign and publishing to 1.6M customers in the App Center.

Learn more