Überprüfen von Codeumgestaltungsszenarien und bewährten Methoden für GitHub Copilot

6 Minuten

Der Umgestaltungscode ist der Prozess der Umstrukturierung vorhandener Code, ohne sein Verhalten zu ändern. Zu den Vorteilen der Umgestaltung gehören die Verbesserung der Codelesbarkeit, die Verringerung der Komplexität, die Einfacherkeit des Codes und das Einfachere Hinzufügen neuer Features. Die Implementierung bewährter Methoden von GitHub Copilot kann Ihnen helfen, effizienter zu arbeiten und bessere Ergebnisse zu erzielen.

Bewährte Methoden für GitHub Copilot

GitHub Copilot ist ein leistungsstarkes Tool, mit dem Sie Ihren Code umgestalten und verbessern können. Um jedoch die besten Ergebnisse zu erzielen, sollten Sie bei der Verwendung von Copilot einige bewährte Methoden befolgen.

Verbessern von Antworten mit besseren Prompts

Sie können die Qualität der Antworten von Copilot verbessern, indem Sie effektivere Eingabeaufforderungen schreiben. Eine gut gestaltete Eingabeaufforderung kann Copilot dabei helfen, Ihre Anforderungen besser zu verstehen und relevantere Codevorschläge zu generieren.

Die folgenden Richtlinien können Ihnen dabei helfen, bessere Eingabeaufforderungen zu schreiben:

Beginnen Sie allgemein und werden Sie dann spezifisch.

Generate a Calculator class. Add methods for addition, subtraction, multiplication, division, and factorial. Don't use any external libraries and don't use recursion.

Geben Sie Beispiele dafür, was Sie möchten.

Generate a function that takes a string and returns the number of vowels in it. For example: findVowels("hello") returns 2, findVowels("sky") returns 0.

Unterteilen Sie komplexe Aufgaben in einfachere Aufgaben.

Statt Copilot aufzufordern, eine Essensplaner-App zu generieren, teilen Sie Ihre Eingabeaufforderungen in kleinere Aufgaben auf.

Beispiel:

Generate a function that takes a list of ingredients and returns a list of recipes.

Generate a function that takes a list of recipes and returns a shopping list.

Generate a function that takes a list of recipes and returns a meal plan for the week.

Stellen Sie den richtigen Kontext bereit, z. B. Codeauswahlen, Dateien, Terminalausgabe und vieles mehr.

Verwenden Sie beispielsweise die #codebase Variable, um auf die gesamte Codebasis zu verweisen: "Wo wird die Datenbankverbindungszeichenfolge in #codebase verwendet?"
Überarbeiten Sie Ihre Prompts.

Stellen Sie Nachverfolgungsaufforderungen bereit, um die Antwort zu verfeinern oder zu ändern.

Wenn Sie beispielsweise mit der folgenden Eingabeaufforderung beginnen:

"Schreiben Sie eine Funktion, um die Faktorialzahl einer Zahl zu berechnen."

Sie können folgende Schritte ausführen:

"Verwenden Sie rekursion nicht, und optimieren Sie sie mithilfe der Zwischenspeicherung."

Und anschließend:

"Verwenden Sie aussagekräftige Variablennamen."
Halten Sie den Chatverlauf relevant.

Copilot verwendet den Verlauf der Unterhaltung, um Kontext bereitzustellen. Entfernen Sie vergangene Fragen und Antworten aus dem Verlauf, wenn sie nicht relevant sind. Oder starten Sie eine neue Sitzung, wenn Sie den Kontext ändern möchten.

Bereitstellen des richtigen Kontexts und der richtigen Tools

Bereichern Sie Ihre Eingabeaufforderungen mit relevantem Kontext, um genauere und relevantere Antworten im Chat zu erhalten. Mit den richtigen Tools können Sie Ihre Entwicklerproduktivität steigern.

Wählen Sie im Agentmodus die Schaltfläche "Tools" aus, um die Tools zu konfigurieren, die Sie verwenden möchten, oder fügen Sie sie ihrer Eingabeaufforderung explizit hinzu.
Verwenden Sie #codebase, damit Copilot die richtigen Dateien automatisch durch eine Codesuche finden kann.
Verwenden Sie das #fetch Tool zum Abrufen von Inhalten von einer Webseite oder zum #githubRepo Ausführen einer Codesuche in einem GitHub-Repository.
Verweisen Sie auf Dateien, Ordner oder Symbole in Ihrer Eingabeaufforderung mithilfe von #<file name>, #<folder name> oder #<symbol>.
Ziehen Sie Dateien, Ordner oder Editorregisterkarten auf die Chataufforderung und legen Sie sie dort ab.
Fügen Sie Ihrer Chataufforderung Probleme, Testfehler oder Terminalausgabe für szenariospezifischen Kontext hinzu.

Hinweis

Wenn Sie den Agent-Modus verwenden, findet Copilot autonom die relevanten Dateien und den entsprechenden Kontext für Sie.

Allgemeine Codeumgestaltungsszenarien

GitHub Copilot kann Ihnen dabei helfen, Code auf vielfältige Weise schnell umzugestalten. Die folgende Liste enthält einige häufige Szenarien für die Umgestaltung von Code:

Optimieren von ineffizienten Code
Bereinigen wiederholter Code
Präzisere Codeerstellung
Aufteilen komplexer Codeeinheiten
Umschreiben von bedingtem Code zur besseren Lesbarkeit
Umformatierung des Codes zur Nutzung einer anderen Struktur

Verwenden von GitHub Copilot zum Optimieren von ineffizienten Code

Copilot kann Ihnen helfen, Code zu optimieren. Beispielsweise können Sie Ihren Code optimieren, damit der Code schneller ausgeführt werden kann.

Betrachten Sie das folgende Bash-Skript:

#!/bin/bash
# Find all .txt files and count the number of lines in each file
for file in $(find . -type f -name "*.txt"); do
  wc -l "$file"
done

Sie können Chatfeatures verwenden, um Optionen zur Optimierung verschiedener Aspekte des Skripts zu bewerten, z. B. Leistung.

#!/bin/bash
# Find all .txt files and count the number of lines in each file (improved performance)
find . -type f -name "*.txt" -print0 | xargs -0 wc -l

Verwenden Sie GitHub Copilot, um redundanten Code zu bereinigen.

Die Vermeidung von Wiederholungen erleichtert das Überarbeiten und Debuggen des Codes. Wenn beispielsweise dieselbe Berechnung an verschiedenen Stellen in einer Datei mehrmals ausgeführt wird, können Sie die Berechnung in eine Funktion verschieben.

Im folgenden sehr einfachen JavaScript-Beispiel wird die gleiche Berechnung (Artikelpreis multipliziert mit der Anzahl der verkauften Artikel) an zwei Stellen ausgeführt.

let totalSales = 0;
let applePrice = 3;
let appleSold = 100;
totalSales += applePrice * appleSold;

let orangePrice = 2;
let orangeSold = 50;
totalSales += orangePrice * orangeSold;

console.log(`Total: ${totalSales}`);

Sie können Chatfeatures bitten, die wiederholte Berechnung in eine Funktion zu verschieben.

function calculateTotal(price, quantity) {
    return price * quantity;
}
let totalSales = 0;
let applePrice = 3;
let appleSold = 100;
totalSales += calculateTotal(applePrice, appleSold);

let orangePrice = 2;
let orangeSold = 50;
totalSales += calculateTotal(orangePrice, orangeSold);
console.log(`Total: ${totalSales}`);

Verwenden von GitHub Copilot, um Code präziser zu gestalten

Wenn Code unnötig ausführlich ist, kann es schwierig sein, sie zu lesen und zu verwalten. Copilot kann eine präzisere Version des ausgewählten Codes vorschlagen.

Der folgende Python-Code gibt den Bereich eines Rechtecks und eines Kreises aus, aber der Code könnte präziser geschrieben werden:

def calculate_area_of_rectangle(length, width):
    area = length * width
    return area

def calculate_area_of_circle(radius):
    area = 3.14 * radius * radius
    return area

rectangle_length = 5
rectangle_width = 10
rectangle_area = calculate_area_of_rectangle(rectangle_length, rectangle_width)
print(f"Area of rectangle: {rectangle_area}")

circle_radius = 7
circle_area = calculate_area_of_circle(circle_radius)
print(f"Area of circle: {circle_area}")

GitHub Copilot kann Ihnen helfen, den Code umzugestalten und präziser zu gestalten.

def calculate_area_of_rectangle(length, width):
    return length * width

def calculate_area_of_circle(radius):
    return 3.14 * radius * radius

rectangle_length = 5
rectangle_width = 10
print(f"Area of rectangle: {calculate_area_of_rectangle(rectangle_length, rectangle_width)}")

circle_radius = 7
print(f"Area of circle: {calculate_area_of_circle(circle_radius)}")

Verwenden von GitHub Copilot zum Aufteilen komplexer Codeeinheiten

Große Methoden oder Funktionen, die mehrere Vorgänge ausführen, bieten wahrscheinlich weniger Möglichkeiten zur Wiederverwendung als kleinere, einfachere Funktionen, die sich auf die Ausführung eines bestimmten Vorgangs konzentrieren. Möglicherweise sind sie auch schwieriger zu verstehen und zu debuggen.

Copilot kann Ihnen helfen, komplexe Codeblöcke in kleinere Einheiten aufzuteilen, die für die Wiederverwendung besser geeignet sind.

Der folgende Python-Code ist ein sehr einfaches Beispiel, aber es zeigt das Prinzip, eine einzelne Funktion in zwei Funktionen aufzuteilen, die bestimmte Vorgänge ausführen.

import pandas as pd
from pandas.io.formats.styler import Styler

def process_data(item, price):
    # Cleanse the data
    item = item.strip()    # Remove leading and trailing whitespace
    price = price.strip()  # Remove leading and trailing whitespace
    price = float(price)   # Convert price to a float
    # More cleansing operations can be added here

    # Create and print a DataFrame
    data = {'Item': [item], 'Price': [price]}
    df = pd.DataFrame(data)
    print(df.to_string(index=False))

# Example usage
item = "  Apple  "
price = "  1.50  "
process_data(item, price)

Mit Copilot können Sie den Code umgestalten, um Funktionen zum Reinigen von Daten, zum Drucken von Daten und zum Verarbeiten von Daten zu erstellen.

import pandas as pd
from pandas.io.formats.styler import Styler

def cleanse_data(item, price):
    # Cleanse the data
    item = item.strip()    # Remove leading and trailing whitespace
    price = price.strip()  # Remove leading and trailing whitespace
    price = float(price)   # Convert price to a float
    return item, price

def print_data(item, price):
    # Create and print a DataFrame
    data = {'Item': [item], 'Price': [price]}
    df = pd.DataFrame(data)
    print(df.to_string(index=False))

def process_data(item, price):
    item, price = cleanse_data(item, price)
    print_data(item, price)

# Example usage
item = "  Apple  "
price = "  1.50  "
item, price = cleanse_data(item, price)
print_data(item, price)

Verwenden von GitHub Copilot zum Umschreiben von bedingtem Code zur besseren Lesbarkeit

Es gibt häufig mehrere Möglichkeiten zum Schreiben von Code, der je nach verschiedenen Bedingungen ausgeführt wird oder nicht. Einige bedingte Strukturen sind besser geeignet als andere für bestimmte Anwendungsfälle, und die Auswahl einer alternativen bedingten Struktur kann manchmal das Lesen des Codes vereinfachen.

Diese Java-Methode verwendet eine Reihe von if und else if Anweisungen, um zu bestimmen, welche Operation ausgeführt werden soll:

public string getSound(String animal) {
    if (animal == null) {
        System.out.println("Animal is null");
    } else if (animal.equalsIgnoreCase("Dog")) {
        return "bark";
    } else if (animal.equalsIgnoreCase("Cat")) {
        return "meow";
    } else if (animal.equalsIgnoreCase("Bird")) {
        return "tweet";
    }
    return "unknown";
}

Eine Switch-Anweisung könnte eine bessere Möglichkeit sein, dieselbe Logik anzuwenden.

/**
    * Returns the sound made by the specified animal.
    *
    * @param animal the name of the animal
    * @return the sound made by the animal, or "unknown" if the animal is not recognized
    */
public String getAnimalSound(String animal) {
    return switch (animal) {
        case null -> "Animal is null";
        case "Dog" -> "bark";
        case "Cat" -> "meow";
        case "Bird" -> "tweet";
        default -> "unknown";
    };
}

Verwenden von GitHub Copilot zum Neuformatieren von Code zur Verwendung einer anderen Struktur

Angenommen, Sie haben die folgende Funktion in JavaScript:

function listRepos(o, p) {
    return fetch(`https://api.github.com/orgs/${o}/repos?per_page=${parseInt()}`)
        .then(response => response.json())
        .then( (data) => data);
}

Wenn Ihre Codierungsstandards die Pfeilnotation für Funktionen und beschreibende Namen für Parameter verwenden müssen, können Sie Copilot verwenden, um diese Änderungen vorzunehmen.

const listRepositories = (organization, perPage) => {
    return fetch(`https://api.github.com/orgs/${organization}/repos?per_page=${parseInt(perPage)}`)
        .then(response => response.json())
        .then(data => data);
};

Zusammenfassung

GitHub Copilot kann Ihnen dabei helfen, Code auf verschiedene Weise umzugestalten. Sie können die Chatansicht oder den Inlinechat verwenden, um Copilot aufzufordern, ineffizienten Code zu optimieren, wiederholten Code zu bereinigen, Code präziser zu gestalten, komplexe Codeeinheiten aufzuteilen, bedingten Code neu zu schreiben, um eine bessere Lesbarkeit zu erzielen und Code neu zu formatieren, um eine andere Struktur zu verwenden.

Feedback

War diese Seite hilfreich?