{"meta":{"title":"Mejora de la legibilidad y el mantenimiento del código","intro":"Copilot Chat puede sugerir formas de facilitar la comprensión y el mantenimiento del código.","product":"GitHub Copilot","breadcrumbs":[{"href":"/es/copilot","title":"GitHub Copilot"},{"href":"/es/copilot/tutorials","title":"Tutoriales"},{"href":"/es/copilot/tutorials/copilot-cookbook","title":"Recetario de GitHub Copilot"},{"href":"/es/copilot/tutorials/copilot-cookbook/refactor-code","title":"Refactorización de código"},{"href":"/es/copilot/tutorials/copilot-cookbook/refactor-code/improve-code-readability","title":"Mejora de la legibilidad del código"}],"documentType":"article"},"body":"# Mejora de la legibilidad y el mantenimiento del código\n\nCopilot Chat puede sugerir formas de facilitar la comprensión y el mantenimiento del código.\n\nEs complicado que otros desarrolladores puedan mantener y ampliar código difícil de leer.\nCopilot Chat puede ayudar de varias maneras. Por ejemplo:\n\n* [Sugerir mejoras en los nombres de variables](#improving-variable-names)\n* [Evitar comprobaciones condicionales secuenciales](#avoiding-sequential-conditional-checks)\n* [Reducir la lógica anidada](#reducing-nested-logic)\n* [Dividir métodos grandes en otros más pequeños y legibles](#splitting-up-large-methods)\n\nDocumentar el código es otra manera de mejorar su capacidad de mantenimiento. Para obtener información sobre cómo usar Copilot Chat para ayudarle a agregar comentarios útiles al código, consulte los mensajes de ejemplo en [Documenting code (Documentación del código](/es/copilot/tutorials/copilot-cookbook/document-code)).\n\n> \\[!NOTE] Las respuestas que se muestran en este artículo son ejemplos.\n> Copilot Chat las respuestas son no deterministas, por lo que puede obtener respuestas diferentes de las que se muestran aquí.\n\n## Mejora de los nombres de variables\n\nLos nombres descriptivos de parámetros y variables facilitan la comprensión de su propósito.\n\n### Escenario de ejemplo\n\nEste código de JavaScript registra un mensaje sobre la edad de una persona en la consola. Los nombres abstractos de los parámetros dificultan la comprensión del propósito del 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### Mensaje de ejemplo\n\nEn el editor, seleccione la función que desea cambiar y, a continuación, pregunte a Copilot Chat:\n\n```copilot copy prompt ref=log-persons-age\nImprove the variable names in this function\n```\n\n### Respuesta de ejemplo\n\nCopilot sugiere nombres descriptivos de variables.\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 comprobaciones condicionales secuenciales\n\nLas cadenas `if...else` pueden ser difíciles de leer, especialmente cuando son largas.\n\n### Escenario de ejemplo\n\nEste código de Python imprime el sonido que hacen distintos animales, en caso de haberse definido, o indica \"Unknown animal\" si no se reconoce el tipo de animal. Sin embargo, la cadena de instrucciones `if...else` hace que el código sea ineficaz y 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### Mensaje de ejemplo\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### Respuesta de ejemplo\n\nCopilot sugiere usar un diccionario para asignar los tipos de animales a sus clases correspondientes.\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## Reducción de la lógica anidada\n\nLas estructuras profundamente anidadas pueden dificultar el seguimiento del código, lo que dificulta a su vez la modificación o ampliación de la lógica del código en el futuro.\n\n### Escenario de ejemplo\n\nEste código de Ruby imprime información sobre una cuenta de usuario basada en tres parámetros. El uso de instrucciones `if...else` anidadas hace que el código sea innecesariamente complejo.\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### Mensaje de ejemplo\n\n```copilot copy prompt ref=determine-access\nRewrite this code to avoid the nested if/else statements\n```\n\n### Respuesta de ejemplo\n\nCopilot sugiere utilizar cláusulas de protección para administrar las condiciones desde el principio y devolver los mensajes adecuados.\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 grandes\n\nPuede ser difícil entender con exactitud lo que hace un método o función si es demasiado largo, lo que dificulta a su vez su mantenimiento. Es posible que los métodos o funciones que realizan varias tareas no sean reutilizables en otros contextos. También puede ser difícil probar cada tarea de forma aislada.\n\n### Escenario de ejemplo\n\nEste método de Java procesa un pedido de cliente e imprime un mensaje. Realiza varias tareas en un ú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### Mensaje de ejemplo\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### Respuesta de ejemplo\n\nCopilot sugiere dividir este método en métodos más pequeños y centrados.\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## Lectura adicional\n\n* [Ingeniería de mensajes para GitHub Copilot Chat](/es/copilot/concepts/prompting/prompt-engineering)\n* [Procedimientos recomendados para usar GitHub Copilot](/es/copilot/get-started/best-practices)"}