Aprimorando a legibilidade e a capacidade de manutenção do código

Bate-papo do Copilot pode sugerir maneiras de tornar seu código mais fácil de entender e manter.

Neste artigo

É difícil para outros desenvolvedores manterem e estenderem código com legibilidade ruim. Bate-papo do Copilot pode ajudar de várias maneiras. Por exemplo, por:

Documentar o código é outra maneira de melhorar a capacidade de manutenção dele. Para obter informações sobre como usar Bate-papo do Copilot para ajudá-lo a adicionar comentários úteis ao seu código, consulte os prompts de exemplo no código de documentação.

Observação

As respostas mostradas neste artigo são exemplos. Bate-papo do Copilot as respostas 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.");
  }
}

Prompt de exemplo

No editor, selecione a função que você deseja alterar e, em seguida, pergunte Bate-papo do Copilot:

Copilot prompt
Improve the variable names in this function

Resposta de exemplo

Copilot sugere nomes de variáveis descritivas.

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

Sequências 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 estiverem definidos, ou "Animal desconhecido", 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"))

Prompt de exemplo

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

Resposta de exemplo

Copilot sugere o uso de um dicionário para mapear os tipos de animais para suas 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)

Prompt de exemplo

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

Resposta de exemplo

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

Prompt de exemplo

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

Resposta de exemplo

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

Leitura adicional