Gennemse scenarier med omstrukturering af kode og bedste praksis for GitHub Copilot

6 minutter

Omstruktureringskode er processen med at omstrukturere eksisterende kode uden at ændre dens funktionsmåde. Fordelene ved omstrukturering omfatter forbedring af læsbarheden af kode, reduktion af kompleksiteten, gør det nemmere at vedligeholde koden og gør det nemmere at tilføje nye funktioner. Implementering af bedste praksis for GitHub Copilot kan hjælpe dig med at arbejde mere effektivt og opnå bedre resultater.

Bedste praksis for GitHub Copilot

GitHub Copilot er et effektivt værktøj, der kan hjælpe dig med at omstrukturere og forbedre din kode. For at få de bedste resultater skal du dog følge nogle bedste fremgangsmåder, når du bruger Copilot.

Gør svar bedre ved hjælp af bedre prompts

Du kan forbedre kvaliteten af Copilots svar ved at skrive mere effektive prompter. En veludbygget prompt kan hjælpe Copilot med at forstå dine krav bedre og generere mere relevante kodeforslag.

Følgende retningslinjer kan hjælpe dig med at skrive bedre prompter:

Start generelt, og bliv derefter specifik.

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

Giv eksempler på, hvad du vil have.

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.

Opdel komplekse opgaver i enklere opgaver.

I stedet for at spørge Copilot om at "Generér en app til kostplanlægning", skal du opdele dine prompter i mindre opgaver.

Eksempler:

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.

Angiv den rette kontekst, f.eks. kodevalg, filer, terminaloutput og meget mere.

Brug f.eks. variablen #codebase til at referere til hele kodebasen: "Hvor bruges databaseforbindelsesstrengen i #codebase?"
Gentage på dine prompter.

Angiv opfølgende prompter for at afgrænse eller ændre svaret.

Hvis du f.eks. starter med følgende prompt:

"Skriv en funktion for at beregne fakultetet for et tal."

Du kan følge op på følgende:

"Brug ikke rekursion, og optimer ved hjælp af cachelagring."

Og derefter:

"Brug meningsfulde variabelnavne."
Hold chathistorikken relevant.

Copilot bruger samtalens historie til at angive kontekst. Fjern tidligere spørgsmål og svar fra oversigten, hvis de ikke er relevante. Du kan også starte en ny session, hvis du vil ændre konteksten.

Angiv den rette kontekst og de rette værktøjer

Berige dine prompter med relevant kontekst for at få mere præcise og relevante svar i chat. Med de rette værktøjer kan du øge din udviklerproduktivitet.

I agent-tilstand vælger du værktøjsknappen for at konfigurere de værktøjer, du vil bruge, eller tilføjer dem eksplicit til din prompt.
Bruges #codebase til automatisk at lade Copilot finde de rigtige filer ved at udføre en kodesøgning.
Brug værktøjet #fetch til at hente indhold fra en webside eller til #githubRepo at udføre en kodesøgning på et GitHub-lager.
Reference til filer, mapper eller symboler i prompten ved hjælp #<file name>af , #<folder name>eller #<symbol>.
Træk og slip filer, mapper eller editorfaner til chatprompten.
Føj problemer, testfejl eller terminaloutput til chatprompten for scenariespecifik kontekst.

Seddel

Når du bruger agenttilstand, finder Copilot autonomt de relevante filer og kontekst for dig.

Almindelige scenarier med omstrukturering af kode

GitHub Copilot kan hjælpe dig med hurtigt at omstrukturere kode på mange måder. Følgende liste indeholder nogle almindelige scenarier for omstrukturering af kode:

Optimering af ineffektiv kode
Rydder op i gentaget kode
Gør kode mere præcis
Opdeling af komplekse kodeenheder
Omskrivning af betinget kode for at forbedre læsbarheden
Omformater kode for at bruge en anden struktur

Brug GitHub Copilot til at optimere ineffektiv kode

Copilot kan hjælpe dig med at optimere kode. Du kan f.eks. optimere din kode for at få koden til at køre hurtigere.

Overvej følgende bash-script:

#!/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

Du kan bruge chatfunktioner til at evaluere muligheder for at optimere forskellige aspekter af scriptet, f.eks. ydeevne.

#!/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

Brug GitHub Copilot til at rydde op i gentaget kode

Hvis du undgår gentagelser, bliver det nemmere at revidere og foretage fejlfinding af din kode. Hvis den samme beregning f.eks. udføres mere end én gang forskellige steder i en fil, kan du flytte beregningen til en funktion.

I følgende meget enkle JavaScript-eksempel udføres den samme beregning (varepris ganget med antallet af solgte varer) to steder.

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}`);

Du kan bede chatfunktioner om at flytte den gentagne beregning til en funktion.

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}`);

Brug GitHub Copilot til at gøre koden mere præcis

Hvis koden er unødvendigt detaljeret, kan det være svært at læse og vedligeholde. Copilot kan foreslå en mere præcis version af den valgte kode.

Følgende Python-kode returnerer området for et rektangel og en cirkel, men koden kan skrives mere præcist:

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 kan hjælpe dig med at omstrukturere koden og gøre den mere præcis.

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)}")

Brug GitHub Copilot til at opdele komplekse kodeenheder

Store metoder eller funktioner, der udfører flere handlinger, vil sandsynligvis give færre muligheder for genbrug end mindre, enklere funktioner, der fokuserer på at udføre en bestemt handling. De kan også være sværere at forstå og foretage fejlfinding af.

Copilot kan hjælpe dig med at opdele komplekse kodeblokke i mindre enheder, der er mere velegnede til genbrug.

Følgende Python-kode er et meget simpelt eksempel, men det viser princippet om at opdele en enkelt funktion i to funktioner, der udfører bestemte handlinger.

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)

Du kan bruge Copilot til at omstrukturere koden for at oprette funktioner til rensning af data, udskrivning af data og behandling af data.

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)

Brug GitHub Copilot til at omskrive betinget kode for at forbedre læsbarheden

Der er ofte flere måder at skrive kode på, der udføres eller ikke udføres afhængigt af forskellige betingelser. Nogle betingede strukturer er bedre egnet end andre til bestemte use cases, og hvis du vælger en alternativ betinget struktur, kan det nogle gange gøre det nemmere at læse koden.

Denne Java-metode bruger en række if sætninger og else if til at bestemme, hvilken handling der skal udføres:

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";
}

En switch-sætning kan være en bedre måde at anvende den samme logik på.

/**
    * 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";
    };
}

Brug GitHub Copilot til at omformatere kode for at bruge en anden struktur

Antag, at du har følgende funktion i JavaScript:

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

Hvis dine kodningsstandarder kræver, at du bruger pilenotationen til funktioner og beskrivende navne for parametre, kan du bruge Copilot til at hjælpe dig med at foretage disse ændringer.

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

Resumé

GitHub Copilot kan hjælpe dig med at omstrukturere kode på forskellige måder. Du kan bruge Chat-visningen eller Indbygget chat til at bede Copilot om at optimere ineffektiv kode, rydde op i gentaget kode, gøre koden mere præcis, opdele komplekse kodeenheder, omskrive betinget kode for at forbedre læsbarheden og omformatere kode for at bruge en anden struktur.

Feedback

Var denne side nyttig?