Przegląd scenariuszy refaktoryzacji kodu i najlepsze praktyki GitHub Copilot

  • 6 min

Refaktoryzacja kodu to proces restrukturyzacji istniejącego kodu bez zmieniania jego zachowania. Zalety refaktoryzacji obejmują poprawę czytelności kodu, zmniejszenie złożoności, ułatwienie obsługi kodu i umożliwienie łatwiejszego dodawania nowych funkcji. Implementowanie GitHub Copilot najlepszych rozwiązań może pomóc ci wydajniej pracować i uzyskać lepsze wyniki.

najlepsze rozwiązania dotyczące GitHub Copilot

GitHub Copilot to zaawansowane narzędzie, które ułatwia refaktoryzację i ulepszanie kodu. Jednak aby uzyskać najlepsze wyniki, należy postępować zgodnie z najlepszymi rozwiązaniami w przypadku korzystania z GitHub Copilot.

Ulepszanie odpowiedzi przy użyciu lepszych monitów

Można poprawić jakość odpowiedzi GitHub Copilot, pisząc bardziej efektywne sugestie. Dobrze spreparowany monit może pomóc GitHub Copilot lepiej zrozumieć wymagania i wygenerować bardziej odpowiednie sugestie dotyczące kodu.

Poniższe wskazówki mogą pomóc w pisaniu lepszych monitów:

  • Zacznij od ogółu, a potem przejdź do szczegółów.

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

  • Podaj przykłady potrzebnych elementów.

    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.

  • Podziel złożone zadania na prostsze zadania.

    Zamiast prosić GitHub Copilot o wygenerowanie aplikacji do planowania posiłków, podziel polecenia na mniejsze zadania.

    Przykład:

    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.

  • Podaj odpowiedni kontekst, taki jak wybór kodu, pliki, dane wyjściowe terminalu i inne.

    Na przykład użyj zmiennej #codebase, aby odwołać się do całego kodu źródłowego: "Gdzie jest używany ciąg połączenia z bazą danych w kodzie źródłowym?"

  • Iteruj po wyświetleniu monitów.

    Podaj wskazówki dotyczące refinowania lub modyfikowania odpowiedzi.

    Jeśli na przykład zaczniesz od następującego monitu:

    "Napisz funkcję, aby obliczyć współczynnik liczby."

    Możesz wykonać następujące czynności:

    "Nie używaj rekursji i optymalizuj przy użyciu buforowania".

    A następnie:

    "Użyj znaczących nazw zmiennych".

  • Zachowaj istotność historii czatu.

    GitHub Copilot używa historii konwersacji w celu zapewnienia kontekstu. Usuń wcześniejsze pytania i odpowiedzi z historii, jeśli nie są one istotne. Możesz też uruchomić nową sesję, jeśli chcesz zmienić kontekst.

Podaj odpowiedni kontekst i narzędzia

Wzbogać swoje zapytania za pomocą odpowiedniego kontekstu, aby uzyskać dokładniejsze i bardziej trafne odpowiedzi na czacie. Dzięki odpowiednim narzędziom możesz zwiększyć produktywność deweloperów.

  • W obszarze Agent wybierz przycisk narzędzia, aby skonfigurować narzędzia, których chcesz użyć, lub jawnie dodać je do monitu.

  • Użyj #codebase, aby umożliwić GitHub Copilot automatyczne znajdowanie odpowiednich plików przez przeprowadzenie wyszukiwania kodu.

  • Użyj narzędzia #fetch, aby pobrać zawartość ze strony internetowej lub użyć #githubRepo, aby przeprowadzić wyszukiwanie kodu w repozytorium GitHub.

  • Możesz odwoływać się do plików, folderów lub symboli w monicie, używając #<file name>, #<folder name> lub #<symbol>.

  • Przeciągnij i upuść pliki, foldery lub karty edytora na pole czatu.

  • Dodaj problemy, błędy testów lub dane wyjściowe terminalu do monitu czatu w kontekście specyficznym dla scenariusza.

Uwaga / Notatka

W przypadku korzystania z agenta GitHub Copilot autonomicznie odnajduje odpowiednie pliki i kontekst.

Typowe scenariusze refaktoryzacji kodu

GitHub Copilot może pomóc szybko refaktoryzować kod na różne sposoby. Poniższa lista zawiera kilka typowych scenariuszy refaktoryzacji kodu:

  • Optymalizowanie nieefektywnego kodu
  • Czyszczenie powtarzającego się kodu
  • Tworzenie zwięzłego kodu
  • Dzielenie złożonych jednostek kodu
  • Ponowne zapisywanie kodu warunkowego w celu uzyskania lepszej czytelności
  • Ponowne formatowanie kodu w celu użycia innej struktury

Używanie GitHub Copilot do optymalizowania nieefektywnego kodu

GitHub Copilot może pomóc w optymalizacji kodu. Możesz na przykład zoptymalizować kod, aby przyspieszyć uruchamianie kodu.

Rozważmy następujący skrypt bash:

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

Możesz użyć funkcji czatu, aby ocenić opcje optymalizacji różnych aspektów skryptu, takich jak wydajność.

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

Używanie GitHub Copilot do czyszczenia powtarzającego się kodu

Unikanie powtórzeń ułatwi poprawienie i debugowanie kodu. Jeśli na przykład to samo obliczenie jest wykonywane więcej niż raz w różnych miejscach w pliku, można przenieść obliczenia do funkcji.

W poniższym bardzo prostym przykładzie języka JavaScript to samo obliczenie (cena produktu pomnożona przez liczbę sprzedanych przedmiotów) jest wykonywane w dwóch miejscach.

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

Możesz poprosić funkcje czatu o przeniesienie powtarzających się obliczeń do funkcji.

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

Użyj GitHub Copilot, aby kod był bardziej zwięzły

Jeśli kod jest nadmiernie rozwlekły, może być trudny do odczytania i utrzymania. GitHub Copilot może sugerować bardziej zwięzłą wersję wybranego kodu.

Poniższy kod Python generuje obszar prostokąta i okręgu, ale kod można napisać bardziej zwięzłie:

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 może pomóc refaktoryzować kod i uczynić go bardziej zwięzłym.

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

Używanie GitHub Copilot do dzielenia złożonych jednostek kodu

Duże metody lub funkcje, które wykonują wiele operacji, mogą oferować mniej możliwości ponownego użycia niż mniejsze, prostsze funkcje, które koncentrują się na wykonywaniu określonej operacji. Mogą również być trudniejsze do zrozumienia i debugowania.

GitHub Copilot może pomóc podzielić złożone bloki kodu na mniejsze jednostki, które są bardziej odpowiednie do ponownego użycia.

Poniższy kod Python jest bardzo prostym przykładem, ale pokazuje zasadę podziału jednej funkcji na dwie funkcje, które wykonują określone operacje.

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)

Za pomocą GitHub Copilot można refaktoryzować kod w celu utworzenia funkcji czyszczenia danych, drukowania danych i przetwarzania danych.

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)

Używanie GitHub Copilot do ponownego zapisywania kodu warunkowego w celu uzyskania lepszej czytelności

Często istnieje kilka sposobów pisania kodu, który jest wykonywany lub nie, w zależności od różnych czynników. Niektóre struktury warunkowe są lepiej dostosowane niż inne do konkretnych przypadków użycia, a wybór alternatywnej struktury warunkowej może czasami ułatwić odczytywanie kodu.

Ta metoda Java używa serii if i else if instrukcji w celu określenia operacji do wykonania:

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

Instrukcja switch może być lepszym sposobem zastosowania tej samej logiki.

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

Użyj GitHub Copilot do ponownego sformatowania kodu w celu użycia innej struktury

Załóżmy, że masz następującą funkcję w języku JavaScript:

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

Jeśli standardy kodowania wymagają użycia notacji strzałek dla funkcji i opisowych nazw parametrów, możesz użyć GitHub Copilot, aby ułatwić wprowadzanie tych zmian.

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

Podsumowanie

GitHub Copilot może pomóc refaktoryzować kod na różne sposoby. Możesz użyć widoku czatu lub wbudowanego czatu, aby poprosić GitHub Copilot o zoptymalizowanie nieefektywnego kodu, oczyszczenie powtarzanego kodu, zwiększenie zwięzłości kodu, podzielenie złożonych jednostek kodu, przepisanie kodu warunkowego w celu uzyskania lepszej czytelności i ponowne sformatowanie kodu w celu użycia innej struktury.