Melhorar a legibilidade e a facilidade de manutenção

O Bate-papo do Copiloto 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 Bate-papo do Copiloto pode ajudar você de diversas formas. Por exemplo, ao:

  •           [Sugerir melhorias em nomes de variáveis](#improving-variable-names)

  •           [Evitar verificações condicionais em sequência](#avoiding-sequential-conditional-checks)

  •           [Reduzir a lógica aninhada](#reducing-nested-logic)

  •           [Dividir métodos extensos em partes menores e de fácil leitura](#splitting-up-large-methods)

A documentação do código é mais um meio de aumentar sua facilidade de manutenção. Para mais informações sobre como utilizar o Bate-papo do Copiloto 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 Bate-papo do Copiloto 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 Bate-papo do Copiloto:

Copilot Chat 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 Chat 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 Chat 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 Chat 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