A kód újrabontási forgatókönyveinek és GitHub Copilot ajánlott eljárásainak áttekintése

Befejeződött

A kód újrabontása a meglévő kód szerkezetátalakításának folyamata anélkül, hogy módosítaná a működését. Az újrabontás előnyei közé tartozik a kód olvashatóságának javítása, az összetettség csökkentése, a kód könnyebb karbantartása és az új funkciók egyszerűbb hozzáadása. A GitHub Copilot ajánlott eljárások implementálása segíthet a hatékonyabb munkában és a jobb eredményekben.

GitHub Copilot legjobb gyakorlatai

GitHub Copilot egy hatékony eszköz, amely segíthet a kód újrabontásában és fejlesztésében. A legjobb eredmények eléréséhez azonban kövesse a GitHub Copilot használatakor ajánlott eljárásokat.

A válaszok javítása jobb kérésekkel

Hatékonyabb kérések megírásával javíthatja GitHub Copilot válaszainak minőségét. A jól megtervezett kérések segíthetnek GitHub Copilot jobban megérteni a követelményeket, és relevánsabb kódjavaslatokat hozhatnak létre.

Az alábbi irányelvek segíthetnek a jobb kérések írásában:

• Kezdje az általános elemet, majd adja meg a konkrét elemet.

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

• Adjon példákat a kívánt elemre.

  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.
  

• Bontsa fel az összetett feladatokat egyszerűbb tevékenységekre.

  Ahelyett, hogy megkérné GitHub Copilotot, hogy "hozzon létre egy étkezési tervező alkalmazást", bontsa le az utasításokat kisebb feladatokra.

  Például:

  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.
  

• Adja meg a megfelelő környezetet, például kódkijelöléseket, fájlokat, terminálkimenetet stb.

  Például használja a #codebase változót a teljes kódbázisra való hivatkozásra: "Hol van használatban az adatbázis kapcsolati karakterlánc a #codebase-ben?"

• Iterálja az utasításokat.

  Adjon meg nyomon követési utasításokat a válasz pontosításához vagy módosításához.

  Ha például a következő utasítással kezd:

  "Írjon egy függvényt egy szám faktoriálisának kiszámításához."

  A következőket végezheti el:

  Ne használjon rekurziót, és optimalizáljon a gyorsítótárazás használatával.

  Majd:

  "Használjon értelmes változóneveket."

• Tartsa a csevegési előzményeket relevánsan.

  GitHub Copilot a beszélgetés előzményeit használja a kontextus megadásához. Ha nem relevánsak, távolítsa el a korábbi kérdéseket és válaszokat az előzményekből. Vagy új munkamenetet is indíthat, ha módosítani szeretné a környezetet.

A megfelelő környezet és eszközök megadása

Az üzeneteit releváns kontextussal bővítheti, hogy pontosabb és relevánsabb válaszokat kapjon a csevegésben. A megfelelő eszközökkel növelheti a fejlesztői hatékonyságot.

• Az Ügynökben válassza az Eszközök gombot a használni kívánt eszközök konfigurálásához, vagy explicit módon vegye fel őket a parancssorba.

• A #codebase használatával GitHub Copilot automatikusan megkeresheti a megfelelő fájlokat egy kódkeresés végrehajtásával.

• A #fetch eszközzel lekérheti a tartalmat egy weblapról, vagy #githubRepo használatával kódkeresést végezhet egy GitHub-adattárban.

• Hivatkozzon fájlokra, mappákra vagy szimbólumokra a parancssorban a #<file name>, #<folder name>, vagy #<symbol> használatával.

• Húzza a fájlokat, mappákat vagy szerkesztőlapokat a csevegési parancssorba.

• Adjon hozzá problémákat, teszthibákat vagy terminálkimenetet a csevegőüzenethez a forgatókönyv-specifikus környezethez.

Megjegyzés:

Az ügynök használatakor GitHub Copilot önállóan megkeresi a megfelelő fájlokat és környezetet.

Gyakori kód újrabontási forgatókönyvek

GitHub Copilot számos módon segíthet a kód gyors újrabontásában. Az alábbi lista néhány gyakori forgatókönyvet tartalmaz a kód újrabontásához:

• Nem hatékony kód optimalizálása
• Ismétlődő kód törlése
• A kód egyszerűbbé tétele
• Összetett kódegységek felosztása
• Feltételes kód újraírása a jobb olvashatóság érdekében
• Kód újraformázása egy másik struktúra használatára

Nem hatékony kód optimalizálása a GitHub Copilot használatával

GitHub Copilot segíthet a kód optimalizálásában. Optimalizálhatja például a kódot, hogy a kód gyorsabban fusson.

Fontolja meg a következő bash-szkriptet:

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

A csevegési funkciókkal kiértékelheti a szkript különböző aspektusainak, például a teljesítménynek a optimalizálására szolgáló lehetőségeket.

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

Ismétlődő kód törlése a GitHub Copilot használatával

Az ismétlődés elkerülése megkönnyíti a kód felülvizsgálatát és hibakeresését. Ha például ugyanazt a számítást többször hajtja végre egy fájl különböző helyeinél, áthelyezheti a számítást egy függvénybe.

Az alábbi nagyon egyszerű JavaScript-példában ugyanazt a számítást (a cikk árát megszorozva az eladott cikkek számával) két helyen hajtjuk végre.

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

Megkérheti a csevegőfunkciót, hogy helyezze át az ismétlődő számítást egy függvénybe.

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

A GitHub Copilot használatával tömörebbé teheti a kódot

Ha a kód szükségtelenül részletes, nehezen olvasható és karbantartható. GitHub Copilot a kijelölt kód tömörebb verzióját javasolhatja.

A következő Python kód egy téglalap és egy kör területét adja ki, de a kód tömörebben írható:

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 segíthet a kód újrabontásában, és tömörebbé teheti azt.

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

Összetett kódegységek felosztása GitHub Copilot használatával

A több műveletet végrehajtó nagyméretű metódusok vagy függvények valószínűleg kevesebb lehetőséget kínálnak az újrafelhasználásra, mint az adott művelet végrehajtására összpontosító kisebb, egyszerűbb függvények. Ezek megértése és hibakeresése is nehezebb lehet.

GitHub Copilot segíthet az összetett kódblokkok kisebb egységekre való felosztásában, amelyek jobban alkalmasak az újrafelhasználásra.

A következő Python kód egy nagyon egyszerű példa, de azt az elvet mutatja, hogy egyetlen függvényt két olyan függvényre kell felosztani, amelyek bizonyos műveleteket hajtanak végre.

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)

A GitHub Copilot használatával újrabontással hozhat létre függvényeket az adatok tisztításához, az adatok nyomtatásához és az adatok feldolgozásához.

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)

A jobb olvashatóságért használja a GitHub Copilotot a feltételes kód átírására.

Gyakran többféleképpen is írhat olyan kódot, amely a különböző feltételektől függően végrehajtja vagy nem hajtja végre a kódot. Egyes feltételes struktúrák jobban megfelelnek másoknak a konkrét használati esetekhez, és egy alternatív feltételes struktúra kiválasztása néha megkönnyíti a kód olvasását.

Ez a Java metódus if és else if utasítások sorozatával határozza meg, hogy melyik műveletet kell végrehajtania:

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

A kapcsolóutasítások jobb módszert jelenthetnek ugyanannak a logikának a alkalmazására.

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

Kód újraformázása a GitHub Copilot használatával egy másik struktúra használatára

Tegyük fel, hogy a Következő függvény van a JavaScriptben:

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

Ha a kódolási szabványok megkövetelik, hogy a függvények nyíl jelölését és a paraméterek leíró nevét használja, a GitHub Copilot segítségével elvégezheti ezeket a módosításokat.

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

Összefoglalás

GitHub Copilot különböző módokon segíthet a kód újrabontásában. A Csevegőnézet vagy a Beágyazott csevegés segítségével megkérheti GitHub Copilot, hogy optimalizálja a nem hatékony kódot, törölje az ismétlődő kódot, tömörebbé tegye a kódot, feloszthassa az összetett kódegységeket, átírhatja a feltételes kódot a jobb olvashatóság érdekében, és újraformázhatja a kódot egy másik struktúra használatára.