Refactorización de código: cómo mejorar el código existente y hacerlo legible

Imagina: abres un código que escribiste hace seis meses y no puedes entender lo que está sucediendo en una función de 200 líneas con las variables data1, data2, temp. ¿Te suena? Es una señal de que el código necesita una refactorización.

¿Qué es la refactorización?

La refactorización es el proceso de cambiar la estructura interna del código sin cambiar su comportamiento externo. Es como ordenar un apartamento: las cosas siguen siendo las mismas, pero es mucho más fácil encontrarlas.

Es importante entender que la refactorización no es corregir errores o añadir nuevas funciones. Es una mejora de la calidad del código existente para que sea más fácil trabajar con él en el futuro.

Cuando el código necesita refactorización

Hay varias señales claras de que es hora de empezar a refactorizar. La duplicación de código es un ejemplo clásico: si copias el mismo bloque en diferentes lugares, este es el primer candidato para ser incluido en una función separada. Las funciones largas que hacen demasiadas cosas diferentes también requieren una división en partes más pequeñas y comprensibles.

Los nombres de variables y funciones malos crean una carga cognitiva. Cuando una variable se llama x o arr, tienes que tener en cuenta lo que significa. Y un nombre como activeUsers o calculateTotalPrice habla por sí solo.

La lógica enrevesada con muchas condiciones anidadas convierte el código en un laberinto. Si ves más de tres niveles de anidamiento if, deberías considerar la refactorización.

Técnicas básicas de refactorización

Extracción de funciones

Esta es la técnica más común. Tomas un fragmento de código y lo llevas a una función separada con un nombre comprensible.

// Antes de la refactorización
function processOrder(order) {
    // Validación
    if (!order.items || order.items.length === 0) {
        throw new Error('Order is empty');
    }
    if (!order.userId) {
        throw new Error('No user specified');
    }
    
    // Cálculo de la cantidad
    let total = 0;
    for (let item of order.items) {
        total += item.price * item.quantity;
    }
    
    // Aplicación de descuentos
    if (order.promoCode) {
        total *= 0.9;
    }
    
    return total;
}

// Después de la refactorización
function processOrder(order) {
    validateOrder(order);
    const total = calculateTotal(order.items);
    return applyDiscount(total, order.promoCode);
}

function validateOrder(order) {
    if (!order.items || order.items.length === 0) {
        throw new Error('Order is empty');
    }
    if (!order.userId) {
        throw new Error('No user specified');
    }
}

function calculateTotal(items) {
    return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

function applyDiscount(total, promoCode) {
    return promoCode ? total * 0.9 : total;
}

Ahora la función processOrder se lee como un libro: validamos el pedido, calculamos el importe, aplicamos el descuento. Cada operación está encapsulada en su función.

Cambio de nombre

Un buen nombre es la mitad del éxito. La variable debe reflejar lo que almacena y la función lo que hace.

# Hasta
def calc(a, b, c):
    return a * b * c / 100

# Después
def calculate_discount_amount(price, quantity, discount_percent):
    return price * quantity * discount_percent / 100

Simplificación de las condiciones

Las condiciones complejas se pueden colocar en funciones con nombres descriptivos o se puede utilizar un retorno temprano.

// Hasta
function canUserEdit(user, document) {
    if (user.isAuthenticated) {
        if (user.role === 'admin' || document.authorId === user.id) {
            if (!document.isLocked) {
                return true;
            }
        }
    }
    return false;
}

// Después
function canUserEdit(user, document) {
    if (!user.isAuthenticated) return false;
    if (document.isLocked) return false;
    
    return user.role === 'admin' || document.authorId === user.id;
}

Sustitución de números mágicos por constantes

Los números mágicos son valores cuyo significado no se entiende sin contexto.

# Hasta
if user.age >= 18:
    grant_access()

# Después
MINIMUM_AGE_FOR_ACCESS = 18

if user.age >= MINIMUM_AGE_FOR_ACCESS:
    grant_access()

Refactorización de clases

Cuando se trabaja con código orientado a objetos, a menudo se encuentran clases que hacen demasiado. El principio de responsabilidad única establece que una clase debe tener una sola razón para cambiar.

# Antes: la clase hace demasiado
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
    
    def save_to_database(self):
        # Lógica de almacenamiento en la base de datos
        pass
    
    def send_welcome_email(self):
        # Lógica de envío de correo electrónico
        pass
    
    def generate_report(self):
        # Lógica de generación de informes
        pass

# Después: se compartió la responsabilidad
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email

class UserRepository:
    def save(self, user):
        # Lógica de almacenamiento en la base de datos
        pass

class EmailService:
    def send_welcome_email(self, user):
        # Lógica de envío de correo electrónico
        pass

class UserReportGenerator:
    def generate(self, user):
        # Lógica de generación de informes
        pass

Reglas para una refactorización segura

La refactorización sin pruebas es un juego de ruleta rusa. Antes de cambiar el código, asegúrate de tener pruebas que cubran su funcionalidad. Si no hay pruebas, escríbelas antes de la refactorización.

Da pequeños pasos. No intentes reescribir todo a la vez. Es mejor hacer una pequeña refactorización, ejecutar las pruebas, asegurarse de que todo funcione y solo entonces pasar a la siguiente.

Comprométete a menudo. Cada paso de refactorización exitoso es un compromiso separado. Si algo sale mal, puedes volver atrás.

Cuándo no se debe refactorizar

La refactorización no es un fin en sí mismo. Hay situaciones en las que es mejor dejar el código tal como está. Si está trabajando en un prototipo que se puede descartar, la refactorización profunda no tiene sentido. Si el código funciona de forma estable durante años y nadie lo toca, tal vez sea mejor no arriesgarse.

Tampoco debe refactorizar el código que no entiende. Primero, averigua cómo funciona, escribe pruebas y solo entonces mejora la estructura.

Herramientas de refactorización

Los IDE modernos facilitan enormemente la refactorización. PyCharm, VS Code o WebStorm tienen funciones de cambio automático de nombre de variables y funciones, extracción de métodos y cambio de firmas de funciones. Utiliza estas herramientas: te ayudarán a evitar errores.

Los linters como ESLint para JavaScript o Pylint para Python ayudan a detectar problemas en el código. Indican duplicaciones, funciones demasiado complejas, variables no utilizadas.

Refactorización como parte de la cultura de desarrollo

El mejor enfoque es hacer una pequeña refactorización de forma regular, en lugar de acumular deuda técnica. La regla de los boy scouts dice: deja el código más limpio de lo que estaba antes de que lo tocaras. ¿Trabajas con una función? Mejora su nombre. ¿Ves duplicación? Pásala a la función general.

La revisión del código es una gran oportunidad para la refactorización. La mirada fresca de un compañero a menudo nota lo que el autor del código ha pasado por alto.

¿Quieres aprender a escribir código limpio desde el principio?

Anexo Kodik creado específicamente para aquellos que están dando sus primeros pasos en la programación. Aquí no solo aprendes la teoría, sino que inmediatamente aplicas los conocimientos en la práctica, creando proyectos reales. Los cursos están estructurados de tal manera que desde el primer día escribas un código que funcione y del que puedas estar orgulloso. Y cuando aprendas a escribir código, aprenderás a hacerlo aún mejor a través de la refactorización.

Únete a nuestro Canal de Telegram!

Tenemos una comunidad de desarrolladores muy unida, donde cualquiera puede hacer cualquier pregunta, desde la más simple hasta la más profesional. Todos los días analizamos los principales temas en desarrollo: desde los conceptos básicos hasta las técnicas avanzadas. Aquí no es vergonzoso preguntar y siempre te ayudarán a entender. ¡Aprender juntos es más interesante!