É difícil para outros desenvolvedores manterem e estenderem código com legibilidade ruim. O Copilot Chat pode ajudar você de várias maneiras. Por exemplo:
- Sugerindo melhorias em nomes de variáveis
- Evitando verificações condicionais sequenciais
- Reduzindo a lógica aninhada
- Dividindo métodos grandes em métodos menores e mais legíveis
Documentar o código é outra maneira de melhorar a capacidade de manutenção dele. Para saber mais sobre como usar o Copilot Chat para ajudar você a adicionar comentários úteis ao seu código, confira os prompts de exemplo Documentando o código.
Note
As respostas mostradas neste artigo são exemplos. Respostas do Copilot Chat são não determinísticas, portanto, você pode obter respostas diferentes das mostradas aqui.
Aprimorando nomes de variável
Nomes de variável e de parâmetro descritivos facilitam a compreensão da finalidade deles.
Cenário de exemplo
Esse código JavaScript registra em log uma mensagem sobre a idade de uma pessoa no console. Nomes de parâmetro abstratos dificultam a compreensão da finalidade do 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.");
}
}
Solicitação de exemplo
No editor, selecione a função que deseja alterar e pergunte ao Copilot Chat:
Improve the variable names in this function
Exemplo de resposta
O Copilot sugere nomes de variável descritivos.
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.");
}
}
Evitando verificações condicionais sequenciais
Cadeias if...else podem ser difíceis de ler, especialmente quando são longas.
Cenário de exemplo
Este código Python imprime o som que vários animais fazem, se definidos, ou "Unknown animal" se o tipo de animal não for reconhecido. No entanto, a cadeia de instruções if...else torna o código ineficiente e 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"))
Solicitação de exemplo
Simplify this code. Avoid using if/else chains but retain all function return values.
Exemplo de resposta
O Copilot sugere o uso de um dicionário para mapear os tipos de animais para as classes correspondentes.
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"))
Reduzindo a lógica aninhada
Estruturas profundamente aninhadas podem tornar o código difícil de acompanhar, dificultando a modificação ou a extensão da lógica do código no futuro.
Cenário de exemplo
Este código Ruby imprime informações sobre uma conta de usuário com base em três parâmetros. O uso de instruções if...else aninhadas torna o código desnecessariamente complexo.
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)
Solicitação de exemplo
Rewrite this code to avoid the nested if/else statements
Exemplo de resposta
O Copilot sugere o uso de cláusulas de proteção para lidar com as condições antecipadamente e retornar as mensagens apropriadas.
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)
Dividindo métodos grandes
Pode ser difícil entender exatamente o que um método ou uma função faz quando ela é muito longa, dificultando a manutenção. Métodos ou funções que executam várias tarefas podem não ser reutilizáveis em outros contextos. Também pode ser difícil testar cada tarefa isoladamente.
Cenário de exemplo
Esse método Java processa um pedido de cliente e imprime uma mensagem. Ele executa várias tarefas em um só 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);
}
Solicitação de exemplo
How could the processOrder method be refactored to be more useful and easier to maintain
Exemplo de resposta
O Copilot sugere dividir esse método em métodos menores e mais focados.
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);
}