El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Refactorización

Siguiente ►
►

La refactorización es el proceso de reestructurar el código existente sin cambiar su comportamiento externo. El objetivo es mejorar la estructura interna del código, haciéndolo más legible, mantenible y eficiente. En esta sección, aprenderás las técnicas y principios básicos de la refactorización en Ruby.

Objetivos de la Refactorización

  • Mejorar la legibilidad: Hacer que el código sea más fácil de entender.
  • Reducir la complejidad: Simplificar el código para que sea más fácil de mantener.
  • Eliminar duplicación: Reducir la redundancia en el código.
  • Mejorar la eficiencia: Optimizar el rendimiento del código.

Principios Básicos de Refactorización

  1. Pequeños pasos: Realiza cambios pequeños y prueba frecuentemente.
  2. Pruebas automatizadas: Asegúrate de tener una suite de pruebas que verifique que el comportamiento del código no cambia.
  3. Comprensión del código: Antes de refactorizar, asegúrate de entender completamente el código existente.

Técnicas Comunes de Refactorización

  1. Renombrar Variables y Métodos

Renombrar variables y métodos para que sus nombres sean más descriptivos puede mejorar significativamente la legibilidad del código.

Ejemplo:

# Antes de la refactorización
def calc(x, y)
  x + y
end

# Después de la refactorización
def calculate_sum(a, b)
  a + b
end

  1. Extraer Métodos

Si un método es demasiado largo o realiza múltiples tareas, considera dividirlo en métodos más pequeños y específicos.

Ejemplo:

# Antes de la refactorización
def print_invoice(order)
  puts "Order ID: #{order.id}"
  puts "Customer: #{order.customer_name}"
  puts "Total: #{order.total}"
end

# Después de la refactorización
def print_invoice(order)
  print_order_id(order)
  print_customer_name(order)
  print_total(order)
end

def print_order_id(order)
  puts "Order ID: #{order.id}"
end

def print_customer_name(order)
  puts "Customer: #{order.customer_name}"
end

def print_total(order)
  puts "Total: #{order.total}"
end

  1. Eliminar Código Duplicado

El código duplicado puede ser un problema común y debe ser eliminado para mejorar la mantenibilidad.

Ejemplo:

# Antes de la refactorización
def calculate_discount(price)
  if price > 100
    price * 0.1
  else
    price * 0.05
  end
end

def apply_discount(price)
  if price > 100
    price - (price * 0.1)
  else
    price - (price * 0.05)
  end
end

# Después de la refactorización
def discount_rate(price)
  price > 100 ? 0.1 : 0.05
end

def calculate_discount(price)
  price * discount_rate(price)
end

def apply_discount(price)
  price - calculate_discount(price)
end

  1. Simplificar Condicionales

Las estructuras condicionales complejas pueden ser difíciles de seguir. Simplificarlas puede mejorar la claridad del código.

Ejemplo:

# Antes de la refactorización
def get_status(age)
  if age < 18
    'minor'
  elsif age >= 18 && age < 65
    'adult'
  else
    'senior'
  end
end

# Después de la refactorización
def get_status(age)
  return 'minor' if age < 18
  return 'adult' if age < 65
  'senior'
end

Ejercicio Práctico

Ejercicio 1: Refactorizar un Método Largo

Refactoriza el siguiente método para mejorar su legibilidad y mantenibilidad.

def process_order(order)
  if order.items.any? { |item| item.stock == 0 }
    puts "Order cannot be processed. Some items are out of stock."
  else
    order.items.each do |item|
      item.stock -= 1
    end
    puts "Order processed successfully."
  end
end

Solución:

def process_order(order)
  if out_of_stock?(order)
    notify_out_of_stock
  else
    update_stock(order)
    notify_success
  end
end

def out_of_stock?(order)
  order.items.any? { |item| item.stock == 0 }
end

def notify_out_of_stock
  puts "Order cannot be processed. Some items are out of stock."
end

def update_stock(order)
  order.items.each { |item| item.stock -= 1 }
end

def notify_success
  puts "Order processed successfully."
end

Conclusión

La refactorización es una práctica esencial para mantener el código limpio, legible y eficiente. Al aplicar técnicas de refactorización, puedes mejorar la calidad de tu código y facilitar su mantenimiento a largo plazo. Asegúrate de realizar cambios incrementales y de contar con una suite de pruebas robusta para verificar que el comportamiento del código no se vea afectado.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados