Eliminación de duplicidades: Mejora clave para la refacción del código

Introducción

La eliminación de duplicidades es una práctica fundamental y crucial en la refactorización del código. No solo mejora la legibilidad y mantenibilidad, sino que también reduce el riesgo de errores al minimizar el número de lugares donde se debe hacer cambios. Sin embargo, esta tarea puede parecer trivial o incluso innecesaria a primera vista. En este artículo, exploraremos por qué es importante eliminar duplicidades en el código, proporcionaremos ejemplos prácticos y discutiremos algunas trampas comunes que deben evitarse.

Explicación principal con ejemplos

La duplicidad en el código puede aparecer de varias formas. Por ejemplo, consideremos un pequeño script de Python que calcula el área de varios rectángulos:

def calcular_area_rectangulo_base1(base):
    return base * altura

altura = 5

# Rectángulo 1 con base 4
area1 = calcular_area_rectangulo_base1(4)

# Rectángulo 2 con base 6
area2 = calcular_area_rectangulo_base1(6)

En este ejemplo, la función calcular_area_rectangulo_base1 se utiliza dos veces para calcular el área de distintos rectángulos. Esto es redundante y desviado del propósito original de la función, que debería ser una herramienta genérica para calcular áreas de cualquier rectángulo basándose en su base.

Mejora: Extracción de duplicados

Para mejorar este código, podemos extraer la duplicación:

def calcular_area_rectangulo(base, altura):
    return base * altura

altura = 5

# Rectángulo 1 con base 4
area1 = calcular_area_rectangulo(4, altura)

# Rectángulo 2 con base 6
area2 = calcular_area_rectangulo(6, altura)

Con esta refactorización, la función calcular_area_rectangulo se convierte en una herramienta más eficiente y genérica. Además, si necesitamos cambiar el valor de altura, solo lo haremos en un lugar.

Errores típicos / trampas

1. Confusión entre duplicados y polimorfismo

A veces, la confusión puede surgir cuando se implementan distintos métodos para realizar tareas similares pero no idénticas. Por ejemplo, en una aplicación de gestión de inventario:

def actualizar_stock_productos(producto1):
    actualizar_stock(producto1)

def actualizar_stock_productos_servicios(servicio1):
    actualizar_stock_servicio(servicio1)

En este caso, la funcionalidad es similar pero no exactamente igual. Utilizar polimorfismo en lugar de duplicar código sería una mejor opción:

class Producto:
    def __init__(self, nombre):
        self.nombre = nombre

def actualizar_stock(item: Producto):
    # lógica para actualizar stock del producto
    pass

# Uso
producto1 = Producto("Teclado")
actualizar_stock(producto1)

2. Ignorar la relevancia del contexto

A veces, el código duplicado puede parecer trivial en un contexto específico pero es crítico en otro. Por ejemplo:

def calcular_descuento(producto):
    if producto.categoria == "ropa":
        return producto.precio * 0.15
    else:
        return producto.precio * 0.2

def aplicar_descuento(producto, descuento):
    producto.precio -= descuento

En este ejemplo, calcular_descuento y aplicar_descuento están relacionados pero no duplican exactamente el mismo código. La duplicación aquí sería más de lógica que de código.

3. Confusión entre variables locales e globales

Otro error común es confundir variables locales con globales o constantes, lo cual puede llevar a duplicar código innecesariamente:

def funcion_local():
    variable = obtener_variable()
    # lógica que usa la variable

variable = "valor_global"

En lugar de duplicar el obtener_variable en varias funciones, se debería hacer una vez y luego reutilizar su resultado.

Checklist accionable

1. Identifica las áreas donde hay duplicidad: Mira por bloques de código que se usan repetidamente.
2. Extrae la lógica común a una función o método: Crea funciones para el código común, y pasa los argumentos necesarios según sea necesario.
3. Evita mezclar polimorfismo con duplicidad: Utiliza herencia y polimorfismo cuando sea apropiado en lugar de repetir código.
4. Verifica la relevancia del contexto: Asegúrate de que no estás duplicando lógica que solo se aplica en un contexto específico.
5. Evita variables locales innecesarias: Utiliza variables globales o constantes cuando sea necesario para evitar duplicar el mismo código.
6. Mantén la consistencia del estilo de codificación: Establece una convención clara y siguela rigurosamente.

Cierre con "Siguientes pasos"

Siguientes pasos

1. Aplica estas técnicas a tus proyectos actuales: Busca oportunidades para eliminar duplicidad en tu código actual.
2. Práctica constante: Continúa aprendiendo y aplicando mejores prácticas de refactorización.
3. Consulte recursos adicionales: Para profundizar, explore "Clean Code" por Robert C. Martin y otros libros sobre programación de calidad.

La eliminación de duplicidades es una habilidad vital para cualquier desarrollador que busque escribir código más limpio, mantenible y eficiente. Siguiendo estos pasos, podrás mejorar significativamente la calidad del código en tus proyectos actuales e futuros.