Es complicado que otros desarrolladores puedan mantener y ampliar código difícil de leer. El Copilot Chat puede ayudar de varias formas. Por ejemplo, puede:
- Sugerir mejoras en los nombres de variables
- Evitar comprobaciones condicionales secuenciales
- Reducir la lógica anidada
- Dividir métodos grandes en otros más pequeños y legibles
Documentar el código es otra manera de mejorar su capacidad de mantenimiento. Para obtener información sobre el uso del Copilot Chat para ayudar a agregar comentarios útiles al código, consulta las indicaciones de ejemplo en Documentación del código.
Note
Las respuestas que se muestran en este artículo son ejemplos. Las respuestas del Copilot Chat 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, selecciona la función que quieres cambiar y, a continuación, pide al Copilot Chat:
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 "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"))
Ejemplos de indicaciones
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"))
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)
Ejemplos de indicaciones
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)
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);
}
Ejemplos de indicaciones
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);
}