Refactorizar hacia un patrón
- Lección 31 de 32
- 10 min
- Intermedio
- 12 pasos
Un `price()` con un `if` por tipo de cliente funciona bien, hasta que llega un tipo más. Vas a llevarlo hacia Strategy en pasos chicos, con los tests en verde después de cada uno, y vas a ver qué hacer cuando un paso sale mal.
- ifs por tipo en price()
- 0
- Tests en verde
- 4
- petición
- respuesta
- petición fallida
Paso 1 de 12
Problema
Un descuento por tipo, un if por tipo
Tu tienda calcula el precio con price(kind, b): un estudiante (student) paga la mitad y un jubilado (senior), el 70 %. Cada tipo es un if dentro de la misma función, y price("student", 100) devuelve 50.
Con dos ramas se lee bien y funciona. Nadie necesita un patrón todavía, y está bien así: no se empieza por el patrón.
Qué cambió
- price() con dos ramas
Paso 2 de 12
Problema
El cambio que pide un tercer if
Producto pide un descuento para docentes: teacher paga el 80 %. Lo fácil es pegar un tercer if igual a los otros dos.
Esa es la señal: el cambio te obliga a repetir lo mismo otra vez, dentro de una función que ya funciona. Antes de sumar la rama, pregúntate si conviene cambiar primero la forma del código para que sumar un tipo sea fácil.
Qué cambió
- price(), a punto de crecer otra vez
Paso 3 de 12
Concepto
Refactorizar no es reescribir
Martin Fowler define refactorizar como reestructurar código existente cambiando su estructura interna sin cambiar su comportamiento externo, con una serie de transformaciones chicas que conservan ese comportamiento.
Reescribir es otra cosa: tirar la función y hacerla de nuevo de un salto. Al refactorizar, price("student", 100) sigue devolviendo 50 después de cada paso.
Paso 4 de 12
Técnica
Primero, tests que fijan lo que hace hoy
Antes de mover una línea, escribe tests que llamen a price() como lo hace checkout: un estudiante, un jubilado y un tipo sin descuento. Los tres pasan: ese es tu punto verde.
Si heredas código sin tests, empieza igual: escribe tests que registren lo que el código hace hoy, aunque te parezca raro, y no lo corrijas en el mismo paso. Sin esa red no estás refactorizando, estás adivinando.
Qué cambió
- 3 tests en verde
Paso 5 de 12
Concepto
El patrón es el destino, no el punto de partida
El catálogo de refactorizaciones de Fowler tiene una receta para este caso, Replace Conditional with Polymorphism: cada rama de un if por tipo pasa a su propia pieza. Es el camino hacia Strategy, que ya viste en su lección.
Joshua Kerievsky dedicó a esta idea *Refactoring to Patterns* (Addison-Wesley, 2004): llegar a un patrón desde código que ya existe, con refactorizaciones chicas, en vez de diseñarlo todo antes. Aquí el plan son cuatro pasos, y los tests corren después de cada uno.
Qué cambió
- un plan de 4 pasos
Paso 6 de 12
Solución
Paso 1: student pasa a un mapa
Creas un mapa byKind con una función por tipo. Su tipo, Discount, es una función que recibe el precio y devuelve el precio con descuento. Mueves solo student, price() lo busca primero en el mapa y borras el if de student.
Corres los tests: 3 de 3 en verde. Por un rato conviven el mapa y el if de senior, y está bien: el patrón no tiene que estar completo en el primer paso. Haces commit y sigues.
Qué cambió
- byKind con student
- el if de student
Paso 7 de 12
Problema
Paso 2: senior se mueve y un test falla
Mueves senior al mapa y borras su if. Al escribir la función se cuela un error: b * 0.07 en vez de b * 0.7. El test de senior espera 70 y recibe 7.
Ya no quedan if por tipo, pero hay un test en rojo: el comportamiento cambió, así que este paso no es un refactor. Como el paso fue chico, sabes exactamente dónde mirar.
Qué cambió
- senior en el mapa, con un error
- el if de senior
Paso 8 de 12
Técnica
Vuelve al último verde y rehaz el paso
No apiles arreglos encima del rojo. Vuelve al último estado verde, por ejemplo con git restore, que descarta los cambios desde el commit del paso 1, y rehaz el paso con senior: (b) => b * 0.7.
Los tests vuelven a 3 de 3. Con pasos chicos y un commit por cada verde, equivocarte te cuesta deshacer un paso, no rehacer todo el refactor.
Qué cambió
- b * 0.07
- b * 0.7
Paso 9 de 12
Solución
Llegaste a Strategy sin diseñarlo antes
Queda limpiar price(): busca en byKind y delega, o devuelve el precio tal cual si el tipo no tiene descuento. Ya no pregunta qué tipo es.
Cada función del mapa cumple el mismo tipo Discount: es Strategy, escrito con funciones. No lo dibujaste el primer día; apareció cuando el código lo pidió, con los tests en verde en cada paso.
Qué cambió
- if (d) … return b
- return d ? d(b) : b
Paso 10 de 12
Solución
Ahora sumar teacher es una línea
Recién ahora haces el cambio que te pidieron: una línea en byKind, teacher: (b) => b * 0.8, y un test nuevo que espera 80 para un precio de 100.
price() no se toca y los tests pasan de 3 a 4, todos en verde. Primero cambiaste la forma del código para que el cambio fuera fácil; después hiciste el cambio fácil.
Qué cambió
- teacher en byKind
- 1 test más
Paso 11 de 12
Compromiso
Cuándo no refactorizar hacia un patrón
Si el código se va a borrar pronto, o no tiene tests y no hay tiempo para escribirlos, déjalo como está. Y con dos ramas que no crecen, el if basta: un mapa y un tipo para dos casos fijos es diseño que nadie pidió.
Fowler resume lo que cuesta construir algo por si acaso (YAGNI): construirlo, la demora de lo demás, cargarlo en cada cambio y repararlo si el diseño era el equivocado. Refactorizar cuando llega la necesidad real no va contra YAGNI, porque deja el código más fácil de cambiar. Lo que cuesta el método: mientras migras conviven código viejo y nuevo, así que termina la migración y no la dejes a medias.
Paso 12 de 12
Resumen
Pasos chicos hacia el patrón, siempre en verde
Empieza simple. Cuando un cambio te obliga a repetir el mismo if, pon tests que fijen lo que hace el código y llévalo hacia el patrón en pasos chicos que no cambian lo que devuelve.
Si un test se pone en rojo, vuelve al último verde y rehaz el paso. Al llegar, el cambio que te pidieron es fácil. Si el código se borra pronto o no hay tests ni tiempo para escribirlos, no empieces.
← → paso · R repetir · Espacio pausa
Aprenderás
- Reconocer la señal: un cambio que te obliga a repetir el mismo `if`. (visto)
- Distinguir refactorizar de reescribir. (visto)
- Poner tests que fijen lo que hace el código antes del primer cambio. (visto)
- Llegar al patrón en pasos chicos y volver al último verde cuando uno falla. (visto)
- Saber cuándo no refactorizar hacia un patrón. (visto)