refactorización
Cambiar la estructura del código sin alterar lo que hace
Qué es
La refactorización consiste en cambiar la estructura interna del código sin cambiar lo que hace para quien lo utiliza. Cambian los nombres, los límites de las funciones y la organización de los módulos; las entradas, las salidas y los efectos secundarios permanecen exactamente como estaban. El verbo es refactorizar, y uno de esos cambios también se llama refactorización.
Martin Fowler define el término en su libro Refactoring y volvió a exponer la definición en su sitio web en 2004. Como sustantivo, una refactorización es un cambio en la estructura interna del software que hace el código más fácil de entender y menos costoso de modificar, mientras su comportamiento visto desde fuera permanece igual. Como verbo, refactorizar es realizar una secuencia de esos cambios manteniendo ese comportamiento externo durante todo el proceso. Ambas partes importan. La finalidad es abaratar el siguiente cambio, y la restricción es que nadie ajeno al código pueda advertir que ha ocurrido algo.
Fowler marca claramente la diferencia: «Refactorizar no es otra forma de decir limpiar el código», escribe en refactoring.com. Nombra una técnica específica. Utiliza reestructuración como término más amplio para reorganizar código por cualquier medio, incluidos los que no conservan el comportamiento en cada paso. Lo que hace de la refactorización una técnica es su tamaño. Cada paso es una transformación pequeña que hace poco por sí sola y tiene pocas probabilidades de salir mal, y el sistema completo sigue funcionando después de cada uno. Una secuencia larga de estos pasos puede aun así sumar un gran cambio de estructura.
Los pasos tienen nombre. El catálogo de refactoring.com, que acompaña a la segunda edición del libro, los enumera con los nombres anteriores a los que sustituyen: Extract Function, extraer una función, también conocido como Extract Method, y su inverso Inline Function, insertar el cuerpo de la función en sus puntos de uso; Inline Variable, sustituir una variable por su expresión; Rename Variable, renombrar una variable; Move Function, mover una función; Split Phase, separar fases, y decenas más. Un nombre compartido permite a un desarrollador decir en dos palabras qué cambio hizo y a quien revisa contrastarlo con un procedimiento conocido.
Por qué importa
El software que tiene éxito sigue cambiando. Las funcionalidades nuevas y las correcciones se superponen, y cada una tiende a dificultar un poco la siguiente hasta que, como describe Fowler, añadir cualquier cosa nueva lleva un tiempo penosamente largo. La refactorización es el contrapeso: remodela el código para que cada incorporación no añada una complejidad innecesaria. Su beneficio se mide en el coste del siguiente cambio, no en el aspecto del código.
Por eso Fowler la trata como parte de la programación habitual en lugar de como una tarea que aparece en un plan de proyecto. Distingue tres momentos. Antes de añadir una funcionalidad, comprueba si el código tiene una forma que facilite incorporarla y, si no, refactoriza primero, algo que suele resultarle más rápido que introducirla a la fuerza. Cuando la funcionalidad funciona, refactoriza el resultado para que quien vuelva unas semanas después pueda seguirlo sin desconcierto. Y cuando tiene que leer código desconocido para entenderlo, lo refactoriza para que el siguiente lector no tropiece en el mismo lugar. El primero de esos momentos tiene su propio nombre, refactorización preparatoria, y Fowler atribuye a Kent Beck la regla que lo sustenta: para cada cambio, primero remodele el código hasta que el cambio sea fácil, lo que puede ser la parte difícil, y solo entonces realícelo.
La refactorización también mantiene bajo el riesgo de una forma que el trabajo en funcionalidades no puede. Fowler transmite otra metáfora de Beck: los dos sombreros. Con el sombrero de refactorizar, cada cambio conserva el comportamiento y las pruebas siguen pasando durante todo el proceso. Al añadir funcionalidad, se añaden pruebas y fallan las existentes, lo que genera más tensión y riesgo. Un desarrollador que sabe qué sombrero lleva sabe qué significa una prueba fallida: durante una refactorización, significa que el último paso fue incorrecto.
La misma idea permite saldar la mayor parte de la deuda técnica. El artículo de Google sobre la deuda oculta en sistemas de aprendizaje automático sitúa refactorizar el código en primer lugar entre las formas de reducirla. Las herramientas ayudan: muchos lenguajes tienen hoy editores que automatizan refactorizaciones comunes. Fowler considera esas herramientas valiosas, pero no imprescindibles, y cuando faltan recurre a pasos pequeños y pruebas frecuentes.
Cómo se aplica en la práctica
Tomemos una función escrita para este artículo que calcula el total de un pedido e imprime un recibo en el mismo lugar:
function printReceipt(order) {
let total = 0;
for (const line of order.lines) {
total += line.price * line.quantity;
}
// print the receipt lines
console.log(`Order ${order.id}`);
console.log(`Total: ${total}`);
}Llega un requisito nuevo: el mismo total debe aparecer en una factura. En lugar de copiar el bucle, el desarrollador refactoriza primero. El primer paso es Extract Function: el bucle pasa a su propia función, con un nombre que indica lo que calcula, y se ejecutan las pruebas. El segundo extrae la impresión de la misma manera, de modo que el nombre de una función sustituye al comentario, y vuelven a ejecutarse las pruebas. El tercero es Inline Variable: la variable total ahora solo se usa una vez, por lo que la llamada ocupa su lugar. Después de cada paso, el programa hace exactamente lo mismo que antes, y cada paso podría confirmarse por separado:
function printReceipt(order) {
printLines(order.id, orderTotal(order));
}
function orderTotal(order) {
let total = 0;
for (const line of order.lines) {
total += line.price * line.quantity;
}
return total;
}
function printLines(id, total) {
console.log(`Order ${id}`);
console.log(`Total: ${total}`);
}Solo ahora se incorpora la funcionalidad, y consiste en una línea del código de la factura que llama a orderTotal. Ninguno de los tres pasos de refactorización necesitó una prueba nueva porque no cambió nada observable; lo demuestran las pruebas que ya cubrían el recibo.
El código de infraestructura también se refactoriza, y allí hay más en juego porque los nombres hacen referencia a recursos en ejecución. La documentación de Terraform advierte de que, de forma predeterminada, dar una dirección nueva a un recurso en la configuración indica a Terraform que destruya el existente y construya otro nuevo. Por eso, renombrar aws_instance.a como aws_instance.web para facilitar su lectura sustituiría un servidor. Desde Terraform v1.1, un bloque moved registra en cambio la dirección anterior, y el siguiente plan actualiza la dirección sin destruir nada:
resource "aws_instance" "web" {
# (configuration unchanged)
}
moved {
from = aws_instance.a
to = aws_instance.web
}Para versiones anteriores, la documentación remite al comando terraform state mv para efectuar el mismo traslado. En ambos casos, la refactorización solo es segura una vez leído el plan y comprobado que muestra un traslado y no una destrucción y una creación.
Mantener esos cambios separados del trabajo en funcionalidades resulta más fácil cuando el historial indica cuál es cuál. La norma de commits descrita en la entrada del portafolio de este sitio sobre aplicar una misma norma de historial a cuatro repositorios empieza cada mensaje de commit con un prefijo convencional que nombra el tipo de cambio, exigido por un hook de mensajes de commit. La página, sobre trabajo realizado en julio de 2026, cuenta 26 refactorizaciones en el historial del repositorio más grande, junto a 156 commits de funcionalidades y 133 correcciones. La misma página reconoce que el hook comprueba el formato y no el contenido. Un commit etiquetado como refactorización sigue teniendo que demostrar mediante sus pruebas y su revisión que no ha alterado el comportamiento.
Dónde surgen los problemas
Los cambios de comportamiento se cuelan con la refactorización. Un desarrollador ordena una función y corrige un error en ella en el mismo commit. Cuando falla una prueba, nadie sabe cuál de las dos cosas lo causó, y quien revisa debe leer cada línea como posible cambio de comportamiento. Lleve un solo sombrero cada vez: refactorice en un commit, cambie el comportamiento en el siguiente y, si falla una prueba al refactorizar, deshaga el último paso en lugar de seguir añadiendo correcciones.
Una gran reestructuración se llama refactorización. Una rama pasa semanas con el proceso de construcción fallando mientras el código «se está refactorizando». Eso es reestructuración en los términos de Fowler y conlleva el riesgo que la refactorización está diseñada para evitar. Divida el trabajo en pasos que dejen el sistema funcionando y puedan fusionarse por separado; donde no sea posible, llámelo reescritura y planifíquelo como tal.
No hay pruebas que demuestren que nada cambió. Conservar el comportamiento es una afirmación, y sin pruebas es una suposición. Antes de tocar código sin pruebas, escriba pruebas que fijen lo que hace hoy, incluso cuando parezca incorrecto, y corrija después sus rarezas en cambios separados. Aquí se aplica la regla orientativa de Fowler en su ejemplo de refactorización preparatoria: cuando sienta la necesidad de ejecutar el código e inspeccionar visualmente su salida, escriba una prueba en su lugar.
Renombrar en el código de infraestructura sustituye el recurso. Un nombre nuevo más claro en Terraform parece una refactorización al revisarlo, y el plan propone discretamente destruir una base de datos y crear otra vacía. Registre cada cambio de nombre y cada traslado hacia dentro o fuera de un módulo mediante un bloque moved, y considere cualquier destrucción en el plan de un cambio que se pretende refactorización como un paso fallido.
Se elimina un bloque moved antiguo. Los bloques moved se acumulan y quitarlos parece limpieza. La documentación de Terraform lo llama un cambio incompatible: cualquier configuración que aún utilice la dirección antigua obtendría entonces un plan que destruye el objeto en lugar de moverlo. Conserve los bloques históricos, encadénelos cuando un objeto se renombre dos veces y elimínelos únicamente de un módulo privado cuando todos sus usuarios hayan aplicado la versión que los contiene.
La refactorización espera una fase dedicada. Un equipo que programa un «sprint de refactorización» para más adelante sigue añadiendo funcionalidades a un código que se resiste, y es fácil recortar un sprint previsto para después cuando cambia una fecha límite. El consejo de Fowler va en sentido contrario: refactorice como parte de cada cambio, primero para facilitarlo y después para dejar claro el resultado, de modo que ese trabajo nunca necesite un hueco propio en el plan.
Lecturas adicionales
- Definición de refactorización — Las definiciones de Martin Fowler como sustantivo y como verbo, tal como aparecen en su libro.
- Refactoring — El sitio de Fowler sobre el libro, con las razones para integrar la refactorización en la programación diaria y el catálogo completo.
- Extract Function — La entrada del catálogo de una de las refactorizaciones más comunes, con su inversa y su nombre en la primera edición.
- Un ejemplo de refactorización preparatoria — Fowler remodela su propio código en pasos pequeños antes de añadir una funcionalidad y explica los dos sombreros.
- Refactorizar módulos — La documentación de Terraform sobre bloques
moved, cambios de nombre, división de módulos y por qué deben conservarse los bloques antiguos.