Melhorar a legibilidade e a facilidade de manutenção

O Chat Copilot consegue indicar formas de tornar o código mais compreensível e fácil de manter.

Neste artigo

Código com baixa legibilidade é difícil de manter e expandir por outros desenvolvedores. O Chat Copilot pode ajudar você de diversas formas. Por exemplo, ao: * Sugerir melhorias em nomes de variáveis * Evitar verificações condicionais em sequência * Reduzir a lógica aninhada * Dividir métodos extensos em partes menores e de fácil leitura

A documentação do código é mais um meio de aumentar sua facilidade de manutenção. Para mais informações sobre como utilizar o Chat Copilot para ajudar a adicionar comentários úteis ao código, consulte os prompts de exemplo em Documentar código.

Observação

As respostas mostradas neste artigo são exemplos. Respostas do Chat Copilot são não determinísticas, portanto, você pode obter respostas diferentes das mostradas aqui.

Melhorar nomes de variáveis

Nomes descritivos para variáveis e parâmetros facilitam a compreensão de sua finalidade.

Cenário de exemplo

Este código em JavaScript exibe no console uma mensagem sobre a idade de alguém. Parâmetros com nomes genéricos 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

Dentro do editor, escolha a função que quer modificar e consulte o Chat Copilot:

Copilot prompt
Improve the variable names in this function

Exemplo de resposta

O Copilot indica nomes de variáveis 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.");
  }
}

Evitar verificações condicionais em sequência

          Cadeias `if...else` podem se tornar difíceis de compreender, principalmente quando extensas.

Cenário de exemplo

Este código em Python mostra o som produzido por vários animais, se estiver definido, ou "Animal desconhecido" caso o tipo de animal não seja reconhecido. Entretanto, a cadeia de declarações if...else deixa 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

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

Exemplo de resposta

O Copilot indica utilizar um dicionário para associar cada tipo de animal à sua respectiva classe.

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

Reduzir a lógica aninhada

Estruturas muito aninhadas tornam o código complicado de entender, o que dificulta alterar ou expandir sua lógica posteriormente.

Cenário de exemplo

O código em Ruby exibe dados de uma conta de usuário de acordo com três parâmetros. A utilização de declarações if...else aninhadas complica o código sem necessidade.

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

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

Exemplo de resposta

O Copilot recomenda utilizar cláusulas de proteção para lidar com as condições antecipadamente e fornecer as mensagens corretas.

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 extensos

Com métodos ou funções muito extensos, torna-se difícil compreender seu funcionamento, o que dificulta a manutenção. Métodos ou funções que realizam diversas tarefas podem não ser reutilizáveis em outros contextos. Testar individualmente cada tarefa pode ser complicado.

Cenário de exemplo

O método em Java processa um pedido de cliente e exibe uma mensagem. Ele executa diversas tarefas em um ú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);
}

Solicitação de exemplo

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

Exemplo de resposta

O Copilot recomenda separar este método em métodos menores com foco específico.

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