Refactorización – Introducción y sus Técnicas

La refactorización o refactorización de código se define como un proceso sistemático de mejora del código informático existente, sin agregar nuevas funciones ni cambiar el comportamiento externo del código. Está destinado a cambiar la implementación, la definición y la estructura del código sin cambiar la funcionalidad del software. Mejora la extensibilidad, la mantenibilidad y la legibilidad del software sin cambiar lo que realmente hace.

¿Por qué deberíamos refactorizar nuestro código cuando funciona bien?
El objetivo de la refactorización no es agregar una nueva funcionalidad o eliminar una existente. El objetivo principal de la refactorización es hacer que el código sea más fácil de mantener en el futuro y luchar contra la deuda técnica. Refactorizamos porque entendemos que lograr un diseño correcto a la primera es difícil y también obtiene los siguientes beneficios de la refactorización:

• El tamaño del código a menudo se reduce
• El código confuso se reestructura en un código más simple

Los dos beneficios anteriores mejoran en gran medida la capacidad de mantenimiento que se requiere porque los requisitos siempre cambian.

¿Cuándo refactorizamos?

• Antes de agregar nuevas funciones, asegúrese de que su diseño y el código actual sean «buenos». Esto ayudará a que el nuevo código sea más fácil de escribir.
• Cuando necesitas corregir un error
• Cuando haces una revisión por pares
• Durante una revisión de código

¿Cómo identificar el código para refactorizar?
Martin Fowler propuso usar «olores de código» para identificar cuándo y dónde refactorizar. Los olores de código son cosas malas que se hacen en el código, al igual que los malos patrones en el código. La refactorización y los olores de código son algunas técnicas que nos ayudan a identificar problemas en el diseño y la implementación. También nos ayuda a aplicar soluciones conocidas a estos problemas.

Técnicas de refactorización:
existen más de 70 técnicas de refactorización. Pero discutiremos solo algunos, más comunes.

1. Método de extracción:
   cuando tenemos un código que se puede agrupar.

   Ejemplo:

   def student():
       getgrades()
       # details
       name = input()
       class = input() 

   Esto podría ser refactorizado como:

   def student():
       getgrades()
       getdetails()
   
   def getdetails():
       name = input()
       class = input() 

2. Reemplazar temperatura con consulta:
   cuando estamos usando una variable temporal para contener el resultado de una expresión.

   Ejemplo :

   SI = P * R * T / 100
   if(SI > 100):
       return SI
   else:
       return SI * 1.5 

   Esto podría ser refactorizado como:

   def SI():
   return P * R * T / 100
   
   if(SI() > 100):
       return SI()
   else:
       return SI()*1.5 

3. Encapsular campo:
   implica proporcionar métodos que se utilizan para leer/escribir datos en lugar de acceder a ellos directamente.

   Ejemplo :

   class A:
       variable 
   This could be refactored as:
   
   class A:
        self.variable
        getvariable()
        setvariable() 
   

4. Método en línea:
   cuando tenemos un cuerpo de método que es más obvio que el método en sí.

   Ejemplo :

   class PizzaDelivery:
       def getgrades(self):
           return 'A' if self.moretheneight() else B
       def ismorethaneight(self):
           return self.number > 8 

   Esto podría ser refactorizado como:

   class PizzaDelivery:
       def getgrades(self):
           return self.number > 8 ? A : B 

5. Método de movimiento:
   cuando una función, una clase es utilizada por otra clase más que la clase en la que existe.

   Class A:
       #...
       abc()
   
   Class B:
       #... 

   Esto podría ser refactorizado como:

   Class A:
       #...
       
   Class B:
       #...
       abc()

6. Reemplazar condicional con polimorfismo:
   cuando tenemos un condicional que realiza varias acciones según el tipo de objeto o las propiedades.

   Ejemplo :

   =class Bird:
       # ...
       def getSpeed(self):
           if self.type == EUROPEAN:
               return self.getBaseSpeed()
           elif self.type == AFRICAN:
               return self.getBaseSpeed() - self.getLoadFactor() * self.numberOfCoconuts
           elif self.type == NORWEGIAN_BLUE:
               return 0 if self.isNailed else self.getBaseSpeed(self.voltage)
           else:
               raise Exception("Should be unreachable") 

   Esto podría refactorizarse como

   class Bird:
       # ...
       def getSpeed(self):
           pass
   
   class European(Bird):
       def getSpeed(self):
           return self.getBaseSpeed()
       
       
   class African(Bird):
       def getSpeed(self):
           return self.getBaseSpeed() - self.getLoadFactor() * self.numberOfCoconuts
   
   
   class NorwegianBlue(Bird):
       def getSpeed(self):
           return 0 if self.isNailed else self.getBaseSpeed(self.voltage)
   
   # Somewhere in client code
   speed = bird.getSpeed() 

Nota :

• La refactorización mejora el diseño del software.
• La refactorización hace que el software sea más fácil de entender.
• La refactorización nos ayuda a encontrar errores en el programa.
• La refactorización nos ayuda a programar más rápido.