Mejora de la legibilidad y el mantenimiento del código

El Chat de Copiloto puede sugerir formas de facilitar la comprensión y el mantenimiento del código.

En este artículo

Es complicado que otros desarrolladores puedan mantener y ampliar código difícil de leer. El Chat de Copiloto puede ayudar de varias formas. Por ejemplo:

  •           [Sugiriendo mejoras en los nombres de variables](#improving-variable-names)

  •           [Evitando comprobaciones condicionales secuenciales](#avoiding-sequential-conditional-checks)

  •           [Reduciendo la lógica anidada](#reducing-nested-logic)

  •           [Dividiendo métodos grandes en otros más pequeños y legibles](#splitting-up-large-methods)

Documentar el código es otra manera de mejorar su capacidad de mantenimiento. Para obtener información sobre el uso del Chat de Copiloto para ayudar a agregar comentarios útiles al código, consulte las indicaciones de ejemplo en Documentación del código.

Nota:

Las respuestas que se muestran en este artículo son ejemplos. Las respuestas del Chat de Copiloto no son deterministas, por lo que puedes obtener respuestas diferentes a las aquí mostradas.

Mejora de los nombres de variables

Los nombres descriptivos de parámetros y variables facilitan la comprensión de su propósito.

Escenario de ejemplo

Este código de JavaScript registra un mensaje sobre la edad de una persona en la consola. Los nombres abstractos de los parámetros dificultan la comprensión del propósito del código.

function logPersonsAge(a, b, c) {
  if (c) {
    console.log(a + " is " + b + " years old.");
  } else {
    console.log(a + " does not want to reveal their age.");
  }
}

Ejemplos de indicaciones

En el editor, seleccione la función que desea cambiar y, a continuación, pregunte al Chat de Copiloto:

Copilot Chat prompt
Improve the variable names in this function

Respuesta de ejemplo

Copilot sugiere nombres de variables descriptivos.

function logPersonAge(name, age, revealAge) {
  if (revealAge) {
    console.log(name + " is " + age + " years old.");
  } else {
    console.log(name + " does not want to reveal their age.");
  }
}

Evitar comprobaciones condicionales secuenciales

          Las cadenas `if...else` pueden ser difíciles de leer, especialmente cuando son largas.

Escenario de ejemplo

Este código de Python imprime el sonido que hacen distintos animales, en caso de haberse definido, o indica "Animal desconocido" si no se reconoce el tipo de animal. Sin embargo, la cadena de instrucciones if...else hace que el código sea ineficaz y complicado.

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Bird(Animal):
    def speak(self):
        return "Tweet!"

def animal_sound(animal_type):
    if animal_type == "dog":
        return Dog().speak()
    elif animal_type == "cat":
        return Cat().speak()
    elif animal_type == "bird":
        return Bird().speak()
    else:
        return "Unknown animal"

print(animal_sound("dog"))
print(animal_sound("cat"))
print(animal_sound("bird"))
print(animal_sound("fish"))

Ejemplos de indicaciones

Copilot Chat prompt
Simplify this code. Avoid using if/else chains but retain all function return values.

Respuesta de ejemplo

Copilot sugiere el uso de un diccionario para asignar los tipos de animales a sus clases correspondientes.

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

class Bird(Animal):
    def speak(self):
        return "Tweet!"

def animal_sound(animal_type):
    animals = {
        "dog": Dog,
        "cat": Cat,
        "bird": Bird
    }
    animal_class = animals.get(animal_type, Animal)
    return animal_class().speak() if animal_class != Animal else "Unknown animal"

print(animal_sound("dog"))
print(animal_sound("cat"))
print(animal_sound("bird"))
print(animal_sound("fish"))

Reducir la lógica anidada

Las estructuras profundamente anidadas pueden dificultar el seguimiento del código, lo que a su vez dificulta la modificación o ampliación de la lógica del código en el futuro.

Escenario de ejemplo

Este código de Ruby imprime información sobre una cuenta de usuario basada en tres parámetros. El uso de instrucciones if...else anidadas hace que el código sea innecesariamente complejo.

def determine_access(user_role, has_permission, is_active)
  if user_role == "admin"
    if has_permission
      if is_active
        "Active admin account with full access."
      else
        "Inactive admin account."
      end
    else
      "Admin account lacks necessary permissions."
    end
  else
    "Access denied."
  end
end

puts determine_access("admin", true, true)
puts determine_access("admin", true, false)
puts determine_access("admin", false, true)
puts determine_access("user", true, true)

Ejemplos de indicaciones

Copilot Chat prompt
Rewrite this code to avoid the nested if/else statements

Respuesta de ejemplo

Copilot sugiere el uso de cláusulas de restricción para controlar las condiciones al principio y devolver los mensajes adecuados.

def determine_access(user_role, has_permission, is_active)
  return "Access denied." unless user_role == "admin"
  return "Admin account lacks necessary permissions." unless has_permission
  return "Inactive admin account." unless is_active

  "Active admin account with full access."
end

puts determine_access("admin", true, true)
puts determine_access("admin", true, false)
puts determine_access("admin", false, true)
puts determine_access("user", true, true)

Dividir métodos grandes

Puede ser difícil entender con exactitud lo que hace un método o función si es demasiado largo, lo que a su vez dificulta su mantenimiento. Es posible que los métodos o funciones que realizan varias tareas no sean reutilizables en otros contextos. También puede ser difícil probar cada tarea de forma aislada.

Escenario de ejemplo

Este método de Java procesa un pedido de cliente e imprime un mensaje. Realiza varias tareas en un único método.

public void processOrder(Order order) {
  if (order == null || order.getItems().isEmpty()) {
    throw new IllegalArgumentException("Order is invalid.");
  }

  double totalPrice = 0.0;
  for (Item item : order.getItems()) {
    totalPrice += item.getPrice() * item.getQuantity();
  }
  order.setTotalPrice(totalPrice);

  if (totalPrice > 0) {
    order.setStatus("Processed");
  } else {
    order.setStatus("Pending");
  }

  System.out.println("Order for customer " + order.getCustomerName() + " has been processed. Total price: " + totalPrice);
}

Ejemplos de indicaciones

Copilot Chat prompt
How could the processOrder method be refactored to be more useful and easier to maintain

Respuesta de ejemplo

Copilot sugiere dividir este método en otros más pequeños y centrados.

public void processOrder(Order order) {
    validateOrder(order);
    double totalPrice = calculateTotalPrice(order);
    updateOrderStatus(order, totalPrice);
    printOrderSummary(order, totalPrice);
}

private void validateOrder(Order order) {
    if (order == null || order.getItems().isEmpty()) {
        throw new IllegalArgumentException("Order is invalid.");
    }
}

private double calculateTotalPrice(Order order) {
    double totalPrice = 0.0;
    for (Item item : order.getItems()) {
        totalPrice += item.getPrice() * item.getQuantity();
    }
    order.setTotalPrice(totalPrice);
    return totalPrice;
}

private void updateOrderStatus(Order order, double totalPrice) {
    if (totalPrice > 0) {
        order.setStatus("Processed");
    } else {
        order.setStatus("Pending");
    }
}

private void printOrderSummary(Order order, double totalPrice) {
    System.out.println("Order for customer " + order.getCustomerName() + " has been processed. Total price: " + totalPrice);
}

Información adicional