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, usauserAgesi representa la edad de un usuario, y en lugar decalculate, 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ónincreaseSalaryByPercentage(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! 💬
Top comments (0)