Schlecht lesbarer Code kann durch andere Entwickler schwer verwaltet und erweitert werden. Copilot Chat kann dich auf verschiedene Weise unterstützen. Beispiel:
- Vorschlagen von Verbesserungen für Variablennamen
- Vermeiden sequenzieller Bedingungsüberprüfungen
- Reduzierung geschachtelter Logik
- Aufteilen großer Methoden in kleinere, besser lesbare Methoden
Die 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.
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.
Verbessern von Variablennamen
Durch beschreibende Variablen- und Parameternamen ist es einfacher, ihren Zweck nachzuvollziehen.
Beispielszenario
Dieser 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.
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.");
}
}
Beispiel für Prompt
Wähle im Editor die Funktion aus, die du ändern möchtest, und stelle Copilot Chat die folgende Frage:
Improve the variable names in this function
Beispielantwort
Copilot schlägt beschreibende Variablennamen vor.
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.");
}
}
Vermeiden sequenzieller Bedingungsüberprüfungen
if...else-Ketten können schwer lesbar sein. Das gilt insbesondere für lange Ketten.
Beispielszenario
Dieser 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.
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"))
Beispiel für Prompt
Simplify this code. Avoid using if/else chains but retain all function return values.
Beispielantwort
Copilot schlägt vor, ein Wörterbuch zu verwenden, um die Tiertypen ihren entsprechenden Klassen zuzuordnen.
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"))
Reduzierung geschachtelter Logik
Durch 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.
Beispielszenario
Dieser Ruby-Code gibt Informationen zu einem Benutzerkonto basierend auf drei Parametern aus. Die Verwendung geschachtelter if...else-Anweisungen macht den Code unnötig komplex.
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)
Beispiel für Prompt
Rewrite this code to avoid the nested if/else statements
Beispielantwort
Copilot schlägt vor, Schutzklauseln zu verwenden, um die Bedingungen frühzeitig zu adressieren und die entsprechenden Nachrichten zurückzugeben.
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)
Aufteilen großer Methoden
Es 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.
Beispielszenario
Diese Java-Methode verarbeitet eine Kundenbestellung und gibt eine Nachricht aus. Sie führt mehrere Aufgaben in einer einzigen Methode aus.
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);
}
Beispiel für Prompt
How could the processOrder method be refactored to be more useful and easier to maintain
Beispielantwort
Copilot schlägt vor, diese Methode in kleinere, zielgerichtetere Methoden zu unterteilen.
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);
}