{"meta":{"title":"Verbessern der Lesbarkeit und Wartbarkeit von Code","intro":"Copilot-Chat kann Möglichkeiten vorschlagen, deinen Code leichter nachvollziehbar und verwaltbar zu gestalten.","product":"GitHub Copilot","breadcrumbs":[{"href":"/de/copilot","title":"GitHub Copilot"},{"href":"/de/copilot/tutorials","title":"Anleitungen"},{"href":"/de/copilot/tutorials/copilot-chat-cookbook","title":"GitHub Copilot Chat-Cookbook"},{"href":"/de/copilot/tutorials/copilot-chat-cookbook/refactor-code","title":"Umgestalten von Code"},{"href":"/de/copilot/tutorials/copilot-chat-cookbook/refactor-code/improve-code-readability","title":"Verbessern der Lesbarkeit von Code"}],"documentType":"article"},"body":"# Verbessern der Lesbarkeit und Wartbarkeit von Code\n\nCopilot-Chat kann Möglichkeiten vorschlagen, deinen Code leichter nachvollziehbar und verwaltbar zu gestalten.\n\nSchlecht lesbarer Code kann durch andere Entwickler schwer verwaltet und erweitert werden. Copilot-Chat kann dich auf verschiedene Weise unterstützen. Zum Beispiel durch:\n\n* [Vorschlagen von Verbesserungen für Variablennamen](#improving-variable-names)\n* [Vermeiden sequenzieller Bedingungsüberprüfungen](#avoiding-sequential-conditional-checks)\n* [Reduzierung geschachtelter Logik](#reducing-nested-logic)\n* [Aufteilen großer Methoden in kleinere, besser lesbare Methoden](#splitting-up-large-methods)\n\nDie Dokumentation deines Codes stellt eine weitere Möglichkeit dar, die Wartbarkeit deines Codes zu verbessern. Informationen zur Verwendung von Copilot-Chat zum Hinzufügen hilfreicher Kommentare zu deinem Code findest du in den Beispielprompts in [Dokumentieren eines Codes](/de/copilot/copilot-chat-cookbook/documenting-code).\n\n> \\[!NOTE] Bei den in diesem Artikel veranschaulichten Antworten handelt es sich um Beispiele. Da die Copilot-Chat-Antworten nicht deterministisch sind, erhältst du möglicherweise andere Antworten als die hier dargestellten.\n\n## Verbessern von Variablennamen\n\nDurch beschreibende Variablen- und Parameternamen ist es einfacher, ihren Zweck nachzuvollziehen.\n\n### Beispielszenario\n\nDieser JavaScript-Code protokolliert eine Meldung über das Alter einer Person in der Konsole. Durch die abstrakten Parameternamen ist es schwierig, den Zweck des Codes nachzuvollziehen.\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### Beispielprompt\n\nWähle im Editor die Funktion aus, die du ändern möchtest, und stelle Copilot-Chat die folgende Frage:\n\n```copilot copy prompt ref=log-persons-age\nImprove the variable names in this function\n```\n\n### Beispielantwort\n\nCopilot schlägt beschreibende Variablennamen vor.\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## Vermeiden sequenzieller Bedingungsüberprüfungen\n\n```\n          `if...else`-Ketten können schwer lesbar sein, besonders wenn sie lang sind.\n```\n\n### Beispielszenario\n\nDieser Python-Code gibt den Laut aus, den verschiedene Tiere machen, sofern eine Definition vorhanden ist. Wird der Typ des Tieres nicht erkannt, gibt der Code „Unknown animal“ aus. Durch die Kette der `if...else`-Anweisungen ist der Code jedoch ineffizient und umständlich.\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### Beispielprompt\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### Beispielantwort\n\nCopilot schlägt vor, ein Wörterbuch zu verwenden, um die Tiertypen ihren entsprechenden Klassen zuzuordnen.\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## Reduzierung geschachtelter Logik\n\nDurch tief geschachtelte Strukturen kann den Code schwer nachvollzogen werden, wodurch es sich in Zukunft als schwierig erweist, die Logik des Codes zu ändern oder zu erweitern.\n\n### Beispielszenario\n\nDieser Ruby-Code gibt Informationen zu einem Benutzerkonto basierend auf drei Parametern aus. Die Verwendung geschachtelter `if...else`-Anweisungen macht den Code unnötig komplex.\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### Beispielprompt\n\n```copilot copy prompt ref=determine-access\nRewrite this code to avoid the nested if/else statements\n```\n\n### Beispielantwort\n\nCopilot schlägt vor, Schutzklauseln zu verwenden, um die Bedingungen frühzeitig zu adressieren und die entsprechenden Nachrichten zurückzugeben.\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## Aufteilen großer Methoden\n\nEs kann schwierig sein, die Funktionsweise einer Methode oder Funktion nachzuvollziehen, wenn diese zu lang sind. Das erschwert zudem die Wartung. Methoden oder Funktionen, die mehrere Aufgaben ausführen, können in anderen Kontexten möglicherweise nicht wiederverwendbar sein. Es kann ebenfalls schwierig sein, jede Aufgabe isoliert zu testen.\n\n### Beispielszenario\n\nDiese Java-Methode verarbeitet eine Kundenbestellung und gibt eine Nachricht aus. Sie führt mehrere Aufgaben in einer einzigen Methode aus.\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### Beispielprompt\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### Beispielantwort\n\nCopilot schlägt vor, diese Methode in kleinere, zielgerichtetere Methoden zu unterteilen.\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## Weitere Informationen\n\n* [Prompt-Engineering für GitHub Copilot Chat](/de/copilot/using-github-copilot/prompt-engineering-for-github-copilot)\n* [Bewährte Methoden für die Verwendung von GitHub Copilot](/de/copilot/using-github-copilot/best-practices-for-using-github-copilot)"}