Mejora de la legibilidad y el mantenimiento del código

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. Chat de Copiloto puede ayudar de varias maneras. Por ejemplo:

Documentar el código es otra manera de mejorar su capacidad de mantenimiento. Para obtener información sobre cómo usar Chat de Copiloto para ayudarle a agregar comentarios útiles al código, consulte los mensajes de ejemplo en Documenting code (Documentación del código).

Nota:

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

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.");
  }
}

Mensaje de ejemplo

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

Copilot prompt
Improve the variable names in this function

Respuesta de ejemplo

Copilot sugiere nombres descriptivos de variables.

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 "Unknown animal" 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"))

Mensaje de ejemplo

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

Respuesta de ejemplo

Copilot sugiere usar 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"))

Reducción de la lógica anidada

Las estructuras profundamente anidadas pueden dificultar el seguimiento del código, lo que dificulta a su vez 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)

Mensaje de ejemplo

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

Respuesta de ejemplo

Copilot sugiere usar cláusulas de guarda para comprobar las condiciones al principio y devolver los mensajes correspondientes.

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)

División de 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 dificulta a su vez 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);
}

Mensaje de ejemplo

Copilot 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 métodos 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);
}

Lectura adicional