Esaminare gli scenari di refactoring del codice e le migliori pratiche di GitHub Copilot

6 minuti

Il refactoring del codice è il processo di ristrutturazione del codice esistente senza modificarne il comportamento. I vantaggi del refactoring includono il miglioramento della leggibilità del codice, la riduzione della complessità, la facilità di manutenzione del codice e l'aggiunta di nuove funzionalità più facilmente. L'implementazione di GitHub Copilot procedure consigliate consente di lavorare in modo più efficiente e ottenere risultati migliori.

GitHub Copilot buone pratiche

GitHub Copilot è uno strumento potente che consente di effettuare il refactoring e migliorare il codice. Tuttavia, per ottenere i risultati migliori, è consigliabile seguire alcune procedure consigliate quando si usa GitHub Copilot.

Migliorare le risposte con richieste migliori

È possibile migliorare la qualità delle risposte di GitHub Copilot scrivendo richieste più efficaci. Un prompt ben creato può aiutare GitHub Copilot comprendere meglio i requisiti e generare suggerimenti di codice più pertinenti.

Le linee guida seguenti consentono di scrivere richieste migliori:

Iniziare in generale, quindi ottenere informazioni specifiche.

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

Fornire esempi di ciò che si vuole.

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.

Suddividere le attività complesse in attività più semplici.

Invece di chiedere GitHub Copilot di "Generare un'app di pianificazione dei pasti", suddividere le richieste in attività più piccole.

Per esempio:

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.

Fornire il contesto corretto, ad esempio selezioni di codice, file, output del terminale e altro ancora.

Ad esempio, usare la variabile #codebase per fare riferimento all'intera codebase: "Dove è il database connection string usato in #codebase?"
Eseguire l'iterazione delle richieste.

Fornire richieste di completamento per perfezionare o modificare la risposta.

Ad esempio, se si inizia con il prompt seguente:

"Scrivere una funzione per calcolare il fattoriale di un numero".

È possibile seguire questa procedura:

"Non usare ricorsione e ottimizzare usando la memorizzazione nella cache".

E quindi:

"Usare nomi di variabili significativi".
Mantieni rilevante la cronologia delle chat.

GitHub Copilot usa la cronologia della conversazione per fornire contesto. Rimuovere le domande e le risposte precedenti dalla cronologia, se non sono rilevanti. In alternativa, avviare una nuova sessione se si vuole modificare il contesto.

Fornire il contesto e gli strumenti appropriati

Arricchire le richieste con il contesto pertinente per ottenere risposte più accurate e pertinenti nella chat. Con gli strumenti giusti, è possibile aumentare la produttività degli sviluppatori.

In Agent selezionare il pulsante Strumenti per configurare gli strumenti da usare o aggiungerli in modo esplicito al prompt.
Usare #codebase per consentire GitHub Copilot trovare automaticamente i file corretti eseguendo una ricerca nel codice.
Usare lo strumento #fetch per recuperare il contenuto da una pagina Web o usare #githubRepo per eseguire una ricerca di codice in un repository GitHub.
Fare riferimento a file, cartelle o simboli nel prompt usando #<file name>, #<folder name>o #<symbol>.
Trascinare file, cartelle o schede dell'editor sul prompt della chat.
Aggiungi problemi, errori di test o output del terminale al prompt di chat per il contesto specifico dello scenario.

Annotazioni

Quando si usa Agent, GitHub Copilot individua autonomamente i file e il contesto pertinenti.

Scenari comuni di refactoring del codice

GitHub Copilot consente di effettuare rapidamente il refactoring del codice in molti modi. L'elenco seguente include alcuni scenari comuni per il refactoring del codice:

Ottimizzazione del codice inefficiente
Pulizia del codice ripetuto
Rendere il codice più conciso
Suddivisione di unità complesse di codice
Riscrittura del codice condizionale per migliorare la leggibilità
Riformattazione del codice per l'uso di una struttura diversa

Usare GitHub Copilot per ottimizzare il codice inefficiente

GitHub Copilot consente di ottimizzare il codice. Ad esempio, è possibile ottimizzare il codice per rendere il codice più rapido.

Si consideri lo script bash seguente:

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

È possibile usare le funzionalità di chat per valutare le opzioni per ottimizzare diversi aspetti dello script, ad esempio le prestazioni.

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

Usare GitHub Copilot per pulire il codice ripetuto

Evitare la ripetizione renderà il codice più semplice da rivedere ed eseguire il debug. Ad esempio, se lo stesso calcolo viene eseguito più volte in posizioni diverse in un file, è possibile spostare il calcolo in una funzione.

Nell'esempio javaScript molto semplice seguente, lo stesso calcolo (prezzo articolo moltiplicato per numero di articoli venduti) viene eseguito in due posizioni.

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

È possibile chiedere alle funzionalità di chat di spostare il calcolo ripetuto in una funzione.

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

Usare GitHub Copilot per rendere il codice più conciso

Se il codice è inutilmente dettagliato, può essere difficile leggere e gestire. GitHub Copilot può suggerire una versione più concisa del codice selezionato.

Il codice seguente Python restituisce l'area di un rettangolo e un cerchio, ma il codice potrebbe essere scritto in modo più conciso:

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 consente di effettuare il refactoring del codice e renderlo più conciso.

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

Usare GitHub Copilot per suddividere unità complesse di codice

È probabile che metodi o funzioni di grandi dimensioni che eseguano più operazioni offrono meno opportunità di riutilizzo rispetto a funzioni più piccole e semplici incentrate sull'esecuzione di una determinata operazione. Possono anche essere più difficili da comprendere ed eseguire il debug.

GitHub Copilot consente di suddividere blocchi complessi di codice in unità più piccole più adatte per il riutilizzo.

Il codice seguente Python è un esempio molto semplice, ma illustra il principio di suddivisione di una singola funzione in due funzioni che eseguono operazioni specifiche.

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)

È possibile usare GitHub Copilot per effettuare il refactoring del codice per creare funzioni per la pulizia dei dati, la stampa dei dati e l'elaborazione dei dati.

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)

Usare GitHub Copilot per riscrivere il codice condizionale per migliorare la leggibilità

Esistono spesso diversi modi per scrivere codice che esegue o non viene eseguito a seconda di varie condizioni. Alcune strutture condizionali sono più adatte ad altri casi d'uso specifici e la scelta di una struttura condizionale alternativa può talvolta rendere il codice più facile da leggere.

Questo metodo Java usa una serie di istruzioni if e else if per determinare quale operazione eseguire:

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

Un'istruzione switch potrebbe essere un modo migliore per applicare la stessa logica.

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

Usare GitHub Copilot per riformattare il codice per usare una struttura diversa

Si supponga di avere la funzione seguente 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);
}

Se gli standard di codifica richiedono di usare la notazione freccia per le funzioni e i nomi descrittivi per i parametri, è possibile usare GitHub Copilot per apportare queste modifiche.

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

Riassunto

GitHub Copilot consente di effettuare il refactoring del codice in vari modi. È possibile usare la visualizzazione Chat o Inline Chat per chiedere GitHub Copilot di ottimizzare il codice inefficiente, pulire il codice ripetuto, rendere il codice più conciso, suddividere unità complesse di codice, riscrivere il codice condizionale per migliorare la leggibilità e riformattare il codice per usare una struttura diversa.

Commenti e suggerimenti

Questa pagina è stata utile?