{"meta":{"title":"Melhorar a legibilidade e a facilidade de manutenção","intro":"O Bate-papo do Copilot consegue indicar formas de tornar o código mais compreensível e fácil de manter.","product":"GitHub Copilot","breadcrumbs":[{"href":"/pt/copilot","title":"GitHub Copilot"},{"href":"/pt/copilot/tutorials","title":"Tutoriais"},{"href":"/pt/copilot/tutorials/copilot-chat-cookbook","title":"Livro de Receitas do GitHub Copilot Chat"},{"href":"/pt/copilot/tutorials/copilot-chat-cookbook/refactor-code","title":"Refatorar o código"},{"href":"/pt/copilot/tutorials/copilot-chat-cookbook/refactor-code/improve-code-readability","title":"Melhorar a legibilidade do código"}],"documentType":"article"},"body":"# Melhorar a legibilidade e a facilidade de manutenção\n\nO Bate-papo do Copilot consegue indicar formas de tornar o código mais compreensível e fácil de manter.\n\nCódigo com baixa legibilidade é difícil de manter e expandir por outros desenvolvedores. O Bate-papo do Copilot pode ajudar você de diversas formas. Por exemplo, ao:\n\n* [Sugerir melhorias em nomes de variáveis](#improving-variable-names)\n* [Evitar verificações condicionais em sequência](#avoiding-sequential-conditional-checks)\n* [Reduzir a lógica aninhada](#reducing-nested-logic)\n* [Dividir métodos extensos em partes menores e de fácil leitura](#splitting-up-large-methods)\n\nA 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 Copilot para ajudar a adicionar comentários úteis ao código, consulte os prompts de exemplo em [Documentar código](/pt/copilot/copilot-chat-cookbook/documenting-code).\n\n> \\[!NOTE] As respostas mostradas neste artigo são exemplos. Respostas do Bate-papo do Copilot são não determinísticas, portanto, você pode obter respostas diferentes das mostradas aqui.\n\n## Melhorar nomes de variáveis\n\nNomes descritivos para variáveis e parâmetros facilitam a compreensão de sua finalidade.\n\n### Cenário de exemplo\n\nEste 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.\n\n```javascript id=log-persons-age\nfunction logPersonsAge(a, b, c) {\n  if (c) {\n    console.log(a + \" is \" + b + \" years old.\");\n  } else {\n    console.log(a + \" does not want to reveal their age.\");\n  }\n}\n```\n\n### Solicitação de exemplo\n\nDentro do editor, escolha a função que quer modificar e consulte o Bate-papo do Copilot:\n\n```copilot copy prompt ref=log-persons-age\nImprove the variable names in this function\n```\n\n### Exemplo de resposta\n\nO Copilot indica nomes de variáveis descritivos.\n\n```javascript\nfunction logPersonAge(name, age, revealAge) {\n  if (revealAge) {\n    console.log(name + \" is \" + age + \" years old.\");\n  } else {\n    console.log(name + \" does not want to reveal their age.\");\n  }\n}\n```\n\n## Evitar verificações condicionais em sequência\n\n```\n          Cadeias `if...else` podem se tornar difíceis de compreender, principalmente quando extensas.\n```\n\n### Cenário de exemplo\n\nEste 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.\n\n```python id=animal-sound\nclass Animal:\n    def speak(self):\n        pass\n\nclass Dog(Animal):\n    def speak(self):\n        return \"Woof!\"\n\nclass Cat(Animal):\n    def speak(self):\n        return \"Meow!\"\n\nclass Bird(Animal):\n    def speak(self):\n        return \"Tweet!\"\n\ndef animal_sound(animal_type):\n    if animal_type == \"dog\":\n        return Dog().speak()\n    elif animal_type == \"cat\":\n        return Cat().speak()\n    elif animal_type == \"bird\":\n        return Bird().speak()\n    else:\n        return \"Unknown animal\"\n\nprint(animal_sound(\"dog\"))\nprint(animal_sound(\"cat\"))\nprint(animal_sound(\"bird\"))\nprint(animal_sound(\"fish\"))\n```\n\n### Solicitação de exemplo\n\n```copilot copy prompt ref=animal-sound\nSimplify this code. Avoid using if/else chains but retain all function return values.\n```\n\n### Exemplo de resposta\n\nO Copilot indica utilizar um dicionário para associar cada tipo de animal à sua respectiva classe.\n\n```python\nclass Animal:\n    def speak(self):\n        pass\n\nclass Dog(Animal):\n    def speak(self):\n        return \"Woof!\"\n\nclass Cat(Animal):\n    def speak(self):\n        return \"Meow!\"\n\nclass Bird(Animal):\n    def speak(self):\n        return \"Tweet!\"\n\ndef animal_sound(animal_type):\n    animals = {\n        \"dog\": Dog,\n        \"cat\": Cat,\n        \"bird\": Bird\n    }\n    animal_class = animals.get(animal_type, Animal)\n    return animal_class().speak() if animal_class != Animal else \"Unknown animal\"\n\nprint(animal_sound(\"dog\"))\nprint(animal_sound(\"cat\"))\nprint(animal_sound(\"bird\"))\nprint(animal_sound(\"fish\"))\n```\n\n## Reduzir a lógica aninhada\n\nEstruturas muito aninhadas tornam o código complicado de entender, o que dificulta alterar ou expandir sua lógica posteriormente.\n\n### Cenário de exemplo\n\nO 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.\n\n```ruby id=determine-access\ndef determine_access(user_role, has_permission, is_active)\n  if user_role == \"admin\"\n    if has_permission\n      if is_active\n        \"Active admin account with full access.\"\n      else\n        \"Inactive admin account.\"\n      end\n    else\n      \"Admin account lacks necessary permissions.\"\n    end\n  else\n    \"Access denied.\"\n  end\nend\n\nputs determine_access(\"admin\", true, true)\nputs determine_access(\"admin\", true, false)\nputs determine_access(\"admin\", false, true)\nputs determine_access(\"user\", true, true)\n```\n\n### Solicitação de exemplo\n\n```copilot copy prompt ref=determine-access\nRewrite this code to avoid the nested if/else statements\n```\n\n### Exemplo de resposta\n\nO Copilot recomenda utilizar cláusulas de proteção para lidar com as condições antecipadamente e fornecer as mensagens corretas.\n\n```ruby\ndef determine_access(user_role, has_permission, is_active)\n  return \"Access denied.\" unless user_role == \"admin\"\n  return \"Admin account lacks necessary permissions.\" unless has_permission\n  return \"Inactive admin account.\" unless is_active\n\n  \"Active admin account with full access.\"\nend\n\nputs determine_access(\"admin\", true, true)\nputs determine_access(\"admin\", true, false)\nputs determine_access(\"admin\", false, true)\nputs determine_access(\"user\", true, true)\n```\n\n## Dividir métodos extensos\n\nCom 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.\n\n### Cenário de exemplo\n\nO método em Java processa um pedido de cliente e exibe uma mensagem. Ele executa diversas tarefas em um único método.\n\n```java id=process-order\npublic void processOrder(Order order) {\n  if (order == null || order.getItems().isEmpty()) {\n    throw new IllegalArgumentException(\"Order is invalid.\");\n  }\n\n  double totalPrice = 0.0;\n  for (Item item : order.getItems()) {\n    totalPrice += item.getPrice() * item.getQuantity();\n  }\n  order.setTotalPrice(totalPrice);\n\n  if (totalPrice > 0) {\n    order.setStatus(\"Processed\");\n  } else {\n    order.setStatus(\"Pending\");\n  }\n\n  System.out.println(\"Order for customer \" + order.getCustomerName() + \" has been processed. Total price: \" + totalPrice);\n}\n```\n\n### Solicitação de exemplo\n\n```copilot copy prompt ref=process-order\nHow could the processOrder method be refactored to be more useful and easier to maintain\n```\n\n### Exemplo de resposta\n\nO Copilot recomenda separar este método em métodos menores com foco específico.\n\n```java\npublic void processOrder(Order order) {\n    validateOrder(order);\n    double totalPrice = calculateTotalPrice(order);\n    updateOrderStatus(order, totalPrice);\n    printOrderSummary(order, totalPrice);\n}\n\nprivate void validateOrder(Order order) {\n    if (order == null || order.getItems().isEmpty()) {\n        throw new IllegalArgumentException(\"Order is invalid.\");\n    }\n}\n\nprivate double calculateTotalPrice(Order order) {\n    double totalPrice = 0.0;\n    for (Item item : order.getItems()) {\n        totalPrice += item.getPrice() * item.getQuantity();\n    }\n    order.setTotalPrice(totalPrice);\n    return totalPrice;\n}\n\nprivate void updateOrderStatus(Order order, double totalPrice) {\n    if (totalPrice > 0) {\n        order.setStatus(\"Processed\");\n    } else {\n        order.setStatus(\"Pending\");\n    }\n}\n\nprivate void printOrderSummary(Order order, double totalPrice) {\n    System.out.println(\"Order for customer \" + order.getCustomerName() + \" has been processed. Total price: \" + totalPrice);\n}\n```\n\n## Leitura adicional\n\n* [Engenharia de prompts para o GitHub Copilot Chat](/pt/copilot/using-github-copilot/prompt-engineering-for-github-copilot)\n* [Práticas recomendadas para usar GitHub Copilot](/pt/copilot/using-github-copilot/best-practices-for-using-github-copilot)"}