{"meta":{"title":"Mejora de la legibilidad y el mantenimiento del código","intro":"El Chat de Copiloto 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-chat-cookbook","title":"Guía de GitHub Copilot Chat"},{"href":"/es/copilot/tutorials/copilot-chat-cookbook/refactor-code","title":"Refactorizar código"},{"href":"/es/copilot/tutorials/copilot-chat-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\nEl Chat de Copiloto 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. El Chat de Copiloto puede ayudar de varias formas. Por ejemplo:\n\n* [Sugiriendo mejoras en los nombres de variables](#improving-variable-names)\n* [Evitando comprobaciones condicionales secuenciales](#avoiding-sequential-conditional-checks)\n* [Reduciendo la lógica anidada](#reducing-nested-logic)\n* [Dividiendo 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 el uso del Chat de Copiloto para ayudar a agregar comentarios útiles al código, consulte las indicaciones de ejemplo en [Documentación del código](/es/copilot/copilot-chat-cookbook/documenting-code).\n\n> \\[!NOTE] Las respuestas que se muestran en este artículo son ejemplos. Las respuestas del Chat de Copiloto no son deterministas, por lo que puedes obtener respuestas diferentes a las aquí mostradas.\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### Ejemplos de indicaciones\n\nEn el editor, seleccione la función que desea cambiar y, a continuación, pregunte al Chat de Copiloto:\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 de variables descriptivos.\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\n```\n          Las cadenas `if...else` pueden ser difíciles de leer, especialmente cuando son largas.\n```\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 \"Animal desconocido\" 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### Ejemplos de indicaciones\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 el uso de 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## Reducir la lógica anidada\n\nLas estructuras profundamente anidadas pueden dificultar el seguimiento del código, lo que a su vez dificulta 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### Ejemplos de indicaciones\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 el uso de cláusulas de restricción para controlar las condiciones al 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 a su vez dificulta 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### Ejemplos de indicaciones\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 otros 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## Información adicional\n\n* [Ingeniería de mensajes para GitHub Copilot Chat](/es/copilot/using-github-copilot/prompt-engineering-for-github-copilot)\n* [Procedimientos recomendados para usar GitHub Copilot](/es/copilot/using-github-copilot/best-practices-for-using-github-copilot)"}