Passez en revue les scénarios de refactorisation du code et les meilleures pratiques de GitHub Copilot.

6 minutes

La refactorisation du code est le processus de restructuration du code existant sans changer son comportement. Les avantages de la refactorisation incluent une meilleure lisibilité du code, une complexité moindre, une maintenance simplifiée du code et un ajout plus facile de nouvelles fonctionnalités. L’implémentation de GitHub Copilot meilleures pratiques peut vous aider à travailler plus efficacement et à obtenir de meilleurs résultats.

bonnes pratiques GitHub Copilot

GitHub Copilot est un outil puissant qui peut vous aider à refactoriser et à améliorer votre code. Toutefois, pour obtenir les meilleurs résultats, vous devez suivre certaines bonnes pratiques lors de l’utilisation de GitHub Copilot.

Améliorer les réponses avec de meilleures instructions

Vous pouvez améliorer la qualité des réponses de GitHub Copilot en écrivant des invites plus efficaces. Une invite bien conçue peut aider GitHub Copilot mieux comprendre vos besoins et générer des suggestions de code plus pertinentes.

Les instructions suivantes peuvent vous aider à écrire de meilleures incitations :

Commencez de manière générale, puis devenez plus spécifique.

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

Donnez des exemples de ce que vous voulez.

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.

Décomposez les tâches complexes en tâches plus simples.

Au lieu de demander GitHub Copilot à « Générer une application planificateur de repas », décomposez vos invites en tâches plus petites.

Par exemple:

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.

Fournissez le contexte approprié, comme les sélections de code, les fichiers, la sortie du terminal, etc.

Par exemple, utilisez la variable #codebase pour faire référence à l’intégralité du codebase : « Où est la base de données connection string utilisée dans #codebase ? »
Itérez vos requêtes.

Fournissez des suggestions de suivi pour affiner ou modifier la réponse.

Par exemple, si vous commencez par l’invite suivante :

« Écrivez une fonction pour calculer la factorielle d’un nombre ».

Vous pouvez suivre les étapes suivantes :

« N’utilisez pas de récursivité et optimisez-les à l’aide de la mise en cache. »

Puis :

« Utiliser des noms de variables explicites ».
Conservez l’historique pertinent des conversations.

GitHub Copilot utilise l’historique de la conversation pour fournir un contexte. Supprimez les questions et réponses passées de l’historique s’ils ne sont pas pertinents. Vous pouvez également démarrer une nouvelle session si vous souhaitez modifier le contexte.

Fournir le contexte et les outils appropriés

Enrichissez vos instructions avec un contexte pertinent pour obtenir des réponses plus précises et pertinentes dans le chat. Avec les outils appropriés, vous pouvez améliorer la productivité de vos développeurs.

Dans l’Agent, sélectionnez le bouton Outils pour configurer les outils que vous souhaitez utiliser ou ajouter explicitement à votre invite.
Utilisez #codebase pour laisser GitHub Copilot rechercher automatiquement les fichiers appropriés en effectuant une recherche de code.
Utilisez l’outil #fetch pour extraire du contenu d’une page web ou utiliser #githubRepo pour effectuer une recherche de code dans un référentiel GitHub.
Faites référence à des fichiers, dossiers ou symboles dans votre invite en utilisant #<file name>, #<folder name> ou #<symbol>.
Faites glisser et déposez des fichiers, des dossiers ou des onglets de l’éditeur dans le champ de conversation.
Ajoutez des problèmes, des échecs de tests ou des sorties de terminal à votre requête de conversation pour fournir un contexte spécifique au scénario.

Remarque

Lorsque vous utilisez l’Agent, GitHub Copilot trouve de manière autonome les fichiers et le contexte pertinents pour vous.

Scénarios de refactorisation de code courants

GitHub Copilot pouvez vous aider à refactoriser rapidement le code de plusieurs façons. La liste suivante inclut certains scénarios courants de refactorisation du code :

Optimisation du code inefficace
Nettoyage du code répété
Concision du code
Division des unités de code complexes
Réécriture du code conditionnel pour une meilleure lisibilité
Reformatage du code pour utiliser une autre structure

Utiliser GitHub Copilot pour optimiser le code inefficace

GitHub Copilot pouvez vous aider à optimiser le code. Par exemple, vous pouvez optimiser votre code pour que le code s’exécute plus rapidement.

Considérez le script bash suivant :

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

Vous pouvez utiliser des fonctionnalités de conversation pour évaluer les options d’optimisation des différents aspects du script, tels que les performances.

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

Utiliser GitHub Copilot pour nettoyer le code répété

En évitant les répétitions, la révision et le débogage de votre code seront plus simples. Par exemple, si le même calcul est effectué plusieurs fois à différents endroits dans un fichier, vous pouvez déplacer le calcul vers une fonction.

Dans l’exemple JavaScript très simple suivant, le même calcul (prix des articles multiplié par nombre d’articles vendus) est effectué à deux endroits.

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

Vous pouvez demander aux fonctionnalités de conversation de déplacer le calcul répété dans une fonction.

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

Utiliser GitHub Copilot pour rendre le code plus concis

Si le code est inutilement détaillé, il peut être difficile à lire et à gérer. GitHub Copilot pouvez suggérer une version plus concise du code sélectionné.

Le code Python suivant génère la zone d’un rectangle et d’un cercle, mais le code peut être écrit plus concisement :

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 pouvez vous aider à refactoriser le code et à le rendre plus concis.

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

Utiliser GitHub Copilot pour fractionner des unités complexes de code

Les grandes méthodes ou fonctions qui effectuent plusieurs opérations sont susceptibles d’offrir moins de possibilités de réutilisation que les fonctions plus simples et plus petites qui se concentrent sur l’exécution d’une opération en particulier. Elles peuvent également être plus difficiles à comprendre et à déboguer.

GitHub Copilot pouvez vous aider à fractionner des blocs de code complexes en unités plus petites qui conviennent mieux à la réutilisation.

Le code Python suivant est un exemple très simple, mais il montre le principe de fractionner une fonction unique en deux fonctions qui effectuent des opérations particulières.

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)

Vous pouvez utiliser GitHub Copilot pour refactoriser le code afin de créer des fonctions de nettoyage des données, d’impression de données et de traitement des données.

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)

Utiliser GitHub Copilot pour réécrire du code conditionnel pour améliorer la lisibilité

Il existe souvent plusieurs façons d’écrire du code qui s’exécute, ou non, en fonction de différentes conditions. Certaines structures conditionnelles sont mieux adaptées que d’autres à des cas d’utilisation particuliers, et le choix d’une autre structure conditionnelle peut parfois faciliter la lecture du code.

Cette méthode Java utilise une série d’instructions if et else if pour déterminer quelle opération effectuer :

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

Une instruction switch peut être une meilleure façon d’appliquer la même logique.

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

Utiliser GitHub Copilot pour reformater le code pour utiliser une autre structure

Supposons que vous disposez de la fonction suivante en JavaScript :

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

Si vos normes de codage vous obligent à utiliser la notation de flèche pour les fonctions et les noms descriptifs des paramètres, vous pouvez utiliser GitHub Copilot pour vous aider à apporter ces modifications.

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

Résumé

GitHub Copilot pouvez vous aider à refactoriser le code de différentes façons. Vous pouvez utiliser l’affichage Chat ou Inline Chat pour demander GitHub Copilot pour optimiser le code inefficace, nettoyer le code répété, rendre le code plus concis, fractionner des unités complexes de code, réécrire le code conditionnel pour une meilleure lisibilité et reformater le code pour utiliser une autre structure.

Commentaires

Cette page a-t-elle été utile ?